HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
vulkan.hpp
Go to the documentation of this file.
1 // Copyright 2015-2022 The Khronos Group Inc.
2 //
3 // SPDX-License-Identifier: Apache-2.0 OR MIT
4 //
5 
6 // This header is generated from the Khronos Vulkan XML API Registry.
7 
8 #ifndef VULKAN_HPP
9 #define VULKAN_HPP
10 
11 #if defined( _MSVC_LANG )
12 # define VULKAN_HPP_CPLUSPLUS _MSVC_LANG
13 #else
14 # define VULKAN_HPP_CPLUSPLUS __cplusplus
15 #endif
16 
17 #if 201703L < VULKAN_HPP_CPLUSPLUS
18 # define VULKAN_HPP_CPP_VERSION 20
19 #elif 201402L < VULKAN_HPP_CPLUSPLUS
20 # define VULKAN_HPP_CPP_VERSION 17
21 #elif 201103L < VULKAN_HPP_CPLUSPLUS
22 # define VULKAN_HPP_CPP_VERSION 14
23 #elif 199711L < VULKAN_HPP_CPLUSPLUS
24 # define VULKAN_HPP_CPP_VERSION 11
25 #else
26 # error "vulkan.hpp needs at least c++ standard version 11"
27 #endif
28 
29 #include <algorithm>
30 #include <array> // ArrayWrapperND
31 #include <string> // std::string
32 #include <vulkan/vulkan.h>
33 #if 17 <= VULKAN_HPP_CPP_VERSION
34 # include <string_view> // std::string_view
35 #endif
36 
37 #if defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
38 # if !defined( VULKAN_HPP_NO_SMART_HANDLE )
39 # define VULKAN_HPP_NO_SMART_HANDLE
40 # endif
41 #else
42 # include <tuple> // std::tie
43 # include <vector> // std::vector
44 #endif
45 
46 #if !defined( VULKAN_HPP_NO_EXCEPTIONS )
47 # include <system_error> // std::is_error_code_enum
48 #endif
49 
50 #if defined( VULKAN_HPP_NO_CONSTRUCTORS )
51 # if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
52 # define VULKAN_HPP_NO_STRUCT_CONSTRUCTORS
53 # endif
54 # if !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS )
55 # define VULKAN_HPP_NO_UNION_CONSTRUCTORS
56 # endif
57 #endif
58 
59 #if defined( VULKAN_HPP_NO_SETTERS )
60 # if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
61 # define VULKAN_HPP_NO_STRUCT_SETTERS
62 # endif
63 # if !defined( VULKAN_HPP_NO_UNION_SETTERS )
64 # define VULKAN_HPP_NO_UNION_SETTERS
65 # endif
66 #endif
67 
68 #if !defined( VULKAN_HPP_ASSERT )
69 # include <cassert>
70 # define VULKAN_HPP_ASSERT assert
71 #endif
72 
73 #if !defined( VULKAN_HPP_ASSERT_ON_RESULT )
74 # define VULKAN_HPP_ASSERT_ON_RESULT VULKAN_HPP_ASSERT
75 #endif
76 
77 #if !defined( VULKAN_HPP_STATIC_ASSERT )
78 # define VULKAN_HPP_STATIC_ASSERT static_assert
79 #endif
80 
81 #if !defined( VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL )
82 # define VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL 1
83 #endif
84 
85 #if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL == 1
86 # if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNXNTO__ ) || defined( __Fuchsia__ )
87 # include <dlfcn.h>
88 # elif defined( _WIN32 )
89 typedef struct HINSTANCE__ * HINSTANCE;
90 # if defined( _WIN64 )
91 typedef int64_t( __stdcall * FARPROC )();
92 # else
93 typedef int( __stdcall * FARPROC )();
94 # endif
95 extern "C" __declspec( dllimport ) HINSTANCE __stdcall LoadLibraryA( char const * lpLibFileName );
96 extern "C" __declspec( dllimport ) int __stdcall FreeLibrary( HINSTANCE hLibModule );
97 extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE hModule, const char * lpProcName );
98 # endif
99 #endif
100 
101 #if !defined( __has_include )
102 # define __has_include( x ) false
103 #endif
104 
105 #if ( 201907 <= __cpp_lib_three_way_comparison ) && __has_include( <compare> ) && !defined( VULKAN_HPP_NO_SPACESHIP_OPERATOR )
106 # define VULKAN_HPP_HAS_SPACESHIP_OPERATOR
107 #endif
108 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
109 # include <compare>
110 #endif
111 
112 #if ( 201803 <= __cpp_lib_span )
113 # define VULKAN_HPP_SUPPORT_SPAN
114 # include <span>
115 #endif
116 
117 static_assert( VK_HEADER_VERSION == 236, "Wrong VK_HEADER_VERSION!" );
118 
119 // 32-bit vulkan is not typesafe for non-dispatchable handles, so don't allow copy constructors on this platform by default.
120 // To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION
121 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
122 # if !defined( VULKAN_HPP_TYPESAFE_CONVERSION )
123 # define VULKAN_HPP_TYPESAFE_CONVERSION
124 # endif
125 #endif
126 
127 // <tuple> includes <sys/sysmacros.h> through some other header
128 // this results in major(x) being resolved to gnu_dev_major(x)
129 // which is an expression in a constructor initializer list.
130 #if defined( major )
131 # undef major
132 #endif
133 #if defined( minor )
134 # undef minor
135 #endif
136 
137 // Windows defines MemoryBarrier which is deprecated and collides
138 // with the VULKAN_HPP_NAMESPACE::MemoryBarrier struct.
139 #if defined( MemoryBarrier )
140 # undef MemoryBarrier
141 #endif
142 
143 #if !defined( VULKAN_HPP_HAS_UNRESTRICTED_UNIONS )
144 # if defined( __clang__ )
145 # if __has_feature( cxx_unrestricted_unions )
146 # define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
147 # endif
148 # elif defined( __GNUC__ )
149 # define GCC_VERSION ( __GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__ )
150 # if 40600 <= GCC_VERSION
151 # define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
152 # endif
153 # elif defined( _MSC_VER )
154 # if 1900 <= _MSC_VER
155 # define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
156 # endif
157 # endif
158 #endif
159 
160 #if !defined( VULKAN_HPP_INLINE )
161 # if defined( __clang__ )
162 # if __has_attribute( always_inline )
163 # define VULKAN_HPP_INLINE __attribute__( ( always_inline ) ) __inline__
164 # else
165 # define VULKAN_HPP_INLINE inline
166 # endif
167 # elif defined( __GNUC__ )
168 # define VULKAN_HPP_INLINE __attribute__( ( always_inline ) ) __inline__
169 # elif defined( _MSC_VER )
170 # define VULKAN_HPP_INLINE inline
171 # else
172 # define VULKAN_HPP_INLINE inline
173 # endif
174 #endif
175 
176 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
177 # define VULKAN_HPP_TYPESAFE_EXPLICIT
178 #else
179 # define VULKAN_HPP_TYPESAFE_EXPLICIT explicit
180 #endif
181 
182 #if defined( __cpp_constexpr )
183 # define VULKAN_HPP_CONSTEXPR constexpr
184 # if __cpp_constexpr >= 201304
185 # define VULKAN_HPP_CONSTEXPR_14 constexpr
186 # else
187 # define VULKAN_HPP_CONSTEXPR_14
188 # endif
189 # define VULKAN_HPP_CONST_OR_CONSTEXPR constexpr
190 #else
191 # define VULKAN_HPP_CONSTEXPR
192 # define VULKAN_HPP_CONSTEXPR_14
193 # define VULKAN_HPP_CONST_OR_CONSTEXPR const
194 #endif
195 
196 #if !defined( VULKAN_HPP_NOEXCEPT )
197 # if defined( _MSC_VER ) && ( _MSC_VER <= 1800 )
198 # define VULKAN_HPP_NOEXCEPT
199 # else
200 # define VULKAN_HPP_NOEXCEPT noexcept
201 # define VULKAN_HPP_HAS_NOEXCEPT 1
202 # if defined( VULKAN_HPP_NO_EXCEPTIONS )
203 # define VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS noexcept
204 # else
205 # define VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
206 # endif
207 # endif
208 #endif
209 
210 #if 14 <= VULKAN_HPP_CPP_VERSION
211 # define VULKAN_HPP_DEPRECATED( msg ) [[deprecated( msg )]]
212 #else
213 # define VULKAN_HPP_DEPRECATED( msg )
214 #endif
215 
216 #if ( 17 <= VULKAN_HPP_CPP_VERSION ) && !defined( VULKAN_HPP_NO_NODISCARD_WARNINGS )
217 # define VULKAN_HPP_NODISCARD [[nodiscard]]
218 # if defined( VULKAN_HPP_NO_EXCEPTIONS )
219 # define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS [[nodiscard]]
220 # else
221 # define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
222 # endif
223 #else
224 # define VULKAN_HPP_NODISCARD
225 # define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
226 #endif
227 
228 #if !defined( VULKAN_HPP_NAMESPACE )
229 # define VULKAN_HPP_NAMESPACE vk
230 #endif
231 
232 #define VULKAN_HPP_STRINGIFY2( text ) #text
233 #define VULKAN_HPP_STRINGIFY( text ) VULKAN_HPP_STRINGIFY2( text )
234 #define VULKAN_HPP_NAMESPACE_STRING VULKAN_HPP_STRINGIFY( VULKAN_HPP_NAMESPACE )
235 
237 {
238  template <typename T, size_t N>
239  class ArrayWrapper1D : public std::array<T, N>
240  {
241  public:
243 
244  VULKAN_HPP_CONSTEXPR ArrayWrapper1D( std::array<T, N> const & data ) VULKAN_HPP_NOEXCEPT : std::array<T, N>( data ) {}
245 
246 #if ( VK_USE_64_BIT_PTR_DEFINES == 0 )
247  // on 32 bit compiles, needs overloads on index type int to resolve ambiguities
249  {
250  return std::array<T, N>::operator[]( index );
251  }
252 
254  {
255  return std::array<T, N>::operator[]( index );
256  }
257 #endif
258 
259  operator T const *() const VULKAN_HPP_NOEXCEPT
260  {
261  return this->data();
262  }
263 
264  operator T *() VULKAN_HPP_NOEXCEPT
265  {
266  return this->data();
267  }
268 
270  operator std::string() const
271  {
272  return std::string( this->data() );
273  }
274 
275 #if 17 <= VULKAN_HPP_CPP_VERSION
277  operator std::string_view() const
278  {
279  return std::string_view( this->data() );
280  }
281 #endif
282 
283 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
285  std::strong_ordering operator<=>( ArrayWrapper1D<char, N> const & rhs ) const VULKAN_HPP_NOEXCEPT
286  {
287  return *static_cast<std::array<char, N> const *>( this ) <=> *static_cast<std::array<char, N> const *>( &rhs );
288  }
289 #else
291  bool 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 
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 
304  {
305  return *static_cast<std::array<char, N> const *>( this ) > *static_cast<std::array<char, N> const *>( &rhs );
306  }
307 
310  {
311  return *static_cast<std::array<char, N> const *>( this ) >= *static_cast<std::array<char, N> const *>( &rhs );
312  }
313 #endif
314 
317  {
318  return *static_cast<std::array<char, N> const *>( this ) == *static_cast<std::array<char, N> const *>( &rhs );
319  }
320 
323  {
324  return *static_cast<std::array<char, N> const *>( this ) != *static_cast<std::array<char, N> const *>( &rhs );
325  }
326  };
327 
328  // specialization of relational operators between std::string and arrays of chars
329  template <size_t N>
330  bool operator<( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
331  {
332  return lhs < rhs.data();
333  }
334 
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>
343  {
344  return lhs > rhs.data();
345  }
346 
347  template <size_t N>
349  {
350  return lhs >= rhs.data();
351  }
352 
353  template <size_t N>
355  {
356  return lhs == rhs.data();
357  }
358 
359  template <size_t N>
361  {
362  return lhs != rhs.data();
363  }
364 
365  template <typename T, size_t N, size_t M>
366  class ArrayWrapper2D : public std::array<ArrayWrapper1D<T, M>, N>
367  {
368  public:
370 
371  VULKAN_HPP_CONSTEXPR ArrayWrapper2D( std::array<std::array<T, M>, N> const & data ) VULKAN_HPP_NOEXCEPT
372  : std::array<ArrayWrapper1D<T, M>, N>( *reinterpret_cast<std::array<ArrayWrapper1D<T, M>, N> const *>( &data ) )
373  {
374  }
375  };
376 
377  template <typename FlagBitsType>
378  struct FlagTraits
379  {
381  };
382 
383  template <typename BitType>
384  class Flags
385  {
386  public:
388 
389  // constructors
391 
392  VULKAN_HPP_CONSTEXPR Flags( BitType bit ) VULKAN_HPP_NOEXCEPT : m_mask( static_cast<MaskType>( bit ) ) {}
393 
395 
397 
398  // relational operators
399 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
400  auto operator<=>( Flags<BitType> const & ) const = default;
401 #else
402  VULKAN_HPP_CONSTEXPR bool operator<( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
403  {
404  return m_mask < rhs.m_mask;
405  }
406 
407  VULKAN_HPP_CONSTEXPR bool operator<=( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
408  {
409  return m_mask <= rhs.m_mask;
410  }
411 
413  {
414  return m_mask > rhs.m_mask;
415  }
416 
418  {
419  return m_mask >= rhs.m_mask;
420  }
421 
423  {
424  return m_mask == rhs.m_mask;
425  }
426 
428  {
429  return m_mask != rhs.m_mask;
430  }
431 #endif
432 
433  // logical operator
435  {
436  return !m_mask;
437  }
438 
439  // bitwise operators
441  {
442  return Flags<BitType>( m_mask & rhs.m_mask );
443  }
444 
446  {
447  return Flags<BitType>( m_mask | rhs.m_mask );
448  }
449 
451  {
452  return Flags<BitType>( m_mask ^ rhs.m_mask );
453  }
454 
456  {
457  return Flags<BitType>( m_mask ^ FlagTraits<BitType>::allFlags.m_mask );
458  }
459 
460  // assignment operators
462 
464  {
465  m_mask |= rhs.m_mask;
466  return *this;
467  }
468 
470  {
471  m_mask &= rhs.m_mask;
472  return *this;
473  }
474 
476  {
477  m_mask ^= rhs.m_mask;
478  return *this;
479  }
480 
481  // cast operators
482  explicit VULKAN_HPP_CONSTEXPR operator bool() const VULKAN_HPP_NOEXCEPT
483  {
484  return !!m_mask;
485  }
486 
488  {
489  return m_mask;
490  }
491 
492 #if defined( VULKAN_HPP_FLAGS_MASK_TYPE_AS_PUBLIC )
493  public:
494 #else
495  private:
496 #endif
497  MaskType m_mask;
498  };
499 
500 #if !defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
501  // relational operators only needed for pre C++20
502  template <typename BitType>
503  VULKAN_HPP_CONSTEXPR bool operator<( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
504  {
505  return flags.operator>( bit );
506  }
507 
508  template <typename BitType>
509  VULKAN_HPP_CONSTEXPR bool operator<=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
510  {
511  return flags.operator>=( bit );
512  }
513 
514  template <typename BitType>
516  {
517  return flags.operator<( bit );
518  }
519 
520  template <typename BitType>
522  {
523  return flags.operator<=( bit );
524  }
525 
526  template <typename BitType>
528  {
529  return flags.operator==( bit );
530  }
531 
532  template <typename BitType>
534  {
535  return flags.operator!=( bit );
536  }
537 #endif
538 
539  // bitwise operators
540  template <typename BitType>
542  {
543  return flags.operator&( bit );
544  }
545 
546  template <typename BitType>
548  {
549  return flags.operator|( bit );
550  }
551 
552  template <typename BitType>
554  {
555  return flags.operator^( bit );
556  }
557 
558  // bitwise operators on BitType
559  template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true>
561  {
562  return Flags<BitType>( lhs ) & rhs;
563  }
564 
565  template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true>
567  {
568  return Flags<BitType>( lhs ) | rhs;
569  }
570 
571  template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true>
573  {
574  return Flags<BitType>( lhs ) ^ rhs;
575  }
576 
577  template <typename BitType, typename std::enable_if<FlagTraits<BitType>::isBitmask, bool>::type = true>
579  {
580  return ~( Flags<BitType>( bit ) );
581  }
582 
583 #if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
584  template <typename T>
586  {
587  public:
589  : m_count( 0 )
590  , m_ptr( nullptr )
591  {
592  }
593 
595  : m_count( 0 )
596  , m_ptr( nullptr )
597  {
598  }
599 
601  : m_count( 1 )
602  , m_ptr( &value )
603  {
604  }
605 
606  ArrayProxy( uint32_t count, T const * ptr ) VULKAN_HPP_NOEXCEPT
607  : m_count( count )
608  , m_ptr( ptr )
609  {
610  }
611 
612  template <std::size_t C>
613  ArrayProxy( T const ( &ptr )[C] ) VULKAN_HPP_NOEXCEPT
614  : m_count( C )
615  , m_ptr( ptr )
616  {
617  }
618 
619 # if __GNUC__ >= 9
620 # pragma GCC diagnostic push
621 # pragma GCC diagnostic ignored "-Winit-list-lifetime"
622 # endif
623 
624  ArrayProxy( std::initializer_list<T> const & list ) VULKAN_HPP_NOEXCEPT
625  : m_count( static_cast<uint32_t>( list.size() ) )
626  , m_ptr( list.begin() )
627  {
628  }
629 
631  ArrayProxy( std::initializer_list<typename std::remove_const<T>::type> const & list ) VULKAN_HPP_NOEXCEPT
632  : m_count( static_cast<uint32_t>( list.size() ) )
633  , m_ptr( list.begin() )
634  {
635  }
636 
637 # if __GNUC__ >= 9
638 # pragma GCC diagnostic pop
639 # endif
640 
641  // Any type with a .data() return type implicitly convertible to T*, and a .size() return type implicitly
642  // convertible to size_t. The const version can capture temporaries, with lifetime ending at end of statement.
643  template <typename V,
644  typename std::enable_if<std::is_convertible<decltype( std::declval<V>().data() ), T *>::value &&
645  std::is_convertible<decltype( std::declval<V>().size() ), std::size_t>::value>::type * = nullptr>
647  : m_count( static_cast<uint32_t>( v.size() ) )
648  , m_ptr( v.data() )
649  {
650  }
651 
652  const T * begin() const VULKAN_HPP_NOEXCEPT
653  {
654  return m_ptr;
655  }
656 
657  const T * end() const VULKAN_HPP_NOEXCEPT
658  {
659  return m_ptr + m_count;
660  }
661 
662  const T & front() const VULKAN_HPP_NOEXCEPT
663  {
664  VULKAN_HPP_ASSERT( m_count && m_ptr );
665  return *m_ptr;
666  }
667 
668  const T & back() const VULKAN_HPP_NOEXCEPT
669  {
670  VULKAN_HPP_ASSERT( m_count && m_ptr );
671  return *( m_ptr + m_count - 1 );
672  }
673 
675  {
676  return ( m_count == 0 );
677  }
678 
679  uint32_t size() const VULKAN_HPP_NOEXCEPT
680  {
681  return m_count;
682  }
683 
684  T const * data() const VULKAN_HPP_NOEXCEPT
685  {
686  return m_ptr;
687  }
688 
689  private:
690  uint32_t m_count;
691  T const * m_ptr;
692  };
693 
694  template <typename T>
696  {
697  public:
699  : m_count( 0 )
700  , m_ptr( nullptr )
701  {
702  }
703 
705  : m_count( 0 )
706  , m_ptr( nullptr )
707  {
708  }
709 
711  : m_count( 1 )
712  , m_ptr( &value )
713  {
714  }
715 
716  template <typename V>
717  ArrayProxyNoTemporaries( V && value ) = delete;
718 
721  : m_count( 1 )
722  , m_ptr( &value )
723  {
724  }
725 
728 
730  : m_count( count )
731  , m_ptr( ptr )
732  {
733  }
734 
737  : m_count( count )
738  , m_ptr( ptr )
739  {
740  }
741 
742  template <std::size_t C>
744  : m_count( C )
745  , m_ptr( ptr )
746  {
747  }
748 
749  template <std::size_t C>
750  ArrayProxyNoTemporaries( T( &&ptr )[C] ) = delete;
751 
754  : m_count( C )
755  , m_ptr( ptr )
756  {
757  }
758 
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 
768  ArrayProxyNoTemporaries( std::initializer_list<T> const && list ) = delete;
769 
771  ArrayProxyNoTemporaries( std::initializer_list<typename std::remove_const<T>::type> const & list ) VULKAN_HPP_NOEXCEPT
772  : m_count( static_cast<uint32_t>( list.size() ) )
773  , m_ptr( list.begin() )
774  {
775  }
776 
778  ArrayProxyNoTemporaries( std::initializer_list<typename std::remove_const<T>::type> const && list ) = delete;
779 
780  ArrayProxyNoTemporaries( std::initializer_list<T> & list ) VULKAN_HPP_NOEXCEPT
781  : m_count( static_cast<uint32_t>( list.size() ) )
782  , m_ptr( list.begin() )
783  {
784  }
785 
786  ArrayProxyNoTemporaries( std::initializer_list<T> && list ) = delete;
787 
790  : m_count( static_cast<uint32_t>( list.size() ) )
791  , m_ptr( list.begin() )
792  {
793  }
794 
796  ArrayProxyNoTemporaries( std::initializer_list<typename std::remove_const<T>::type> && list ) = delete;
797 
798  // Any type with a .data() return type implicitly convertible to T*, and a .size() return type implicitly convertible to size_t.
799  template <typename V,
800  typename std::enable_if<std::is_convertible<decltype( std::declval<V>().data() ), T *>::value &&
801  std::is_convertible<decltype( std::declval<V>().size() ), std::size_t>::value>::type * = nullptr>
803  : m_count( static_cast<uint32_t>( v.size() ) )
804  , m_ptr( v.data() )
805  {
806  }
807 
808  const T * begin() const VULKAN_HPP_NOEXCEPT
809  {
810  return m_ptr;
811  }
812 
813  const T * end() const VULKAN_HPP_NOEXCEPT
814  {
815  return m_ptr + m_count;
816  }
817 
818  const T & front() const VULKAN_HPP_NOEXCEPT
819  {
820  VULKAN_HPP_ASSERT( m_count && m_ptr );
821  return *m_ptr;
822  }
823 
824  const T & back() const VULKAN_HPP_NOEXCEPT
825  {
826  VULKAN_HPP_ASSERT( m_count && m_ptr );
827  return *( m_ptr + m_count - 1 );
828  }
829 
831  {
832  return ( m_count == 0 );
833  }
834 
835  uint32_t size() const VULKAN_HPP_NOEXCEPT
836  {
837  return m_count;
838  }
839 
841  {
842  return m_ptr;
843  }
844 
845  private:
846  uint32_t m_count;
847  T * m_ptr;
848  };
849 
850  template <typename T>
852  {
853  public:
855 
856  StridedArrayProxy( uint32_t count, T const * ptr, uint32_t stride ) VULKAN_HPP_NOEXCEPT
857  : ArrayProxy<T>( count, ptr )
858  , m_stride( stride )
859  {
860  VULKAN_HPP_ASSERT( sizeof( T ) <= stride );
861  }
862 
863  using ArrayProxy<T>::begin;
864 
865  const T * end() const VULKAN_HPP_NOEXCEPT
866  {
867  return reinterpret_cast<T const *>( static_cast<uint8_t const *>( begin() ) + size() * m_stride );
868  }
869 
870  using ArrayProxy<T>::front;
871 
872  const T & back() const VULKAN_HPP_NOEXCEPT
873  {
874  VULKAN_HPP_ASSERT( begin() && size() );
875  return *reinterpret_cast<T const *>( static_cast<uint8_t const *>( begin() ) + ( size() - 1 ) * m_stride );
876  }
877 
878  using ArrayProxy<T>::empty;
879  using ArrayProxy<T>::size;
880  using ArrayProxy<T>::data;
881 
882  uint32_t stride() const
883  {
884  return m_stride;
885  }
886 
887  private:
888  uint32_t m_stride = sizeof( T );
889  };
890 
891  template <typename RefType>
892  class Optional
893  {
894  public:
896  {
897  m_ptr = &reference;
898  }
900  {
901  m_ptr = ptr;
902  }
903  Optional( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
904  {
905  m_ptr = nullptr;
906  }
907 
908  operator RefType *() const VULKAN_HPP_NOEXCEPT
909  {
910  return m_ptr;
911  }
912  RefType const * operator->() const VULKAN_HPP_NOEXCEPT
913  {
914  return m_ptr;
915  }
916  explicit operator bool() const VULKAN_HPP_NOEXCEPT
917  {
918  return !!m_ptr;
919  }
920 
921  private:
922  RefType * m_ptr;
923  };
924 
925  template <typename X, typename Y>
927  {
928  enum
929  {
930  value = false
931  };
932  };
933 
934  template <typename Type, class...>
936  {
937  static const bool valid = false;
938  };
939 
940  template <typename Type, typename Head, typename... Tail>
941  struct IsPartOfStructureChain<Type, Head, Tail...>
942  {
944  };
945 
946  template <size_t Index, typename T, typename... ChainElements>
948  {
949  static const bool value = std::is_same<T, typename std::tuple_element<Index, std::tuple<ChainElements...>>::type>::value ||
950  StructureChainContains<Index - 1, T, ChainElements...>::value;
951  };
952 
953  template <typename T, typename... ChainElements>
954  struct StructureChainContains<0, T, ChainElements...>
955  {
956  static const bool value = std::is_same<T, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value;
957  };
958 
959  template <size_t Index, typename... ChainElements>
961  {
962  using TestType = typename std::tuple_element<Index, std::tuple<ChainElements...>>::type;
963  static const bool valid = StructExtends<TestType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value &&
964  ( TestType::allowDuplicate || !StructureChainContains<Index - 1, TestType, ChainElements...>::value ) &&
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:
979  {
980  static_assert( StructureChainValidation<sizeof...( ChainElements ) - 1, ChainElements...>::valid, "The structure chain is not valid!" );
981  link<sizeof...( ChainElements ) - 1>();
982  }
983 
984  StructureChain( StructureChain const & rhs ) VULKAN_HPP_NOEXCEPT : std::tuple<ChainElements...>( rhs )
985  {
986  static_assert( StructureChainValidation<sizeof...( ChainElements ) - 1, ChainElements...>::valid, "The structure chain is not valid!" );
987  link( &std::get<0>( *this ),
988  &std::get<0>( rhs ),
989  reinterpret_cast<VkBaseOutStructure *>( &std::get<0>( *this ) ),
990  reinterpret_cast<VkBaseInStructure const *>( &std::get<0>( rhs ) ) );
991  }
992 
993  StructureChain( StructureChain && rhs ) VULKAN_HPP_NOEXCEPT : std::tuple<ChainElements...>( std::forward<std::tuple<ChainElements...>>( rhs ) )
994  {
995  static_assert( StructureChainValidation<sizeof...( ChainElements ) - 1, ChainElements...>::valid, "The structure chain is not valid!" );
996  link( &std::get<0>( *this ),
997  &std::get<0>( rhs ),
998  reinterpret_cast<VkBaseOutStructure *>( &std::get<0>( *this ) ),
999  reinterpret_cast<VkBaseInStructure const *>( &std::get<0>( rhs ) ) );
1000  }
1001 
1002  StructureChain( ChainElements const &... elems ) VULKAN_HPP_NOEXCEPT : std::tuple<ChainElements...>( elems... )
1003  {
1004  static_assert( StructureChainValidation<sizeof...( ChainElements ) - 1, ChainElements...>::valid, "The structure chain is not valid!" );
1005  link<sizeof...( ChainElements ) - 1>();
1006  }
1007 
1009  {
1011  link( &std::get<0>( *this ),
1012  &std::get<0>( rhs ),
1013  reinterpret_cast<VkBaseOutStructure *>( &std::get<0>( *this ) ),
1014  reinterpret_cast<VkBaseInStructure const *>( &std::get<0>( rhs ) ) );
1015  return *this;
1016  }
1017 
1018  StructureChain & operator=( StructureChain && rhs ) = delete;
1019 
1020  template <typename T = typename std::tuple_element<0, std::tuple<ChainElements...>>::type, size_t Which = 0>
1022  {
1023  return std::get<ChainElementIndex<0, T, Which, void, ChainElements...>::value>( static_cast<std::tuple<ChainElements...> &>( *this ) );
1024  }
1025 
1026  template <typename T = typename std::tuple_element<0, std::tuple<ChainElements...>>::type, size_t Which = 0>
1027  T const & get() const VULKAN_HPP_NOEXCEPT
1028  {
1029  return std::get<ChainElementIndex<0, T, Which, void, ChainElements...>::value>( static_cast<std::tuple<ChainElements...> const &>( *this ) );
1030  }
1031 
1032  template <typename T0, typename T1, typename... Ts>
1033  std::tuple<T0 &, T1 &, Ts &...> get() VULKAN_HPP_NOEXCEPT
1034  {
1035  return std::tie( get<T0>(), get<T1>(), get<Ts>()... );
1036  }
1037 
1038  template <typename T0, typename T1, typename... Ts>
1039  std::tuple<T0 const &, T1 const &, Ts const &...> get() const VULKAN_HPP_NOEXCEPT
1040  {
1041  return std::tie( get<T0>(), get<T1>(), get<Ts>()... );
1042  }
1043 
1044  template <typename ClassType, size_t Which = 0>
1045  typename std::enable_if<std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value && ( Which == 0 ), bool>::type
1047  {
1048  return true;
1049  }
1050 
1051  template <typename ClassType, size_t Which = 0>
1052  typename std::enable_if<!std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value || ( Which != 0 ), bool>::type
1054  {
1055  static_assert( IsPartOfStructureChain<ClassType, ChainElements...>::valid, "Can't unlink Structure that's not part of this StructureChain!" );
1056  return isLinked( reinterpret_cast<VkBaseInStructure const *>( &get<ClassType, Which>() ) );
1057  }
1058 
1059  template <typename ClassType, size_t Which = 0>
1060  typename std::enable_if<!std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value || ( Which != 0 ), void>::type
1062  {
1063  static_assert( IsPartOfStructureChain<ClassType, ChainElements...>::valid, "Can't relink Structure that's not part of this StructureChain!" );
1064  auto pNext = reinterpret_cast<VkBaseInStructure *>( &get<ClassType, Which>() );
1065  VULKAN_HPP_ASSERT( !isLinked( pNext ) );
1066  auto & headElement = std::get<0>( static_cast<std::tuple<ChainElements...> &>( *this ) );
1067  pNext->pNext = reinterpret_cast<VkBaseInStructure const *>( headElement.pNext );
1068  headElement.pNext = pNext;
1069  }
1070 
1071  template <typename ClassType, size_t Which = 0>
1072  typename std::enable_if<!std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value || ( Which != 0 ), void>::type
1074  {
1075  static_assert( IsPartOfStructureChain<ClassType, ChainElements...>::valid, "Can't unlink Structure that's not part of this StructureChain!" );
1076  unlink( reinterpret_cast<VkBaseOutStructure const *>( &get<ClassType, Which>() ) );
1077  }
1078 
1079  private:
1080  template <int Index, typename T, int Which, typename, class First, class... Types>
1081  struct ChainElementIndex : ChainElementIndex<Index + 1, T, Which, void, Types...>
1082  {
1083  };
1084 
1085  template <int Index, typename T, int Which, class First, class... Types>
1086  struct ChainElementIndex<Index, T, Which, typename std::enable_if<!std::is_same<T, First>::value, void>::type, First, Types...>
1087  : ChainElementIndex<Index + 1, T, Which, void, Types...>
1088  {
1089  };
1090 
1091  template <int Index, typename T, int Which, class First, class... Types>
1092  struct ChainElementIndex<Index, T, Which, typename std::enable_if<std::is_same<T, First>::value, void>::type, First, Types...>
1093  : ChainElementIndex<Index + 1, T, Which - 1, void, Types...>
1094  {
1095  };
1096 
1097  template <int Index, typename T, class First, class... Types>
1098  struct ChainElementIndex<Index, T, 0, typename std::enable_if<std::is_same<T, First>::value, void>::type, First, Types...>
1099  : std::integral_constant<int, Index>
1100  {
1101  };
1102 
1103  bool isLinked( VkBaseInStructure const * pNext ) const VULKAN_HPP_NOEXCEPT
1104  {
1105  VkBaseInStructure const * elementPtr =
1106  reinterpret_cast<VkBaseInStructure const *>( &std::get<0>( static_cast<std::tuple<ChainElements...> const &>( *this ) ) );
1107  while ( elementPtr )
1108  {
1109  if ( elementPtr->pNext == pNext )
1110  {
1111  return true;
1112  }
1113  elementPtr = elementPtr->pNext;
1114  }
1115  return false;
1116  }
1117 
1118  template <size_t Index>
1120  {
1121  auto & x = std::get<Index - 1>( static_cast<std::tuple<ChainElements...> &>( *this ) );
1122  x.pNext = &std::get<Index>( static_cast<std::tuple<ChainElements...> &>( *this ) );
1123  link<Index - 1>();
1124  }
1125 
1126  template <size_t Index>
1128  {
1129  }
1130 
1131  void link( void * dstBase, void const * srcBase, VkBaseOutStructure * dst, VkBaseInStructure const * src )
1132  {
1133  while ( src->pNext )
1134  {
1135  std::ptrdiff_t offset = reinterpret_cast<char const *>( src->pNext ) - reinterpret_cast<char const *>( srcBase );
1136  dst->pNext = reinterpret_cast<VkBaseOutStructure *>( reinterpret_cast<char *>( dstBase ) + offset );
1137  dst = dst->pNext;
1138  src = src->pNext;
1139  }
1140  dst->pNext = nullptr;
1141  }
1142 
1143  void unlink( VkBaseOutStructure const * pNext ) VULKAN_HPP_NOEXCEPT
1144  {
1145  VkBaseOutStructure * elementPtr = reinterpret_cast<VkBaseOutStructure *>( &std::get<0>( static_cast<std::tuple<ChainElements...> &>( *this ) ) );
1146  while ( elementPtr && ( elementPtr->pNext != pNext ) )
1147  {
1148  elementPtr = elementPtr->pNext;
1149  }
1150  if ( elementPtr )
1151  {
1152  elementPtr->pNext = pNext->pNext;
1153  }
1154  else
1155  {
1156  VULKAN_HPP_ASSERT( false ); // fires, if the ClassType member has already been unlinked !
1157  }
1158  }
1159  };
1160 
1161 # if !defined( VULKAN_HPP_NO_SMART_HANDLE )
1162  template <typename Type, typename Dispatch>
1164 
1165  template <typename Type, typename Dispatch>
1166  class UniqueHandle : public UniqueHandleTraits<Type, Dispatch>::deleter
1167  {
1168  private:
1169  using Deleter = typename UniqueHandleTraits<Type, Dispatch>::deleter;
1170 
1171  public:
1173 
1174  UniqueHandle() : Deleter(), m_value() {}
1175 
1176  explicit UniqueHandle( Type const & value, Deleter const & deleter = Deleter() ) VULKAN_HPP_NOEXCEPT
1177  : Deleter( deleter )
1178  , m_value( value )
1179  {
1180  }
1181 
1182  UniqueHandle( UniqueHandle const & ) = delete;
1183 
1185  : Deleter( std::move( static_cast<Deleter &>( other ) ) )
1186  , m_value( other.release() )
1187  {
1188  }
1189 
1191  {
1192  if ( m_value )
1193  {
1194  this->destroy( m_value );
1195  }
1196  }
1197 
1198  UniqueHandle & operator=( UniqueHandle const & ) = delete;
1199 
1201  {
1202  reset( other.release() );
1203  *static_cast<Deleter *>( this ) = std::move( static_cast<Deleter &>( other ) );
1204  return *this;
1205  }
1206 
1207  explicit operator bool() const VULKAN_HPP_NOEXCEPT
1208  {
1209  return m_value.operator bool();
1210  }
1211 
1213  {
1214  return &m_value;
1215  }
1216 
1218  {
1219  return &m_value;
1220  }
1221 
1223  {
1224  return m_value;
1225  }
1226 
1228  {
1229  return m_value;
1230  }
1231 
1232  const Type & get() const VULKAN_HPP_NOEXCEPT
1233  {
1234  return m_value;
1235  }
1236 
1238  {
1239  return m_value;
1240  }
1241 
1242  void reset( Type const & value = Type() ) VULKAN_HPP_NOEXCEPT
1243  {
1244  if ( m_value != value )
1245  {
1246  if ( m_value )
1247  {
1248  this->destroy( m_value );
1249  }
1250  m_value = value;
1251  }
1252  }
1253 
1255  {
1256  Type value = m_value;
1257  m_value = nullptr;
1258  return value;
1259  }
1260 
1262  {
1263  std::swap( m_value, rhs.m_value );
1264  std::swap( static_cast<Deleter &>( *this ), static_cast<Deleter &>( rhs ) );
1265  }
1266 
1267  private:
1268  Type m_value;
1269  };
1270 
1271  template <typename UniqueType>
1272  VULKAN_HPP_INLINE std::vector<typename UniqueType::element_type> uniqueToRaw( std::vector<UniqueType> const & handles )
1273  {
1274  std::vector<typename UniqueType::element_type> newBuffer( handles.size() );
1275  std::transform( handles.begin(), handles.end(), newBuffer.begin(), []( UniqueType const & handle ) { return handle.get(); } );
1276  return newBuffer;
1277  }
1278 
1279  template <typename Type, typename Dispatch>
1281  {
1282  lhs.swap( rhs );
1283  }
1284 # endif
1285 #endif // VULKAN_HPP_DISABLE_ENHANCED_MODE
1286 
1288  {
1289  public:
1290  DispatchLoaderBase() = default;
1291  DispatchLoaderBase( std::nullptr_t )
1292 #if !defined( NDEBUG )
1293  : m_valid( false )
1294 #endif
1295  {
1296  }
1297 
1298 #if !defined( NDEBUG )
1299  size_t getVkHeaderVersion() const
1300  {
1301  VULKAN_HPP_ASSERT( m_valid );
1302  return vkHeaderVersion;
1303  }
1304 
1305  private:
1306  size_t vkHeaderVersion = VK_HEADER_VERSION;
1307  bool m_valid = true;
1308 #endif
1309  };
1310 
1311 #if !defined( VK_NO_PROTOTYPES )
1313  {
1314  public:
1315  //=== VK_VERSION_1_0 ===
1316 
1317  VkResult
1318  vkCreateInstance( const VkInstanceCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkInstance * pInstance ) const VULKAN_HPP_NOEXCEPT
1319  {
1320  return ::vkCreateInstance( pCreateInfo, pAllocator, pInstance );
1321  }
1322 
1323  void vkDestroyInstance( VkInstance instance, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1324  {
1325  return ::vkDestroyInstance( instance, pAllocator );
1326  }
1327 
1328  VkResult vkEnumeratePhysicalDevices( VkInstance instance, uint32_t * pPhysicalDeviceCount, VkPhysicalDevice * pPhysicalDevices ) const VULKAN_HPP_NOEXCEPT
1329  {
1330  return ::vkEnumeratePhysicalDevices( instance, pPhysicalDeviceCount, pPhysicalDevices );
1331  }
1332 
1333  void vkGetPhysicalDeviceFeatures( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures * pFeatures ) const VULKAN_HPP_NOEXCEPT
1334  {
1335  return ::vkGetPhysicalDeviceFeatures( physicalDevice, pFeatures );
1336  }
1337 
1338  void
1339  vkGetPhysicalDeviceFormatProperties( VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties * pFormatProperties ) const VULKAN_HPP_NOEXCEPT
1340  {
1341  return ::vkGetPhysicalDeviceFormatProperties( physicalDevice, format, pFormatProperties );
1342  }
1343 
1344  VkResult vkGetPhysicalDeviceImageFormatProperties( VkPhysicalDevice physicalDevice,
1345  VkFormat format,
1346  VkImageType type,
1347  VkImageTiling tiling,
1350  VkImageFormatProperties * pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
1351  {
1352  return ::vkGetPhysicalDeviceImageFormatProperties( physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties );
1353  }
1354 
1355  void vkGetPhysicalDeviceProperties( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
1356  {
1357  return ::vkGetPhysicalDeviceProperties( physicalDevice, pProperties );
1358  }
1359 
1360  void vkGetPhysicalDeviceQueueFamilyProperties( VkPhysicalDevice physicalDevice,
1361  uint32_t * pQueueFamilyPropertyCount,
1362  VkQueueFamilyProperties * pQueueFamilyProperties ) const VULKAN_HPP_NOEXCEPT
1363  {
1364  return ::vkGetPhysicalDeviceQueueFamilyProperties( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties );
1365  }
1366 
1367  void vkGetPhysicalDeviceMemoryProperties( VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties * pMemoryProperties ) const VULKAN_HPP_NOEXCEPT
1368  {
1369  return ::vkGetPhysicalDeviceMemoryProperties( physicalDevice, pMemoryProperties );
1370  }
1371 
1372  PFN_vkVoidFunction vkGetInstanceProcAddr( VkInstance instance, const char * pName ) const VULKAN_HPP_NOEXCEPT
1373  {
1374  return ::vkGetInstanceProcAddr( instance, pName );
1375  }
1376 
1377  PFN_vkVoidFunction vkGetDeviceProcAddr( VkDevice device, const char * pName ) const VULKAN_HPP_NOEXCEPT
1378  {
1379  return ::vkGetDeviceProcAddr( device, pName );
1380  }
1381 
1382  VkResult vkCreateDevice( VkPhysicalDevice physicalDevice,
1383  const VkDeviceCreateInfo * pCreateInfo,
1384  const VkAllocationCallbacks * pAllocator,
1385  VkDevice * pDevice ) const VULKAN_HPP_NOEXCEPT
1386  {
1387  return ::vkCreateDevice( physicalDevice, pCreateInfo, pAllocator, pDevice );
1388  }
1389 
1390  void vkDestroyDevice( VkDevice device, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1391  {
1392  return ::vkDestroyDevice( device, pAllocator );
1393  }
1394 
1396  uint32_t * pPropertyCount,
1397  VkExtensionProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
1398  {
1399  return ::vkEnumerateInstanceExtensionProperties( pLayerName, pPropertyCount, pProperties );
1400  }
1401 
1402  VkResult vkEnumerateDeviceExtensionProperties( VkPhysicalDevice physicalDevice,
1403  const char * pLayerName,
1404  uint32_t * pPropertyCount,
1405  VkExtensionProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
1406  {
1407  return ::vkEnumerateDeviceExtensionProperties( physicalDevice, pLayerName, pPropertyCount, pProperties );
1408  }
1409 
1410  VkResult vkEnumerateInstanceLayerProperties( uint32_t * pPropertyCount, VkLayerProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
1411  {
1412  return ::vkEnumerateInstanceLayerProperties( pPropertyCount, pProperties );
1413  }
1414 
1415  VkResult
1416  vkEnumerateDeviceLayerProperties( VkPhysicalDevice physicalDevice, uint32_t * pPropertyCount, VkLayerProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
1417  {
1418  return ::vkEnumerateDeviceLayerProperties( physicalDevice, pPropertyCount, pProperties );
1419  }
1420 
1421  void vkGetDeviceQueue( VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue * pQueue ) const VULKAN_HPP_NOEXCEPT
1422  {
1423  return ::vkGetDeviceQueue( device, queueFamilyIndex, queueIndex, pQueue );
1424  }
1425 
1426  VkResult vkQueueSubmit( VkQueue queue, uint32_t submitCount, const VkSubmitInfo * pSubmits, VkFence fence ) const VULKAN_HPP_NOEXCEPT
1427  {
1428  return ::vkQueueSubmit( queue, submitCount, pSubmits, fence );
1429  }
1430 
1432  {
1434  }
1435 
1437  {
1438  return ::vkDeviceWaitIdle( device );
1439  }
1440 
1441  VkResult vkAllocateMemory( VkDevice device,
1442  const VkMemoryAllocateInfo * pAllocateInfo,
1443  const VkAllocationCallbacks * pAllocator,
1444  VkDeviceMemory * pMemory ) const VULKAN_HPP_NOEXCEPT
1445  {
1446  return ::vkAllocateMemory( device, pAllocateInfo, pAllocator, pMemory );
1447  }
1448 
1449  void vkFreeMemory( VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1450  {
1451  return ::vkFreeMemory( device, memory, pAllocator );
1452  }
1453 
1454  VkResult vkMapMemory( VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void ** ppData ) const
1456  {
1457  return ::vkMapMemory( device, memory, offset, size, flags, ppData );
1458  }
1459 
1460  void vkUnmapMemory( VkDevice device, VkDeviceMemory memory ) const VULKAN_HPP_NOEXCEPT
1461  {
1462  return ::vkUnmapMemory( device, memory );
1463  }
1464 
1465  VkResult vkFlushMappedMemoryRanges( VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange * pMemoryRanges ) const VULKAN_HPP_NOEXCEPT
1466  {
1467  return ::vkFlushMappedMemoryRanges( device, memoryRangeCount, pMemoryRanges );
1468  }
1469 
1470  VkResult vkInvalidateMappedMemoryRanges( VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange * pMemoryRanges ) const VULKAN_HPP_NOEXCEPT
1471  {
1472  return ::vkInvalidateMappedMemoryRanges( device, memoryRangeCount, pMemoryRanges );
1473  }
1474 
1475  void vkGetDeviceMemoryCommitment( VkDevice device, VkDeviceMemory memory, VkDeviceSize * pCommittedMemoryInBytes ) const VULKAN_HPP_NOEXCEPT
1476  {
1477  return ::vkGetDeviceMemoryCommitment( device, memory, pCommittedMemoryInBytes );
1478  }
1479 
1480  VkResult vkBindBufferMemory( VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset ) const VULKAN_HPP_NOEXCEPT
1481  {
1482  return ::vkBindBufferMemory( device, buffer, memory, memoryOffset );
1483  }
1484 
1485  VkResult vkBindImageMemory( VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset ) const VULKAN_HPP_NOEXCEPT
1486  {
1487  return ::vkBindImageMemory( device, image, memory, memoryOffset );
1488  }
1489 
1490  void vkGetBufferMemoryRequirements( VkDevice device, VkBuffer buffer, VkMemoryRequirements * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
1491  {
1492  return ::vkGetBufferMemoryRequirements( device, buffer, pMemoryRequirements );
1493  }
1494 
1495  void vkGetImageMemoryRequirements( VkDevice device, VkImage image, VkMemoryRequirements * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
1496  {
1497  return ::vkGetImageMemoryRequirements( device, image, pMemoryRequirements );
1498  }
1499 
1500  void vkGetImageSparseMemoryRequirements( VkDevice device,
1501  VkImage image,
1502  uint32_t * pSparseMemoryRequirementCount,
1503  VkSparseImageMemoryRequirements * pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
1504  {
1505  return ::vkGetImageSparseMemoryRequirements( device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
1506  }
1507 
1508  void vkGetPhysicalDeviceSparseImageFormatProperties( VkPhysicalDevice physicalDevice,
1509  VkFormat format,
1510  VkImageType type,
1513  VkImageTiling tiling,
1514  uint32_t * pPropertyCount,
1516  {
1517  return ::vkGetPhysicalDeviceSparseImageFormatProperties( physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties );
1518  }
1519 
1520  VkResult vkQueueBindSparse( VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo * pBindInfo, VkFence fence ) const VULKAN_HPP_NOEXCEPT
1521  {
1522  return ::vkQueueBindSparse( queue, bindInfoCount, pBindInfo, fence );
1523  }
1524 
1525  VkResult vkCreateFence( VkDevice device,
1526  const VkFenceCreateInfo * pCreateInfo,
1527  const VkAllocationCallbacks * pAllocator,
1528  VkFence * pFence ) const VULKAN_HPP_NOEXCEPT
1529  {
1530  return ::vkCreateFence( device, pCreateInfo, pAllocator, pFence );
1531  }
1532 
1533  void vkDestroyFence( VkDevice device, VkFence fence, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1534  {
1535  return ::vkDestroyFence( device, fence, pAllocator );
1536  }
1537 
1538  VkResult vkResetFences( VkDevice device, uint32_t fenceCount, const VkFence * pFences ) const VULKAN_HPP_NOEXCEPT
1539  {
1540  return ::vkResetFences( device, fenceCount, pFences );
1541  }
1542 
1543  VkResult vkGetFenceStatus( VkDevice device, VkFence fence ) const VULKAN_HPP_NOEXCEPT
1544  {
1545  return ::vkGetFenceStatus( device, fence );
1546  }
1547 
1548  VkResult vkWaitForFences( VkDevice device, uint32_t fenceCount, const VkFence * pFences, VkBool32 waitAll, uint64_t timeout ) const VULKAN_HPP_NOEXCEPT
1549  {
1550  return ::vkWaitForFences( device, fenceCount, pFences, waitAll, timeout );
1551  }
1552 
1553  VkResult vkCreateSemaphore( VkDevice device,
1554  const VkSemaphoreCreateInfo * pCreateInfo,
1555  const VkAllocationCallbacks * pAllocator,
1556  VkSemaphore * pSemaphore ) const VULKAN_HPP_NOEXCEPT
1557  {
1558  return ::vkCreateSemaphore( device, pCreateInfo, pAllocator, pSemaphore );
1559  }
1560 
1561  void vkDestroySemaphore( VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1562  {
1563  return ::vkDestroySemaphore( device, semaphore, pAllocator );
1564  }
1565 
1566  VkResult vkCreateEvent( VkDevice device,
1567  const VkEventCreateInfo * pCreateInfo,
1568  const VkAllocationCallbacks * pAllocator,
1569  VkEvent * pEvent ) const VULKAN_HPP_NOEXCEPT
1570  {
1571  return ::vkCreateEvent( device, pCreateInfo, pAllocator, pEvent );
1572  }
1573 
1574  void vkDestroyEvent( VkDevice device, VkEvent event, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1575  {
1576  return ::vkDestroyEvent( device, event, pAllocator );
1577  }
1578 
1579  VkResult vkGetEventStatus( VkDevice device, VkEvent event ) const VULKAN_HPP_NOEXCEPT
1580  {
1581  return ::vkGetEventStatus( device, event );
1582  }
1583 
1584  VkResult vkSetEvent( VkDevice device, VkEvent event ) const VULKAN_HPP_NOEXCEPT
1585  {
1586  return ::vkSetEvent( device, event );
1587  }
1588 
1589  VkResult vkResetEvent( VkDevice device, VkEvent event ) const VULKAN_HPP_NOEXCEPT
1590  {
1591  return ::vkResetEvent( device, event );
1592  }
1593 
1594  VkResult vkCreateQueryPool( VkDevice device,
1595  const VkQueryPoolCreateInfo * pCreateInfo,
1596  const VkAllocationCallbacks * pAllocator,
1597  VkQueryPool * pQueryPool ) const VULKAN_HPP_NOEXCEPT
1598  {
1599  return ::vkCreateQueryPool( device, pCreateInfo, pAllocator, pQueryPool );
1600  }
1601 
1602  void vkDestroyQueryPool( VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1603  {
1604  return ::vkDestroyQueryPool( device, queryPool, pAllocator );
1605  }
1606 
1608  VkQueryPool queryPool,
1609  uint32_t firstQuery,
1610  uint32_t queryCount,
1611  size_t dataSize,
1612  void * pData,
1615  {
1616  return ::vkGetQueryPoolResults( device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags );
1617  }
1618 
1619  VkResult vkCreateBuffer( VkDevice device,
1620  const VkBufferCreateInfo * pCreateInfo,
1621  const VkAllocationCallbacks * pAllocator,
1622  VkBuffer * pBuffer ) const VULKAN_HPP_NOEXCEPT
1623  {
1624  return ::vkCreateBuffer( device, pCreateInfo, pAllocator, pBuffer );
1625  }
1626 
1627  void vkDestroyBuffer( VkDevice device, VkBuffer buffer, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1628  {
1629  return ::vkDestroyBuffer( device, buffer, pAllocator );
1630  }
1631 
1632  VkResult vkCreateBufferView( VkDevice device,
1633  const VkBufferViewCreateInfo * pCreateInfo,
1634  const VkAllocationCallbacks * pAllocator,
1635  VkBufferView * pView ) const VULKAN_HPP_NOEXCEPT
1636  {
1637  return ::vkCreateBufferView( device, pCreateInfo, pAllocator, pView );
1638  }
1639 
1640  void vkDestroyBufferView( VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1641  {
1642  return ::vkDestroyBufferView( device, bufferView, pAllocator );
1643  }
1644 
1645  VkResult vkCreateImage( VkDevice device,
1646  const VkImageCreateInfo * pCreateInfo,
1647  const VkAllocationCallbacks * pAllocator,
1648  VkImage * pImage ) const VULKAN_HPP_NOEXCEPT
1649  {
1650  return ::vkCreateImage( device, pCreateInfo, pAllocator, pImage );
1651  }
1652 
1653  void vkDestroyImage( VkDevice device, VkImage image, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1654  {
1655  return ::vkDestroyImage( device, image, pAllocator );
1656  }
1657 
1658  void vkGetImageSubresourceLayout( VkDevice device,
1659  VkImage image,
1660  const VkImageSubresource * pSubresource,
1661  VkSubresourceLayout * pLayout ) const VULKAN_HPP_NOEXCEPT
1662  {
1663  return ::vkGetImageSubresourceLayout( device, image, pSubresource, pLayout );
1664  }
1665 
1666  VkResult vkCreateImageView( VkDevice device,
1667  const VkImageViewCreateInfo * pCreateInfo,
1668  const VkAllocationCallbacks * pAllocator,
1669  VkImageView * pView ) const VULKAN_HPP_NOEXCEPT
1670  {
1671  return ::vkCreateImageView( device, pCreateInfo, pAllocator, pView );
1672  }
1673 
1674  void vkDestroyImageView( VkDevice device, VkImageView imageView, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1675  {
1676  return ::vkDestroyImageView( device, imageView, pAllocator );
1677  }
1678 
1679  VkResult vkCreateShaderModule( VkDevice device,
1680  const VkShaderModuleCreateInfo * pCreateInfo,
1681  const VkAllocationCallbacks * pAllocator,
1682  VkShaderModule * pShaderModule ) const VULKAN_HPP_NOEXCEPT
1683  {
1684  return ::vkCreateShaderModule( device, pCreateInfo, pAllocator, pShaderModule );
1685  }
1686 
1687  void vkDestroyShaderModule( VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1688  {
1689  return ::vkDestroyShaderModule( device, shaderModule, pAllocator );
1690  }
1691 
1693  const VkPipelineCacheCreateInfo * pCreateInfo,
1694  const VkAllocationCallbacks * pAllocator,
1695  VkPipelineCache * pPipelineCache ) const VULKAN_HPP_NOEXCEPT
1696  {
1697  return ::vkCreatePipelineCache( device, pCreateInfo, pAllocator, pPipelineCache );
1698  }
1699 
1700  void vkDestroyPipelineCache( VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1701  {
1702  return ::vkDestroyPipelineCache( device, pipelineCache, pAllocator );
1703  }
1704 
1705  VkResult vkGetPipelineCacheData( VkDevice device, VkPipelineCache pipelineCache, size_t * pDataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
1706  {
1707  return ::vkGetPipelineCacheData( device, pipelineCache, pDataSize, pData );
1708  }
1709 
1710  VkResult
1711  vkMergePipelineCaches( VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache * pSrcCaches ) const VULKAN_HPP_NOEXCEPT
1712  {
1713  return ::vkMergePipelineCaches( device, dstCache, srcCacheCount, pSrcCaches );
1714  }
1715 
1717  VkPipelineCache pipelineCache,
1718  uint32_t createInfoCount,
1719  const VkGraphicsPipelineCreateInfo * pCreateInfos,
1720  const VkAllocationCallbacks * pAllocator,
1721  VkPipeline * pPipelines ) const VULKAN_HPP_NOEXCEPT
1722  {
1723  return ::vkCreateGraphicsPipelines( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
1724  }
1725 
1727  VkPipelineCache pipelineCache,
1728  uint32_t createInfoCount,
1729  const VkComputePipelineCreateInfo * pCreateInfos,
1730  const VkAllocationCallbacks * pAllocator,
1731  VkPipeline * pPipelines ) const VULKAN_HPP_NOEXCEPT
1732  {
1733  return ::vkCreateComputePipelines( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
1734  }
1735 
1736  void vkDestroyPipeline( VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1737  {
1738  return ::vkDestroyPipeline( device, pipeline, pAllocator );
1739  }
1740 
1742  const VkPipelineLayoutCreateInfo * pCreateInfo,
1743  const VkAllocationCallbacks * pAllocator,
1744  VkPipelineLayout * pPipelineLayout ) const VULKAN_HPP_NOEXCEPT
1745  {
1746  return ::vkCreatePipelineLayout( device, pCreateInfo, pAllocator, pPipelineLayout );
1747  }
1748 
1749  void vkDestroyPipelineLayout( VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1750  {
1751  return ::vkDestroyPipelineLayout( device, pipelineLayout, pAllocator );
1752  }
1753 
1754  VkResult vkCreateSampler( VkDevice device,
1755  const VkSamplerCreateInfo * pCreateInfo,
1756  const VkAllocationCallbacks * pAllocator,
1757  VkSampler * pSampler ) const VULKAN_HPP_NOEXCEPT
1758  {
1759  return ::vkCreateSampler( device, pCreateInfo, pAllocator, pSampler );
1760  }
1761 
1762  void vkDestroySampler( VkDevice device, VkSampler sampler, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1763  {
1764  return ::vkDestroySampler( device, sampler, pAllocator );
1765  }
1766 
1768  const VkDescriptorSetLayoutCreateInfo * pCreateInfo,
1769  const VkAllocationCallbacks * pAllocator,
1770  VkDescriptorSetLayout * pSetLayout ) const VULKAN_HPP_NOEXCEPT
1771  {
1772  return ::vkCreateDescriptorSetLayout( device, pCreateInfo, pAllocator, pSetLayout );
1773  }
1774 
1775  void vkDestroyDescriptorSetLayout( VkDevice device,
1776  VkDescriptorSetLayout descriptorSetLayout,
1777  const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1778  {
1779  return ::vkDestroyDescriptorSetLayout( device, descriptorSetLayout, pAllocator );
1780  }
1781 
1783  const VkDescriptorPoolCreateInfo * pCreateInfo,
1784  const VkAllocationCallbacks * pAllocator,
1785  VkDescriptorPool * pDescriptorPool ) const VULKAN_HPP_NOEXCEPT
1786  {
1787  return ::vkCreateDescriptorPool( device, pCreateInfo, pAllocator, pDescriptorPool );
1788  }
1789 
1790  void vkDestroyDescriptorPool( VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1791  {
1792  return ::vkDestroyDescriptorPool( device, descriptorPool, pAllocator );
1793  }
1794 
1795  VkResult vkResetDescriptorPool( VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags ) const VULKAN_HPP_NOEXCEPT
1796  {
1797  return ::vkResetDescriptorPool( device, descriptorPool, flags );
1798  }
1799 
1801  const VkDescriptorSetAllocateInfo * pAllocateInfo,
1802  VkDescriptorSet * pDescriptorSets ) const VULKAN_HPP_NOEXCEPT
1803  {
1804  return ::vkAllocateDescriptorSets( device, pAllocateInfo, pDescriptorSets );
1805  }
1806 
1807  VkResult vkFreeDescriptorSets( VkDevice device,
1808  VkDescriptorPool descriptorPool,
1809  uint32_t descriptorSetCount,
1810  const VkDescriptorSet * pDescriptorSets ) const VULKAN_HPP_NOEXCEPT
1811  {
1812  return ::vkFreeDescriptorSets( device, descriptorPool, descriptorSetCount, pDescriptorSets );
1813  }
1814 
1815  void vkUpdateDescriptorSets( VkDevice device,
1816  uint32_t descriptorWriteCount,
1817  const VkWriteDescriptorSet * pDescriptorWrites,
1818  uint32_t descriptorCopyCount,
1819  const VkCopyDescriptorSet * pDescriptorCopies ) const VULKAN_HPP_NOEXCEPT
1820  {
1821  return ::vkUpdateDescriptorSets( device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies );
1822  }
1823 
1824  VkResult vkCreateFramebuffer( VkDevice device,
1825  const VkFramebufferCreateInfo * pCreateInfo,
1826  const VkAllocationCallbacks * pAllocator,
1827  VkFramebuffer * pFramebuffer ) const VULKAN_HPP_NOEXCEPT
1828  {
1829  return ::vkCreateFramebuffer( device, pCreateInfo, pAllocator, pFramebuffer );
1830  }
1831 
1832  void vkDestroyFramebuffer( VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1833  {
1834  return ::vkDestroyFramebuffer( device, framebuffer, pAllocator );
1835  }
1836 
1837  VkResult vkCreateRenderPass( VkDevice device,
1838  const VkRenderPassCreateInfo * pCreateInfo,
1839  const VkAllocationCallbacks * pAllocator,
1840  VkRenderPass * pRenderPass ) const VULKAN_HPP_NOEXCEPT
1841  {
1842  return ::vkCreateRenderPass( device, pCreateInfo, pAllocator, pRenderPass );
1843  }
1844 
1845  void vkDestroyRenderPass( VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1846  {
1847  return ::vkDestroyRenderPass( device, renderPass, pAllocator );
1848  }
1849 
1850  void vkGetRenderAreaGranularity( VkDevice device, VkRenderPass renderPass, VkExtent2D * pGranularity ) const VULKAN_HPP_NOEXCEPT
1851  {
1852  return ::vkGetRenderAreaGranularity( device, renderPass, pGranularity );
1853  }
1854 
1855  VkResult vkCreateCommandPool( VkDevice device,
1856  const VkCommandPoolCreateInfo * pCreateInfo,
1857  const VkAllocationCallbacks * pAllocator,
1858  VkCommandPool * pCommandPool ) const VULKAN_HPP_NOEXCEPT
1859  {
1860  return ::vkCreateCommandPool( device, pCreateInfo, pAllocator, pCommandPool );
1861  }
1862 
1863  void vkDestroyCommandPool( VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1864  {
1865  return ::vkDestroyCommandPool( device, commandPool, pAllocator );
1866  }
1867 
1868  VkResult vkResetCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags ) const VULKAN_HPP_NOEXCEPT
1869  {
1870  return ::vkResetCommandPool( device, commandPool, flags );
1871  }
1872 
1874  const VkCommandBufferAllocateInfo * pAllocateInfo,
1875  VkCommandBuffer * pCommandBuffers ) const VULKAN_HPP_NOEXCEPT
1876  {
1877  return ::vkAllocateCommandBuffers( device, pAllocateInfo, pCommandBuffers );
1878  }
1879 
1880  void vkFreeCommandBuffers( VkDevice device,
1881  VkCommandPool commandPool,
1882  uint32_t commandBufferCount,
1883  const VkCommandBuffer * pCommandBuffers ) const VULKAN_HPP_NOEXCEPT
1884  {
1885  return ::vkFreeCommandBuffers( device, commandPool, commandBufferCount, pCommandBuffers );
1886  }
1887 
1888  VkResult vkBeginCommandBuffer( VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo * pBeginInfo ) const VULKAN_HPP_NOEXCEPT
1889  {
1890  return ::vkBeginCommandBuffer( commandBuffer, pBeginInfo );
1891  }
1892 
1893  VkResult vkEndCommandBuffer( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
1894  {
1895  return ::vkEndCommandBuffer( commandBuffer );
1896  }
1897 
1899  {
1900  return ::vkResetCommandBuffer( commandBuffer, flags );
1901  }
1902 
1903  void vkCmdBindPipeline( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline ) const VULKAN_HPP_NOEXCEPT
1904  {
1905  return ::vkCmdBindPipeline( commandBuffer, pipelineBindPoint, pipeline );
1906  }
1907 
1908  void
1909  vkCmdSetViewport( VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport * pViewports ) const VULKAN_HPP_NOEXCEPT
1910  {
1911  return ::vkCmdSetViewport( commandBuffer, firstViewport, viewportCount, pViewports );
1912  }
1913 
1914  void vkCmdSetScissor( VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D * pScissors ) const VULKAN_HPP_NOEXCEPT
1915  {
1916  return ::vkCmdSetScissor( commandBuffer, firstScissor, scissorCount, pScissors );
1917  }
1918 
1919  void vkCmdSetLineWidth( VkCommandBuffer commandBuffer, float lineWidth ) const VULKAN_HPP_NOEXCEPT
1920  {
1921  return ::vkCmdSetLineWidth( commandBuffer, lineWidth );
1922  }
1923 
1924  void vkCmdSetDepthBias( VkCommandBuffer commandBuffer,
1925  float depthBiasConstantFactor,
1926  float depthBiasClamp,
1927  float depthBiasSlopeFactor ) const VULKAN_HPP_NOEXCEPT
1928  {
1929  return ::vkCmdSetDepthBias( commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor );
1930  }
1931 
1932  void vkCmdSetBlendConstants( VkCommandBuffer commandBuffer, const float blendConstants[4] ) const VULKAN_HPP_NOEXCEPT
1933  {
1934  return ::vkCmdSetBlendConstants( commandBuffer, blendConstants );
1935  }
1936 
1937  void vkCmdSetDepthBounds( VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds ) const VULKAN_HPP_NOEXCEPT
1938  {
1939  return ::vkCmdSetDepthBounds( commandBuffer, minDepthBounds, maxDepthBounds );
1940  }
1941 
1942  void vkCmdSetStencilCompareMask( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask ) const VULKAN_HPP_NOEXCEPT
1943  {
1944  return ::vkCmdSetStencilCompareMask( commandBuffer, faceMask, compareMask );
1945  }
1946 
1947  void vkCmdSetStencilWriteMask( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask ) const VULKAN_HPP_NOEXCEPT
1948  {
1949  return ::vkCmdSetStencilWriteMask( commandBuffer, faceMask, writeMask );
1950  }
1951 
1952  void vkCmdSetStencilReference( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference ) const VULKAN_HPP_NOEXCEPT
1953  {
1954  return ::vkCmdSetStencilReference( commandBuffer, faceMask, reference );
1955  }
1956 
1957  void vkCmdBindDescriptorSets( VkCommandBuffer commandBuffer,
1958  VkPipelineBindPoint pipelineBindPoint,
1959  VkPipelineLayout layout,
1960  uint32_t firstSet,
1961  uint32_t descriptorSetCount,
1962  const VkDescriptorSet * pDescriptorSets,
1963  uint32_t dynamicOffsetCount,
1964  const uint32_t * pDynamicOffsets ) const VULKAN_HPP_NOEXCEPT
1965  {
1967  commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets );
1968  }
1969 
1970  void vkCmdBindIndexBuffer( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType ) const VULKAN_HPP_NOEXCEPT
1971  {
1972  return ::vkCmdBindIndexBuffer( commandBuffer, buffer, offset, indexType );
1973  }
1974 
1975  void vkCmdBindVertexBuffers( VkCommandBuffer commandBuffer,
1976  uint32_t firstBinding,
1977  uint32_t bindingCount,
1978  const VkBuffer * pBuffers,
1979  const VkDeviceSize * pOffsets ) const VULKAN_HPP_NOEXCEPT
1980  {
1981  return ::vkCmdBindVertexBuffers( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets );
1982  }
1983 
1984  void vkCmdDraw( VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance ) const
1986  {
1987  return ::vkCmdDraw( commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance );
1988  }
1989 
1990  void vkCmdDrawIndexed( VkCommandBuffer commandBuffer,
1991  uint32_t indexCount,
1992  uint32_t instanceCount,
1993  uint32_t firstIndex,
1994  int32_t vertexOffset,
1995  uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT
1996  {
1997  return ::vkCmdDrawIndexed( commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance );
1998  }
1999 
2000  void vkCmdDrawIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const VULKAN_HPP_NOEXCEPT
2001  {
2002  return ::vkCmdDrawIndirect( commandBuffer, buffer, offset, drawCount, stride );
2003  }
2004 
2005  void vkCmdDrawIndexedIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const
2007  {
2008  return ::vkCmdDrawIndexedIndirect( commandBuffer, buffer, offset, drawCount, stride );
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  void vkCmdDispatchIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset ) const VULKAN_HPP_NOEXCEPT
2017  {
2018  return ::vkCmdDispatchIndirect( commandBuffer, buffer, offset );
2019  }
2020 
2021  void vkCmdCopyBuffer( VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy * pRegions ) const
2023  {
2024  return ::vkCmdCopyBuffer( commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions );
2025  }
2026 
2027  void vkCmdCopyImage( VkCommandBuffer commandBuffer,
2028  VkImage srcImage,
2029  VkImageLayout srcImageLayout,
2030  VkImage dstImage,
2031  VkImageLayout dstImageLayout,
2032  uint32_t regionCount,
2033  const VkImageCopy * pRegions ) const VULKAN_HPP_NOEXCEPT
2034  {
2035  return ::vkCmdCopyImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions );
2036  }
2037 
2038  void vkCmdBlitImage( VkCommandBuffer commandBuffer,
2039  VkImage srcImage,
2040  VkImageLayout srcImageLayout,
2041  VkImage dstImage,
2042  VkImageLayout dstImageLayout,
2043  uint32_t regionCount,
2044  const VkImageBlit * pRegions,
2046  {
2047  return ::vkCmdBlitImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter );
2048  }
2049 
2050  void vkCmdCopyBufferToImage( VkCommandBuffer commandBuffer,
2051  VkBuffer srcBuffer,
2052  VkImage dstImage,
2053  VkImageLayout dstImageLayout,
2054  uint32_t regionCount,
2055  const VkBufferImageCopy * pRegions ) const VULKAN_HPP_NOEXCEPT
2056  {
2057  return ::vkCmdCopyBufferToImage( commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions );
2058  }
2059 
2060  void vkCmdCopyImageToBuffer( VkCommandBuffer commandBuffer,
2061  VkImage srcImage,
2062  VkImageLayout srcImageLayout,
2063  VkBuffer dstBuffer,
2064  uint32_t regionCount,
2065  const VkBufferImageCopy * pRegions ) const VULKAN_HPP_NOEXCEPT
2066  {
2067  return ::vkCmdCopyImageToBuffer( commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions );
2068  }
2069 
2070  void vkCmdUpdateBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void * pData ) const
2072  {
2073  return ::vkCmdUpdateBuffer( commandBuffer, dstBuffer, dstOffset, dataSize, pData );
2074  }
2075 
2076  void
2077  vkCmdFillBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data ) const VULKAN_HPP_NOEXCEPT
2078  {
2079  return ::vkCmdFillBuffer( commandBuffer, dstBuffer, dstOffset, size, data );
2080  }
2081 
2082  void vkCmdClearColorImage( VkCommandBuffer commandBuffer,
2083  VkImage image,
2084  VkImageLayout imageLayout,
2085  const VkClearColorValue * pColor,
2086  uint32_t rangeCount,
2087  const VkImageSubresourceRange * pRanges ) const VULKAN_HPP_NOEXCEPT
2088  {
2089  return ::vkCmdClearColorImage( commandBuffer, image, imageLayout, pColor, rangeCount, pRanges );
2090  }
2091 
2092  void vkCmdClearDepthStencilImage( VkCommandBuffer commandBuffer,
2093  VkImage image,
2094  VkImageLayout imageLayout,
2095  const VkClearDepthStencilValue * pDepthStencil,
2096  uint32_t rangeCount,
2097  const VkImageSubresourceRange * pRanges ) const VULKAN_HPP_NOEXCEPT
2098  {
2099  return ::vkCmdClearDepthStencilImage( commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges );
2100  }
2101 
2102  void vkCmdClearAttachments( VkCommandBuffer commandBuffer,
2103  uint32_t attachmentCount,
2104  const VkClearAttachment * pAttachments,
2105  uint32_t rectCount,
2106  const VkClearRect * pRects ) const VULKAN_HPP_NOEXCEPT
2107  {
2108  return ::vkCmdClearAttachments( commandBuffer, attachmentCount, pAttachments, rectCount, pRects );
2109  }
2110 
2111  void vkCmdResolveImage( VkCommandBuffer commandBuffer,
2112  VkImage srcImage,
2113  VkImageLayout srcImageLayout,
2114  VkImage dstImage,
2115  VkImageLayout dstImageLayout,
2116  uint32_t regionCount,
2117  const VkImageResolve * pRegions ) const VULKAN_HPP_NOEXCEPT
2118  {
2119  return ::vkCmdResolveImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions );
2120  }
2121 
2122  void vkCmdSetEvent( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask ) const VULKAN_HPP_NOEXCEPT
2123  {
2124  return ::vkCmdSetEvent( commandBuffer, event, stageMask );
2125  }
2126 
2127  void vkCmdResetEvent( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask ) const VULKAN_HPP_NOEXCEPT
2128  {
2129  return ::vkCmdResetEvent( commandBuffer, event, stageMask );
2130  }
2131 
2132  void vkCmdWaitEvents( VkCommandBuffer commandBuffer,
2133  uint32_t eventCount,
2134  const VkEvent * pEvents,
2135  VkPipelineStageFlags srcStageMask,
2136  VkPipelineStageFlags dstStageMask,
2137  uint32_t memoryBarrierCount,
2138  const VkMemoryBarrier * pMemoryBarriers,
2139  uint32_t bufferMemoryBarrierCount,
2140  const VkBufferMemoryBarrier * pBufferMemoryBarriers,
2141  uint32_t imageMemoryBarrierCount,
2142  const VkImageMemoryBarrier * pImageMemoryBarriers ) const VULKAN_HPP_NOEXCEPT
2143  {
2144  return ::vkCmdWaitEvents( commandBuffer,
2145  eventCount,
2146  pEvents,
2147  srcStageMask,
2148  dstStageMask,
2149  memoryBarrierCount,
2150  pMemoryBarriers,
2151  bufferMemoryBarrierCount,
2152  pBufferMemoryBarriers,
2153  imageMemoryBarrierCount,
2154  pImageMemoryBarriers );
2155  }
2156 
2157  void vkCmdPipelineBarrier( VkCommandBuffer commandBuffer,
2158  VkPipelineStageFlags srcStageMask,
2159  VkPipelineStageFlags dstStageMask,
2160  VkDependencyFlags dependencyFlags,
2161  uint32_t memoryBarrierCount,
2162  const VkMemoryBarrier * pMemoryBarriers,
2163  uint32_t bufferMemoryBarrierCount,
2164  const VkBufferMemoryBarrier * pBufferMemoryBarriers,
2165  uint32_t imageMemoryBarrierCount,
2166  const VkImageMemoryBarrier * pImageMemoryBarriers ) const VULKAN_HPP_NOEXCEPT
2167  {
2168  return ::vkCmdPipelineBarrier( commandBuffer,
2169  srcStageMask,
2170  dstStageMask,
2171  dependencyFlags,
2172  memoryBarrierCount,
2173  pMemoryBarriers,
2174  bufferMemoryBarrierCount,
2175  pBufferMemoryBarriers,
2176  imageMemoryBarrierCount,
2177  pImageMemoryBarriers );
2178  }
2179 
2180  void vkCmdBeginQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags ) const VULKAN_HPP_NOEXCEPT
2181  {
2182  return ::vkCmdBeginQuery( commandBuffer, queryPool, query, flags );
2183  }
2184 
2185  void vkCmdEndQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT
2186  {
2187  return ::vkCmdEndQuery( commandBuffer, queryPool, query );
2188  }
2189 
2190  void vkCmdResetQueryPool( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT
2191  {
2192  return ::vkCmdResetQueryPool( commandBuffer, queryPool, firstQuery, queryCount );
2193  }
2194 
2195  void vkCmdWriteTimestamp( VkCommandBuffer commandBuffer,
2196  VkPipelineStageFlagBits pipelineStage,
2197  VkQueryPool queryPool,
2198  uint32_t query ) const VULKAN_HPP_NOEXCEPT
2199  {
2200  return ::vkCmdWriteTimestamp( commandBuffer, pipelineStage, queryPool, query );
2201  }
2202 
2203  void vkCmdCopyQueryPoolResults( VkCommandBuffer commandBuffer,
2204  VkQueryPool queryPool,
2205  uint32_t firstQuery,
2206  uint32_t queryCount,
2207  VkBuffer dstBuffer,
2208  VkDeviceSize dstOffset,
2211  {
2212  return ::vkCmdCopyQueryPoolResults( commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags );
2213  }
2214 
2215  void vkCmdPushConstants( VkCommandBuffer commandBuffer,
2216  VkPipelineLayout layout,
2217  VkShaderStageFlags stageFlags,
2218  uint32_t offset,
2219  uint32_t size,
2220  const void * pValues ) const VULKAN_HPP_NOEXCEPT
2221  {
2222  return ::vkCmdPushConstants( commandBuffer, layout, stageFlags, offset, size, pValues );
2223  }
2224 
2225  void vkCmdBeginRenderPass( VkCommandBuffer commandBuffer,
2226  const VkRenderPassBeginInfo * pRenderPassBegin,
2227  VkSubpassContents contents ) const VULKAN_HPP_NOEXCEPT
2228  {
2229  return ::vkCmdBeginRenderPass( commandBuffer, pRenderPassBegin, contents );
2230  }
2231 
2232  void vkCmdNextSubpass( VkCommandBuffer commandBuffer, VkSubpassContents contents ) const VULKAN_HPP_NOEXCEPT
2233  {
2234  return ::vkCmdNextSubpass( commandBuffer, contents );
2235  }
2236 
2237  void vkCmdEndRenderPass( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
2238  {
2239  return ::vkCmdEndRenderPass( commandBuffer );
2240  }
2241 
2242  void vkCmdExecuteCommands( VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer * pCommandBuffers ) const VULKAN_HPP_NOEXCEPT
2243  {
2244  return ::vkCmdExecuteCommands( commandBuffer, commandBufferCount, pCommandBuffers );
2245  }
2246 
2247  //=== VK_VERSION_1_1 ===
2248 
2250  {
2251  return ::vkEnumerateInstanceVersion( pApiVersion );
2252  }
2253 
2254  VkResult vkBindBufferMemory2( VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT
2255  {
2256  return ::vkBindBufferMemory2( device, bindInfoCount, pBindInfos );
2257  }
2258 
2259  VkResult vkBindImageMemory2( VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT
2260  {
2261  return ::vkBindImageMemory2( device, bindInfoCount, pBindInfos );
2262  }
2263 
2264  void vkGetDeviceGroupPeerMemoryFeatures( VkDevice device,
2265  uint32_t heapIndex,
2266  uint32_t localDeviceIndex,
2267  uint32_t remoteDeviceIndex,
2268  VkPeerMemoryFeatureFlags * pPeerMemoryFeatures ) const VULKAN_HPP_NOEXCEPT
2269  {
2270  return ::vkGetDeviceGroupPeerMemoryFeatures( device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures );
2271  }
2272 
2273  void vkCmdSetDeviceMask( VkCommandBuffer commandBuffer, uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT
2274  {
2275  return ::vkCmdSetDeviceMask( commandBuffer, deviceMask );
2276  }
2277 
2278  void vkCmdDispatchBase( VkCommandBuffer commandBuffer,
2279  uint32_t baseGroupX,
2280  uint32_t baseGroupY,
2281  uint32_t baseGroupZ,
2282  uint32_t groupCountX,
2283  uint32_t groupCountY,
2284  uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
2285  {
2286  return ::vkCmdDispatchBase( commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
2287  }
2288 
2290  uint32_t * pPhysicalDeviceGroupCount,
2291  VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties ) const VULKAN_HPP_NOEXCEPT
2292  {
2293  return ::vkEnumeratePhysicalDeviceGroups( instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties );
2294  }
2295 
2296  void vkGetImageMemoryRequirements2( VkDevice device,
2297  const VkImageMemoryRequirementsInfo2 * pInfo,
2298  VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
2299  {
2300  return ::vkGetImageMemoryRequirements2( device, pInfo, pMemoryRequirements );
2301  }
2302 
2303  void vkGetBufferMemoryRequirements2( VkDevice device,
2304  const VkBufferMemoryRequirementsInfo2 * pInfo,
2305  VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
2306  {
2307  return ::vkGetBufferMemoryRequirements2( device, pInfo, pMemoryRequirements );
2308  }
2309 
2312  uint32_t * pSparseMemoryRequirementCount,
2313  VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
2314  {
2315  return ::vkGetImageSparseMemoryRequirements2( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
2316  }
2317 
2318  void vkGetPhysicalDeviceFeatures2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 * pFeatures ) const VULKAN_HPP_NOEXCEPT
2319  {
2320  return ::vkGetPhysicalDeviceFeatures2( physicalDevice, pFeatures );
2321  }
2322 
2323  void vkGetPhysicalDeviceProperties2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 * pProperties ) const VULKAN_HPP_NOEXCEPT
2324  {
2325  return ::vkGetPhysicalDeviceProperties2( physicalDevice, pProperties );
2326  }
2327 
2328  void vkGetPhysicalDeviceFormatProperties2( VkPhysicalDevice physicalDevice,
2329  VkFormat format,
2330  VkFormatProperties2 * pFormatProperties ) const VULKAN_HPP_NOEXCEPT
2331  {
2332  return ::vkGetPhysicalDeviceFormatProperties2( physicalDevice, format, pFormatProperties );
2333  }
2334 
2335  VkResult vkGetPhysicalDeviceImageFormatProperties2( VkPhysicalDevice physicalDevice,
2336  const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,
2337  VkImageFormatProperties2 * pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
2338  {
2339  return ::vkGetPhysicalDeviceImageFormatProperties2( physicalDevice, pImageFormatInfo, pImageFormatProperties );
2340  }
2341 
2342  void vkGetPhysicalDeviceQueueFamilyProperties2( VkPhysicalDevice physicalDevice,
2343  uint32_t * pQueueFamilyPropertyCount,
2344  VkQueueFamilyProperties2 * pQueueFamilyProperties ) const VULKAN_HPP_NOEXCEPT
2345  {
2346  return ::vkGetPhysicalDeviceQueueFamilyProperties2( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties );
2347  }
2348 
2349  void vkGetPhysicalDeviceMemoryProperties2( VkPhysicalDevice physicalDevice,
2350  VkPhysicalDeviceMemoryProperties2 * pMemoryProperties ) const VULKAN_HPP_NOEXCEPT
2351  {
2352  return ::vkGetPhysicalDeviceMemoryProperties2( physicalDevice, pMemoryProperties );
2353  }
2354 
2355  void vkGetPhysicalDeviceSparseImageFormatProperties2( VkPhysicalDevice physicalDevice,
2356  const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
2357  uint32_t * pPropertyCount,
2359  {
2360  return ::vkGetPhysicalDeviceSparseImageFormatProperties2( physicalDevice, pFormatInfo, pPropertyCount, pProperties );
2361  }
2362 
2363  void vkTrimCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags ) const VULKAN_HPP_NOEXCEPT
2364  {
2365  return ::vkTrimCommandPool( device, commandPool, flags );
2366  }
2367 
2368  void vkGetDeviceQueue2( VkDevice device, const VkDeviceQueueInfo2 * pQueueInfo, VkQueue * pQueue ) const VULKAN_HPP_NOEXCEPT
2369  {
2370  return ::vkGetDeviceQueue2( device, pQueueInfo, pQueue );
2371  }
2372 
2374  const VkSamplerYcbcrConversionCreateInfo * pCreateInfo,
2375  const VkAllocationCallbacks * pAllocator,
2376  VkSamplerYcbcrConversion * pYcbcrConversion ) const VULKAN_HPP_NOEXCEPT
2377  {
2378  return ::vkCreateSamplerYcbcrConversion( device, pCreateInfo, pAllocator, pYcbcrConversion );
2379  }
2380 
2381  void vkDestroySamplerYcbcrConversion( VkDevice device,
2382  VkSamplerYcbcrConversion ycbcrConversion,
2383  const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
2384  {
2385  return ::vkDestroySamplerYcbcrConversion( device, ycbcrConversion, pAllocator );
2386  }
2387 
2389  const VkDescriptorUpdateTemplateCreateInfo * pCreateInfo,
2390  const VkAllocationCallbacks * pAllocator,
2391  VkDescriptorUpdateTemplate * pDescriptorUpdateTemplate ) const VULKAN_HPP_NOEXCEPT
2392  {
2393  return ::vkCreateDescriptorUpdateTemplate( device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate );
2394  }
2395 
2396  void vkDestroyDescriptorUpdateTemplate( VkDevice device,
2397  VkDescriptorUpdateTemplate descriptorUpdateTemplate,
2398  const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
2399  {
2400  return ::vkDestroyDescriptorUpdateTemplate( device, descriptorUpdateTemplate, pAllocator );
2401  }
2402 
2403  void vkUpdateDescriptorSetWithTemplate( VkDevice device,
2404  VkDescriptorSet descriptorSet,
2405  VkDescriptorUpdateTemplate descriptorUpdateTemplate,
2406  const void * pData ) const VULKAN_HPP_NOEXCEPT
2407  {
2408  return ::vkUpdateDescriptorSetWithTemplate( device, descriptorSet, descriptorUpdateTemplate, pData );
2409  }
2410 
2411  void vkGetPhysicalDeviceExternalBufferProperties( VkPhysicalDevice physicalDevice,
2412  const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
2413  VkExternalBufferProperties * pExternalBufferProperties ) const VULKAN_HPP_NOEXCEPT
2414  {
2415  return ::vkGetPhysicalDeviceExternalBufferProperties( physicalDevice, pExternalBufferInfo, pExternalBufferProperties );
2416  }
2417 
2418  void vkGetPhysicalDeviceExternalFenceProperties( VkPhysicalDevice physicalDevice,
2419  const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,
2420  VkExternalFenceProperties * pExternalFenceProperties ) const VULKAN_HPP_NOEXCEPT
2421  {
2422  return ::vkGetPhysicalDeviceExternalFenceProperties( physicalDevice, pExternalFenceInfo, pExternalFenceProperties );
2423  }
2424 
2425  void vkGetPhysicalDeviceExternalSemaphoreProperties( VkPhysicalDevice physicalDevice,
2426  const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,
2427  VkExternalSemaphoreProperties * pExternalSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT
2428  {
2429  return ::vkGetPhysicalDeviceExternalSemaphoreProperties( physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties );
2430  }
2431 
2432  void vkGetDescriptorSetLayoutSupport( VkDevice device,
2433  const VkDescriptorSetLayoutCreateInfo * pCreateInfo,
2435  {
2436  return ::vkGetDescriptorSetLayoutSupport( device, pCreateInfo, pSupport );
2437  }
2438 
2439  //=== VK_VERSION_1_2 ===
2440 
2441  void vkCmdDrawIndirectCount( VkCommandBuffer commandBuffer,
2442  VkBuffer buffer,
2444  VkBuffer countBuffer,
2445  VkDeviceSize countBufferOffset,
2446  uint32_t maxDrawCount,
2447  uint32_t stride ) const VULKAN_HPP_NOEXCEPT
2448  {
2449  return ::vkCmdDrawIndirectCount( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
2450  }
2451 
2452  void vkCmdDrawIndexedIndirectCount( VkCommandBuffer commandBuffer,
2453  VkBuffer buffer,
2455  VkBuffer countBuffer,
2456  VkDeviceSize countBufferOffset,
2457  uint32_t maxDrawCount,
2458  uint32_t stride ) const VULKAN_HPP_NOEXCEPT
2459  {
2460  return ::vkCmdDrawIndexedIndirectCount( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
2461  }
2462 
2463  VkResult vkCreateRenderPass2( VkDevice device,
2464  const VkRenderPassCreateInfo2 * pCreateInfo,
2465  const VkAllocationCallbacks * pAllocator,
2466  VkRenderPass * pRenderPass ) const VULKAN_HPP_NOEXCEPT
2467  {
2468  return ::vkCreateRenderPass2( device, pCreateInfo, pAllocator, pRenderPass );
2469  }
2470 
2471  void vkCmdBeginRenderPass2( VkCommandBuffer commandBuffer,
2472  const VkRenderPassBeginInfo * pRenderPassBegin,
2473  const VkSubpassBeginInfo * pSubpassBeginInfo ) const VULKAN_HPP_NOEXCEPT
2474  {
2475  return ::vkCmdBeginRenderPass2( commandBuffer, pRenderPassBegin, pSubpassBeginInfo );
2476  }
2477 
2478  void vkCmdNextSubpass2( VkCommandBuffer commandBuffer,
2479  const VkSubpassBeginInfo * pSubpassBeginInfo,
2480  const VkSubpassEndInfo * pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT
2481  {
2482  return ::vkCmdNextSubpass2( commandBuffer, pSubpassBeginInfo, pSubpassEndInfo );
2483  }
2484 
2485  void vkCmdEndRenderPass2( VkCommandBuffer commandBuffer, const VkSubpassEndInfo * pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT
2486  {
2487  return ::vkCmdEndRenderPass2( commandBuffer, pSubpassEndInfo );
2488  }
2489 
2490  void vkResetQueryPool( VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT
2491  {
2492  return ::vkResetQueryPool( device, queryPool, firstQuery, queryCount );
2493  }
2494 
2495  VkResult vkGetSemaphoreCounterValue( VkDevice device, VkSemaphore semaphore, uint64_t * pValue ) const VULKAN_HPP_NOEXCEPT
2496  {
2497  return ::vkGetSemaphoreCounterValue( device, semaphore, pValue );
2498  }
2499 
2500  VkResult vkWaitSemaphores( VkDevice device, const VkSemaphoreWaitInfo * pWaitInfo, uint64_t timeout ) const VULKAN_HPP_NOEXCEPT
2501  {
2502  return ::vkWaitSemaphores( device, pWaitInfo, timeout );
2503  }
2504 
2505  VkResult vkSignalSemaphore( VkDevice device, const VkSemaphoreSignalInfo * pSignalInfo ) const VULKAN_HPP_NOEXCEPT
2506  {
2507  return ::vkSignalSemaphore( device, pSignalInfo );
2508  }
2509 
2511  {
2512  return ::vkGetBufferDeviceAddress( device, pInfo );
2513  }
2514 
2515  uint64_t vkGetBufferOpaqueCaptureAddress( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
2516  {
2518  }
2519 
2521  {
2523  }
2524 
2525  //=== VK_VERSION_1_3 ===
2526 
2527  VkResult vkGetPhysicalDeviceToolProperties( VkPhysicalDevice physicalDevice,
2528  uint32_t * pToolCount,
2529  VkPhysicalDeviceToolProperties * pToolProperties ) const VULKAN_HPP_NOEXCEPT
2530  {
2531  return ::vkGetPhysicalDeviceToolProperties( physicalDevice, pToolCount, pToolProperties );
2532  }
2533 
2535  const VkPrivateDataSlotCreateInfo * pCreateInfo,
2536  const VkAllocationCallbacks * pAllocator,
2537  VkPrivateDataSlot * pPrivateDataSlot ) const VULKAN_HPP_NOEXCEPT
2538  {
2539  return ::vkCreatePrivateDataSlot( device, pCreateInfo, pAllocator, pPrivateDataSlot );
2540  }
2541 
2542  void vkDestroyPrivateDataSlot( VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
2543  {
2544  return ::vkDestroyPrivateDataSlot( device, privateDataSlot, pAllocator );
2545  }
2546 
2547  VkResult vkSetPrivateData( VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data ) const
2549  {
2550  return ::vkSetPrivateData( device, objectType, objectHandle, privateDataSlot, data );
2551  }
2552 
2553  void vkGetPrivateData( VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t * pData ) const
2555  {
2556  return ::vkGetPrivateData( device, objectType, objectHandle, privateDataSlot, pData );
2557  }
2558 
2559  void vkCmdSetEvent2( VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT
2560  {
2561  return ::vkCmdSetEvent2( commandBuffer, event, pDependencyInfo );
2562  }
2563 
2564  void vkCmdResetEvent2( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask ) const VULKAN_HPP_NOEXCEPT
2565  {
2566  return ::vkCmdResetEvent2( commandBuffer, event, stageMask );
2567  }
2568 
2569  void vkCmdWaitEvents2( VkCommandBuffer commandBuffer,
2570  uint32_t eventCount,
2571  const VkEvent * pEvents,
2572  const VkDependencyInfo * pDependencyInfos ) const VULKAN_HPP_NOEXCEPT
2573  {
2574  return ::vkCmdWaitEvents2( commandBuffer, eventCount, pEvents, pDependencyInfos );
2575  }
2576 
2577  void vkCmdPipelineBarrier2( VkCommandBuffer commandBuffer, const VkDependencyInfo * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT
2578  {
2579  return ::vkCmdPipelineBarrier2( commandBuffer, pDependencyInfo );
2580  }
2581 
2582  void vkCmdWriteTimestamp2( VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT
2583  {
2584  return ::vkCmdWriteTimestamp2( commandBuffer, stage, queryPool, query );
2585  }
2586 
2587  VkResult vkQueueSubmit2( VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 * pSubmits, VkFence fence ) const VULKAN_HPP_NOEXCEPT
2588  {
2589  return ::vkQueueSubmit2( queue, submitCount, pSubmits, fence );
2590  }
2591 
2592  void vkCmdCopyBuffer2( VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 * pCopyBufferInfo ) const VULKAN_HPP_NOEXCEPT
2593  {
2594  return ::vkCmdCopyBuffer2( commandBuffer, pCopyBufferInfo );
2595  }
2596 
2597  void vkCmdCopyImage2( VkCommandBuffer commandBuffer, const VkCopyImageInfo2 * pCopyImageInfo ) const VULKAN_HPP_NOEXCEPT
2598  {
2599  return ::vkCmdCopyImage2( commandBuffer, pCopyImageInfo );
2600  }
2601 
2602  void vkCmdCopyBufferToImage2( VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 * pCopyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT
2603  {
2604  return ::vkCmdCopyBufferToImage2( commandBuffer, pCopyBufferToImageInfo );
2605  }
2606 
2607  void vkCmdCopyImageToBuffer2( VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 * pCopyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT
2608  {
2609  return ::vkCmdCopyImageToBuffer2( commandBuffer, pCopyImageToBufferInfo );
2610  }
2611 
2612  void vkCmdBlitImage2( VkCommandBuffer commandBuffer, const VkBlitImageInfo2 * pBlitImageInfo ) const VULKAN_HPP_NOEXCEPT
2613  {
2614  return ::vkCmdBlitImage2( commandBuffer, pBlitImageInfo );
2615  }
2616 
2617  void vkCmdResolveImage2( VkCommandBuffer commandBuffer, const VkResolveImageInfo2 * pResolveImageInfo ) const VULKAN_HPP_NOEXCEPT
2618  {
2619  return ::vkCmdResolveImage2( commandBuffer, pResolveImageInfo );
2620  }
2621 
2622  void vkCmdBeginRendering( VkCommandBuffer commandBuffer, const VkRenderingInfo * pRenderingInfo ) const VULKAN_HPP_NOEXCEPT
2623  {
2624  return ::vkCmdBeginRendering( commandBuffer, pRenderingInfo );
2625  }
2626 
2627  void vkCmdEndRendering( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
2628  {
2629  return ::vkCmdEndRendering( commandBuffer );
2630  }
2631 
2632  void vkCmdSetCullMode( VkCommandBuffer commandBuffer, VkCullModeFlags cullMode ) const VULKAN_HPP_NOEXCEPT
2633  {
2634  return ::vkCmdSetCullMode( commandBuffer, cullMode );
2635  }
2636 
2637  void vkCmdSetFrontFace( VkCommandBuffer commandBuffer, VkFrontFace frontFace ) const VULKAN_HPP_NOEXCEPT
2638  {
2639  return ::vkCmdSetFrontFace( commandBuffer, frontFace );
2640  }
2641 
2642  void vkCmdSetPrimitiveTopology( VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT
2643  {
2644  return ::vkCmdSetPrimitiveTopology( commandBuffer, primitiveTopology );
2645  }
2646 
2647  void vkCmdSetViewportWithCount( VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport * pViewports ) const VULKAN_HPP_NOEXCEPT
2648  {
2649  return ::vkCmdSetViewportWithCount( commandBuffer, viewportCount, pViewports );
2650  }
2651 
2652  void vkCmdSetScissorWithCount( VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D * pScissors ) const VULKAN_HPP_NOEXCEPT
2653  {
2654  return ::vkCmdSetScissorWithCount( commandBuffer, scissorCount, pScissors );
2655  }
2656 
2657  void vkCmdBindVertexBuffers2( VkCommandBuffer commandBuffer,
2658  uint32_t firstBinding,
2659  uint32_t bindingCount,
2660  const VkBuffer * pBuffers,
2661  const VkDeviceSize * pOffsets,
2662  const VkDeviceSize * pSizes,
2663  const VkDeviceSize * pStrides ) const VULKAN_HPP_NOEXCEPT
2664  {
2665  return ::vkCmdBindVertexBuffers2( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides );
2666  }
2667 
2668  void vkCmdSetDepthTestEnable( VkCommandBuffer commandBuffer, VkBool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT
2669  {
2670  return ::vkCmdSetDepthTestEnable( commandBuffer, depthTestEnable );
2671  }
2672 
2673  void vkCmdSetDepthWriteEnable( VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT
2674  {
2675  return ::vkCmdSetDepthWriteEnable( commandBuffer, depthWriteEnable );
2676  }
2677 
2678  void vkCmdSetDepthCompareOp( VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT
2679  {
2680  return ::vkCmdSetDepthCompareOp( commandBuffer, depthCompareOp );
2681  }
2682 
2683  void vkCmdSetDepthBoundsTestEnable( VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT
2684  {
2685  return ::vkCmdSetDepthBoundsTestEnable( commandBuffer, depthBoundsTestEnable );
2686  }
2687 
2688  void vkCmdSetStencilTestEnable( VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT
2689  {
2690  return ::vkCmdSetStencilTestEnable( commandBuffer, stencilTestEnable );
2691  }
2692 
2693  void vkCmdSetStencilOp( VkCommandBuffer commandBuffer,
2694  VkStencilFaceFlags faceMask,
2695  VkStencilOp failOp,
2696  VkStencilOp passOp,
2697  VkStencilOp depthFailOp,
2698  VkCompareOp compareOp ) const VULKAN_HPP_NOEXCEPT
2699  {
2700  return ::vkCmdSetStencilOp( commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp );
2701  }
2702 
2703  void vkCmdSetRasterizerDiscardEnable( VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT
2704  {
2705  return ::vkCmdSetRasterizerDiscardEnable( commandBuffer, rasterizerDiscardEnable );
2706  }
2707 
2708  void vkCmdSetDepthBiasEnable( VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT
2709  {
2710  return ::vkCmdSetDepthBiasEnable( commandBuffer, depthBiasEnable );
2711  }
2712 
2713  void vkCmdSetPrimitiveRestartEnable( VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT
2714  {
2715  return ::vkCmdSetPrimitiveRestartEnable( commandBuffer, primitiveRestartEnable );
2716  }
2717 
2719  const VkDeviceBufferMemoryRequirements * pInfo,
2720  VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
2721  {
2722  return ::vkGetDeviceBufferMemoryRequirements( device, pInfo, pMemoryRequirements );
2723  }
2724 
2725  void vkGetDeviceImageMemoryRequirements( VkDevice device,
2726  const VkDeviceImageMemoryRequirements * pInfo,
2727  VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
2728  {
2729  return ::vkGetDeviceImageMemoryRequirements( device, pInfo, pMemoryRequirements );
2730  }
2731 
2733  const VkDeviceImageMemoryRequirements * pInfo,
2734  uint32_t * pSparseMemoryRequirementCount,
2735  VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
2736  {
2737  return ::vkGetDeviceImageSparseMemoryRequirements( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
2738  }
2739 
2740  //=== VK_KHR_surface ===
2741 
2742  void vkDestroySurfaceKHR( VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
2743  {
2744  return ::vkDestroySurfaceKHR( instance, surface, pAllocator );
2745  }
2746 
2747  VkResult vkGetPhysicalDeviceSurfaceSupportKHR( VkPhysicalDevice physicalDevice,
2748  uint32_t queueFamilyIndex,
2749  VkSurfaceKHR surface,
2750  VkBool32 * pSupported ) const VULKAN_HPP_NOEXCEPT
2751  {
2752  return ::vkGetPhysicalDeviceSurfaceSupportKHR( physicalDevice, queueFamilyIndex, surface, pSupported );
2753  }
2754 
2755  VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR( VkPhysicalDevice physicalDevice,
2756  VkSurfaceKHR surface,
2757  VkSurfaceCapabilitiesKHR * pSurfaceCapabilities ) const VULKAN_HPP_NOEXCEPT
2758  {
2759  return ::vkGetPhysicalDeviceSurfaceCapabilitiesKHR( physicalDevice, surface, pSurfaceCapabilities );
2760  }
2761 
2762  VkResult vkGetPhysicalDeviceSurfaceFormatsKHR( VkPhysicalDevice physicalDevice,
2763  VkSurfaceKHR surface,
2764  uint32_t * pSurfaceFormatCount,
2765  VkSurfaceFormatKHR * pSurfaceFormats ) const VULKAN_HPP_NOEXCEPT
2766  {
2767  return ::vkGetPhysicalDeviceSurfaceFormatsKHR( physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats );
2768  }
2769 
2770  VkResult vkGetPhysicalDeviceSurfacePresentModesKHR( VkPhysicalDevice physicalDevice,
2771  VkSurfaceKHR surface,
2772  uint32_t * pPresentModeCount,
2773  VkPresentModeKHR * pPresentModes ) const VULKAN_HPP_NOEXCEPT
2774  {
2775  return ::vkGetPhysicalDeviceSurfacePresentModesKHR( physicalDevice, surface, pPresentModeCount, pPresentModes );
2776  }
2777 
2778  //=== VK_KHR_swapchain ===
2779 
2780  VkResult vkCreateSwapchainKHR( VkDevice device,
2781  const VkSwapchainCreateInfoKHR * pCreateInfo,
2782  const VkAllocationCallbacks * pAllocator,
2783  VkSwapchainKHR * pSwapchain ) const VULKAN_HPP_NOEXCEPT
2784  {
2785  return ::vkCreateSwapchainKHR( device, pCreateInfo, pAllocator, pSwapchain );
2786  }
2787 
2788  void vkDestroySwapchainKHR( VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
2789  {
2790  return ::vkDestroySwapchainKHR( device, swapchain, pAllocator );
2791  }
2792 
2794  VkSwapchainKHR swapchain,
2795  uint32_t * pSwapchainImageCount,
2796  VkImage * pSwapchainImages ) const VULKAN_HPP_NOEXCEPT
2797  {
2798  return ::vkGetSwapchainImagesKHR( device, swapchain, pSwapchainImageCount, pSwapchainImages );
2799  }
2800 
2802  VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t * pImageIndex ) const VULKAN_HPP_NOEXCEPT
2803  {
2804  return ::vkAcquireNextImageKHR( device, swapchain, timeout, semaphore, fence, pImageIndex );
2805  }
2806 
2808  {
2809  return ::vkQueuePresentKHR( queue, pPresentInfo );
2810  }
2811 
2813  VkDeviceGroupPresentCapabilitiesKHR * pDeviceGroupPresentCapabilities ) const VULKAN_HPP_NOEXCEPT
2814  {
2815  return ::vkGetDeviceGroupPresentCapabilitiesKHR( device, pDeviceGroupPresentCapabilities );
2816  }
2817 
2818  VkResult
2820  {
2822  }
2823 
2824  VkResult vkGetPhysicalDevicePresentRectanglesKHR( VkPhysicalDevice physicalDevice,
2825  VkSurfaceKHR surface,
2826  uint32_t * pRectCount,
2827  VkRect2D * pRects ) const VULKAN_HPP_NOEXCEPT
2828  {
2829  return ::vkGetPhysicalDevicePresentRectanglesKHR( physicalDevice, surface, pRectCount, pRects );
2830  }
2831 
2832  VkResult vkAcquireNextImage2KHR( VkDevice device, const VkAcquireNextImageInfoKHR * pAcquireInfo, uint32_t * pImageIndex ) const VULKAN_HPP_NOEXCEPT
2833  {
2834  return ::vkAcquireNextImage2KHR( device, pAcquireInfo, pImageIndex );
2835  }
2836 
2837  //=== VK_KHR_display ===
2838 
2839  VkResult vkGetPhysicalDeviceDisplayPropertiesKHR( VkPhysicalDevice physicalDevice,
2840  uint32_t * pPropertyCount,
2841  VkDisplayPropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT
2842  {
2843  return ::vkGetPhysicalDeviceDisplayPropertiesKHR( physicalDevice, pPropertyCount, pProperties );
2844  }
2845 
2846  VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR( VkPhysicalDevice physicalDevice,
2847  uint32_t * pPropertyCount,
2848  VkDisplayPlanePropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT
2849  {
2850  return ::vkGetPhysicalDeviceDisplayPlanePropertiesKHR( physicalDevice, pPropertyCount, pProperties );
2851  }
2852 
2853  VkResult vkGetDisplayPlaneSupportedDisplaysKHR( VkPhysicalDevice physicalDevice,
2854  uint32_t planeIndex,
2855  uint32_t * pDisplayCount,
2856  VkDisplayKHR * pDisplays ) const VULKAN_HPP_NOEXCEPT
2857  {
2858  return ::vkGetDisplayPlaneSupportedDisplaysKHR( physicalDevice, planeIndex, pDisplayCount, pDisplays );
2859  }
2860 
2861  VkResult vkGetDisplayModePropertiesKHR( VkPhysicalDevice physicalDevice,
2862  VkDisplayKHR display,
2863  uint32_t * pPropertyCount,
2864  VkDisplayModePropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT
2865  {
2866  return ::vkGetDisplayModePropertiesKHR( physicalDevice, display, pPropertyCount, pProperties );
2867  }
2868 
2869  VkResult vkCreateDisplayModeKHR( VkPhysicalDevice physicalDevice,
2870  VkDisplayKHR display,
2871  const VkDisplayModeCreateInfoKHR * pCreateInfo,
2872  const VkAllocationCallbacks * pAllocator,
2873  VkDisplayModeKHR * pMode ) const VULKAN_HPP_NOEXCEPT
2874  {
2875  return ::vkCreateDisplayModeKHR( physicalDevice, display, pCreateInfo, pAllocator, pMode );
2876  }
2877 
2878  VkResult vkGetDisplayPlaneCapabilitiesKHR( VkPhysicalDevice physicalDevice,
2879  VkDisplayModeKHR mode,
2880  uint32_t planeIndex,
2881  VkDisplayPlaneCapabilitiesKHR * pCapabilities ) const VULKAN_HPP_NOEXCEPT
2882  {
2883  return ::vkGetDisplayPlaneCapabilitiesKHR( physicalDevice, mode, planeIndex, pCapabilities );
2884  }
2885 
2887  const VkDisplaySurfaceCreateInfoKHR * pCreateInfo,
2888  const VkAllocationCallbacks * pAllocator,
2889  VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
2890  {
2891  return ::vkCreateDisplayPlaneSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
2892  }
2893 
2894  //=== VK_KHR_display_swapchain ===
2895 
2897  uint32_t swapchainCount,
2898  const VkSwapchainCreateInfoKHR * pCreateInfos,
2899  const VkAllocationCallbacks * pAllocator,
2900  VkSwapchainKHR * pSwapchains ) const VULKAN_HPP_NOEXCEPT
2901  {
2902  return ::vkCreateSharedSwapchainsKHR( device, swapchainCount, pCreateInfos, pAllocator, pSwapchains );
2903  }
2904 
2905 # if defined( VK_USE_PLATFORM_XLIB_KHR )
2906  //=== VK_KHR_xlib_surface ===
2907 
2908  VkResult vkCreateXlibSurfaceKHR( VkInstance instance,
2909  const VkXlibSurfaceCreateInfoKHR * pCreateInfo,
2910  const VkAllocationCallbacks * pAllocator,
2911  VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
2912  {
2913  return ::vkCreateXlibSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
2914  }
2915 
2916  VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR( VkPhysicalDevice physicalDevice,
2917  uint32_t queueFamilyIndex,
2918  Display * dpy,
2919  VisualID visualID ) const VULKAN_HPP_NOEXCEPT
2920  {
2921  return ::vkGetPhysicalDeviceXlibPresentationSupportKHR( physicalDevice, queueFamilyIndex, dpy, visualID );
2922  }
2923 # endif /*VK_USE_PLATFORM_XLIB_KHR*/
2924 
2925 # if defined( VK_USE_PLATFORM_XCB_KHR )
2926  //=== VK_KHR_xcb_surface ===
2927 
2928  VkResult vkCreateXcbSurfaceKHR( VkInstance instance,
2929  const VkXcbSurfaceCreateInfoKHR * pCreateInfo,
2930  const VkAllocationCallbacks * pAllocator,
2931  VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
2932  {
2933  return ::vkCreateXcbSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
2934  }
2935 
2936  VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR( VkPhysicalDevice physicalDevice,
2937  uint32_t queueFamilyIndex,
2938  xcb_connection_t * connection,
2939  xcb_visualid_t visual_id ) const VULKAN_HPP_NOEXCEPT
2940  {
2941  return ::vkGetPhysicalDeviceXcbPresentationSupportKHR( physicalDevice, queueFamilyIndex, connection, visual_id );
2942  }
2943 # endif /*VK_USE_PLATFORM_XCB_KHR*/
2944 
2945 # if defined( VK_USE_PLATFORM_WAYLAND_KHR )
2946  //=== VK_KHR_wayland_surface ===
2947 
2948  VkResult vkCreateWaylandSurfaceKHR( VkInstance instance,
2949  const VkWaylandSurfaceCreateInfoKHR * pCreateInfo,
2950  const VkAllocationCallbacks * pAllocator,
2951  VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
2952  {
2953  return ::vkCreateWaylandSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
2954  }
2955 
2956  VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR( VkPhysicalDevice physicalDevice,
2957  uint32_t queueFamilyIndex,
2958  struct wl_display * display ) const VULKAN_HPP_NOEXCEPT
2959  {
2960  return ::vkGetPhysicalDeviceWaylandPresentationSupportKHR( physicalDevice, queueFamilyIndex, display );
2961  }
2962 # endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
2963 
2964 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
2965  //=== VK_KHR_android_surface ===
2966 
2967  VkResult vkCreateAndroidSurfaceKHR( VkInstance instance,
2968  const VkAndroidSurfaceCreateInfoKHR * pCreateInfo,
2969  const VkAllocationCallbacks * pAllocator,
2970  VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
2971  {
2972  return ::vkCreateAndroidSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
2973  }
2974 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
2975 
2976 # if defined( VK_USE_PLATFORM_WIN32_KHR )
2977  //=== VK_KHR_win32_surface ===
2978 
2979  VkResult vkCreateWin32SurfaceKHR( VkInstance instance,
2980  const VkWin32SurfaceCreateInfoKHR * pCreateInfo,
2981  const VkAllocationCallbacks * pAllocator,
2982  VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
2983  {
2984  return ::vkCreateWin32SurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
2985  }
2986 
2987  VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex ) const VULKAN_HPP_NOEXCEPT
2988  {
2989  return ::vkGetPhysicalDeviceWin32PresentationSupportKHR( physicalDevice, queueFamilyIndex );
2990  }
2991 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
2992 
2993  //=== VK_EXT_debug_report ===
2994 
2996  const VkDebugReportCallbackCreateInfoEXT * pCreateInfo,
2997  const VkAllocationCallbacks * pAllocator,
2998  VkDebugReportCallbackEXT * pCallback ) const VULKAN_HPP_NOEXCEPT
2999  {
3000  return ::vkCreateDebugReportCallbackEXT( instance, pCreateInfo, pAllocator, pCallback );
3001  }
3002 
3003  void vkDestroyDebugReportCallbackEXT( VkInstance instance,
3004  VkDebugReportCallbackEXT callback,
3005  const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
3006  {
3007  return ::vkDestroyDebugReportCallbackEXT( instance, callback, pAllocator );
3008  }
3009 
3010  void vkDebugReportMessageEXT( VkInstance instance,
3012  VkDebugReportObjectTypeEXT objectType,
3013  uint64_t object,
3014  size_t location,
3015  int32_t messageCode,
3016  const char * pLayerPrefix,
3017  const char * pMessage ) const VULKAN_HPP_NOEXCEPT
3018  {
3019  return ::vkDebugReportMessageEXT( instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage );
3020  }
3021 
3022  //=== VK_EXT_debug_marker ===
3023 
3025  {
3026  return ::vkDebugMarkerSetObjectTagEXT( device, pTagInfo );
3027  }
3028 
3030  {
3031  return ::vkDebugMarkerSetObjectNameEXT( device, pNameInfo );
3032  }
3033 
3034  void vkCmdDebugMarkerBeginEXT( VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT
3035  {
3036  return ::vkCmdDebugMarkerBeginEXT( commandBuffer, pMarkerInfo );
3037  }
3038 
3039  void vkCmdDebugMarkerEndEXT( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
3040  {
3041  return ::vkCmdDebugMarkerEndEXT( commandBuffer );
3042  }
3043 
3044  void vkCmdDebugMarkerInsertEXT( VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT
3045  {
3046  return ::vkCmdDebugMarkerInsertEXT( commandBuffer, pMarkerInfo );
3047  }
3048 
3049 # if defined( VK_ENABLE_BETA_EXTENSIONS )
3050  //=== VK_KHR_video_queue ===
3051 
3052  VkResult vkGetPhysicalDeviceVideoCapabilitiesKHR( VkPhysicalDevice physicalDevice,
3053  const VkVideoProfileInfoKHR * pVideoProfile,
3054  VkVideoCapabilitiesKHR * pCapabilities ) const VULKAN_HPP_NOEXCEPT
3055  {
3056  return ::vkGetPhysicalDeviceVideoCapabilitiesKHR( physicalDevice, pVideoProfile, pCapabilities );
3057  }
3058 
3059  VkResult vkGetPhysicalDeviceVideoFormatPropertiesKHR( VkPhysicalDevice physicalDevice,
3060  const VkPhysicalDeviceVideoFormatInfoKHR * pVideoFormatInfo,
3061  uint32_t * pVideoFormatPropertyCount,
3062  VkVideoFormatPropertiesKHR * pVideoFormatProperties ) const VULKAN_HPP_NOEXCEPT
3063  {
3064  return ::vkGetPhysicalDeviceVideoFormatPropertiesKHR( physicalDevice, pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties );
3065  }
3066 
3067  VkResult vkCreateVideoSessionKHR( VkDevice device,
3068  const VkVideoSessionCreateInfoKHR * pCreateInfo,
3069  const VkAllocationCallbacks * pAllocator,
3070  VkVideoSessionKHR * pVideoSession ) const VULKAN_HPP_NOEXCEPT
3071  {
3072  return ::vkCreateVideoSessionKHR( device, pCreateInfo, pAllocator, pVideoSession );
3073  }
3074 
3075  void vkDestroyVideoSessionKHR( VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
3076  {
3077  return ::vkDestroyVideoSessionKHR( device, videoSession, pAllocator );
3078  }
3079 
3081  VkVideoSessionKHR videoSession,
3082  uint32_t * pMemoryRequirementsCount,
3083  VkVideoSessionMemoryRequirementsKHR * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
3084  {
3085  return ::vkGetVideoSessionMemoryRequirementsKHR( device, videoSession, pMemoryRequirementsCount, pMemoryRequirements );
3086  }
3087 
3088  VkResult vkBindVideoSessionMemoryKHR( VkDevice device,
3089  VkVideoSessionKHR videoSession,
3090  uint32_t bindSessionMemoryInfoCount,
3091  const VkBindVideoSessionMemoryInfoKHR * pBindSessionMemoryInfos ) const VULKAN_HPP_NOEXCEPT
3092  {
3093  return ::vkBindVideoSessionMemoryKHR( device, videoSession, bindSessionMemoryInfoCount, pBindSessionMemoryInfos );
3094  }
3095 
3097  const VkVideoSessionParametersCreateInfoKHR * pCreateInfo,
3098  const VkAllocationCallbacks * pAllocator,
3099  VkVideoSessionParametersKHR * pVideoSessionParameters ) const VULKAN_HPP_NOEXCEPT
3100  {
3101  return ::vkCreateVideoSessionParametersKHR( device, pCreateInfo, pAllocator, pVideoSessionParameters );
3102  }
3103 
3105  VkVideoSessionParametersKHR videoSessionParameters,
3107  {
3108  return ::vkUpdateVideoSessionParametersKHR( device, videoSessionParameters, pUpdateInfo );
3109  }
3110 
3111  void vkDestroyVideoSessionParametersKHR( VkDevice device,
3112  VkVideoSessionParametersKHR videoSessionParameters,
3113  const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
3114  {
3115  return ::vkDestroyVideoSessionParametersKHR( device, videoSessionParameters, pAllocator );
3116  }
3117 
3118  void vkCmdBeginVideoCodingKHR( VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR * pBeginInfo ) const VULKAN_HPP_NOEXCEPT
3119  {
3120  return ::vkCmdBeginVideoCodingKHR( commandBuffer, pBeginInfo );
3121  }
3122 
3123  void vkCmdEndVideoCodingKHR( VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR * pEndCodingInfo ) const VULKAN_HPP_NOEXCEPT
3124  {
3125  return ::vkCmdEndVideoCodingKHR( commandBuffer, pEndCodingInfo );
3126  }
3127 
3128  void vkCmdControlVideoCodingKHR( VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR * pCodingControlInfo ) const VULKAN_HPP_NOEXCEPT
3129  {
3130  return ::vkCmdControlVideoCodingKHR( commandBuffer, pCodingControlInfo );
3131  }
3132 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
3133 
3134 # if defined( VK_ENABLE_BETA_EXTENSIONS )
3135  //=== VK_KHR_video_decode_queue ===
3136 
3137  void vkCmdDecodeVideoKHR( VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR * pDecodeInfo ) const VULKAN_HPP_NOEXCEPT
3138  {
3139  return ::vkCmdDecodeVideoKHR( commandBuffer, pDecodeInfo );
3140  }
3141 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
3142 
3143  //=== VK_EXT_transform_feedback ===
3144 
3145  void vkCmdBindTransformFeedbackBuffersEXT( VkCommandBuffer commandBuffer,
3146  uint32_t firstBinding,
3147  uint32_t bindingCount,
3148  const VkBuffer * pBuffers,
3149  const VkDeviceSize * pOffsets,
3150  const VkDeviceSize * pSizes ) const VULKAN_HPP_NOEXCEPT
3151  {
3152  return ::vkCmdBindTransformFeedbackBuffersEXT( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes );
3153  }
3154 
3155  void vkCmdBeginTransformFeedbackEXT( VkCommandBuffer commandBuffer,
3156  uint32_t firstCounterBuffer,
3157  uint32_t counterBufferCount,
3158  const VkBuffer * pCounterBuffers,
3159  const VkDeviceSize * pCounterBufferOffsets ) const VULKAN_HPP_NOEXCEPT
3160  {
3161  return ::vkCmdBeginTransformFeedbackEXT( commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets );
3162  }
3163 
3164  void vkCmdEndTransformFeedbackEXT( VkCommandBuffer commandBuffer,
3165  uint32_t firstCounterBuffer,
3166  uint32_t counterBufferCount,
3167  const VkBuffer * pCounterBuffers,
3168  const VkDeviceSize * pCounterBufferOffsets ) const VULKAN_HPP_NOEXCEPT
3169  {
3170  return ::vkCmdEndTransformFeedbackEXT( commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets );
3171  }
3172 
3173  void vkCmdBeginQueryIndexedEXT( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index ) const
3175  {
3176  return ::vkCmdBeginQueryIndexedEXT( commandBuffer, queryPool, query, flags, index );
3177  }
3178 
3179  void vkCmdEndQueryIndexedEXT( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index ) const VULKAN_HPP_NOEXCEPT
3180  {
3181  return ::vkCmdEndQueryIndexedEXT( commandBuffer, queryPool, query, index );
3182  }
3183 
3184  void vkCmdDrawIndirectByteCountEXT( VkCommandBuffer commandBuffer,
3185  uint32_t instanceCount,
3186  uint32_t firstInstance,
3187  VkBuffer counterBuffer,
3188  VkDeviceSize counterBufferOffset,
3189  uint32_t counterOffset,
3190  uint32_t vertexStride ) const VULKAN_HPP_NOEXCEPT
3191  {
3192  return ::vkCmdDrawIndirectByteCountEXT( commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride );
3193  }
3194 
3195  //=== VK_NVX_binary_import ===
3196 
3197  VkResult vkCreateCuModuleNVX( VkDevice device,
3198  const VkCuModuleCreateInfoNVX * pCreateInfo,
3199  const VkAllocationCallbacks * pAllocator,
3200  VkCuModuleNVX * pModule ) const VULKAN_HPP_NOEXCEPT
3201  {
3202  return ::vkCreateCuModuleNVX( device, pCreateInfo, pAllocator, pModule );
3203  }
3204 
3206  const VkCuFunctionCreateInfoNVX * pCreateInfo,
3207  const VkAllocationCallbacks * pAllocator,
3208  VkCuFunctionNVX * pFunction ) const VULKAN_HPP_NOEXCEPT
3209  {
3210  return ::vkCreateCuFunctionNVX( device, pCreateInfo, pAllocator, pFunction );
3211  }
3212 
3213  void vkDestroyCuModuleNVX( VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
3214  {
3215  return ::vkDestroyCuModuleNVX( device, module, pAllocator );
3216  }
3217 
3218  void vkDestroyCuFunctionNVX( VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
3219  {
3220  return ::vkDestroyCuFunctionNVX( device, function, pAllocator );
3221  }
3222 
3223  void vkCmdCuLaunchKernelNVX( VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX * pLaunchInfo ) const VULKAN_HPP_NOEXCEPT
3224  {
3225  return ::vkCmdCuLaunchKernelNVX( commandBuffer, pLaunchInfo );
3226  }
3227 
3228  //=== VK_NVX_image_view_handle ===
3229 
3230  uint32_t vkGetImageViewHandleNVX( VkDevice device, const VkImageViewHandleInfoNVX * pInfo ) const VULKAN_HPP_NOEXCEPT
3231  {
3232  return ::vkGetImageViewHandleNVX( device, pInfo );
3233  }
3234 
3235  VkResult vkGetImageViewAddressNVX( VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX * pProperties ) const VULKAN_HPP_NOEXCEPT
3236  {
3237  return ::vkGetImageViewAddressNVX( device, imageView, pProperties );
3238  }
3239 
3240  //=== VK_AMD_draw_indirect_count ===
3241 
3242  void vkCmdDrawIndirectCountAMD( VkCommandBuffer commandBuffer,
3243  VkBuffer buffer,
3245  VkBuffer countBuffer,
3246  VkDeviceSize countBufferOffset,
3247  uint32_t maxDrawCount,
3248  uint32_t stride ) const VULKAN_HPP_NOEXCEPT
3249  {
3250  return ::vkCmdDrawIndirectCountAMD( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
3251  }
3252 
3253  void vkCmdDrawIndexedIndirectCountAMD( VkCommandBuffer commandBuffer,
3254  VkBuffer buffer,
3256  VkBuffer countBuffer,
3257  VkDeviceSize countBufferOffset,
3258  uint32_t maxDrawCount,
3259  uint32_t stride ) const VULKAN_HPP_NOEXCEPT
3260  {
3261  return ::vkCmdDrawIndexedIndirectCountAMD( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
3262  }
3263 
3264  //=== VK_AMD_shader_info ===
3265 
3266  VkResult vkGetShaderInfoAMD( VkDevice device,
3267  VkPipeline pipeline,
3268  VkShaderStageFlagBits shaderStage,
3269  VkShaderInfoTypeAMD infoType,
3270  size_t * pInfoSize,
3271  void * pInfo ) const VULKAN_HPP_NOEXCEPT
3272  {
3273  return ::vkGetShaderInfoAMD( device, pipeline, shaderStage, infoType, pInfoSize, pInfo );
3274  }
3275 
3276  //=== VK_KHR_dynamic_rendering ===
3277 
3278  void vkCmdBeginRenderingKHR( VkCommandBuffer commandBuffer, const VkRenderingInfo * pRenderingInfo ) const VULKAN_HPP_NOEXCEPT
3279  {
3280  return ::vkCmdBeginRenderingKHR( commandBuffer, pRenderingInfo );
3281  }
3282 
3283  void vkCmdEndRenderingKHR( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
3284  {
3285  return ::vkCmdEndRenderingKHR( commandBuffer );
3286  }
3287 
3288 # if defined( VK_USE_PLATFORM_GGP )
3289  //=== VK_GGP_stream_descriptor_surface ===
3290 
3291  VkResult vkCreateStreamDescriptorSurfaceGGP( VkInstance instance,
3292  const VkStreamDescriptorSurfaceCreateInfoGGP * pCreateInfo,
3293  const VkAllocationCallbacks * pAllocator,
3294  VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
3295  {
3296  return ::vkCreateStreamDescriptorSurfaceGGP( instance, pCreateInfo, pAllocator, pSurface );
3297  }
3298 # endif /*VK_USE_PLATFORM_GGP*/
3299 
3300  //=== VK_NV_external_memory_capabilities ===
3301 
3303  VkFormat format,
3304  VkImageType type,
3305  VkImageTiling tiling,
3308  VkExternalMemoryHandleTypeFlagsNV externalHandleType,
3309  VkExternalImageFormatPropertiesNV * pExternalImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
3310  {
3312  physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties );
3313  }
3314 
3315 # if defined( VK_USE_PLATFORM_WIN32_KHR )
3316  //=== VK_NV_external_memory_win32 ===
3317 
3318  VkResult vkGetMemoryWin32HandleNV( VkDevice device,
3319  VkDeviceMemory memory,
3321  HANDLE * pHandle ) const VULKAN_HPP_NOEXCEPT
3322  {
3324  }
3325 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
3326 
3327  //=== VK_KHR_get_physical_device_properties2 ===
3328 
3329  void vkGetPhysicalDeviceFeatures2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 * pFeatures ) const VULKAN_HPP_NOEXCEPT
3330  {
3331  return ::vkGetPhysicalDeviceFeatures2KHR( physicalDevice, pFeatures );
3332  }
3333 
3334  void vkGetPhysicalDeviceProperties2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 * pProperties ) const VULKAN_HPP_NOEXCEPT
3335  {
3336  return ::vkGetPhysicalDeviceProperties2KHR( physicalDevice, pProperties );
3337  }
3338 
3339  void vkGetPhysicalDeviceFormatProperties2KHR( VkPhysicalDevice physicalDevice,
3340  VkFormat format,
3341  VkFormatProperties2 * pFormatProperties ) const VULKAN_HPP_NOEXCEPT
3342  {
3343  return ::vkGetPhysicalDeviceFormatProperties2KHR( physicalDevice, format, pFormatProperties );
3344  }
3345 
3346  VkResult vkGetPhysicalDeviceImageFormatProperties2KHR( VkPhysicalDevice physicalDevice,
3347  const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,
3348  VkImageFormatProperties2 * pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
3349  {
3350  return ::vkGetPhysicalDeviceImageFormatProperties2KHR( physicalDevice, pImageFormatInfo, pImageFormatProperties );
3351  }
3352 
3353  void vkGetPhysicalDeviceQueueFamilyProperties2KHR( VkPhysicalDevice physicalDevice,
3354  uint32_t * pQueueFamilyPropertyCount,
3355  VkQueueFamilyProperties2 * pQueueFamilyProperties ) const VULKAN_HPP_NOEXCEPT
3356  {
3357  return ::vkGetPhysicalDeviceQueueFamilyProperties2KHR( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties );
3358  }
3359 
3360  void vkGetPhysicalDeviceMemoryProperties2KHR( VkPhysicalDevice physicalDevice,
3361  VkPhysicalDeviceMemoryProperties2 * pMemoryProperties ) const VULKAN_HPP_NOEXCEPT
3362  {
3363  return ::vkGetPhysicalDeviceMemoryProperties2KHR( physicalDevice, pMemoryProperties );
3364  }
3365 
3366  void vkGetPhysicalDeviceSparseImageFormatProperties2KHR( VkPhysicalDevice physicalDevice,
3367  const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
3368  uint32_t * pPropertyCount,
3370  {
3371  return ::vkGetPhysicalDeviceSparseImageFormatProperties2KHR( physicalDevice, pFormatInfo, pPropertyCount, pProperties );
3372  }
3373 
3374  //=== VK_KHR_device_group ===
3375 
3377  uint32_t heapIndex,
3378  uint32_t localDeviceIndex,
3379  uint32_t remoteDeviceIndex,
3380  VkPeerMemoryFeatureFlags * pPeerMemoryFeatures ) const VULKAN_HPP_NOEXCEPT
3381  {
3382  return ::vkGetDeviceGroupPeerMemoryFeaturesKHR( device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures );
3383  }
3384 
3385  void vkCmdSetDeviceMaskKHR( VkCommandBuffer commandBuffer, uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT
3386  {
3387  return ::vkCmdSetDeviceMaskKHR( commandBuffer, deviceMask );
3388  }
3389 
3390  void vkCmdDispatchBaseKHR( VkCommandBuffer commandBuffer,
3391  uint32_t baseGroupX,
3392  uint32_t baseGroupY,
3393  uint32_t baseGroupZ,
3394  uint32_t groupCountX,
3395  uint32_t groupCountY,
3396  uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
3397  {
3398  return ::vkCmdDispatchBaseKHR( commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
3399  }
3400 
3401 # if defined( VK_USE_PLATFORM_VI_NN )
3402  //=== VK_NN_vi_surface ===
3403 
3404  VkResult vkCreateViSurfaceNN( VkInstance instance,
3405  const VkViSurfaceCreateInfoNN * pCreateInfo,
3406  const VkAllocationCallbacks * pAllocator,
3407  VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
3408  {
3409  return ::vkCreateViSurfaceNN( instance, pCreateInfo, pAllocator, pSurface );
3410  }
3411 # endif /*VK_USE_PLATFORM_VI_NN*/
3412 
3413  //=== VK_KHR_maintenance1 ===
3414 
3415  void vkTrimCommandPoolKHR( VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags ) const VULKAN_HPP_NOEXCEPT
3416  {
3417  return ::vkTrimCommandPoolKHR( device, commandPool, flags );
3418  }
3419 
3420  //=== VK_KHR_device_group_creation ===
3421 
3423  uint32_t * pPhysicalDeviceGroupCount,
3424  VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties ) const VULKAN_HPP_NOEXCEPT
3425  {
3426  return ::vkEnumeratePhysicalDeviceGroupsKHR( instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties );
3427  }
3428 
3429  //=== VK_KHR_external_memory_capabilities ===
3430 
3431  void vkGetPhysicalDeviceExternalBufferPropertiesKHR( VkPhysicalDevice physicalDevice,
3432  const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
3433  VkExternalBufferProperties * pExternalBufferProperties ) const VULKAN_HPP_NOEXCEPT
3434  {
3435  return ::vkGetPhysicalDeviceExternalBufferPropertiesKHR( physicalDevice, pExternalBufferInfo, pExternalBufferProperties );
3436  }
3437 
3438 # if defined( VK_USE_PLATFORM_WIN32_KHR )
3439  //=== VK_KHR_external_memory_win32 ===
3440 
3441  VkResult vkGetMemoryWin32HandleKHR( VkDevice device, const VkMemoryGetWin32HandleInfoKHR * pGetWin32HandleInfo, HANDLE * pHandle ) const VULKAN_HPP_NOEXCEPT
3442  {
3443  return ::vkGetMemoryWin32HandleKHR( device, pGetWin32HandleInfo, pHandle );
3444  }
3445 
3448  HANDLE handle,
3449  VkMemoryWin32HandlePropertiesKHR * pMemoryWin32HandleProperties ) const VULKAN_HPP_NOEXCEPT
3450  {
3451  return ::vkGetMemoryWin32HandlePropertiesKHR( device, handleType, handle, pMemoryWin32HandleProperties );
3452  }
3453 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
3454 
3455  //=== VK_KHR_external_memory_fd ===
3456 
3457  VkResult vkGetMemoryFdKHR( VkDevice device, const VkMemoryGetFdInfoKHR * pGetFdInfo, int * pFd ) const VULKAN_HPP_NOEXCEPT
3458  {
3459  return ::vkGetMemoryFdKHR( device, pGetFdInfo, pFd );
3460  }
3461 
3464  int fd,
3465  VkMemoryFdPropertiesKHR * pMemoryFdProperties ) const VULKAN_HPP_NOEXCEPT
3466  {
3467  return ::vkGetMemoryFdPropertiesKHR( device, handleType, fd, pMemoryFdProperties );
3468  }
3469 
3470  //=== VK_KHR_external_semaphore_capabilities ===
3471 
3472  void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( VkPhysicalDevice physicalDevice,
3473  const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,
3474  VkExternalSemaphoreProperties * pExternalSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT
3475  {
3476  return ::vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties );
3477  }
3478 
3479 # if defined( VK_USE_PLATFORM_WIN32_KHR )
3480  //=== VK_KHR_external_semaphore_win32 ===
3481 
3482  VkResult vkImportSemaphoreWin32HandleKHR( VkDevice device,
3483  const VkImportSemaphoreWin32HandleInfoKHR * pImportSemaphoreWin32HandleInfo ) const VULKAN_HPP_NOEXCEPT
3484  {
3485  return ::vkImportSemaphoreWin32HandleKHR( device, pImportSemaphoreWin32HandleInfo );
3486  }
3487 
3488  VkResult
3489  vkGetSemaphoreWin32HandleKHR( VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR * pGetWin32HandleInfo, HANDLE * pHandle ) const VULKAN_HPP_NOEXCEPT
3490  {
3491  return ::vkGetSemaphoreWin32HandleKHR( device, pGetWin32HandleInfo, pHandle );
3492  }
3493 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
3494 
3495  //=== VK_KHR_external_semaphore_fd ===
3496 
3497  VkResult vkImportSemaphoreFdKHR( VkDevice device, const VkImportSemaphoreFdInfoKHR * pImportSemaphoreFdInfo ) const VULKAN_HPP_NOEXCEPT
3498  {
3499  return ::vkImportSemaphoreFdKHR( device, pImportSemaphoreFdInfo );
3500  }
3501 
3502  VkResult vkGetSemaphoreFdKHR( VkDevice device, const VkSemaphoreGetFdInfoKHR * pGetFdInfo, int * pFd ) const VULKAN_HPP_NOEXCEPT
3503  {
3504  return ::vkGetSemaphoreFdKHR( device, pGetFdInfo, pFd );
3505  }
3506 
3507  //=== VK_KHR_push_descriptor ===
3508 
3509  void vkCmdPushDescriptorSetKHR( VkCommandBuffer commandBuffer,
3510  VkPipelineBindPoint pipelineBindPoint,
3511  VkPipelineLayout layout,
3512  uint32_t set,
3513  uint32_t descriptorWriteCount,
3514  const VkWriteDescriptorSet * pDescriptorWrites ) const VULKAN_HPP_NOEXCEPT
3515  {
3516  return ::vkCmdPushDescriptorSetKHR( commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites );
3517  }
3518 
3519  void vkCmdPushDescriptorSetWithTemplateKHR( VkCommandBuffer commandBuffer,
3520  VkDescriptorUpdateTemplate descriptorUpdateTemplate,
3521  VkPipelineLayout layout,
3522  uint32_t set,
3523  const void * pData ) const VULKAN_HPP_NOEXCEPT
3524  {
3525  return ::vkCmdPushDescriptorSetWithTemplateKHR( commandBuffer, descriptorUpdateTemplate, layout, set, pData );
3526  }
3527 
3528  //=== VK_EXT_conditional_rendering ===
3529 
3530  void vkCmdBeginConditionalRenderingEXT( VkCommandBuffer commandBuffer,
3531  const VkConditionalRenderingBeginInfoEXT * pConditionalRenderingBegin ) const VULKAN_HPP_NOEXCEPT
3532  {
3533  return ::vkCmdBeginConditionalRenderingEXT( commandBuffer, pConditionalRenderingBegin );
3534  }
3535 
3536  void vkCmdEndConditionalRenderingEXT( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
3537  {
3539  }
3540 
3541  //=== VK_KHR_descriptor_update_template ===
3542 
3544  const VkDescriptorUpdateTemplateCreateInfo * pCreateInfo,
3545  const VkAllocationCallbacks * pAllocator,
3546  VkDescriptorUpdateTemplate * pDescriptorUpdateTemplate ) const VULKAN_HPP_NOEXCEPT
3547  {
3548  return ::vkCreateDescriptorUpdateTemplateKHR( device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate );
3549  }
3550 
3552  VkDescriptorUpdateTemplate descriptorUpdateTemplate,
3553  const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
3554  {
3555  return ::vkDestroyDescriptorUpdateTemplateKHR( device, descriptorUpdateTemplate, pAllocator );
3556  }
3557 
3559  VkDescriptorSet descriptorSet,
3560  VkDescriptorUpdateTemplate descriptorUpdateTemplate,
3561  const void * pData ) const VULKAN_HPP_NOEXCEPT
3562  {
3563  return ::vkUpdateDescriptorSetWithTemplateKHR( device, descriptorSet, descriptorUpdateTemplate, pData );
3564  }
3565 
3566  //=== VK_NV_clip_space_w_scaling ===
3567 
3568  void vkCmdSetViewportWScalingNV( VkCommandBuffer commandBuffer,
3569  uint32_t firstViewport,
3570  uint32_t viewportCount,
3571  const VkViewportWScalingNV * pViewportWScalings ) const VULKAN_HPP_NOEXCEPT
3572  {
3573  return ::vkCmdSetViewportWScalingNV( commandBuffer, firstViewport, viewportCount, pViewportWScalings );
3574  }
3575 
3576  //=== VK_EXT_direct_mode_display ===
3577 
3578  VkResult vkReleaseDisplayEXT( VkPhysicalDevice physicalDevice, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT
3579  {
3580  return ::vkReleaseDisplayEXT( physicalDevice, display );
3581  }
3582 
3583 # if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
3584  //=== VK_EXT_acquire_xlib_display ===
3585 
3586  VkResult vkAcquireXlibDisplayEXT( VkPhysicalDevice physicalDevice, Display * dpy, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT
3587  {
3588  return ::vkAcquireXlibDisplayEXT( physicalDevice, dpy, display );
3589  }
3590 
3591  VkResult vkGetRandROutputDisplayEXT( VkPhysicalDevice physicalDevice, Display * dpy, RROutput rrOutput, VkDisplayKHR * pDisplay ) const VULKAN_HPP_NOEXCEPT
3592  {
3593  return ::vkGetRandROutputDisplayEXT( physicalDevice, dpy, rrOutput, pDisplay );
3594  }
3595 # endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
3596 
3597  //=== VK_EXT_display_surface_counter ===
3598 
3599  VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT( VkPhysicalDevice physicalDevice,
3600  VkSurfaceKHR surface,
3601  VkSurfaceCapabilities2EXT * pSurfaceCapabilities ) const VULKAN_HPP_NOEXCEPT
3602  {
3603  return ::vkGetPhysicalDeviceSurfaceCapabilities2EXT( physicalDevice, surface, pSurfaceCapabilities );
3604  }
3605 
3606  //=== VK_EXT_display_control ===
3607 
3608  VkResult vkDisplayPowerControlEXT( VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT * pDisplayPowerInfo ) const VULKAN_HPP_NOEXCEPT
3609  {
3610  return ::vkDisplayPowerControlEXT( device, display, pDisplayPowerInfo );
3611  }
3612 
3614  const VkDeviceEventInfoEXT * pDeviceEventInfo,
3615  const VkAllocationCallbacks * pAllocator,
3616  VkFence * pFence ) const VULKAN_HPP_NOEXCEPT
3617  {
3618  return ::vkRegisterDeviceEventEXT( device, pDeviceEventInfo, pAllocator, pFence );
3619  }
3620 
3622  VkDisplayKHR display,
3623  const VkDisplayEventInfoEXT * pDisplayEventInfo,
3624  const VkAllocationCallbacks * pAllocator,
3625  VkFence * pFence ) const VULKAN_HPP_NOEXCEPT
3626  {
3627  return ::vkRegisterDisplayEventEXT( device, display, pDisplayEventInfo, pAllocator, pFence );
3628  }
3629 
3631  VkSwapchainKHR swapchain,
3633  uint64_t * pCounterValue ) const VULKAN_HPP_NOEXCEPT
3634  {
3635  return ::vkGetSwapchainCounterEXT( device, swapchain, counter, pCounterValue );
3636  }
3637 
3638  //=== VK_GOOGLE_display_timing ===
3639 
3641  VkSwapchainKHR swapchain,
3642  VkRefreshCycleDurationGOOGLE * pDisplayTimingProperties ) const VULKAN_HPP_NOEXCEPT
3643  {
3644  return ::vkGetRefreshCycleDurationGOOGLE( device, swapchain, pDisplayTimingProperties );
3645  }
3646 
3648  VkSwapchainKHR swapchain,
3649  uint32_t * pPresentationTimingCount,
3650  VkPastPresentationTimingGOOGLE * pPresentationTimings ) const VULKAN_HPP_NOEXCEPT
3651  {
3652  return ::vkGetPastPresentationTimingGOOGLE( device, swapchain, pPresentationTimingCount, pPresentationTimings );
3653  }
3654 
3655  //=== VK_EXT_discard_rectangles ===
3656 
3657  void vkCmdSetDiscardRectangleEXT( VkCommandBuffer commandBuffer,
3658  uint32_t firstDiscardRectangle,
3659  uint32_t discardRectangleCount,
3660  const VkRect2D * pDiscardRectangles ) const VULKAN_HPP_NOEXCEPT
3661  {
3662  return ::vkCmdSetDiscardRectangleEXT( commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles );
3663  }
3664 
3665  //=== VK_EXT_hdr_metadata ===
3666 
3667  void vkSetHdrMetadataEXT( VkDevice device,
3668  uint32_t swapchainCount,
3669  const VkSwapchainKHR * pSwapchains,
3670  const VkHdrMetadataEXT * pMetadata ) const VULKAN_HPP_NOEXCEPT
3671  {
3672  return ::vkSetHdrMetadataEXT( device, swapchainCount, pSwapchains, pMetadata );
3673  }
3674 
3675  //=== VK_KHR_create_renderpass2 ===
3676 
3678  const VkRenderPassCreateInfo2 * pCreateInfo,
3679  const VkAllocationCallbacks * pAllocator,
3680  VkRenderPass * pRenderPass ) const VULKAN_HPP_NOEXCEPT
3681  {
3682  return ::vkCreateRenderPass2KHR( device, pCreateInfo, pAllocator, pRenderPass );
3683  }
3684 
3685  void vkCmdBeginRenderPass2KHR( VkCommandBuffer commandBuffer,
3686  const VkRenderPassBeginInfo * pRenderPassBegin,
3687  const VkSubpassBeginInfo * pSubpassBeginInfo ) const VULKAN_HPP_NOEXCEPT
3688  {
3689  return ::vkCmdBeginRenderPass2KHR( commandBuffer, pRenderPassBegin, pSubpassBeginInfo );
3690  }
3691 
3692  void vkCmdNextSubpass2KHR( VkCommandBuffer commandBuffer,
3693  const VkSubpassBeginInfo * pSubpassBeginInfo,
3694  const VkSubpassEndInfo * pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT
3695  {
3696  return ::vkCmdNextSubpass2KHR( commandBuffer, pSubpassBeginInfo, pSubpassEndInfo );
3697  }
3698 
3699  void vkCmdEndRenderPass2KHR( VkCommandBuffer commandBuffer, const VkSubpassEndInfo * pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT
3700  {
3701  return ::vkCmdEndRenderPass2KHR( commandBuffer, pSubpassEndInfo );
3702  }
3703 
3704  //=== VK_KHR_shared_presentable_image ===
3705 
3706  VkResult vkGetSwapchainStatusKHR( VkDevice device, VkSwapchainKHR swapchain ) const VULKAN_HPP_NOEXCEPT
3707  {
3708  return ::vkGetSwapchainStatusKHR( device, swapchain );
3709  }
3710 
3711  //=== VK_KHR_external_fence_capabilities ===
3712 
3713  void vkGetPhysicalDeviceExternalFencePropertiesKHR( VkPhysicalDevice physicalDevice,
3714  const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,
3715  VkExternalFenceProperties * pExternalFenceProperties ) const VULKAN_HPP_NOEXCEPT
3716  {
3717  return ::vkGetPhysicalDeviceExternalFencePropertiesKHR( physicalDevice, pExternalFenceInfo, pExternalFenceProperties );
3718  }
3719 
3720 # if defined( VK_USE_PLATFORM_WIN32_KHR )
3721  //=== VK_KHR_external_fence_win32 ===
3722 
3723  VkResult vkImportFenceWin32HandleKHR( VkDevice device, const VkImportFenceWin32HandleInfoKHR * pImportFenceWin32HandleInfo ) const VULKAN_HPP_NOEXCEPT
3724  {
3725  return ::vkImportFenceWin32HandleKHR( device, pImportFenceWin32HandleInfo );
3726  }
3727 
3728  VkResult vkGetFenceWin32HandleKHR( VkDevice device, const VkFenceGetWin32HandleInfoKHR * pGetWin32HandleInfo, HANDLE * pHandle ) const VULKAN_HPP_NOEXCEPT
3729  {
3730  return ::vkGetFenceWin32HandleKHR( device, pGetWin32HandleInfo, pHandle );
3731  }
3732 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
3733 
3734  //=== VK_KHR_external_fence_fd ===
3735 
3736  VkResult vkImportFenceFdKHR( VkDevice device, const VkImportFenceFdInfoKHR * pImportFenceFdInfo ) const VULKAN_HPP_NOEXCEPT
3737  {
3738  return ::vkImportFenceFdKHR( device, pImportFenceFdInfo );
3739  }
3740 
3741  VkResult vkGetFenceFdKHR( VkDevice device, const VkFenceGetFdInfoKHR * pGetFdInfo, int * pFd ) const VULKAN_HPP_NOEXCEPT
3742  {
3743  return ::vkGetFenceFdKHR( device, pGetFdInfo, pFd );
3744  }
3745 
3746  //=== VK_KHR_performance_query ===
3747 
3748  VkResult
3750  uint32_t queueFamilyIndex,
3751  uint32_t * pCounterCount,
3752  VkPerformanceCounterKHR * pCounters,
3753  VkPerformanceCounterDescriptionKHR * pCounterDescriptions ) const VULKAN_HPP_NOEXCEPT
3754  {
3756  physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions );
3757  }
3758 
3759  void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( VkPhysicalDevice physicalDevice,
3760  const VkQueryPoolPerformanceCreateInfoKHR * pPerformanceQueryCreateInfo,
3761  uint32_t * pNumPasses ) const VULKAN_HPP_NOEXCEPT
3762  {
3763  return ::vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( physicalDevice, pPerformanceQueryCreateInfo, pNumPasses );
3764  }
3765 
3767  {
3768  return ::vkAcquireProfilingLockKHR( device, pInfo );
3769  }
3770 
3771  void vkReleaseProfilingLockKHR( VkDevice device ) const VULKAN_HPP_NOEXCEPT
3772  {
3774  }
3775 
3776  //=== VK_KHR_get_surface_capabilities2 ===
3777 
3778  VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR( VkPhysicalDevice physicalDevice,
3779  const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
3780  VkSurfaceCapabilities2KHR * pSurfaceCapabilities ) const VULKAN_HPP_NOEXCEPT
3781  {
3782  return ::vkGetPhysicalDeviceSurfaceCapabilities2KHR( physicalDevice, pSurfaceInfo, pSurfaceCapabilities );
3783  }
3784 
3785  VkResult vkGetPhysicalDeviceSurfaceFormats2KHR( VkPhysicalDevice physicalDevice,
3786  const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
3787  uint32_t * pSurfaceFormatCount,
3788  VkSurfaceFormat2KHR * pSurfaceFormats ) const VULKAN_HPP_NOEXCEPT
3789  {
3790  return ::vkGetPhysicalDeviceSurfaceFormats2KHR( physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats );
3791  }
3792 
3793  //=== VK_KHR_get_display_properties2 ===
3794 
3795  VkResult vkGetPhysicalDeviceDisplayProperties2KHR( VkPhysicalDevice physicalDevice,
3796  uint32_t * pPropertyCount,
3797  VkDisplayProperties2KHR * pProperties ) const VULKAN_HPP_NOEXCEPT
3798  {
3799  return ::vkGetPhysicalDeviceDisplayProperties2KHR( physicalDevice, pPropertyCount, pProperties );
3800  }
3801 
3803  uint32_t * pPropertyCount,
3805  {
3806  return ::vkGetPhysicalDeviceDisplayPlaneProperties2KHR( physicalDevice, pPropertyCount, pProperties );
3807  }
3808 
3809  VkResult vkGetDisplayModeProperties2KHR( VkPhysicalDevice physicalDevice,
3810  VkDisplayKHR display,
3811  uint32_t * pPropertyCount,
3812  VkDisplayModeProperties2KHR * pProperties ) const VULKAN_HPP_NOEXCEPT
3813  {
3814  return ::vkGetDisplayModeProperties2KHR( physicalDevice, display, pPropertyCount, pProperties );
3815  }
3816 
3817  VkResult vkGetDisplayPlaneCapabilities2KHR( VkPhysicalDevice physicalDevice,
3818  const VkDisplayPlaneInfo2KHR * pDisplayPlaneInfo,
3819  VkDisplayPlaneCapabilities2KHR * pCapabilities ) const VULKAN_HPP_NOEXCEPT
3820  {
3821  return ::vkGetDisplayPlaneCapabilities2KHR( physicalDevice, pDisplayPlaneInfo, pCapabilities );
3822  }
3823 
3824 # if defined( VK_USE_PLATFORM_IOS_MVK )
3825  //=== VK_MVK_ios_surface ===
3826 
3827  VkResult vkCreateIOSSurfaceMVK( VkInstance instance,
3828  const VkIOSSurfaceCreateInfoMVK * pCreateInfo,
3829  const VkAllocationCallbacks * pAllocator,
3830  VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
3831  {
3832  return ::vkCreateIOSSurfaceMVK( instance, pCreateInfo, pAllocator, pSurface );
3833  }
3834 # endif /*VK_USE_PLATFORM_IOS_MVK*/
3835 
3836 # if defined( VK_USE_PLATFORM_MACOS_MVK )
3837  //=== VK_MVK_macos_surface ===
3838 
3839  VkResult vkCreateMacOSSurfaceMVK( VkInstance instance,
3840  const VkMacOSSurfaceCreateInfoMVK * pCreateInfo,
3841  const VkAllocationCallbacks * pAllocator,
3842  VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
3843  {
3844  return ::vkCreateMacOSSurfaceMVK( instance, pCreateInfo, pAllocator, pSurface );
3845  }
3846 # endif /*VK_USE_PLATFORM_MACOS_MVK*/
3847 
3848  //=== VK_EXT_debug_utils ===
3849 
3851  {
3852  return ::vkSetDebugUtilsObjectNameEXT( device, pNameInfo );
3853  }
3854 
3856  {
3857  return ::vkSetDebugUtilsObjectTagEXT( device, pTagInfo );
3858  }
3859 
3861  {
3863  }
3864 
3866  {
3868  }
3869 
3871  {
3873  }
3874 
3875  void vkCmdBeginDebugUtilsLabelEXT( VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT
3876  {
3877  return ::vkCmdBeginDebugUtilsLabelEXT( commandBuffer, pLabelInfo );
3878  }
3879 
3880  void vkCmdEndDebugUtilsLabelEXT( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
3881  {
3882  return ::vkCmdEndDebugUtilsLabelEXT( commandBuffer );
3883  }
3884 
3885  void vkCmdInsertDebugUtilsLabelEXT( VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT
3886  {
3887  return ::vkCmdInsertDebugUtilsLabelEXT( commandBuffer, pLabelInfo );
3888  }
3889 
3891  const VkDebugUtilsMessengerCreateInfoEXT * pCreateInfo,
3892  const VkAllocationCallbacks * pAllocator,
3893  VkDebugUtilsMessengerEXT * pMessenger ) const VULKAN_HPP_NOEXCEPT
3894  {
3895  return ::vkCreateDebugUtilsMessengerEXT( instance, pCreateInfo, pAllocator, pMessenger );
3896  }
3897 
3898  void vkDestroyDebugUtilsMessengerEXT( VkInstance instance,
3899  VkDebugUtilsMessengerEXT messenger,
3900  const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
3901  {
3902  return ::vkDestroyDebugUtilsMessengerEXT( instance, messenger, pAllocator );
3903  }
3904 
3905  void vkSubmitDebugUtilsMessageEXT( VkInstance instance,
3907  VkDebugUtilsMessageTypeFlagsEXT messageTypes,
3908  const VkDebugUtilsMessengerCallbackDataEXT * pCallbackData ) const VULKAN_HPP_NOEXCEPT
3909  {
3910  return ::vkSubmitDebugUtilsMessageEXT( instance, messageSeverity, messageTypes, pCallbackData );
3911  }
3912 
3913 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
3914  //=== VK_ANDROID_external_memory_android_hardware_buffer ===
3915 
3917  const struct AHardwareBuffer * buffer,
3919  {
3921  }
3922 
3925  struct AHardwareBuffer ** pBuffer ) const VULKAN_HPP_NOEXCEPT
3926  {
3927  return ::vkGetMemoryAndroidHardwareBufferANDROID( device, pInfo, pBuffer );
3928  }
3929 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
3930 
3931  //=== VK_EXT_sample_locations ===
3932 
3933  void vkCmdSetSampleLocationsEXT( VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT * pSampleLocationsInfo ) const VULKAN_HPP_NOEXCEPT
3934  {
3935  return ::vkCmdSetSampleLocationsEXT( commandBuffer, pSampleLocationsInfo );
3936  }
3937 
3938  void vkGetPhysicalDeviceMultisamplePropertiesEXT( VkPhysicalDevice physicalDevice,
3940  VkMultisamplePropertiesEXT * pMultisampleProperties ) const VULKAN_HPP_NOEXCEPT
3941  {
3942  return ::vkGetPhysicalDeviceMultisamplePropertiesEXT( physicalDevice, samples, pMultisampleProperties );
3943  }
3944 
3945  //=== VK_KHR_get_memory_requirements2 ===
3946 
3947  void vkGetImageMemoryRequirements2KHR( VkDevice device,
3948  const VkImageMemoryRequirementsInfo2 * pInfo,
3949  VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
3950  {
3951  return ::vkGetImageMemoryRequirements2KHR( device, pInfo, pMemoryRequirements );
3952  }
3953 
3954  void vkGetBufferMemoryRequirements2KHR( VkDevice device,
3955  const VkBufferMemoryRequirementsInfo2 * pInfo,
3956  VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
3957  {
3958  return ::vkGetBufferMemoryRequirements2KHR( device, pInfo, pMemoryRequirements );
3959  }
3960 
3963  uint32_t * pSparseMemoryRequirementCount,
3964  VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
3965  {
3966  return ::vkGetImageSparseMemoryRequirements2KHR( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
3967  }
3968 
3969  //=== VK_KHR_acceleration_structure ===
3970 
3972  const VkAccelerationStructureCreateInfoKHR * pCreateInfo,
3973  const VkAllocationCallbacks * pAllocator,
3974  VkAccelerationStructureKHR * pAccelerationStructure ) const VULKAN_HPP_NOEXCEPT
3975  {
3976  return ::vkCreateAccelerationStructureKHR( device, pCreateInfo, pAllocator, pAccelerationStructure );
3977  }
3978 
3979  void vkDestroyAccelerationStructureKHR( VkDevice device,
3980  VkAccelerationStructureKHR accelerationStructure,
3981  const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
3982  {
3983  return ::vkDestroyAccelerationStructureKHR( device, accelerationStructure, pAllocator );
3984  }
3985 
3986  void vkCmdBuildAccelerationStructuresKHR( VkCommandBuffer commandBuffer,
3987  uint32_t infoCount,
3989  const VkAccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos ) const VULKAN_HPP_NOEXCEPT
3990  {
3991  return ::vkCmdBuildAccelerationStructuresKHR( commandBuffer, infoCount, pInfos, ppBuildRangeInfos );
3992  }
3993 
3994  void vkCmdBuildAccelerationStructuresIndirectKHR( VkCommandBuffer commandBuffer,
3995  uint32_t infoCount,
3997  const VkDeviceAddress * pIndirectDeviceAddresses,
3998  const uint32_t * pIndirectStrides,
3999  const uint32_t * const * ppMaxPrimitiveCounts ) const VULKAN_HPP_NOEXCEPT
4000  {
4002  commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts );
4003  }
4004 
4006  VkDeferredOperationKHR deferredOperation,
4007  uint32_t infoCount,
4009  const VkAccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos ) const VULKAN_HPP_NOEXCEPT
4010  {
4011  return ::vkBuildAccelerationStructuresKHR( device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos );
4012  }
4013 
4015  VkDeferredOperationKHR deferredOperation,
4017  {
4018  return ::vkCopyAccelerationStructureKHR( device, deferredOperation, pInfo );
4019  }
4020 
4022  VkDeferredOperationKHR deferredOperation,
4024  {
4025  return ::vkCopyAccelerationStructureToMemoryKHR( device, deferredOperation, pInfo );
4026  }
4027 
4029  VkDeferredOperationKHR deferredOperation,
4031  {
4032  return ::vkCopyMemoryToAccelerationStructureKHR( device, deferredOperation, pInfo );
4033  }
4034 
4036  uint32_t accelerationStructureCount,
4037  const VkAccelerationStructureKHR * pAccelerationStructures,
4038  VkQueryType queryType,
4039  size_t dataSize,
4040  void * pData,
4041  size_t stride ) const VULKAN_HPP_NOEXCEPT
4042  {
4043  return ::vkWriteAccelerationStructuresPropertiesKHR( device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride );
4044  }
4045 
4046  void vkCmdCopyAccelerationStructureKHR( VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
4047  {
4048  return ::vkCmdCopyAccelerationStructureKHR( commandBuffer, pInfo );
4049  }
4050 
4051  void vkCmdCopyAccelerationStructureToMemoryKHR( VkCommandBuffer commandBuffer,
4053  {
4055  }
4056 
4057  void vkCmdCopyMemoryToAccelerationStructureKHR( VkCommandBuffer commandBuffer,
4059  {
4061  }
4062 
4065  {
4067  }
4068 
4069  void vkCmdWriteAccelerationStructuresPropertiesKHR( VkCommandBuffer commandBuffer,
4070  uint32_t accelerationStructureCount,
4071  const VkAccelerationStructureKHR * pAccelerationStructures,
4072  VkQueryType queryType,
4073  VkQueryPool queryPool,
4074  uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT
4075  {
4077  commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery );
4078  }
4079 
4081  const VkAccelerationStructureVersionInfoKHR * pVersionInfo,
4083  {
4084  return ::vkGetDeviceAccelerationStructureCompatibilityKHR( device, pVersionInfo, pCompatibility );
4085  }
4086 
4090  const uint32_t * pMaxPrimitiveCounts,
4092  {
4093  return ::vkGetAccelerationStructureBuildSizesKHR( device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo );
4094  }
4095 
4096  //=== VK_KHR_sampler_ycbcr_conversion ===
4097 
4099  const VkSamplerYcbcrConversionCreateInfo * pCreateInfo,
4100  const VkAllocationCallbacks * pAllocator,
4101  VkSamplerYcbcrConversion * pYcbcrConversion ) const VULKAN_HPP_NOEXCEPT
4102  {
4103  return ::vkCreateSamplerYcbcrConversionKHR( device, pCreateInfo, pAllocator, pYcbcrConversion );
4104  }
4105 
4106  void vkDestroySamplerYcbcrConversionKHR( VkDevice device,
4107  VkSamplerYcbcrConversion ycbcrConversion,
4108  const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
4109  {
4110  return ::vkDestroySamplerYcbcrConversionKHR( device, ycbcrConversion, pAllocator );
4111  }
4112 
4113  //=== VK_KHR_bind_memory2 ===
4114 
4115  VkResult vkBindBufferMemory2KHR( VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT
4116  {
4117  return ::vkBindBufferMemory2KHR( device, bindInfoCount, pBindInfos );
4118  }
4119 
4120  VkResult vkBindImageMemory2KHR( VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT
4121  {
4122  return ::vkBindImageMemory2KHR( device, bindInfoCount, pBindInfos );
4123  }
4124 
4125  //=== VK_EXT_image_drm_format_modifier ===
4126 
4127  VkResult
4129  {
4131  }
4132 
4133  //=== VK_EXT_validation_cache ===
4134 
4136  const VkValidationCacheCreateInfoEXT * pCreateInfo,
4137  const VkAllocationCallbacks * pAllocator,
4138  VkValidationCacheEXT * pValidationCache ) const VULKAN_HPP_NOEXCEPT
4139  {
4140  return ::vkCreateValidationCacheEXT( device, pCreateInfo, pAllocator, pValidationCache );
4141  }
4142 
4143  void
4144  vkDestroyValidationCacheEXT( VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
4145  {
4146  return ::vkDestroyValidationCacheEXT( device, validationCache, pAllocator );
4147  }
4148 
4150  VkValidationCacheEXT dstCache,
4151  uint32_t srcCacheCount,
4152  const VkValidationCacheEXT * pSrcCaches ) const VULKAN_HPP_NOEXCEPT
4153  {
4154  return ::vkMergeValidationCachesEXT( device, dstCache, srcCacheCount, pSrcCaches );
4155  }
4156 
4157  VkResult vkGetValidationCacheDataEXT( VkDevice device, VkValidationCacheEXT validationCache, size_t * pDataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
4158  {
4159  return ::vkGetValidationCacheDataEXT( device, validationCache, pDataSize, pData );
4160  }
4161 
4162  //=== VK_NV_shading_rate_image ===
4163 
4164  void vkCmdBindShadingRateImageNV( VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT
4165  {
4166  return ::vkCmdBindShadingRateImageNV( commandBuffer, imageView, imageLayout );
4167  }
4168 
4169  void vkCmdSetViewportShadingRatePaletteNV( VkCommandBuffer commandBuffer,
4170  uint32_t firstViewport,
4171  uint32_t viewportCount,
4172  const VkShadingRatePaletteNV * pShadingRatePalettes ) const VULKAN_HPP_NOEXCEPT
4173  {
4174  return ::vkCmdSetViewportShadingRatePaletteNV( commandBuffer, firstViewport, viewportCount, pShadingRatePalettes );
4175  }
4176 
4177  void vkCmdSetCoarseSampleOrderNV( VkCommandBuffer commandBuffer,
4178  VkCoarseSampleOrderTypeNV sampleOrderType,
4179  uint32_t customSampleOrderCount,
4180  const VkCoarseSampleOrderCustomNV * pCustomSampleOrders ) const VULKAN_HPP_NOEXCEPT
4181  {
4182  return ::vkCmdSetCoarseSampleOrderNV( commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders );
4183  }
4184 
4185  //=== VK_NV_ray_tracing ===
4186 
4188  const VkAccelerationStructureCreateInfoNV * pCreateInfo,
4189  const VkAllocationCallbacks * pAllocator,
4190  VkAccelerationStructureNV * pAccelerationStructure ) const VULKAN_HPP_NOEXCEPT
4191  {
4192  return ::vkCreateAccelerationStructureNV( device, pCreateInfo, pAllocator, pAccelerationStructure );
4193  }
4194 
4195  void vkDestroyAccelerationStructureNV( VkDevice device,
4196  VkAccelerationStructureNV accelerationStructure,
4197  const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
4198  {
4199  return ::vkDestroyAccelerationStructureNV( device, accelerationStructure, pAllocator );
4200  }
4201 
4204  VkMemoryRequirements2KHR * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
4205  {
4206  return ::vkGetAccelerationStructureMemoryRequirementsNV( device, pInfo, pMemoryRequirements );
4207  }
4208 
4210  uint32_t bindInfoCount,
4212  {
4213  return ::vkBindAccelerationStructureMemoryNV( device, bindInfoCount, pBindInfos );
4214  }
4215 
4216  void vkCmdBuildAccelerationStructureNV( VkCommandBuffer commandBuffer,
4217  const VkAccelerationStructureInfoNV * pInfo,
4218  VkBuffer instanceData,
4219  VkDeviceSize instanceOffset,
4220  VkBool32 update,
4221  VkAccelerationStructureNV dst,
4222  VkAccelerationStructureNV src,
4223  VkBuffer scratch,
4224  VkDeviceSize scratchOffset ) const VULKAN_HPP_NOEXCEPT
4225  {
4226  return ::vkCmdBuildAccelerationStructureNV( commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset );
4227  }
4228 
4229  void vkCmdCopyAccelerationStructureNV( VkCommandBuffer commandBuffer,
4230  VkAccelerationStructureNV dst,
4231  VkAccelerationStructureNV src,
4233  {
4234  return ::vkCmdCopyAccelerationStructureNV( commandBuffer, dst, src, mode );
4235  }
4236 
4237  void vkCmdTraceRaysNV( VkCommandBuffer commandBuffer,
4238  VkBuffer raygenShaderBindingTableBuffer,
4239  VkDeviceSize raygenShaderBindingOffset,
4240  VkBuffer missShaderBindingTableBuffer,
4241  VkDeviceSize missShaderBindingOffset,
4242  VkDeviceSize missShaderBindingStride,
4243  VkBuffer hitShaderBindingTableBuffer,
4244  VkDeviceSize hitShaderBindingOffset,
4245  VkDeviceSize hitShaderBindingStride,
4246  VkBuffer callableShaderBindingTableBuffer,
4247  VkDeviceSize callableShaderBindingOffset,
4248  VkDeviceSize callableShaderBindingStride,
4249  uint32_t width,
4250  uint32_t height,
4251  uint32_t depth ) const VULKAN_HPP_NOEXCEPT
4252  {
4253  return ::vkCmdTraceRaysNV( commandBuffer,
4254  raygenShaderBindingTableBuffer,
4255  raygenShaderBindingOffset,
4256  missShaderBindingTableBuffer,
4257  missShaderBindingOffset,
4258  missShaderBindingStride,
4259  hitShaderBindingTableBuffer,
4260  hitShaderBindingOffset,
4261  hitShaderBindingStride,
4262  callableShaderBindingTableBuffer,
4263  callableShaderBindingOffset,
4264  callableShaderBindingStride,
4265  width,
4266  height,
4267  depth );
4268  }
4269 
4271  VkPipelineCache pipelineCache,
4272  uint32_t createInfoCount,
4273  const VkRayTracingPipelineCreateInfoNV * pCreateInfos,
4274  const VkAllocationCallbacks * pAllocator,
4275  VkPipeline * pPipelines ) const VULKAN_HPP_NOEXCEPT
4276  {
4277  return ::vkCreateRayTracingPipelinesNV( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
4278  }
4279 
4281  VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
4282  {
4283  return ::vkGetRayTracingShaderGroupHandlesNV( device, pipeline, firstGroup, groupCount, dataSize, pData );
4284  }
4285 
4287  VkAccelerationStructureNV accelerationStructure,
4288  size_t dataSize,
4289  void * pData ) const VULKAN_HPP_NOEXCEPT
4290  {
4291  return ::vkGetAccelerationStructureHandleNV( device, accelerationStructure, dataSize, pData );
4292  }
4293 
4294  void vkCmdWriteAccelerationStructuresPropertiesNV( VkCommandBuffer commandBuffer,
4295  uint32_t accelerationStructureCount,
4296  const VkAccelerationStructureNV * pAccelerationStructures,
4297  VkQueryType queryType,
4298  VkQueryPool queryPool,
4299  uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT
4300  {
4302  commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery );
4303  }
4304 
4305  VkResult vkCompileDeferredNV( VkDevice device, VkPipeline pipeline, uint32_t shader ) const VULKAN_HPP_NOEXCEPT
4306  {
4307  return ::vkCompileDeferredNV( device, pipeline, shader );
4308  }
4309 
4310  //=== VK_KHR_maintenance3 ===
4311 
4312  void vkGetDescriptorSetLayoutSupportKHR( VkDevice device,
4313  const VkDescriptorSetLayoutCreateInfo * pCreateInfo,
4315  {
4316  return ::vkGetDescriptorSetLayoutSupportKHR( device, pCreateInfo, pSupport );
4317  }
4318 
4319  //=== VK_KHR_draw_indirect_count ===
4320 
4321  void vkCmdDrawIndirectCountKHR( VkCommandBuffer commandBuffer,
4322  VkBuffer buffer,
4324  VkBuffer countBuffer,
4325  VkDeviceSize countBufferOffset,
4326  uint32_t maxDrawCount,
4327  uint32_t stride ) const VULKAN_HPP_NOEXCEPT
4328  {
4329  return ::vkCmdDrawIndirectCountKHR( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
4330  }
4331 
4332  void vkCmdDrawIndexedIndirectCountKHR( VkCommandBuffer commandBuffer,
4333  VkBuffer buffer,
4335  VkBuffer countBuffer,
4336  VkDeviceSize countBufferOffset,
4337  uint32_t maxDrawCount,
4338  uint32_t stride ) const VULKAN_HPP_NOEXCEPT
4339  {
4340  return ::vkCmdDrawIndexedIndirectCountKHR( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
4341  }
4342 
4343  //=== VK_EXT_external_memory_host ===
4344 
4347  const void * pHostPointer,
4348  VkMemoryHostPointerPropertiesEXT * pMemoryHostPointerProperties ) const VULKAN_HPP_NOEXCEPT
4349  {
4350  return ::vkGetMemoryHostPointerPropertiesEXT( device, handleType, pHostPointer, pMemoryHostPointerProperties );
4351  }
4352 
4353  //=== VK_AMD_buffer_marker ===
4354 
4355  void vkCmdWriteBufferMarkerAMD( VkCommandBuffer commandBuffer,
4356  VkPipelineStageFlagBits pipelineStage,
4357  VkBuffer dstBuffer,
4358  VkDeviceSize dstOffset,
4359  uint32_t marker ) const VULKAN_HPP_NOEXCEPT
4360  {
4361  return ::vkCmdWriteBufferMarkerAMD( commandBuffer, pipelineStage, dstBuffer, dstOffset, marker );
4362  }
4363 
4364  //=== VK_EXT_calibrated_timestamps ===
4365 
4367  uint32_t * pTimeDomainCount,
4368  VkTimeDomainEXT * pTimeDomains ) const VULKAN_HPP_NOEXCEPT
4369  {
4370  return ::vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( physicalDevice, pTimeDomainCount, pTimeDomains );
4371  }
4372 
4374  uint32_t timestampCount,
4375  const VkCalibratedTimestampInfoEXT * pTimestampInfos,
4376  uint64_t * pTimestamps,
4377  uint64_t * pMaxDeviation ) const VULKAN_HPP_NOEXCEPT
4378  {
4379  return ::vkGetCalibratedTimestampsEXT( device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation );
4380  }
4381 
4382  //=== VK_NV_mesh_shader ===
4383 
4384  void vkCmdDrawMeshTasksNV( VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask ) const VULKAN_HPP_NOEXCEPT
4385  {
4386  return ::vkCmdDrawMeshTasksNV( commandBuffer, taskCount, firstTask );
4387  }
4388 
4389  void vkCmdDrawMeshTasksIndirectNV( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const
4391  {
4392  return ::vkCmdDrawMeshTasksIndirectNV( commandBuffer, buffer, offset, drawCount, stride );
4393  }
4394 
4395  void vkCmdDrawMeshTasksIndirectCountNV( VkCommandBuffer commandBuffer,
4396  VkBuffer buffer,
4398  VkBuffer countBuffer,
4399  VkDeviceSize countBufferOffset,
4400  uint32_t maxDrawCount,
4401  uint32_t stride ) const VULKAN_HPP_NOEXCEPT
4402  {
4403  return ::vkCmdDrawMeshTasksIndirectCountNV( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
4404  }
4405 
4406  //=== VK_NV_scissor_exclusive ===
4407 
4408  void vkCmdSetExclusiveScissorNV( VkCommandBuffer commandBuffer,
4409  uint32_t firstExclusiveScissor,
4410  uint32_t exclusiveScissorCount,
4411  const VkRect2D * pExclusiveScissors ) const VULKAN_HPP_NOEXCEPT
4412  {
4413  return ::vkCmdSetExclusiveScissorNV( commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors );
4414  }
4415 
4416  //=== VK_NV_device_diagnostic_checkpoints ===
4417 
4418  void vkCmdSetCheckpointNV( VkCommandBuffer commandBuffer, const void * pCheckpointMarker ) const VULKAN_HPP_NOEXCEPT
4419  {
4420  return ::vkCmdSetCheckpointNV( commandBuffer, pCheckpointMarker );
4421  }
4422 
4423  void vkGetQueueCheckpointDataNV( VkQueue queue, uint32_t * pCheckpointDataCount, VkCheckpointDataNV * pCheckpointData ) const VULKAN_HPP_NOEXCEPT
4424  {
4425  return ::vkGetQueueCheckpointDataNV( queue, pCheckpointDataCount, pCheckpointData );
4426  }
4427 
4428  //=== VK_KHR_timeline_semaphore ===
4429 
4430  VkResult vkGetSemaphoreCounterValueKHR( VkDevice device, VkSemaphore semaphore, uint64_t * pValue ) const VULKAN_HPP_NOEXCEPT
4431  {
4432  return ::vkGetSemaphoreCounterValueKHR( device, semaphore, pValue );
4433  }
4434 
4435  VkResult vkWaitSemaphoresKHR( VkDevice device, const VkSemaphoreWaitInfo * pWaitInfo, uint64_t timeout ) const VULKAN_HPP_NOEXCEPT
4436  {
4437  return ::vkWaitSemaphoresKHR( device, pWaitInfo, timeout );
4438  }
4439 
4440  VkResult vkSignalSemaphoreKHR( VkDevice device, const VkSemaphoreSignalInfo * pSignalInfo ) const VULKAN_HPP_NOEXCEPT
4441  {
4442  return ::vkSignalSemaphoreKHR( device, pSignalInfo );
4443  }
4444 
4445  //=== VK_INTEL_performance_query ===
4446 
4448  {
4449  return ::vkInitializePerformanceApiINTEL( device, pInitializeInfo );
4450  }
4451 
4453  {
4455  }
4456 
4457  VkResult vkCmdSetPerformanceMarkerINTEL( VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT
4458  {
4459  return ::vkCmdSetPerformanceMarkerINTEL( commandBuffer, pMarkerInfo );
4460  }
4461 
4462  VkResult vkCmdSetPerformanceStreamMarkerINTEL( VkCommandBuffer commandBuffer,
4463  const VkPerformanceStreamMarkerInfoINTEL * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT
4464  {
4465  return ::vkCmdSetPerformanceStreamMarkerINTEL( commandBuffer, pMarkerInfo );
4466  }
4467 
4468  VkResult vkCmdSetPerformanceOverrideINTEL( VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL * pOverrideInfo ) const VULKAN_HPP_NOEXCEPT
4469  {
4470  return ::vkCmdSetPerformanceOverrideINTEL( commandBuffer, pOverrideInfo );
4471  }
4472 
4474  const VkPerformanceConfigurationAcquireInfoINTEL * pAcquireInfo,
4475  VkPerformanceConfigurationINTEL * pConfiguration ) const VULKAN_HPP_NOEXCEPT
4476  {
4477  return ::vkAcquirePerformanceConfigurationINTEL( device, pAcquireInfo, pConfiguration );
4478  }
4479 
4480  VkResult vkReleasePerformanceConfigurationINTEL( VkDevice device, VkPerformanceConfigurationINTEL configuration ) const VULKAN_HPP_NOEXCEPT
4481  {
4482  return ::vkReleasePerformanceConfigurationINTEL( device, configuration );
4483  }
4484 
4485  VkResult vkQueueSetPerformanceConfigurationINTEL( VkQueue queue, VkPerformanceConfigurationINTEL configuration ) const VULKAN_HPP_NOEXCEPT
4486  {
4488  }
4489 
4490  VkResult
4492  {
4493  return ::vkGetPerformanceParameterINTEL( device, parameter, pValue );
4494  }
4495 
4496  //=== VK_AMD_display_native_hdr ===
4497 
4498  void vkSetLocalDimmingAMD( VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable ) const VULKAN_HPP_NOEXCEPT
4499  {
4500  return ::vkSetLocalDimmingAMD( device, swapChain, localDimmingEnable );
4501  }
4502 
4503 # if defined( VK_USE_PLATFORM_FUCHSIA )
4504  //=== VK_FUCHSIA_imagepipe_surface ===
4505 
4506  VkResult vkCreateImagePipeSurfaceFUCHSIA( VkInstance instance,
4507  const VkImagePipeSurfaceCreateInfoFUCHSIA * pCreateInfo,
4508  const VkAllocationCallbacks * pAllocator,
4509  VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
4510  {
4511  return ::vkCreateImagePipeSurfaceFUCHSIA( instance, pCreateInfo, pAllocator, pSurface );
4512  }
4513 # endif /*VK_USE_PLATFORM_FUCHSIA*/
4514 
4515 # if defined( VK_USE_PLATFORM_METAL_EXT )
4516  //=== VK_EXT_metal_surface ===
4517 
4518  VkResult vkCreateMetalSurfaceEXT( VkInstance instance,
4519  const VkMetalSurfaceCreateInfoEXT * pCreateInfo,
4520  const VkAllocationCallbacks * pAllocator,
4521  VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
4522  {
4523  return ::vkCreateMetalSurfaceEXT( instance, pCreateInfo, pAllocator, pSurface );
4524  }
4525 # endif /*VK_USE_PLATFORM_METAL_EXT*/
4526 
4527  //=== VK_KHR_fragment_shading_rate ===
4528 
4529  VkResult vkGetPhysicalDeviceFragmentShadingRatesKHR( VkPhysicalDevice physicalDevice,
4530  uint32_t * pFragmentShadingRateCount,
4531  VkPhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates ) const VULKAN_HPP_NOEXCEPT
4532  {
4533  return ::vkGetPhysicalDeviceFragmentShadingRatesKHR( physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates );
4534  }
4535 
4536  void vkCmdSetFragmentShadingRateKHR( VkCommandBuffer commandBuffer,
4537  const VkExtent2D * pFragmentSize,
4538  const VkFragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT
4539  {
4540  return ::vkCmdSetFragmentShadingRateKHR( commandBuffer, pFragmentSize, combinerOps );
4541  }
4542 
4543  //=== VK_EXT_buffer_device_address ===
4544 
4546  {
4547  return ::vkGetBufferDeviceAddressEXT( device, pInfo );
4548  }
4549 
4550  //=== VK_EXT_tooling_info ===
4551 
4552  VkResult vkGetPhysicalDeviceToolPropertiesEXT( VkPhysicalDevice physicalDevice,
4553  uint32_t * pToolCount,
4554  VkPhysicalDeviceToolProperties * pToolProperties ) const VULKAN_HPP_NOEXCEPT
4555  {
4556  return ::vkGetPhysicalDeviceToolPropertiesEXT( physicalDevice, pToolCount, pToolProperties );
4557  }
4558 
4559  //=== VK_KHR_present_wait ===
4560 
4561  VkResult vkWaitForPresentKHR( VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout ) const VULKAN_HPP_NOEXCEPT
4562  {
4563  return ::vkWaitForPresentKHR( device, swapchain, presentId, timeout );
4564  }
4565 
4566  //=== VK_NV_cooperative_matrix ===
4567 
4569  uint32_t * pPropertyCount,
4571  {
4572  return ::vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( physicalDevice, pPropertyCount, pProperties );
4573  }
4574 
4575  //=== VK_NV_coverage_reduction_mode ===
4576 
4578  VkPhysicalDevice physicalDevice, uint32_t * pCombinationCount, VkFramebufferMixedSamplesCombinationNV * pCombinations ) const VULKAN_HPP_NOEXCEPT
4579  {
4580  return ::vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( physicalDevice, pCombinationCount, pCombinations );
4581  }
4582 
4583 # if defined( VK_USE_PLATFORM_WIN32_KHR )
4584  //=== VK_EXT_full_screen_exclusive ===
4585 
4586  VkResult vkGetPhysicalDeviceSurfacePresentModes2EXT( VkPhysicalDevice physicalDevice,
4587  const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
4588  uint32_t * pPresentModeCount,
4589  VkPresentModeKHR * pPresentModes ) const VULKAN_HPP_NOEXCEPT
4590  {
4591  return ::vkGetPhysicalDeviceSurfacePresentModes2EXT( physicalDevice, pSurfaceInfo, pPresentModeCount, pPresentModes );
4592  }
4593 
4594  VkResult vkAcquireFullScreenExclusiveModeEXT( VkDevice device, VkSwapchainKHR swapchain ) const VULKAN_HPP_NOEXCEPT
4595  {
4596  return ::vkAcquireFullScreenExclusiveModeEXT( device, swapchain );
4597  }
4598 
4599  VkResult vkReleaseFullScreenExclusiveModeEXT( VkDevice device, VkSwapchainKHR swapchain ) const VULKAN_HPP_NOEXCEPT
4600  {
4601  return ::vkReleaseFullScreenExclusiveModeEXT( device, swapchain );
4602  }
4603 
4605  const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
4607  {
4608  return ::vkGetDeviceGroupSurfacePresentModes2EXT( device, pSurfaceInfo, pModes );
4609  }
4610 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
4611 
4612  //=== VK_EXT_headless_surface ===
4613 
4614  VkResult vkCreateHeadlessSurfaceEXT( VkInstance instance,
4615  const VkHeadlessSurfaceCreateInfoEXT * pCreateInfo,
4616  const VkAllocationCallbacks * pAllocator,
4617  VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
4618  {
4619  return ::vkCreateHeadlessSurfaceEXT( instance, pCreateInfo, pAllocator, pSurface );
4620  }
4621 
4622  //=== VK_KHR_buffer_device_address ===
4623 
4625  {
4626  return ::vkGetBufferDeviceAddressKHR( device, pInfo );
4627  }
4628 
4630  {
4632  }
4633 
4635  {
4637  }
4638 
4639  //=== VK_EXT_line_rasterization ===
4640 
4641  void vkCmdSetLineStippleEXT( VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT
4642  {
4643  return ::vkCmdSetLineStippleEXT( commandBuffer, lineStippleFactor, lineStipplePattern );
4644  }
4645 
4646  //=== VK_EXT_host_query_reset ===
4647 
4648  void vkResetQueryPoolEXT( VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT
4649  {
4650  return ::vkResetQueryPoolEXT( device, queryPool, firstQuery, queryCount );
4651  }
4652 
4653  //=== VK_EXT_extended_dynamic_state ===
4654 
4655  void vkCmdSetCullModeEXT( VkCommandBuffer commandBuffer, VkCullModeFlags cullMode ) const VULKAN_HPP_NOEXCEPT
4656  {
4657  return ::vkCmdSetCullModeEXT( commandBuffer, cullMode );
4658  }
4659 
4660  void vkCmdSetFrontFaceEXT( VkCommandBuffer commandBuffer, VkFrontFace frontFace ) const VULKAN_HPP_NOEXCEPT
4661  {
4662  return ::vkCmdSetFrontFaceEXT( commandBuffer, frontFace );
4663  }
4664 
4665  void vkCmdSetPrimitiveTopologyEXT( VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT
4666  {
4667  return ::vkCmdSetPrimitiveTopologyEXT( commandBuffer, primitiveTopology );
4668  }
4669 
4670  void vkCmdSetViewportWithCountEXT( VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport * pViewports ) const VULKAN_HPP_NOEXCEPT
4671  {
4672  return ::vkCmdSetViewportWithCountEXT( commandBuffer, viewportCount, pViewports );
4673  }
4674 
4675  void vkCmdSetScissorWithCountEXT( VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D * pScissors ) const VULKAN_HPP_NOEXCEPT
4676  {
4677  return ::vkCmdSetScissorWithCountEXT( commandBuffer, scissorCount, pScissors );
4678  }
4679 
4680  void vkCmdBindVertexBuffers2EXT( VkCommandBuffer commandBuffer,
4681  uint32_t firstBinding,
4682  uint32_t bindingCount,
4683  const VkBuffer * pBuffers,
4684  const VkDeviceSize * pOffsets,
4685  const VkDeviceSize * pSizes,
4686  const VkDeviceSize * pStrides ) const VULKAN_HPP_NOEXCEPT
4687  {
4688  return ::vkCmdBindVertexBuffers2EXT( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides );
4689  }
4690 
4691  void vkCmdSetDepthTestEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT
4692  {
4693  return ::vkCmdSetDepthTestEnableEXT( commandBuffer, depthTestEnable );
4694  }
4695 
4696  void vkCmdSetDepthWriteEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT
4697  {
4698  return ::vkCmdSetDepthWriteEnableEXT( commandBuffer, depthWriteEnable );
4699  }
4700 
4701  void vkCmdSetDepthCompareOpEXT( VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT
4702  {
4703  return ::vkCmdSetDepthCompareOpEXT( commandBuffer, depthCompareOp );
4704  }
4705 
4706  void vkCmdSetDepthBoundsTestEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT
4707  {
4708  return ::vkCmdSetDepthBoundsTestEnableEXT( commandBuffer, depthBoundsTestEnable );
4709  }
4710 
4711  void vkCmdSetStencilTestEnableEXT( VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT
4712  {
4713  return ::vkCmdSetStencilTestEnableEXT( commandBuffer, stencilTestEnable );
4714  }
4715 
4716  void vkCmdSetStencilOpEXT( VkCommandBuffer commandBuffer,
4717  VkStencilFaceFlags faceMask,
4718  VkStencilOp failOp,
4719  VkStencilOp passOp,
4720  VkStencilOp depthFailOp,
4721  VkCompareOp compareOp ) const VULKAN_HPP_NOEXCEPT
4722  {
4723  return ::vkCmdSetStencilOpEXT( commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp );
4724  }
4725 
4726  //=== VK_KHR_deferred_host_operations ===
4727 
4729  const VkAllocationCallbacks * pAllocator,
4730  VkDeferredOperationKHR * pDeferredOperation ) const VULKAN_HPP_NOEXCEPT
4731  {
4732  return ::vkCreateDeferredOperationKHR( device, pAllocator, pDeferredOperation );
4733  }
4734 
4735  void vkDestroyDeferredOperationKHR( VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
4736  {
4737  return ::vkDestroyDeferredOperationKHR( device, operation, pAllocator );
4738  }
4739 
4740  uint32_t vkGetDeferredOperationMaxConcurrencyKHR( VkDevice device, VkDeferredOperationKHR operation ) const VULKAN_HPP_NOEXCEPT
4741  {
4743  }
4744 
4745  VkResult vkGetDeferredOperationResultKHR( VkDevice device, VkDeferredOperationKHR operation ) const VULKAN_HPP_NOEXCEPT
4746  {
4747  return ::vkGetDeferredOperationResultKHR( device, operation );
4748  }
4749 
4750  VkResult vkDeferredOperationJoinKHR( VkDevice device, VkDeferredOperationKHR operation ) const VULKAN_HPP_NOEXCEPT
4751  {
4752  return ::vkDeferredOperationJoinKHR( device, operation );
4753  }
4754 
4755  //=== VK_KHR_pipeline_executable_properties ===
4756 
4758  const VkPipelineInfoKHR * pPipelineInfo,
4759  uint32_t * pExecutableCount,
4761  {
4762  return ::vkGetPipelineExecutablePropertiesKHR( device, pPipelineInfo, pExecutableCount, pProperties );
4763  }
4764 
4766  const VkPipelineExecutableInfoKHR * pExecutableInfo,
4767  uint32_t * pStatisticCount,
4769  {
4770  return ::vkGetPipelineExecutableStatisticsKHR( device, pExecutableInfo, pStatisticCount, pStatistics );
4771  }
4772 
4773  VkResult
4775  const VkPipelineExecutableInfoKHR * pExecutableInfo,
4776  uint32_t * pInternalRepresentationCount,
4777  VkPipelineExecutableInternalRepresentationKHR * pInternalRepresentations ) const VULKAN_HPP_NOEXCEPT
4778  {
4779  return ::vkGetPipelineExecutableInternalRepresentationsKHR( device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations );
4780  }
4781 
4782  //=== VK_NV_device_generated_commands ===
4783 
4786  VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
4787  {
4788  return ::vkGetGeneratedCommandsMemoryRequirementsNV( device, pInfo, pMemoryRequirements );
4789  }
4790 
4791  void vkCmdPreprocessGeneratedCommandsNV( VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV * pGeneratedCommandsInfo ) const VULKAN_HPP_NOEXCEPT
4792  {
4793  return ::vkCmdPreprocessGeneratedCommandsNV( commandBuffer, pGeneratedCommandsInfo );
4794  }
4795 
4796  void vkCmdExecuteGeneratedCommandsNV( VkCommandBuffer commandBuffer,
4797  VkBool32 isPreprocessed,
4798  const VkGeneratedCommandsInfoNV * pGeneratedCommandsInfo ) const VULKAN_HPP_NOEXCEPT
4799  {
4800  return ::vkCmdExecuteGeneratedCommandsNV( commandBuffer, isPreprocessed, pGeneratedCommandsInfo );
4801  }
4802 
4803  void vkCmdBindPipelineShaderGroupNV( VkCommandBuffer commandBuffer,
4804  VkPipelineBindPoint pipelineBindPoint,
4805  VkPipeline pipeline,
4806  uint32_t groupIndex ) const VULKAN_HPP_NOEXCEPT
4807  {
4808  return ::vkCmdBindPipelineShaderGroupNV( commandBuffer, pipelineBindPoint, pipeline, groupIndex );
4809  }
4810 
4812  const VkIndirectCommandsLayoutCreateInfoNV * pCreateInfo,
4813  const VkAllocationCallbacks * pAllocator,
4814  VkIndirectCommandsLayoutNV * pIndirectCommandsLayout ) const VULKAN_HPP_NOEXCEPT
4815  {
4816  return ::vkCreateIndirectCommandsLayoutNV( device, pCreateInfo, pAllocator, pIndirectCommandsLayout );
4817  }
4818 
4819  void vkDestroyIndirectCommandsLayoutNV( VkDevice device,
4820  VkIndirectCommandsLayoutNV indirectCommandsLayout,
4821  const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
4822  {
4823  return ::vkDestroyIndirectCommandsLayoutNV( device, indirectCommandsLayout, pAllocator );
4824  }
4825 
4826  //=== VK_EXT_acquire_drm_display ===
4827 
4828  VkResult vkAcquireDrmDisplayEXT( VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT
4829  {
4830  return ::vkAcquireDrmDisplayEXT( physicalDevice, drmFd, display );
4831  }
4832 
4833  VkResult vkGetDrmDisplayEXT( VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR * display ) const VULKAN_HPP_NOEXCEPT
4834  {
4835  return ::vkGetDrmDisplayEXT( physicalDevice, drmFd, connectorId, display );
4836  }
4837 
4838  //=== VK_EXT_private_data ===
4839 
4841  const VkPrivateDataSlotCreateInfo * pCreateInfo,
4842  const VkAllocationCallbacks * pAllocator,
4843  VkPrivateDataSlot * pPrivateDataSlot ) const VULKAN_HPP_NOEXCEPT
4844  {
4845  return ::vkCreatePrivateDataSlotEXT( device, pCreateInfo, pAllocator, pPrivateDataSlot );
4846  }
4847 
4848  void vkDestroyPrivateDataSlotEXT( VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
4849  {
4850  return ::vkDestroyPrivateDataSlotEXT( device, privateDataSlot, pAllocator );
4851  }
4852 
4853  VkResult vkSetPrivateDataEXT( VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data ) const
4855  {
4856  return ::vkSetPrivateDataEXT( device, objectType, objectHandle, privateDataSlot, data );
4857  }
4858 
4859  void vkGetPrivateDataEXT( VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t * pData ) const
4861  {
4862  return ::vkGetPrivateDataEXT( device, objectType, objectHandle, privateDataSlot, pData );
4863  }
4864 
4865 # if defined( VK_ENABLE_BETA_EXTENSIONS )
4866  //=== VK_KHR_video_encode_queue ===
4867 
4868  void vkCmdEncodeVideoKHR( VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR * pEncodeInfo ) const VULKAN_HPP_NOEXCEPT
4869  {
4870  return ::vkCmdEncodeVideoKHR( commandBuffer, pEncodeInfo );
4871  }
4872 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
4873 
4874 # if defined( VK_USE_PLATFORM_METAL_EXT )
4875  //=== VK_EXT_metal_objects ===
4876 
4877  void vkExportMetalObjectsEXT( VkDevice device, VkExportMetalObjectsInfoEXT * pMetalObjectsInfo ) const VULKAN_HPP_NOEXCEPT
4878  {
4879  return ::vkExportMetalObjectsEXT( device, pMetalObjectsInfo );
4880  }
4881 # endif /*VK_USE_PLATFORM_METAL_EXT*/
4882 
4883  //=== VK_KHR_synchronization2 ===
4884 
4885  void vkCmdSetEvent2KHR( VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT
4886  {
4887  return ::vkCmdSetEvent2KHR( commandBuffer, event, pDependencyInfo );
4888  }
4889 
4890  void vkCmdResetEvent2KHR( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask ) const VULKAN_HPP_NOEXCEPT
4891  {
4892  return ::vkCmdResetEvent2KHR( commandBuffer, event, stageMask );
4893  }
4894 
4895  void vkCmdWaitEvents2KHR( VkCommandBuffer commandBuffer,
4896  uint32_t eventCount,
4897  const VkEvent * pEvents,
4898  const VkDependencyInfo * pDependencyInfos ) const VULKAN_HPP_NOEXCEPT
4899  {
4900  return ::vkCmdWaitEvents2KHR( commandBuffer, eventCount, pEvents, pDependencyInfos );
4901  }
4902 
4903  void vkCmdPipelineBarrier2KHR( VkCommandBuffer commandBuffer, const VkDependencyInfo * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT
4904  {
4905  return ::vkCmdPipelineBarrier2KHR( commandBuffer, pDependencyInfo );
4906  }
4907 
4908  void vkCmdWriteTimestamp2KHR( VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT
4909  {
4910  return ::vkCmdWriteTimestamp2KHR( commandBuffer, stage, queryPool, query );
4911  }
4912 
4913  VkResult vkQueueSubmit2KHR( VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 * pSubmits, VkFence fence ) const VULKAN_HPP_NOEXCEPT
4914  {
4915  return ::vkQueueSubmit2KHR( queue, submitCount, pSubmits, fence );
4916  }
4917 
4919  VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker ) const VULKAN_HPP_NOEXCEPT
4920  {
4921  return ::vkCmdWriteBufferMarker2AMD( commandBuffer, stage, dstBuffer, dstOffset, marker );
4922  }
4923 
4924  void vkGetQueueCheckpointData2NV( VkQueue queue, uint32_t * pCheckpointDataCount, VkCheckpointData2NV * pCheckpointData ) const VULKAN_HPP_NOEXCEPT
4925  {
4926  return ::vkGetQueueCheckpointData2NV( queue, pCheckpointDataCount, pCheckpointData );
4927  }
4928 
4929  //=== VK_EXT_descriptor_buffer ===
4930 
4931  void vkGetDescriptorSetLayoutSizeEXT( VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize * pLayoutSizeInBytes ) const VULKAN_HPP_NOEXCEPT
4932  {
4933  return ::vkGetDescriptorSetLayoutSizeEXT( device, layout, pLayoutSizeInBytes );
4934  }
4935 
4937  VkDescriptorSetLayout layout,
4938  uint32_t binding,
4939  VkDeviceSize * pOffset ) const VULKAN_HPP_NOEXCEPT
4940  {
4941  return ::vkGetDescriptorSetLayoutBindingOffsetEXT( device, layout, binding, pOffset );
4942  }
4943 
4944  void vkGetDescriptorEXT( VkDevice device, const VkDescriptorGetInfoEXT * pDescriptorInfo, size_t dataSize, void * pDescriptor ) const VULKAN_HPP_NOEXCEPT
4945  {
4946  return ::vkGetDescriptorEXT( device, pDescriptorInfo, dataSize, pDescriptor );
4947  }
4948 
4949  void vkCmdBindDescriptorBuffersEXT( VkCommandBuffer commandBuffer,
4950  uint32_t bufferCount,
4951  const VkDescriptorBufferBindingInfoEXT * pBindingInfos ) const VULKAN_HPP_NOEXCEPT
4952  {
4953  return ::vkCmdBindDescriptorBuffersEXT( commandBuffer, bufferCount, pBindingInfos );
4954  }
4955 
4956  void vkCmdSetDescriptorBufferOffsetsEXT( VkCommandBuffer commandBuffer,
4957  VkPipelineBindPoint pipelineBindPoint,
4958  VkPipelineLayout layout,
4959  uint32_t firstSet,
4960  uint32_t setCount,
4961  const uint32_t * pBufferIndices,
4962  const VkDeviceSize * pOffsets ) const VULKAN_HPP_NOEXCEPT
4963  {
4964  return ::vkCmdSetDescriptorBufferOffsetsEXT( commandBuffer, pipelineBindPoint, layout, firstSet, setCount, pBufferIndices, pOffsets );
4965  }
4966 
4967  void vkCmdBindDescriptorBufferEmbeddedSamplersEXT( VkCommandBuffer commandBuffer,
4968  VkPipelineBindPoint pipelineBindPoint,
4969  VkPipelineLayout layout,
4970  uint32_t set ) const VULKAN_HPP_NOEXCEPT
4971  {
4972  return ::vkCmdBindDescriptorBufferEmbeddedSamplersEXT( commandBuffer, pipelineBindPoint, layout, set );
4973  }
4974 
4975  VkResult
4977  {
4979  }
4980 
4981  VkResult
4983  {
4984  return ::vkGetImageOpaqueCaptureDescriptorDataEXT( device, pInfo, pData );
4985  }
4986 
4989  void * pData ) const VULKAN_HPP_NOEXCEPT
4990  {
4992  }
4993 
4994  VkResult
4996  {
4998  }
4999 
5002  void * pData ) const VULKAN_HPP_NOEXCEPT
5003  {
5005  }
5006 
5007  //=== VK_NV_fragment_shading_rate_enums ===
5008 
5009  void vkCmdSetFragmentShadingRateEnumNV( VkCommandBuffer commandBuffer,
5010  VkFragmentShadingRateNV shadingRate,
5011  const VkFragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT
5012  {
5013  return ::vkCmdSetFragmentShadingRateEnumNV( commandBuffer, shadingRate, combinerOps );
5014  }
5015 
5016  //=== VK_EXT_mesh_shader ===
5017 
5018  void vkCmdDrawMeshTasksEXT( VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
5019  {
5020  return ::vkCmdDrawMeshTasksEXT( commandBuffer, groupCountX, groupCountY, groupCountZ );
5021  }
5022 
5023  void vkCmdDrawMeshTasksIndirectEXT( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const
5025  {
5026  return ::vkCmdDrawMeshTasksIndirectEXT( commandBuffer, buffer, offset, drawCount, stride );
5027  }
5028 
5029  void vkCmdDrawMeshTasksIndirectCountEXT( VkCommandBuffer commandBuffer,
5030  VkBuffer buffer,
5032  VkBuffer countBuffer,
5033  VkDeviceSize countBufferOffset,
5034  uint32_t maxDrawCount,
5035  uint32_t stride ) const VULKAN_HPP_NOEXCEPT
5036  {
5037  return ::vkCmdDrawMeshTasksIndirectCountEXT( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
5038  }
5039 
5040  //=== VK_KHR_copy_commands2 ===
5041 
5042  void vkCmdCopyBuffer2KHR( VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 * pCopyBufferInfo ) const VULKAN_HPP_NOEXCEPT
5043  {
5044  return ::vkCmdCopyBuffer2KHR( commandBuffer, pCopyBufferInfo );
5045  }
5046 
5047  void vkCmdCopyImage2KHR( VkCommandBuffer commandBuffer, const VkCopyImageInfo2 * pCopyImageInfo ) const VULKAN_HPP_NOEXCEPT
5048  {
5049  return ::vkCmdCopyImage2KHR( commandBuffer, pCopyImageInfo );
5050  }
5051 
5052  void vkCmdCopyBufferToImage2KHR( VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 * pCopyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT
5053  {
5054  return ::vkCmdCopyBufferToImage2KHR( commandBuffer, pCopyBufferToImageInfo );
5055  }
5056 
5057  void vkCmdCopyImageToBuffer2KHR( VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 * pCopyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT
5058  {
5059  return ::vkCmdCopyImageToBuffer2KHR( commandBuffer, pCopyImageToBufferInfo );
5060  }
5061 
5062  void vkCmdBlitImage2KHR( VkCommandBuffer commandBuffer, const VkBlitImageInfo2 * pBlitImageInfo ) const VULKAN_HPP_NOEXCEPT
5063  {
5064  return ::vkCmdBlitImage2KHR( commandBuffer, pBlitImageInfo );
5065  }
5066 
5067  void vkCmdResolveImage2KHR( VkCommandBuffer commandBuffer, const VkResolveImageInfo2 * pResolveImageInfo ) const VULKAN_HPP_NOEXCEPT
5068  {
5069  return ::vkCmdResolveImage2KHR( commandBuffer, pResolveImageInfo );
5070  }
5071 
5072  //=== VK_EXT_image_compression_control ===
5073 
5074  void vkGetImageSubresourceLayout2EXT( VkDevice device,
5075  VkImage image,
5076  const VkImageSubresource2EXT * pSubresource,
5078  {
5079  return ::vkGetImageSubresourceLayout2EXT( device, image, pSubresource, pLayout );
5080  }
5081 
5082  //=== VK_EXT_device_fault ===
5083 
5085  {
5086  return ::vkGetDeviceFaultInfoEXT( device, pFaultCounts, pFaultInfo );
5087  }
5088 
5089 # if defined( VK_USE_PLATFORM_WIN32_KHR )
5090  //=== VK_NV_acquire_winrt_display ===
5091 
5092  VkResult vkAcquireWinrtDisplayNV( VkPhysicalDevice physicalDevice, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT
5093  {
5094  return ::vkAcquireWinrtDisplayNV( physicalDevice, display );
5095  }
5096 
5097  VkResult vkGetWinrtDisplayNV( VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR * pDisplay ) const VULKAN_HPP_NOEXCEPT
5098  {
5099  return ::vkGetWinrtDisplayNV( physicalDevice, deviceRelativeId, pDisplay );
5100  }
5101 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
5102 
5103 # if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
5104  //=== VK_EXT_directfb_surface ===
5105 
5106  VkResult vkCreateDirectFBSurfaceEXT( VkInstance instance,
5107  const VkDirectFBSurfaceCreateInfoEXT * pCreateInfo,
5108  const VkAllocationCallbacks * pAllocator,
5109  VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
5110  {
5111  return ::vkCreateDirectFBSurfaceEXT( instance, pCreateInfo, pAllocator, pSurface );
5112  }
5113 
5114  VkBool32
5115  vkGetPhysicalDeviceDirectFBPresentationSupportEXT( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, IDirectFB * dfb ) const VULKAN_HPP_NOEXCEPT
5116  {
5117  return ::vkGetPhysicalDeviceDirectFBPresentationSupportEXT( physicalDevice, queueFamilyIndex, dfb );
5118  }
5119 # endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
5120 
5121  //=== VK_KHR_ray_tracing_pipeline ===
5122 
5123  void vkCmdTraceRaysKHR( VkCommandBuffer commandBuffer,
5124  const VkStridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
5125  const VkStridedDeviceAddressRegionKHR * pMissShaderBindingTable,
5126  const VkStridedDeviceAddressRegionKHR * pHitShaderBindingTable,
5127  const VkStridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
5128  uint32_t width,
5129  uint32_t height,
5130  uint32_t depth ) const VULKAN_HPP_NOEXCEPT
5131  {
5133  commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth );
5134  }
5135 
5137  VkDeferredOperationKHR deferredOperation,
5138  VkPipelineCache pipelineCache,
5139  uint32_t createInfoCount,
5140  const VkRayTracingPipelineCreateInfoKHR * pCreateInfos,
5141  const VkAllocationCallbacks * pAllocator,
5142  VkPipeline * pPipelines ) const VULKAN_HPP_NOEXCEPT
5143  {
5144  return ::vkCreateRayTracingPipelinesKHR( device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
5145  }
5146 
5148  VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
5149  {
5150  return ::vkGetRayTracingShaderGroupHandlesKHR( device, pipeline, firstGroup, groupCount, dataSize, pData );
5151  }
5152 
5154  VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
5155  {
5156  return ::vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( device, pipeline, firstGroup, groupCount, dataSize, pData );
5157  }
5158 
5159  void vkCmdTraceRaysIndirectKHR( VkCommandBuffer commandBuffer,
5160  const VkStridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
5161  const VkStridedDeviceAddressRegionKHR * pMissShaderBindingTable,
5162  const VkStridedDeviceAddressRegionKHR * pHitShaderBindingTable,
5163  const VkStridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
5164  VkDeviceAddress indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT
5165  {
5167  commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress );
5168  }
5169 
5171  VkPipeline pipeline,
5172  uint32_t group,
5173  VkShaderGroupShaderKHR groupShader ) const VULKAN_HPP_NOEXCEPT
5174  {
5175  return ::vkGetRayTracingShaderGroupStackSizeKHR( device, pipeline, group, groupShader );
5176  }
5177 
5178  void vkCmdSetRayTracingPipelineStackSizeKHR( VkCommandBuffer commandBuffer, uint32_t pipelineStackSize ) const VULKAN_HPP_NOEXCEPT
5179  {
5180  return ::vkCmdSetRayTracingPipelineStackSizeKHR( commandBuffer, pipelineStackSize );
5181  }
5182 
5183  //=== VK_EXT_vertex_input_dynamic_state ===
5184 
5185  void vkCmdSetVertexInputEXT( VkCommandBuffer commandBuffer,
5186  uint32_t vertexBindingDescriptionCount,
5187  const VkVertexInputBindingDescription2EXT * pVertexBindingDescriptions,
5188  uint32_t vertexAttributeDescriptionCount,
5189  const VkVertexInputAttributeDescription2EXT * pVertexAttributeDescriptions ) const VULKAN_HPP_NOEXCEPT
5190  {
5192  commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions );
5193  }
5194 
5195 # if defined( VK_USE_PLATFORM_FUCHSIA )
5196  //=== VK_FUCHSIA_external_memory ===
5197 
5198  VkResult vkGetMemoryZirconHandleFUCHSIA( VkDevice device,
5199  const VkMemoryGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
5200  zx_handle_t * pZirconHandle ) const VULKAN_HPP_NOEXCEPT
5201  {
5202  return ::vkGetMemoryZirconHandleFUCHSIA( device, pGetZirconHandleInfo, pZirconHandle );
5203  }
5204 
5207  zx_handle_t zirconHandle,
5208  VkMemoryZirconHandlePropertiesFUCHSIA * pMemoryZirconHandleProperties ) const VULKAN_HPP_NOEXCEPT
5209  {
5210  return ::vkGetMemoryZirconHandlePropertiesFUCHSIA( device, handleType, zirconHandle, pMemoryZirconHandleProperties );
5211  }
5212 # endif /*VK_USE_PLATFORM_FUCHSIA*/
5213 
5214 # if defined( VK_USE_PLATFORM_FUCHSIA )
5215  //=== VK_FUCHSIA_external_semaphore ===
5216 
5218  const VkImportSemaphoreZirconHandleInfoFUCHSIA * pImportSemaphoreZirconHandleInfo ) const VULKAN_HPP_NOEXCEPT
5219  {
5220  return ::vkImportSemaphoreZirconHandleFUCHSIA( device, pImportSemaphoreZirconHandleInfo );
5221  }
5222 
5224  const VkSemaphoreGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
5225  zx_handle_t * pZirconHandle ) const VULKAN_HPP_NOEXCEPT
5226  {
5227  return ::vkGetSemaphoreZirconHandleFUCHSIA( device, pGetZirconHandleInfo, pZirconHandle );
5228  }
5229 # endif /*VK_USE_PLATFORM_FUCHSIA*/
5230 
5231 # if defined( VK_USE_PLATFORM_FUCHSIA )
5232  //=== VK_FUCHSIA_buffer_collection ===
5233 
5234  VkResult vkCreateBufferCollectionFUCHSIA( VkDevice device,
5235  const VkBufferCollectionCreateInfoFUCHSIA * pCreateInfo,
5236  const VkAllocationCallbacks * pAllocator,
5237  VkBufferCollectionFUCHSIA * pCollection ) const VULKAN_HPP_NOEXCEPT
5238  {
5239  return ::vkCreateBufferCollectionFUCHSIA( device, pCreateInfo, pAllocator, pCollection );
5240  }
5241 
5243  VkBufferCollectionFUCHSIA collection,
5244  const VkImageConstraintsInfoFUCHSIA * pImageConstraintsInfo ) const VULKAN_HPP_NOEXCEPT
5245  {
5246  return ::vkSetBufferCollectionImageConstraintsFUCHSIA( device, collection, pImageConstraintsInfo );
5247  }
5248 
5250  VkBufferCollectionFUCHSIA collection,
5251  const VkBufferConstraintsInfoFUCHSIA * pBufferConstraintsInfo ) const VULKAN_HPP_NOEXCEPT
5252  {
5253  return ::vkSetBufferCollectionBufferConstraintsFUCHSIA( device, collection, pBufferConstraintsInfo );
5254  }
5255 
5256  void vkDestroyBufferCollectionFUCHSIA( VkDevice device,
5257  VkBufferCollectionFUCHSIA collection,
5258  const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
5259  {
5260  return ::vkDestroyBufferCollectionFUCHSIA( device, collection, pAllocator );
5261  }
5262 
5264  VkBufferCollectionFUCHSIA collection,
5266  {
5267  return ::vkGetBufferCollectionPropertiesFUCHSIA( device, collection, pProperties );
5268  }
5269 # endif /*VK_USE_PLATFORM_FUCHSIA*/
5270 
5271  //=== VK_HUAWEI_subpass_shading ===
5272 
5273  VkResult
5274  vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( VkDevice device, VkRenderPass renderpass, VkExtent2D * pMaxWorkgroupSize ) const VULKAN_HPP_NOEXCEPT
5275  {
5276  return ::vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( device, renderpass, pMaxWorkgroupSize );
5277  }
5278 
5279  void vkCmdSubpassShadingHUAWEI( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
5280  {
5281  return ::vkCmdSubpassShadingHUAWEI( commandBuffer );
5282  }
5283 
5284  //=== VK_HUAWEI_invocation_mask ===
5285 
5286  void vkCmdBindInvocationMaskHUAWEI( VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT
5287  {
5288  return ::vkCmdBindInvocationMaskHUAWEI( commandBuffer, imageView, imageLayout );
5289  }
5290 
5291  //=== VK_NV_external_memory_rdma ===
5292 
5294  const VkMemoryGetRemoteAddressInfoNV * pMemoryGetRemoteAddressInfo,
5295  VkRemoteAddressNV * pAddress ) const VULKAN_HPP_NOEXCEPT
5296  {
5297  return ::vkGetMemoryRemoteAddressNV( device, pMemoryGetRemoteAddressInfo, pAddress );
5298  }
5299 
5300  //=== VK_EXT_pipeline_properties ===
5301 
5302  VkResult
5303  vkGetPipelinePropertiesEXT( VkDevice device, const VkPipelineInfoEXT * pPipelineInfo, VkBaseOutStructure * pPipelineProperties ) const VULKAN_HPP_NOEXCEPT
5304  {
5305  return ::vkGetPipelinePropertiesEXT( device, pPipelineInfo, pPipelineProperties );
5306  }
5307 
5308  //=== VK_EXT_extended_dynamic_state2 ===
5309 
5310  void vkCmdSetPatchControlPointsEXT( VkCommandBuffer commandBuffer, uint32_t patchControlPoints ) const VULKAN_HPP_NOEXCEPT
5311  {
5312  return ::vkCmdSetPatchControlPointsEXT( commandBuffer, patchControlPoints );
5313  }
5314 
5315  void vkCmdSetRasterizerDiscardEnableEXT( VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT
5316  {
5317  return ::vkCmdSetRasterizerDiscardEnableEXT( commandBuffer, rasterizerDiscardEnable );
5318  }
5319 
5320  void vkCmdSetDepthBiasEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT
5321  {
5322  return ::vkCmdSetDepthBiasEnableEXT( commandBuffer, depthBiasEnable );
5323  }
5324 
5325  void vkCmdSetLogicOpEXT( VkCommandBuffer commandBuffer, VkLogicOp logicOp ) const VULKAN_HPP_NOEXCEPT
5326  {
5327  return ::vkCmdSetLogicOpEXT( commandBuffer, logicOp );
5328  }
5329 
5330  void vkCmdSetPrimitiveRestartEnableEXT( VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT
5331  {
5332  return ::vkCmdSetPrimitiveRestartEnableEXT( commandBuffer, primitiveRestartEnable );
5333  }
5334 
5335 # if defined( VK_USE_PLATFORM_SCREEN_QNX )
5336  //=== VK_QNX_screen_surface ===
5337 
5338  VkResult vkCreateScreenSurfaceQNX( VkInstance instance,
5339  const VkScreenSurfaceCreateInfoQNX * pCreateInfo,
5340  const VkAllocationCallbacks * pAllocator,
5341  VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
5342  {
5343  return ::vkCreateScreenSurfaceQNX( instance, pCreateInfo, pAllocator, pSurface );
5344  }
5345 
5346  VkBool32 vkGetPhysicalDeviceScreenPresentationSupportQNX( VkPhysicalDevice physicalDevice,
5347  uint32_t queueFamilyIndex,
5348  struct _screen_window * window ) const VULKAN_HPP_NOEXCEPT
5349  {
5350  return ::vkGetPhysicalDeviceScreenPresentationSupportQNX( physicalDevice, queueFamilyIndex, window );
5351  }
5352 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/
5353 
5354  //=== VK_EXT_color_write_enable ===
5355 
5356  void vkCmdSetColorWriteEnableEXT( VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32 * pColorWriteEnables ) const VULKAN_HPP_NOEXCEPT
5357  {
5358  return ::vkCmdSetColorWriteEnableEXT( commandBuffer, attachmentCount, pColorWriteEnables );
5359  }
5360 
5361  //=== VK_KHR_ray_tracing_maintenance1 ===
5362 
5363  void vkCmdTraceRaysIndirect2KHR( VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT
5364  {
5365  return ::vkCmdTraceRaysIndirect2KHR( commandBuffer, indirectDeviceAddress );
5366  }
5367 
5368  //=== VK_EXT_multi_draw ===
5369 
5370  void vkCmdDrawMultiEXT( VkCommandBuffer commandBuffer,
5371  uint32_t drawCount,
5372  const VkMultiDrawInfoEXT * pVertexInfo,
5373  uint32_t instanceCount,
5374  uint32_t firstInstance,
5375  uint32_t stride ) const VULKAN_HPP_NOEXCEPT
5376  {
5377  return ::vkCmdDrawMultiEXT( commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride );
5378  }
5379 
5380  void vkCmdDrawMultiIndexedEXT( VkCommandBuffer commandBuffer,
5381  uint32_t drawCount,
5382  const VkMultiDrawIndexedInfoEXT * pIndexInfo,
5383  uint32_t instanceCount,
5384  uint32_t firstInstance,
5385  uint32_t stride,
5386  const int32_t * pVertexOffset ) const VULKAN_HPP_NOEXCEPT
5387  {
5388  return ::vkCmdDrawMultiIndexedEXT( commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset );
5389  }
5390 
5391  //=== VK_EXT_opacity_micromap ===
5392 
5393  VkResult vkCreateMicromapEXT( VkDevice device,
5394  const VkMicromapCreateInfoEXT * pCreateInfo,
5395  const VkAllocationCallbacks * pAllocator,
5396  VkMicromapEXT * pMicromap ) const VULKAN_HPP_NOEXCEPT
5397  {
5398  return ::vkCreateMicromapEXT( device, pCreateInfo, pAllocator, pMicromap );
5399  }
5400 
5401  void vkDestroyMicromapEXT( VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
5402  {
5403  return ::vkDestroyMicromapEXT( device, micromap, pAllocator );
5404  }
5405 
5406  void vkCmdBuildMicromapsEXT( VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT * pInfos ) const VULKAN_HPP_NOEXCEPT
5407  {
5408  return ::vkCmdBuildMicromapsEXT( commandBuffer, infoCount, pInfos );
5409  }
5410 
5411  VkResult vkBuildMicromapsEXT( VkDevice device,
5412  VkDeferredOperationKHR deferredOperation,
5413  uint32_t infoCount,
5414  const VkMicromapBuildInfoEXT * pInfos ) const VULKAN_HPP_NOEXCEPT
5415  {
5416  return ::vkBuildMicromapsEXT( device, deferredOperation, infoCount, pInfos );
5417  }
5418 
5419  VkResult vkCopyMicromapEXT( VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT
5420  {
5421  return ::vkCopyMicromapEXT( device, deferredOperation, pInfo );
5422  }
5423 
5425  VkDeferredOperationKHR deferredOperation,
5427  {
5428  return ::vkCopyMicromapToMemoryEXT( device, deferredOperation, pInfo );
5429  }
5430 
5432  VkDeferredOperationKHR deferredOperation,
5434  {
5435  return ::vkCopyMemoryToMicromapEXT( device, deferredOperation, pInfo );
5436  }
5437 
5439  uint32_t micromapCount,
5440  const VkMicromapEXT * pMicromaps,
5441  VkQueryType queryType,
5442  size_t dataSize,
5443  void * pData,
5444  size_t stride ) const VULKAN_HPP_NOEXCEPT
5445  {
5446  return ::vkWriteMicromapsPropertiesEXT( device, micromapCount, pMicromaps, queryType, dataSize, pData, stride );
5447  }
5448 
5449  void vkCmdCopyMicromapEXT( VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT
5450  {
5451  return ::vkCmdCopyMicromapEXT( commandBuffer, pInfo );
5452  }
5453 
5454  void vkCmdCopyMicromapToMemoryEXT( VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT
5455  {
5456  return ::vkCmdCopyMicromapToMemoryEXT( commandBuffer, pInfo );
5457  }
5458 
5459  void vkCmdCopyMemoryToMicromapEXT( VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT
5460  {
5461  return ::vkCmdCopyMemoryToMicromapEXT( commandBuffer, pInfo );
5462  }
5463 
5464  void vkCmdWriteMicromapsPropertiesEXT( VkCommandBuffer commandBuffer,
5465  uint32_t micromapCount,
5466  const VkMicromapEXT * pMicromaps,
5467  VkQueryType queryType,
5468  VkQueryPool queryPool,
5469  uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT
5470  {
5471  return ::vkCmdWriteMicromapsPropertiesEXT( commandBuffer, micromapCount, pMicromaps, queryType, queryPool, firstQuery );
5472  }
5473 
5475  const VkMicromapVersionInfoEXT * pVersionInfo,
5477  {
5478  return ::vkGetDeviceMicromapCompatibilityEXT( device, pVersionInfo, pCompatibility );
5479  }
5480 
5481  void vkGetMicromapBuildSizesEXT( VkDevice device,
5483  const VkMicromapBuildInfoEXT * pBuildInfo,
5485  {
5486  return ::vkGetMicromapBuildSizesEXT( device, buildType, pBuildInfo, pSizeInfo );
5487  }
5488 
5489  //=== VK_EXT_pageable_device_local_memory ===
5490 
5491  void vkSetDeviceMemoryPriorityEXT( VkDevice device, VkDeviceMemory memory, float priority ) const VULKAN_HPP_NOEXCEPT
5492  {
5493  return ::vkSetDeviceMemoryPriorityEXT( device, memory, priority );
5494  }
5495 
5496  //=== VK_KHR_maintenance4 ===
5497 
5499  const VkDeviceBufferMemoryRequirements * pInfo,
5500  VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
5501  {
5502  return ::vkGetDeviceBufferMemoryRequirementsKHR( device, pInfo, pMemoryRequirements );
5503  }
5504 
5506  const VkDeviceImageMemoryRequirements * pInfo,
5507  VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
5508  {
5509  return ::vkGetDeviceImageMemoryRequirementsKHR( device, pInfo, pMemoryRequirements );
5510  }
5511 
5513  const VkDeviceImageMemoryRequirements * pInfo,
5514  uint32_t * pSparseMemoryRequirementCount,
5515  VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
5516  {
5517  return ::vkGetDeviceImageSparseMemoryRequirementsKHR( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
5518  }
5519 
5520  //=== VK_VALVE_descriptor_set_host_mapping ===
5521 
5523  const VkDescriptorSetBindingReferenceVALVE * pBindingReference,
5525  {
5526  return ::vkGetDescriptorSetLayoutHostMappingInfoVALVE( device, pBindingReference, pHostMapping );
5527  }
5528 
5529  void vkGetDescriptorSetHostMappingVALVE( VkDevice device, VkDescriptorSet descriptorSet, void ** ppData ) const VULKAN_HPP_NOEXCEPT
5530  {
5531  return ::vkGetDescriptorSetHostMappingVALVE( device, descriptorSet, ppData );
5532  }
5533 
5534  //=== VK_NV_copy_memory_indirect ===
5535 
5536  void vkCmdCopyMemoryIndirectNV( VkCommandBuffer commandBuffer,
5537  VkDeviceAddress copyBufferAddress,
5538  uint32_t copyCount,
5539  uint32_t stride ) const VULKAN_HPP_NOEXCEPT
5540  {
5541  return ::vkCmdCopyMemoryIndirectNV( commandBuffer, copyBufferAddress, copyCount, stride );
5542  }
5543 
5544  void vkCmdCopyMemoryToImageIndirectNV( VkCommandBuffer commandBuffer,
5545  VkDeviceAddress copyBufferAddress,
5546  uint32_t copyCount,
5547  uint32_t stride,
5548  VkImage dstImage,
5549  VkImageLayout dstImageLayout,
5550  const VkImageSubresourceLayers * pImageSubresources ) const VULKAN_HPP_NOEXCEPT
5551  {
5552  return ::vkCmdCopyMemoryToImageIndirectNV( commandBuffer, copyBufferAddress, copyCount, stride, dstImage, dstImageLayout, pImageSubresources );
5553  }
5554 
5555  //=== VK_NV_memory_decompression ===
5556 
5557  void vkCmdDecompressMemoryNV( VkCommandBuffer commandBuffer,
5558  uint32_t decompressRegionCount,
5559  const VkDecompressMemoryRegionNV * pDecompressMemoryRegions ) const VULKAN_HPP_NOEXCEPT
5560  {
5561  return ::vkCmdDecompressMemoryNV( commandBuffer, decompressRegionCount, pDecompressMemoryRegions );
5562  }
5563 
5564  void vkCmdDecompressMemoryIndirectCountNV( VkCommandBuffer commandBuffer,
5565  VkDeviceAddress indirectCommandsAddress,
5566  VkDeviceAddress indirectCommandsCountAddress,
5567  uint32_t stride ) const VULKAN_HPP_NOEXCEPT
5568  {
5569  return ::vkCmdDecompressMemoryIndirectCountNV( commandBuffer, indirectCommandsAddress, indirectCommandsCountAddress, stride );
5570  }
5571 
5572  //=== VK_EXT_extended_dynamic_state3 ===
5573 
5574  void vkCmdSetTessellationDomainOriginEXT( VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin ) const VULKAN_HPP_NOEXCEPT
5575  {
5576  return ::vkCmdSetTessellationDomainOriginEXT( commandBuffer, domainOrigin );
5577  }
5578 
5579  void vkCmdSetDepthClampEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthClampEnable ) const VULKAN_HPP_NOEXCEPT
5580  {
5581  return ::vkCmdSetDepthClampEnableEXT( commandBuffer, depthClampEnable );
5582  }
5583 
5584  void vkCmdSetPolygonModeEXT( VkCommandBuffer commandBuffer, VkPolygonMode polygonMode ) const VULKAN_HPP_NOEXCEPT
5585  {
5586  return ::vkCmdSetPolygonModeEXT( commandBuffer, polygonMode );
5587  }
5588 
5589  void vkCmdSetRasterizationSamplesEXT( VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples ) const VULKAN_HPP_NOEXCEPT
5590  {
5591  return ::vkCmdSetRasterizationSamplesEXT( commandBuffer, rasterizationSamples );
5592  }
5593 
5594  void vkCmdSetSampleMaskEXT( VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask * pSampleMask ) const VULKAN_HPP_NOEXCEPT
5595  {
5596  return ::vkCmdSetSampleMaskEXT( commandBuffer, samples, pSampleMask );
5597  }
5598 
5599  void vkCmdSetAlphaToCoverageEnableEXT( VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable ) const VULKAN_HPP_NOEXCEPT
5600  {
5601  return ::vkCmdSetAlphaToCoverageEnableEXT( commandBuffer, alphaToCoverageEnable );
5602  }
5603 
5604  void vkCmdSetAlphaToOneEnableEXT( VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable ) const VULKAN_HPP_NOEXCEPT
5605  {
5606  return ::vkCmdSetAlphaToOneEnableEXT( commandBuffer, alphaToOneEnable );
5607  }
5608 
5609  void vkCmdSetLogicOpEnableEXT( VkCommandBuffer commandBuffer, VkBool32 logicOpEnable ) const VULKAN_HPP_NOEXCEPT
5610  {
5611  return ::vkCmdSetLogicOpEnableEXT( commandBuffer, logicOpEnable );
5612  }
5613 
5614  void vkCmdSetColorBlendEnableEXT( VkCommandBuffer commandBuffer,
5615  uint32_t firstAttachment,
5616  uint32_t attachmentCount,
5617  const VkBool32 * pColorBlendEnables ) const VULKAN_HPP_NOEXCEPT
5618  {
5619  return ::vkCmdSetColorBlendEnableEXT( commandBuffer, firstAttachment, attachmentCount, pColorBlendEnables );
5620  }
5621 
5622  void vkCmdSetColorBlendEquationEXT( VkCommandBuffer commandBuffer,
5623  uint32_t firstAttachment,
5624  uint32_t attachmentCount,
5625  const VkColorBlendEquationEXT * pColorBlendEquations ) const VULKAN_HPP_NOEXCEPT
5626  {
5627  return ::vkCmdSetColorBlendEquationEXT( commandBuffer, firstAttachment, attachmentCount, pColorBlendEquations );
5628  }
5629 
5630  void vkCmdSetColorWriteMaskEXT( VkCommandBuffer commandBuffer,
5631  uint32_t firstAttachment,
5632  uint32_t attachmentCount,
5633  const VkColorComponentFlags * pColorWriteMasks ) const VULKAN_HPP_NOEXCEPT
5634  {
5635  return ::vkCmdSetColorWriteMaskEXT( commandBuffer, firstAttachment, attachmentCount, pColorWriteMasks );
5636  }
5637 
5638  void vkCmdSetRasterizationStreamEXT( VkCommandBuffer commandBuffer, uint32_t rasterizationStream ) const VULKAN_HPP_NOEXCEPT
5639  {
5640  return ::vkCmdSetRasterizationStreamEXT( commandBuffer, rasterizationStream );
5641  }
5642 
5643  void vkCmdSetConservativeRasterizationModeEXT( VkCommandBuffer commandBuffer,
5644  VkConservativeRasterizationModeEXT conservativeRasterizationMode ) const VULKAN_HPP_NOEXCEPT
5645  {
5646  return ::vkCmdSetConservativeRasterizationModeEXT( commandBuffer, conservativeRasterizationMode );
5647  }
5648 
5649  void vkCmdSetExtraPrimitiveOverestimationSizeEXT( VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize ) const VULKAN_HPP_NOEXCEPT
5650  {
5651  return ::vkCmdSetExtraPrimitiveOverestimationSizeEXT( commandBuffer, extraPrimitiveOverestimationSize );
5652  }
5653 
5654  void vkCmdSetDepthClipEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthClipEnable ) const VULKAN_HPP_NOEXCEPT
5655  {
5656  return ::vkCmdSetDepthClipEnableEXT( commandBuffer, depthClipEnable );
5657  }
5658 
5659  void vkCmdSetSampleLocationsEnableEXT( VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable ) const VULKAN_HPP_NOEXCEPT
5660  {
5661  return ::vkCmdSetSampleLocationsEnableEXT( commandBuffer, sampleLocationsEnable );
5662  }
5663 
5664  void vkCmdSetColorBlendAdvancedEXT( VkCommandBuffer commandBuffer,
5665  uint32_t firstAttachment,
5666  uint32_t attachmentCount,
5667  const VkColorBlendAdvancedEXT * pColorBlendAdvanced ) const VULKAN_HPP_NOEXCEPT
5668  {
5669  return ::vkCmdSetColorBlendAdvancedEXT( commandBuffer, firstAttachment, attachmentCount, pColorBlendAdvanced );
5670  }
5671 
5672  void vkCmdSetProvokingVertexModeEXT( VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode ) const VULKAN_HPP_NOEXCEPT
5673  {
5674  return ::vkCmdSetProvokingVertexModeEXT( commandBuffer, provokingVertexMode );
5675  }
5676 
5677  void vkCmdSetLineRasterizationModeEXT( VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode ) const VULKAN_HPP_NOEXCEPT
5678  {
5679  return ::vkCmdSetLineRasterizationModeEXT( commandBuffer, lineRasterizationMode );
5680  }
5681 
5682  void vkCmdSetLineStippleEnableEXT( VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable ) const VULKAN_HPP_NOEXCEPT
5683  {
5684  return ::vkCmdSetLineStippleEnableEXT( commandBuffer, stippledLineEnable );
5685  }
5686 
5687  void vkCmdSetDepthClipNegativeOneToOneEXT( VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne ) const VULKAN_HPP_NOEXCEPT
5688  {
5689  return ::vkCmdSetDepthClipNegativeOneToOneEXT( commandBuffer, negativeOneToOne );
5690  }
5691 
5692  void vkCmdSetViewportWScalingEnableNV( VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable ) const VULKAN_HPP_NOEXCEPT
5693  {
5694  return ::vkCmdSetViewportWScalingEnableNV( commandBuffer, viewportWScalingEnable );
5695  }
5696 
5697  void vkCmdSetViewportSwizzleNV( VkCommandBuffer commandBuffer,
5698  uint32_t firstViewport,
5699  uint32_t viewportCount,
5700  const VkViewportSwizzleNV * pViewportSwizzles ) const VULKAN_HPP_NOEXCEPT
5701  {
5702  return ::vkCmdSetViewportSwizzleNV( commandBuffer, firstViewport, viewportCount, pViewportSwizzles );
5703  }
5704 
5705  void vkCmdSetCoverageToColorEnableNV( VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable ) const VULKAN_HPP_NOEXCEPT
5706  {
5707  return ::vkCmdSetCoverageToColorEnableNV( commandBuffer, coverageToColorEnable );
5708  }
5709 
5710  void vkCmdSetCoverageToColorLocationNV( VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation ) const VULKAN_HPP_NOEXCEPT
5711  {
5712  return ::vkCmdSetCoverageToColorLocationNV( commandBuffer, coverageToColorLocation );
5713  }
5714 
5715  void vkCmdSetCoverageModulationModeNV( VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode ) const VULKAN_HPP_NOEXCEPT
5716  {
5717  return ::vkCmdSetCoverageModulationModeNV( commandBuffer, coverageModulationMode );
5718  }
5719 
5720  void vkCmdSetCoverageModulationTableEnableNV( VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable ) const VULKAN_HPP_NOEXCEPT
5721  {
5722  return ::vkCmdSetCoverageModulationTableEnableNV( commandBuffer, coverageModulationTableEnable );
5723  }
5724 
5725  void vkCmdSetCoverageModulationTableNV( VkCommandBuffer commandBuffer,
5726  uint32_t coverageModulationTableCount,
5727  const float * pCoverageModulationTable ) const VULKAN_HPP_NOEXCEPT
5728  {
5729  return ::vkCmdSetCoverageModulationTableNV( commandBuffer, coverageModulationTableCount, pCoverageModulationTable );
5730  }
5731 
5732  void vkCmdSetShadingRateImageEnableNV( VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable ) const VULKAN_HPP_NOEXCEPT
5733  {
5734  return ::vkCmdSetShadingRateImageEnableNV( commandBuffer, shadingRateImageEnable );
5735  }
5736 
5737  void vkCmdSetRepresentativeFragmentTestEnableNV( VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable ) const VULKAN_HPP_NOEXCEPT
5738  {
5739  return ::vkCmdSetRepresentativeFragmentTestEnableNV( commandBuffer, representativeFragmentTestEnable );
5740  }
5741 
5742  void vkCmdSetCoverageReductionModeNV( VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode ) const VULKAN_HPP_NOEXCEPT
5743  {
5744  return ::vkCmdSetCoverageReductionModeNV( commandBuffer, coverageReductionMode );
5745  }
5746 
5747  //=== VK_EXT_shader_module_identifier ===
5748 
5749  void vkGetShaderModuleIdentifierEXT( VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT * pIdentifier ) const VULKAN_HPP_NOEXCEPT
5750  {
5751  return ::vkGetShaderModuleIdentifierEXT( device, shaderModule, pIdentifier );
5752  }
5753 
5755  const VkShaderModuleCreateInfo * pCreateInfo,
5756  VkShaderModuleIdentifierEXT * pIdentifier ) const VULKAN_HPP_NOEXCEPT
5757  {
5758  return ::vkGetShaderModuleCreateInfoIdentifierEXT( device, pCreateInfo, pIdentifier );
5759  }
5760 
5761  //=== VK_NV_optical_flow ===
5762 
5763  VkResult vkGetPhysicalDeviceOpticalFlowImageFormatsNV( VkPhysicalDevice physicalDevice,
5764  const VkOpticalFlowImageFormatInfoNV * pOpticalFlowImageFormatInfo,
5765  uint32_t * pFormatCount,
5766  VkOpticalFlowImageFormatPropertiesNV * pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
5767  {
5768  return ::vkGetPhysicalDeviceOpticalFlowImageFormatsNV( physicalDevice, pOpticalFlowImageFormatInfo, pFormatCount, pImageFormatProperties );
5769  }
5770 
5772  const VkOpticalFlowSessionCreateInfoNV * pCreateInfo,
5773  const VkAllocationCallbacks * pAllocator,
5774  VkOpticalFlowSessionNV * pSession ) const VULKAN_HPP_NOEXCEPT
5775  {
5776  return ::vkCreateOpticalFlowSessionNV( device, pCreateInfo, pAllocator, pSession );
5777  }
5778 
5779  void vkDestroyOpticalFlowSessionNV( VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
5780  {
5781  return ::vkDestroyOpticalFlowSessionNV( device, session, pAllocator );
5782  }
5783 
5785  VkOpticalFlowSessionNV session,
5787  VkImageView view,
5788  VkImageLayout layout ) const VULKAN_HPP_NOEXCEPT
5789  {
5790  return ::vkBindOpticalFlowSessionImageNV( device, session, bindingPoint, view, layout );
5791  }
5792 
5793  void vkCmdOpticalFlowExecuteNV( VkCommandBuffer commandBuffer,
5794  VkOpticalFlowSessionNV session,
5795  const VkOpticalFlowExecuteInfoNV * pExecuteInfo ) const VULKAN_HPP_NOEXCEPT
5796  {
5797  return ::vkCmdOpticalFlowExecuteNV( commandBuffer, session, pExecuteInfo );
5798  }
5799 
5800  //=== VK_QCOM_tile_properties ===
5801 
5803  VkFramebuffer framebuffer,
5804  uint32_t * pPropertiesCount,
5805  VkTilePropertiesQCOM * pProperties ) const VULKAN_HPP_NOEXCEPT
5806  {
5807  return ::vkGetFramebufferTilePropertiesQCOM( device, framebuffer, pPropertiesCount, pProperties );
5808  }
5809 
5811  const VkRenderingInfo * pRenderingInfo,
5812  VkTilePropertiesQCOM * pProperties ) const VULKAN_HPP_NOEXCEPT
5813  {
5814  return ::vkGetDynamicRenderingTilePropertiesQCOM( device, pRenderingInfo, pProperties );
5815  }
5816  };
5817 #endif
5818 
5819  class DispatchLoaderDynamic;
5820 #if !defined( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC )
5821 # if defined( VK_NO_PROTOTYPES )
5822 # define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC 1
5823 # else
5824 # define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC 0
5825 # endif
5826 #endif
5827 
5828 #if !defined( VULKAN_HPP_STORAGE_API )
5829 # if defined( VULKAN_HPP_STORAGE_SHARED )
5830 # if defined( _MSC_VER )
5831 # if defined( VULKAN_HPP_STORAGE_SHARED_EXPORT )
5832 # define VULKAN_HPP_STORAGE_API __declspec( dllexport )
5833 # else
5834 # define VULKAN_HPP_STORAGE_API __declspec( dllimport )
5835 # endif
5836 # elif defined( __clang__ ) || defined( __GNUC__ )
5837 # if defined( VULKAN_HPP_STORAGE_SHARED_EXPORT )
5838 # define VULKAN_HPP_STORAGE_API __attribute__( ( visibility( "default" ) ) )
5839 # else
5840 # define VULKAN_HPP_STORAGE_API
5841 # endif
5842 # else
5843 # define VULKAN_HPP_STORAGE_API
5844 # pragma warning Unknown import / export semantics
5845 # endif
5846 # else
5847 # define VULKAN_HPP_STORAGE_API
5848 # endif
5849 #endif
5850 
5851 #if !defined( VULKAN_HPP_DEFAULT_DISPATCHER )
5852 # if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1
5853 # define VULKAN_HPP_DEFAULT_DISPATCHER ::VULKAN_HPP_NAMESPACE::defaultDispatchLoaderDynamic
5854 # define VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE \
5855  namespace VULKAN_HPP_NAMESPACE \
5856  { \
5857  VULKAN_HPP_STORAGE_API DispatchLoaderDynamic defaultDispatchLoaderDynamic; \
5858  }
5859  extern VULKAN_HPP_STORAGE_API DispatchLoaderDynamic defaultDispatchLoaderDynamic;
5860 # else
5861  static inline ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic & getDispatchLoaderStatic()
5862  {
5863  static ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic dls;
5864  return dls;
5865  }
5866 # define VULKAN_HPP_DEFAULT_DISPATCHER ::VULKAN_HPP_NAMESPACE::getDispatchLoaderStatic()
5867 # define VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE
5868 # endif
5869 #endif
5870 
5871 #if !defined( VULKAN_HPP_DEFAULT_DISPATCHER_TYPE )
5872 # if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1
5873 # define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE ::VULKAN_HPP_NAMESPACE::DispatchLoaderDynamic
5874 # else
5875 # define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic
5876 # endif
5877 #endif
5878 
5879 #if defined( VULKAN_HPP_NO_DEFAULT_DISPATCHER )
5880 # define VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT
5881 # define VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT
5882 # define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT
5883 #else
5884 # define VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT = {}
5885 # define VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT = nullptr
5886 # define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT = VULKAN_HPP_DEFAULT_DISPATCHER
5887 #endif
5888 
5889 #if !defined( VULKAN_HPP_NO_SMART_HANDLE )
5890  struct AllocationCallbacks;
5891 
5892  template <typename OwnerType, typename Dispatch>
5894  {
5895  public:
5896  ObjectDestroy() = default;
5897 
5898  ObjectDestroy( OwnerType owner,
5901  : m_owner( owner )
5902  , m_allocationCallbacks( allocationCallbacks )
5903  , m_dispatch( &dispatch )
5904  {
5905  }
5906 
5907  OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
5908  {
5909  return m_owner;
5910  }
5912  {
5913  return m_allocationCallbacks;
5914  }
5915 
5916  protected:
5917  template <typename T>
5919  {
5920  VULKAN_HPP_ASSERT( m_owner && m_dispatch );
5921  m_owner.destroy( t, m_allocationCallbacks, *m_dispatch );
5922  }
5923 
5924  private:
5925  OwnerType m_owner = {};
5926  Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
5927  Dispatch const * m_dispatch = nullptr;
5928  };
5929 
5930  class NoParent;
5931 
5932  template <typename Dispatch>
5933  class ObjectDestroy<NoParent, Dispatch>
5934  {
5935  public:
5936  ObjectDestroy() = default;
5937 
5940  : m_allocationCallbacks( allocationCallbacks )
5941  , m_dispatch( &dispatch )
5942  {
5943  }
5944 
5946  {
5947  return m_allocationCallbacks;
5948  }
5949 
5950  protected:
5951  template <typename T>
5953  {
5954  VULKAN_HPP_ASSERT( m_dispatch );
5955  t.destroy( m_allocationCallbacks, *m_dispatch );
5956  }
5957 
5958  private:
5959  Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
5960  Dispatch const * m_dispatch = nullptr;
5961  };
5962 
5963  template <typename OwnerType, typename Dispatch>
5965  {
5966  public:
5967  ObjectFree() = default;
5968 
5969  ObjectFree( OwnerType owner,
5972  : m_owner( owner )
5973  , m_allocationCallbacks( allocationCallbacks )
5974  , m_dispatch( &dispatch )
5975  {
5976  }
5977 
5978  OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
5979  {
5980  return m_owner;
5981  }
5982 
5984  {
5985  return m_allocationCallbacks;
5986  }
5987 
5988  protected:
5989  template <typename T>
5991  {
5992  VULKAN_HPP_ASSERT( m_owner && m_dispatch );
5993  ( m_owner.free )( t, m_allocationCallbacks, *m_dispatch );
5994  }
5995 
5996  private:
5997  OwnerType m_owner = {};
5998  Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
5999  Dispatch const * m_dispatch = nullptr;
6000  };
6001 
6002  template <typename OwnerType, typename Dispatch>
6004  {
6005  public:
6006  ObjectRelease() = default;
6007 
6009  : m_owner( owner )
6010  , m_dispatch( &dispatch )
6011  {
6012  }
6013 
6014  OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
6015  {
6016  return m_owner;
6017  }
6018 
6019  protected:
6020  template <typename T>
6022  {
6023  VULKAN_HPP_ASSERT( m_owner && m_dispatch );
6024  m_owner.release( t, *m_dispatch );
6025  }
6026 
6027  private:
6028  OwnerType m_owner = {};
6029  Dispatch const * m_dispatch = nullptr;
6030  };
6031 
6032  template <typename OwnerType, typename PoolType, typename Dispatch>
6033  class PoolFree
6034  {
6035  public:
6036  PoolFree() = default;
6037 
6038  PoolFree( OwnerType owner, PoolType pool, Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
6039  : m_owner( owner )
6040  , m_pool( pool )
6041  , m_dispatch( &dispatch )
6042  {
6043  }
6044 
6045  OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
6046  {
6047  return m_owner;
6048  }
6049  PoolType getPool() const VULKAN_HPP_NOEXCEPT
6050  {
6051  return m_pool;
6052  }
6053 
6054  protected:
6055  template <typename T>
6057  {
6058  ( m_owner.free )( m_pool, t, *m_dispatch );
6059  }
6060 
6061  private:
6062  OwnerType m_owner = OwnerType();
6063  PoolType m_pool = PoolType();
6064  Dispatch const * m_dispatch = nullptr;
6065  };
6066 
6067 #endif // !VULKAN_HPP_NO_SMART_HANDLE
6068 
6069  //==================
6070  //=== BASE TYPEs ===
6071  //==================
6072 
6073  using Bool32 = uint32_t;
6074  using DeviceAddress = uint64_t;
6075  using DeviceSize = uint64_t;
6076  using RemoteAddressNV = void *;
6077  using SampleMask = uint32_t;
6078 
6079 } // namespace VULKAN_HPP_NAMESPACE
6080 
6081 #include <vulkan/vulkan_enums.hpp>
6082 #if !defined( VULKAN_HPP_NO_TO_STRING )
6083 # include <vulkan/vulkan_to_string.hpp>
6084 #endif
6085 
6086 #ifndef VULKAN_HPP_NO_EXCEPTIONS
6087 namespace std
6088 {
6089  template <>
6090  struct is_error_code_enum<VULKAN_HPP_NAMESPACE::Result> : public true_type
6091  {
6092  };
6093 } // namespace std
6094 #endif
6095 
6096 namespace VULKAN_HPP_NAMESPACE
6097 {
6098 #ifndef VULKAN_HPP_NO_EXCEPTIONS
6099  class ErrorCategoryImpl : public std::error_category
6100  {
6101  public:
6102  virtual const char * name() const VULKAN_HPP_NOEXCEPT override
6103  {
6104  return VULKAN_HPP_NAMESPACE_STRING "::Result";
6105  }
6106  virtual std::string message( int ev ) const override
6107  {
6108 # if defined( VULKAN_HPP_NO_TO_STRING )
6109  return std::to_string( ev );
6110 # else
6111  return VULKAN_HPP_NAMESPACE::to_string( static_cast<VULKAN_HPP_NAMESPACE::Result>( ev ) );
6112 # endif
6113  }
6114  };
6115 
6116  class Error
6117  {
6118  public:
6119  Error() VULKAN_HPP_NOEXCEPT = default;
6120  Error( const Error & ) VULKAN_HPP_NOEXCEPT = default;
6121  virtual ~Error() VULKAN_HPP_NOEXCEPT = default;
6122 
6123  virtual const char * what() const VULKAN_HPP_NOEXCEPT = 0;
6124  };
6125 
6127  : public Error
6128  , public std::logic_error
6129  {
6130  public:
6131  explicit LogicError( const std::string & what ) : Error(), std::logic_error( what ) {}
6132  explicit LogicError( char const * what ) : Error(), std::logic_error( what ) {}
6133 
6134  virtual const char * what() const VULKAN_HPP_NOEXCEPT
6135  {
6136  return std::logic_error::what();
6137  }
6138  };
6139 
6141  : public Error
6142  , public std::system_error
6143  {
6144  public:
6145  SystemError( std::error_code ec ) : Error(), std::system_error( ec ) {}
6146  SystemError( std::error_code ec, std::string const & what ) : Error(), std::system_error( ec, what ) {}
6147  SystemError( std::error_code ec, char const * what ) : Error(), std::system_error( ec, what ) {}
6148  SystemError( int ev, std::error_category const & ecat ) : Error(), std::system_error( ev, ecat ) {}
6149  SystemError( int ev, std::error_category const & ecat, std::string const & what ) : Error(), std::system_error( ev, ecat, what ) {}
6150  SystemError( int ev, std::error_category const & ecat, char const * what ) : Error(), std::system_error( ev, ecat, what ) {}
6151 
6152  virtual const char * what() const VULKAN_HPP_NOEXCEPT
6153  {
6154  return std::system_error::what();
6155  }
6156  };
6157 
6159  {
6160  static ErrorCategoryImpl instance;
6161  return instance;
6162  }
6163 
6165  {
6166  return std::error_code( static_cast<int>( e ), errorCategory() );
6167  }
6168 
6170  {
6171  return std::error_condition( static_cast<int>( e ), errorCategory() );
6172  }
6173 
6175  {
6176  public:
6179  };
6180 
6182  {
6183  public:
6186  };
6187 
6189  {
6190  public:
6193  };
6194 
6196  {
6197  public:
6200  };
6201 
6203  {
6204  public:
6207  };
6208 
6210  {
6211  public:
6214  };
6215 
6217  {
6218  public:
6221  };
6222 
6224  {
6225  public:
6228  };
6229 
6231  {
6232  public:
6235  };
6236 
6238  {
6239  public:
6242  };
6243 
6245  {
6246  public:
6249  };
6250 
6252  {
6253  public:
6256  };
6257 
6258  class UnknownError : public SystemError
6259  {
6260  public:
6263  };
6264 
6266  {
6267  public:
6270  };
6271 
6273  {
6274  public:
6277  };
6278 
6280  {
6281  public:
6284  };
6285 
6287  {
6288  public:
6291  };
6292 
6294  {
6295  public:
6298  };
6299 
6301  {
6302  public:
6305  };
6306 
6308  {
6309  public:
6312  };
6313 
6315  {
6316  public:
6319  };
6320 
6322  {
6323  public:
6326  };
6327 
6329  {
6330  public:
6333  };
6334 
6335 # if defined( VK_ENABLE_BETA_EXTENSIONS )
6336  class ImageUsageNotSupportedKHRError : public SystemError
6337  {
6338  public:
6339  ImageUsageNotSupportedKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorImageUsageNotSupportedKHR ), message ) {}
6340  ImageUsageNotSupportedKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorImageUsageNotSupportedKHR ), message ) {}
6341  };
6342 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
6343 
6344 # if defined( VK_ENABLE_BETA_EXTENSIONS )
6345  class VideoPictureLayoutNotSupportedKHRError : public SystemError
6346  {
6347  public:
6348  VideoPictureLayoutNotSupportedKHRError( std::string const & message )
6349  : SystemError( make_error_code( Result::eErrorVideoPictureLayoutNotSupportedKHR ), message )
6350  {
6351  }
6352  VideoPictureLayoutNotSupportedKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorVideoPictureLayoutNotSupportedKHR ), message )
6353  {
6354  }
6355  };
6356 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
6357 
6358 # if defined( VK_ENABLE_BETA_EXTENSIONS )
6359  class VideoProfileOperationNotSupportedKHRError : public SystemError
6360  {
6361  public:
6362  VideoProfileOperationNotSupportedKHRError( std::string const & message )
6363  : SystemError( make_error_code( Result::eErrorVideoProfileOperationNotSupportedKHR ), message )
6364  {
6365  }
6366  VideoProfileOperationNotSupportedKHRError( char const * message )
6367  : SystemError( make_error_code( Result::eErrorVideoProfileOperationNotSupportedKHR ), message )
6368  {
6369  }
6370  };
6371 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
6372 
6373 # if defined( VK_ENABLE_BETA_EXTENSIONS )
6374  class VideoProfileFormatNotSupportedKHRError : public SystemError
6375  {
6376  public:
6377  VideoProfileFormatNotSupportedKHRError( std::string const & message )
6378  : SystemError( make_error_code( Result::eErrorVideoProfileFormatNotSupportedKHR ), message )
6379  {
6380  }
6381  VideoProfileFormatNotSupportedKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorVideoProfileFormatNotSupportedKHR ), message )
6382  {
6383  }
6384  };
6385 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
6386 
6387 # if defined( VK_ENABLE_BETA_EXTENSIONS )
6388  class VideoProfileCodecNotSupportedKHRError : public SystemError
6389  {
6390  public:
6391  VideoProfileCodecNotSupportedKHRError( std::string const & message )
6392  : SystemError( make_error_code( Result::eErrorVideoProfileCodecNotSupportedKHR ), message )
6393  {
6394  }
6395  VideoProfileCodecNotSupportedKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorVideoProfileCodecNotSupportedKHR ), message ) {}
6396  };
6397 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
6398 
6399 # if defined( VK_ENABLE_BETA_EXTENSIONS )
6400  class VideoStdVersionNotSupportedKHRError : public SystemError
6401  {
6402  public:
6403  VideoStdVersionNotSupportedKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorVideoStdVersionNotSupportedKHR ), message )
6404  {
6405  }
6406  VideoStdVersionNotSupportedKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorVideoStdVersionNotSupportedKHR ), message ) {}
6407  };
6408 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
6409 
6411  {
6412  public:
6415  {
6416  }
6419  {
6420  }
6421  };
6422 
6424  {
6425  public:
6428  };
6429 
6430 # if defined( VK_USE_PLATFORM_WIN32_KHR )
6431  class FullScreenExclusiveModeLostEXTError : public SystemError
6432  {
6433  public:
6434  FullScreenExclusiveModeLostEXTError( std::string const & message ) : SystemError( make_error_code( Result::eErrorFullScreenExclusiveModeLostEXT ), message )
6435  {
6436  }
6437  FullScreenExclusiveModeLostEXTError( char const * message ) : SystemError( make_error_code( Result::eErrorFullScreenExclusiveModeLostEXT ), message ) {}
6438  };
6439 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
6440 
6442  {
6443  public:
6446  };
6447 
6448  namespace
6449  {
6450  [[noreturn]] void throwResultException( Result result, char const * message )
6451  {
6452  switch ( result )
6453  {
6454  case Result::eErrorOutOfHostMemory: throw OutOfHostMemoryError( message );
6455  case Result::eErrorOutOfDeviceMemory: throw OutOfDeviceMemoryError( message );
6456  case Result::eErrorInitializationFailed: throw InitializationFailedError( message );
6457  case Result::eErrorDeviceLost: throw DeviceLostError( message );
6458  case Result::eErrorMemoryMapFailed: throw MemoryMapFailedError( message );
6459  case Result::eErrorLayerNotPresent: throw LayerNotPresentError( message );
6460  case Result::eErrorExtensionNotPresent: throw ExtensionNotPresentError( message );
6461  case Result::eErrorFeatureNotPresent: throw FeatureNotPresentError( message );
6462  case Result::eErrorIncompatibleDriver: throw IncompatibleDriverError( message );
6463  case Result::eErrorTooManyObjects: throw TooManyObjectsError( message );
6464  case Result::eErrorFormatNotSupported: throw FormatNotSupportedError( message );
6465  case Result::eErrorFragmentedPool: throw FragmentedPoolError( message );
6466  case Result::eErrorUnknown: throw UnknownError( message );
6467  case Result::eErrorOutOfPoolMemory: throw OutOfPoolMemoryError( message );
6468  case Result::eErrorInvalidExternalHandle: throw InvalidExternalHandleError( message );
6469  case Result::eErrorFragmentation: throw FragmentationError( message );
6470  case Result::eErrorInvalidOpaqueCaptureAddress: throw InvalidOpaqueCaptureAddressError( message );
6471  case Result::eErrorSurfaceLostKHR: throw SurfaceLostKHRError( message );
6472  case Result::eErrorNativeWindowInUseKHR: throw NativeWindowInUseKHRError( message );
6473  case Result::eErrorOutOfDateKHR: throw OutOfDateKHRError( message );
6474  case Result::eErrorIncompatibleDisplayKHR: throw IncompatibleDisplayKHRError( message );
6475  case Result::eErrorValidationFailedEXT: throw ValidationFailedEXTError( message );
6476  case Result::eErrorInvalidShaderNV: throw InvalidShaderNVError( message );
6477 # if defined( VK_ENABLE_BETA_EXTENSIONS )
6478  case Result::eErrorImageUsageNotSupportedKHR: throw ImageUsageNotSupportedKHRError( message );
6479 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
6480 # if defined( VK_ENABLE_BETA_EXTENSIONS )
6481  case Result::eErrorVideoPictureLayoutNotSupportedKHR: throw VideoPictureLayoutNotSupportedKHRError( message );
6482 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
6483 # if defined( VK_ENABLE_BETA_EXTENSIONS )
6484  case Result::eErrorVideoProfileOperationNotSupportedKHR: throw VideoProfileOperationNotSupportedKHRError( message );
6485 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
6486 # if defined( VK_ENABLE_BETA_EXTENSIONS )
6487  case Result::eErrorVideoProfileFormatNotSupportedKHR: throw VideoProfileFormatNotSupportedKHRError( message );
6488 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
6489 # if defined( VK_ENABLE_BETA_EXTENSIONS )
6490  case Result::eErrorVideoProfileCodecNotSupportedKHR: throw VideoProfileCodecNotSupportedKHRError( message );
6491 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
6492 # if defined( VK_ENABLE_BETA_EXTENSIONS )
6493  case Result::eErrorVideoStdVersionNotSupportedKHR: throw VideoStdVersionNotSupportedKHRError( message );
6494 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
6495  case Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT: throw InvalidDrmFormatModifierPlaneLayoutEXTError( message );
6496  case Result::eErrorNotPermittedKHR: throw NotPermittedKHRError( message );
6497 # if defined( VK_USE_PLATFORM_WIN32_KHR )
6498  case Result::eErrorFullScreenExclusiveModeLostEXT: throw FullScreenExclusiveModeLostEXTError( message );
6499 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
6500  case Result::eErrorCompressionExhaustedEXT: throw CompressionExhaustedEXTError( message );
6501  default: throw SystemError( make_error_code( result ) );
6502  }
6503  }
6504  } // namespace
6505 #endif
6506 
6507  template <typename T>
6508  void ignore( T const & ) VULKAN_HPP_NOEXCEPT
6509  {
6510  }
6511 
6512  template <typename T>
6514  {
6515 #ifdef VULKAN_HPP_HAS_NOEXCEPT
6517 #else
6518  ResultValue( Result r, T & v )
6519 #endif
6520  : result( r ), value( v )
6521  {
6522  }
6523 
6524 #ifdef VULKAN_HPP_HAS_NOEXCEPT
6525  ResultValue( Result r, T && v ) VULKAN_HPP_NOEXCEPT( VULKAN_HPP_NOEXCEPT( T( std::move( v ) ) ) )
6526 #else
6527  ResultValue( Result r, T && v )
6528 #endif
6529  : result( r ), value( std::move( v ) )
6530  {
6531  }
6532 
6535 
6536  operator std::tuple<Result &, T &>() VULKAN_HPP_NOEXCEPT
6537  {
6538  return std::tuple<Result &, T &>( result, value );
6539  }
6540  };
6541 
6542 #if !defined( VULKAN_HPP_NO_SMART_HANDLE )
6543  template <typename Type, typename Dispatch>
6544  struct ResultValue<UniqueHandle<Type, Dispatch>>
6545  {
6546 # ifdef VULKAN_HPP_HAS_NOEXCEPT
6548 # else
6550 # endif
6551  : result( r )
6552  , value( std::move( v ) )
6553  {
6554  }
6555 
6556  std::tuple<Result, UniqueHandle<Type, Dispatch>> asTuple()
6557  {
6558  return std::make_tuple( result, std::move( value ) );
6559  }
6560 
6563  };
6564 
6565  template <typename Type, typename Dispatch>
6566  struct ResultValue<std::vector<UniqueHandle<Type, Dispatch>>>
6567  {
6568 # ifdef VULKAN_HPP_HAS_NOEXCEPT
6570 # else
6571  ResultValue( Result r, std::vector<UniqueHandle<Type, Dispatch>> && v )
6572 # endif
6573  : result( r )
6574  , value( std::move( v ) )
6575  {
6576  }
6577 
6578  std::tuple<Result, std::vector<UniqueHandle<Type, Dispatch>>> asTuple()
6579  {
6580  return std::make_tuple( result, std::move( value ) );
6581  }
6582 
6584  std::vector<UniqueHandle<Type, Dispatch>> value;
6585  };
6586 #endif
6587 
6588  template <typename T>
6590  {
6591 #ifdef VULKAN_HPP_NO_EXCEPTIONS
6592  typedef ResultValue<T> type;
6593 #else
6594  typedef T type;
6595 #endif
6596  };
6597 
6598  template <>
6600  {
6601 #ifdef VULKAN_HPP_NO_EXCEPTIONS
6602  typedef Result type;
6603 #else
6604  typedef void type;
6605 #endif
6606  };
6607 
6609  {
6610 #ifdef VULKAN_HPP_NO_EXCEPTIONS
6611  return result;
6612 #else
6613  ignore( result );
6614 #endif
6615  }
6616 
6617  template <typename T>
6619  {
6620 #ifdef VULKAN_HPP_NO_EXCEPTIONS
6621  return ResultValue<T>( result, data );
6622 #else
6623  ignore( result );
6624  return data;
6625 #endif
6626  }
6627 
6628  template <typename T>
6630  {
6631 #ifdef VULKAN_HPP_NO_EXCEPTIONS
6632  return ResultValue<T>( result, std::move( data ) );
6633 #else
6634  ignore( result );
6635  return std::move( data );
6636 #endif
6637  }
6638 
6639  VULKAN_HPP_INLINE void resultCheck( Result result, char const * message )
6640  {
6641 #ifdef VULKAN_HPP_NO_EXCEPTIONS
6642  ignore( result ); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
6643  ignore( message );
6645 #else
6646  if ( result != Result::eSuccess )
6647  {
6648  throwResultException( result, message );
6649  }
6650 #endif
6651  }
6652 
6653  VULKAN_HPP_INLINE void resultCheck( Result result, char const * message, std::initializer_list<Result> successCodes )
6654  {
6655 #ifdef VULKAN_HPP_NO_EXCEPTIONS
6656  ignore( result ); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
6657  ignore( message );
6658  ignore( successCodes ); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
6659  VULKAN_HPP_ASSERT_ON_RESULT( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() );
6660 #else
6661  if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() )
6662  {
6663  throwResultException( result, message );
6664  }
6665 #endif
6666  }
6667 } // namespace VULKAN_HPP_NAMESPACE
6668 
6669 // clang-format off
6670 #include <vulkan/vulkan_handles.hpp>
6671 #include <vulkan/vulkan_structs.hpp>
6672 #include <vulkan/vulkan_funcs.hpp>
6673 // clang-format on
6674 
6675 namespace VULKAN_HPP_NAMESPACE
6676 {
6677 #if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
6678 
6679  //=======================
6680  //=== STRUCTS EXTENDS ===
6681  //=======================
6682 
6683  //=== VK_VERSION_1_0 ===
6684  template <>
6686  {
6687  enum
6688  {
6689  value = true
6690  };
6691  };
6692 
6693  //=== VK_VERSION_1_1 ===
6694  template <>
6696  {
6697  enum
6698  {
6699  value = true
6700  };
6701  };
6702  template <>
6704  {
6705  enum
6706  {
6707  value = true
6708  };
6709  };
6710  template <>
6712  {
6713  enum
6714  {
6715  value = true
6716  };
6717  };
6718  template <>
6720  {
6721  enum
6722  {
6723  value = true
6724  };
6725  };
6726  template <>
6728  {
6729  enum
6730  {
6731  value = true
6732  };
6733  };
6734  template <>
6736  {
6737  enum
6738  {
6739  value = true
6740  };
6741  };
6742  template <>
6744  {
6745  enum
6746  {
6747  value = true
6748  };
6749  };
6750  template <>
6752  {
6753  enum
6754  {
6755  value = true
6756  };
6757  };
6758  template <>
6760  {
6761  enum
6762  {
6763  value = true
6764  };
6765  };
6766  template <>
6768  {
6769  enum
6770  {
6771  value = true
6772  };
6773  };
6774  template <>
6776  {
6777  enum
6778  {
6779  value = true
6780  };
6781  };
6782  template <>
6784  {
6785  enum
6786  {
6787  value = true
6788  };
6789  };
6790  template <>
6792  {
6793  enum
6794  {
6795  value = true
6796  };
6797  };
6798  template <>
6800  {
6801  enum
6802  {
6803  value = true
6804  };
6805  };
6806  template <>
6808  {
6809  enum
6810  {
6811  value = true
6812  };
6813  };
6814  template <>
6816  {
6817  enum
6818  {
6819  value = true
6820  };
6821  };
6822  template <>
6824  {
6825  enum
6826  {
6827  value = true
6828  };
6829  };
6830  template <>
6832  {
6833  enum
6834  {
6835  value = true
6836  };
6837  };
6838  template <>
6840  {
6841  enum
6842  {
6843  value = true
6844  };
6845  };
6846  template <>
6848  {
6849  enum
6850  {
6851  value = true
6852  };
6853  };
6854  template <>
6856  {
6857  enum
6858  {
6859  value = true
6860  };
6861  };
6862  template <>
6864  {
6865  enum
6866  {
6867  value = true
6868  };
6869  };
6870  template <>
6872  {
6873  enum
6874  {
6875  value = true
6876  };
6877  };
6878  template <>
6880  {
6881  enum
6882  {
6883  value = true
6884  };
6885  };
6886  template <>
6888  {
6889  enum
6890  {
6891  value = true
6892  };
6893  };
6894  template <>
6896  {
6897  enum
6898  {
6899  value = true
6900  };
6901  };
6902  template <>
6904  {
6905  enum
6906  {
6907  value = true
6908  };
6909  };
6910  template <>
6912  {
6913  enum
6914  {
6915  value = true
6916  };
6917  };
6918  template <>
6920  {
6921  enum
6922  {
6923  value = true
6924  };
6925  };
6926  template <>
6928  {
6929  enum
6930  {
6931  value = true
6932  };
6933  };
6934  template <>
6936  {
6937  enum
6938  {
6939  value = true
6940  };
6941  };
6942  template <>
6944  {
6945  enum
6946  {
6947  value = true
6948  };
6949  };
6950  template <>
6952  {
6953  enum
6954  {
6955  value = true
6956  };
6957  };
6958  template <>
6960  {
6961  enum
6962  {
6963  value = true
6964  };
6965  };
6966  template <>
6968  {
6969  enum
6970  {
6971  value = true
6972  };
6973  };
6974  template <>
6976  {
6977  enum
6978  {
6979  value = true
6980  };
6981  };
6982  template <>
6984  {
6985  enum
6986  {
6987  value = true
6988  };
6989  };
6990  template <>
6992  {
6993  enum
6994  {
6995  value = true
6996  };
6997  };
6998  template <>
7000  {
7001  enum
7002  {
7003  value = true
7004  };
7005  };
7006  template <>
7008  {
7009  enum
7010  {
7011  value = true
7012  };
7013  };
7014  template <>
7016  {
7017  enum
7018  {
7019  value = true
7020  };
7021  };
7022  template <>
7024  {
7025  enum
7026  {
7027  value = true
7028  };
7029  };
7030  template <>
7032  {
7033  enum
7034  {
7035  value = true
7036  };
7037  };
7038  template <>
7040  {
7041  enum
7042  {
7043  value = true
7044  };
7045  };
7046  template <>
7048  {
7049  enum
7050  {
7051  value = true
7052  };
7053  };
7054  template <>
7056  {
7057  enum
7058  {
7059  value = true
7060  };
7061  };
7062  template <>
7064  {
7065  enum
7066  {
7067  value = true
7068  };
7069  };
7070 
7071  //=== VK_VERSION_1_2 ===
7072  template <>
7074  {
7075  enum
7076  {
7077  value = true
7078  };
7079  };
7080  template <>
7082  {
7083  enum
7084  {
7085  value = true
7086  };
7087  };
7088  template <>
7090  {
7091  enum
7092  {
7093  value = true
7094  };
7095  };
7096  template <>
7098  {
7099  enum
7100  {
7101  value = true
7102  };
7103  };
7104  template <>
7106  {
7107  enum
7108  {
7109  value = true
7110  };
7111  };
7112  template <>
7114  {
7115  enum
7116  {
7117  value = true
7118  };
7119  };
7120  template <>
7122  {
7123  enum
7124  {
7125  value = true
7126  };
7127  };
7128  template <>
7130  {
7131  enum
7132  {
7133  value = true
7134  };
7135  };
7136  template <>
7138  {
7139  enum
7140  {
7141  value = true
7142  };
7143  };
7144  template <>
7146  {
7147  enum
7148  {
7149  value = true
7150  };
7151  };
7152  template <>
7154  {
7155  enum
7156  {
7157  value = true
7158  };
7159  };
7160  template <>
7162  {
7163  enum
7164  {
7165  value = true
7166  };
7167  };
7168  template <>
7170  {
7171  enum
7172  {
7173  value = true
7174  };
7175  };
7176  template <>
7178  {
7179  enum
7180  {
7181  value = true
7182  };
7183  };
7184  template <>
7186  {
7187  enum
7188  {
7189  value = true
7190  };
7191  };
7192  template <>
7194  {
7195  enum
7196  {
7197  value = true
7198  };
7199  };
7200  template <>
7202  {
7203  enum
7204  {
7205  value = true
7206  };
7207  };
7208  template <>
7210  {
7211  enum
7212  {
7213  value = true
7214  };
7215  };
7216  template <>
7218  {
7219  enum
7220  {
7221  value = true
7222  };
7223  };
7224  template <>
7226  {
7227  enum
7228  {
7229  value = true
7230  };
7231  };
7232  template <>
7234  {
7235  enum
7236  {
7237  value = true
7238  };
7239  };
7240  template <>
7242  {
7243  enum
7244  {
7245  value = true
7246  };
7247  };
7248  template <>
7250  {
7251  enum
7252  {
7253  value = true
7254  };
7255  };
7256  template <>
7258  {
7259  enum
7260  {
7261  value = true
7262  };
7263  };
7264  template <>
7266  {
7267  enum
7268  {
7269  value = true
7270  };
7271  };
7272  template <>
7274  {
7275  enum
7276  {
7277  value = true
7278  };
7279  };
7280  template <>
7282  {
7283  enum
7284  {
7285  value = true
7286  };
7287  };
7288  template <>
7290  {
7291  enum
7292  {
7293  value = true
7294  };
7295  };
7296  template <>
7298  {
7299  enum
7300  {
7301  value = true
7302  };
7303  };
7304  template <>
7306  {
7307  enum
7308  {
7309  value = true
7310  };
7311  };
7312  template <>
7314  {
7315  enum
7316  {
7317  value = true
7318  };
7319  };
7320  template <>
7322  {
7323  enum
7324  {
7325  value = true
7326  };
7327  };
7328  template <>
7330  {
7331  enum
7332  {
7333  value = true
7334  };
7335  };
7336  template <>
7338  {
7339  enum
7340  {
7341  value = true
7342  };
7343  };
7344  template <>
7346  {
7347  enum
7348  {
7349  value = true
7350  };
7351  };
7352  template <>
7354  {
7355  enum
7356  {
7357  value = true
7358  };
7359  };
7360  template <>
7362  {
7363  enum
7364  {
7365  value = true
7366  };
7367  };
7368  template <>
7370  {
7371  enum
7372  {
7373  value = true
7374  };
7375  };
7376  template <>
7378  {
7379  enum
7380  {
7381  value = true
7382  };
7383  };
7384  template <>
7386  {
7387  enum
7388  {
7389  value = true
7390  };
7391  };
7392  template <>
7394  {
7395  enum
7396  {
7397  value = true
7398  };
7399  };
7400  template <>
7402  {
7403  enum
7404  {
7405  value = true
7406  };
7407  };
7408  template <>
7410  {
7411  enum
7412  {
7413  value = true
7414  };
7415  };
7416  template <>
7418  {
7419  enum
7420  {
7421  value = true
7422  };
7423  };
7424  template <>
7426  {
7427  enum
7428  {
7429  value = true
7430  };
7431  };
7432  template <>
7434  {
7435  enum
7436  {
7437  value = true
7438  };
7439  };
7440  template <>
7442  {
7443  enum
7444  {
7445  value = true
7446  };
7447  };
7448  template <>
7450  {
7451  enum
7452  {
7453  value = true
7454  };
7455  };
7456  template <>
7458  {
7459  enum
7460  {
7461  value = true
7462  };
7463  };
7464  template <>
7466  {
7467  enum
7468  {
7469  value = true
7470  };
7471  };
7472  template <>
7474  {
7475  enum
7476  {
7477  value = true
7478  };
7479  };
7480  template <>
7482  {
7483  enum
7484  {
7485  value = true
7486  };
7487  };
7488  template <>
7490  {
7491  enum
7492  {
7493  value = true
7494  };
7495  };
7496  template <>
7498  {
7499  enum
7500  {
7501  value = true
7502  };
7503  };
7504  template <>
7506  {
7507  enum
7508  {
7509  value = true
7510  };
7511  };
7512  template <>
7514  {
7515  enum
7516  {
7517  value = true
7518  };
7519  };
7520  template <>
7522  {
7523  enum
7524  {
7525  value = true
7526  };
7527  };
7528  template <>
7530  {
7531  enum
7532  {
7533  value = true
7534  };
7535  };
7536 
7537  //=== VK_VERSION_1_3 ===
7538  template <>
7540  {
7541  enum
7542  {
7543  value = true
7544  };
7545  };
7546  template <>
7548  {
7549  enum
7550  {
7551  value = true
7552  };
7553  };
7554  template <>
7556  {
7557  enum
7558  {
7559  value = true
7560  };
7561  };
7562  template <>
7564  {
7565  enum
7566  {
7567  value = true
7568  };
7569  };
7570  template <>
7572  {
7573  enum
7574  {
7575  value = true
7576  };
7577  };
7578  template <>
7580  {
7581  enum
7582  {
7583  value = true
7584  };
7585  };
7586  template <>
7588  {
7589  enum
7590  {
7591  value = true
7592  };
7593  };
7594  template <>
7596  {
7597  enum
7598  {
7599  value = true
7600  };
7601  };
7602  template <>
7604  {
7605  enum
7606  {
7607  value = true
7608  };
7609  };
7610  template <>
7612  {
7613  enum
7614  {
7615  value = true
7616  };
7617  };
7618  template <>
7620  {
7621  enum
7622  {
7623  value = true
7624  };
7625  };
7626  template <>
7628  {
7629  enum
7630  {
7631  value = true
7632  };
7633  };
7634  template <>
7636  {
7637  enum
7638  {
7639  value = true
7640  };
7641  };
7642  template <>
7644  {
7645  enum
7646  {
7647  value = true
7648  };
7649  };
7650  template <>
7652  {
7653  enum
7654  {
7655  value = true
7656  };
7657  };
7658  template <>
7660  {
7661  enum
7662  {
7663  value = true
7664  };
7665  };
7666  template <>
7668  {
7669  enum
7670  {
7671  value = true
7672  };
7673  };
7674  template <>
7676  {
7677  enum
7678  {
7679  value = true
7680  };
7681  };
7682  template <>
7684  {
7685  enum
7686  {
7687  value = true
7688  };
7689  };
7690  template <>
7692  {
7693  enum
7694  {
7695  value = true
7696  };
7697  };
7698  template <>
7700  {
7701  enum
7702  {
7703  value = true
7704  };
7705  };
7706  template <>
7708  {
7709  enum
7710  {
7711  value = true
7712  };
7713  };
7714  template <>
7716  {
7717  enum
7718  {
7719  value = true
7720  };
7721  };
7722  template <>
7724  {
7725  enum
7726  {
7727  value = true
7728  };
7729  };
7730  template <>
7732  {
7733  enum
7734  {
7735  value = true
7736  };
7737  };
7738  template <>
7740  {
7741  enum
7742  {
7743  value = true
7744  };
7745  };
7746  template <>
7748  {
7749  enum
7750  {
7751  value = true
7752  };
7753  };
7754  template <>
7756  {
7757  enum
7758  {
7759  value = true
7760  };
7761  };
7762  template <>
7764  {
7765  enum
7766  {
7767  value = true
7768  };
7769  };
7770  template <>
7772  {
7773  enum
7774  {
7775  value = true
7776  };
7777  };
7778  template <>
7780  {
7781  enum
7782  {
7783  value = true
7784  };
7785  };
7786  template <>
7788  {
7789  enum
7790  {
7791  value = true
7792  };
7793  };
7794  template <>
7796  {
7797  enum
7798  {
7799  value = true
7800  };
7801  };
7802  template <>
7804  {
7805  enum
7806  {
7807  value = true
7808  };
7809  };
7810  template <>
7812  {
7813  enum
7814  {
7815  value = true
7816  };
7817  };
7818  template <>
7820  {
7821  enum
7822  {
7823  value = true
7824  };
7825  };
7826  template <>
7828  {
7829  enum
7830  {
7831  value = true
7832  };
7833  };
7834  template <>
7836  {
7837  enum
7838  {
7839  value = true
7840  };
7841  };
7842  template <>
7844  {
7845  enum
7846  {
7847  value = true
7848  };
7849  };
7850  template <>
7852  {
7853  enum
7854  {
7855  value = true
7856  };
7857  };
7858  template <>
7860  {
7861  enum
7862  {
7863  value = true
7864  };
7865  };
7866  template <>
7868  {
7869  enum
7870  {
7871  value = true
7872  };
7873  };
7874  template <>
7876  {
7877  enum
7878  {
7879  value = true
7880  };
7881  };
7882  template <>
7884  {
7885  enum
7886  {
7887  value = true
7888  };
7889  };
7890  template <>
7892  {
7893  enum
7894  {
7895  value = true
7896  };
7897  };
7898  template <>
7900  {
7901  enum
7902  {
7903  value = true
7904  };
7905  };
7906 
7907  //=== VK_KHR_swapchain ===
7908  template <>
7910  {
7911  enum
7912  {
7913  value = true
7914  };
7915  };
7916  template <>
7918  {
7919  enum
7920  {
7921  value = true
7922  };
7923  };
7924  template <>
7926  {
7927  enum
7928  {
7929  value = true
7930  };
7931  };
7932  template <>
7934  {
7935  enum
7936  {
7937  value = true
7938  };
7939  };
7940 
7941  //=== VK_KHR_display_swapchain ===
7942  template <>
7944  {
7945  enum
7946  {
7947  value = true
7948  };
7949  };
7950 
7951  //=== VK_EXT_debug_report ===
7952  template <>
7954  {
7955  enum
7956  {
7957  value = true
7958  };
7959  };
7960 
7961  //=== VK_AMD_rasterization_order ===
7962  template <>
7964  {
7965  enum
7966  {
7967  value = true
7968  };
7969  };
7970 
7971 # if defined( VK_ENABLE_BETA_EXTENSIONS )
7972  //=== VK_KHR_video_queue ===
7973  template <>
7974  struct StructExtends<QueueFamilyQueryResultStatusPropertiesKHR, QueueFamilyProperties2>
7975  {
7976  enum
7977  {
7978  value = true
7979  };
7980  };
7981  template <>
7982  struct StructExtends<QueueFamilyVideoPropertiesKHR, QueueFamilyProperties2>
7983  {
7984  enum
7985  {
7986  value = true
7987  };
7988  };
7989  template <>
7990  struct StructExtends<VideoProfileInfoKHR, QueryPoolCreateInfo>
7991  {
7992  enum
7993  {
7994  value = true
7995  };
7996  };
7997  template <>
7998  struct StructExtends<VideoProfileListInfoKHR, PhysicalDeviceImageFormatInfo2>
7999  {
8000  enum
8001  {
8002  value = true
8003  };
8004  };
8005  template <>
8006  struct StructExtends<VideoProfileListInfoKHR, PhysicalDeviceVideoFormatInfoKHR>
8007  {
8008  enum
8009  {
8010  value = true
8011  };
8012  };
8013  template <>
8014  struct StructExtends<VideoProfileListInfoKHR, ImageCreateInfo>
8015  {
8016  enum
8017  {
8018  value = true
8019  };
8020  };
8021  template <>
8022  struct StructExtends<VideoProfileListInfoKHR, BufferCreateInfo>
8023  {
8024  enum
8025  {
8026  value = true
8027  };
8028  };
8029 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
8030 
8031 # if defined( VK_ENABLE_BETA_EXTENSIONS )
8032  //=== VK_KHR_video_decode_queue ===
8033  template <>
8034  struct StructExtends<VideoDecodeCapabilitiesKHR, VideoCapabilitiesKHR>
8035  {
8036  enum
8037  {
8038  value = true
8039  };
8040  };
8041  template <>
8042  struct StructExtends<VideoDecodeUsageInfoKHR, VideoProfileInfoKHR>
8043  {
8044  enum
8045  {
8046  value = true
8047  };
8048  };
8049  template <>
8050  struct StructExtends<VideoDecodeUsageInfoKHR, QueryPoolCreateInfo>
8051  {
8052  enum
8053  {
8054  value = true
8055  };
8056  };
8057 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
8058 
8059  //=== VK_NV_dedicated_allocation ===
8060  template <>
8062  {
8063  enum
8064  {
8065  value = true
8066  };
8067  };
8068  template <>
8070  {
8071  enum
8072  {
8073  value = true
8074  };
8075  };
8076  template <>
8078  {
8079  enum
8080  {
8081  value = true
8082  };
8083  };
8084 
8085  //=== VK_EXT_transform_feedback ===
8086  template <>
8088  {
8089  enum
8090  {
8091  value = true
8092  };
8093  };
8094  template <>
8096  {
8097  enum
8098  {
8099  value = true
8100  };
8101  };
8102  template <>
8104  {
8105  enum
8106  {
8107  value = true
8108  };
8109  };
8110  template <>
8112  {
8113  enum
8114  {
8115  value = true
8116  };
8117  };
8118 
8119 # if defined( VK_ENABLE_BETA_EXTENSIONS )
8120  //=== VK_EXT_video_encode_h264 ===
8121  template <>
8122  struct StructExtends<VideoEncodeH264CapabilitiesEXT, VideoCapabilitiesKHR>
8123  {
8124  enum
8125  {
8126  value = true
8127  };
8128  };
8129  template <>
8130  struct StructExtends<VideoEncodeH264SessionParametersCreateInfoEXT, VideoSessionParametersCreateInfoKHR>
8131  {
8132  enum
8133  {
8134  value = true
8135  };
8136  };
8137  template <>
8138  struct StructExtends<VideoEncodeH264SessionParametersAddInfoEXT, VideoSessionParametersUpdateInfoKHR>
8139  {
8140  enum
8141  {
8142  value = true
8143  };
8144  };
8145  template <>
8146  struct StructExtends<VideoEncodeH264VclFrameInfoEXT, VideoEncodeInfoKHR>
8147  {
8148  enum
8149  {
8150  value = true
8151  };
8152  };
8153  template <>
8154  struct StructExtends<VideoEncodeH264EmitPictureParametersInfoEXT, VideoEncodeInfoKHR>
8155  {
8156  enum
8157  {
8158  value = true
8159  };
8160  };
8161  template <>
8162  struct StructExtends<VideoEncodeH264ProfileInfoEXT, VideoProfileInfoKHR>
8163  {
8164  enum
8165  {
8166  value = true
8167  };
8168  };
8169  template <>
8170  struct StructExtends<VideoEncodeH264ProfileInfoEXT, QueryPoolCreateInfo>
8171  {
8172  enum
8173  {
8174  value = true
8175  };
8176  };
8177  template <>
8178  struct StructExtends<VideoEncodeH264RateControlInfoEXT, VideoCodingControlInfoKHR>
8179  {
8180  enum
8181  {
8182  value = true
8183  };
8184  };
8185  template <>
8186  struct StructExtends<VideoEncodeH264RateControlLayerInfoEXT, VideoCodingControlInfoKHR>
8187  {
8188  enum
8189  {
8190  value = true
8191  };
8192  };
8193  template <>
8194  struct StructExtends<VideoEncodeH264RateControlLayerInfoEXT, VideoEncodeRateControlLayerInfoKHR>
8195  {
8196  enum
8197  {
8198  value = true
8199  };
8200  };
8201 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
8202 
8203 # if defined( VK_ENABLE_BETA_EXTENSIONS )
8204  //=== VK_EXT_video_encode_h265 ===
8205  template <>
8206  struct StructExtends<VideoEncodeH265CapabilitiesEXT, VideoCapabilitiesKHR>
8207  {
8208  enum
8209  {
8210  value = true
8211  };
8212  };
8213  template <>
8214  struct StructExtends<VideoEncodeH265SessionParametersCreateInfoEXT, VideoSessionParametersCreateInfoKHR>
8215  {
8216  enum
8217  {
8218  value = true
8219  };
8220  };
8221  template <>
8222  struct StructExtends<VideoEncodeH265SessionParametersAddInfoEXT, VideoSessionParametersUpdateInfoKHR>
8223  {
8224  enum
8225  {
8226  value = true
8227  };
8228  };
8229  template <>
8230  struct StructExtends<VideoEncodeH265VclFrameInfoEXT, VideoEncodeInfoKHR>
8231  {
8232  enum
8233  {
8234  value = true
8235  };
8236  };
8237  template <>
8238  struct StructExtends<VideoEncodeH265EmitPictureParametersInfoEXT, VideoEncodeInfoKHR>
8239  {
8240  enum
8241  {
8242  value = true
8243  };
8244  };
8245  template <>
8246  struct StructExtends<VideoEncodeH265ProfileInfoEXT, VideoProfileInfoKHR>
8247  {
8248  enum
8249  {
8250  value = true
8251  };
8252  };
8253  template <>
8254  struct StructExtends<VideoEncodeH265ProfileInfoEXT, QueryPoolCreateInfo>
8255  {
8256  enum
8257  {
8258  value = true
8259  };
8260  };
8261  template <>
8262  struct StructExtends<VideoEncodeH265RateControlInfoEXT, VideoCodingControlInfoKHR>
8263  {
8264  enum
8265  {
8266  value = true
8267  };
8268  };
8269  template <>
8270  struct StructExtends<VideoEncodeH265RateControlLayerInfoEXT, VideoCodingControlInfoKHR>
8271  {
8272  enum
8273  {
8274  value = true
8275  };
8276  };
8277  template <>
8278  struct StructExtends<VideoEncodeH265RateControlLayerInfoEXT, VideoEncodeRateControlLayerInfoKHR>
8279  {
8280  enum
8281  {
8282  value = true
8283  };
8284  };
8285 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
8286 
8287 # if defined( VK_ENABLE_BETA_EXTENSIONS )
8288  //=== VK_EXT_video_decode_h264 ===
8289  template <>
8290  struct StructExtends<VideoDecodeH264ProfileInfoEXT, VideoProfileInfoKHR>
8291  {
8292  enum
8293  {
8294  value = true
8295  };
8296  };
8297  template <>
8298  struct StructExtends<VideoDecodeH264ProfileInfoEXT, QueryPoolCreateInfo>
8299  {
8300  enum
8301  {
8302  value = true
8303  };
8304  };
8305  template <>
8306  struct StructExtends<VideoDecodeH264CapabilitiesEXT, VideoCapabilitiesKHR>
8307  {
8308  enum
8309  {
8310  value = true
8311  };
8312  };
8313  template <>
8314  struct StructExtends<VideoDecodeH264SessionParametersCreateInfoEXT, VideoSessionParametersCreateInfoKHR>
8315  {
8316  enum
8317  {
8318  value = true
8319  };
8320  };
8321  template <>
8322  struct StructExtends<VideoDecodeH264SessionParametersAddInfoEXT, VideoSessionParametersUpdateInfoKHR>
8323  {
8324  enum
8325  {
8326  value = true
8327  };
8328  };
8329  template <>
8330  struct StructExtends<VideoDecodeH264PictureInfoEXT, VideoDecodeInfoKHR>
8331  {
8332  enum
8333  {
8334  value = true
8335  };
8336  };
8337  template <>
8338  struct StructExtends<VideoDecodeH264DpbSlotInfoEXT, VideoReferenceSlotInfoKHR>
8339  {
8340  enum
8341  {
8342  value = true
8343  };
8344  };
8345 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
8346 
8347  //=== VK_AMD_texture_gather_bias_lod ===
8348  template <>
8350  {
8351  enum
8352  {
8353  value = true
8354  };
8355  };
8356 
8357  //=== VK_KHR_dynamic_rendering ===
8358  template <>
8360  {
8361  enum
8362  {
8363  value = true
8364  };
8365  };
8366  template <>
8368  {
8369  enum
8370  {
8371  value = true
8372  };
8373  };
8374  template <>
8376  {
8377  enum
8378  {
8379  value = true
8380  };
8381  };
8382  template <>
8384  {
8385  enum
8386  {
8387  value = true
8388  };
8389  };
8390  template <>
8392  {
8393  enum
8394  {
8395  value = true
8396  };
8397  };
8398  template <>
8400  {
8401  enum
8402  {
8403  value = true
8404  };
8405  };
8406  template <>
8408  {
8409  enum
8410  {
8411  value = true
8412  };
8413  };
8414 
8415  //=== VK_NV_corner_sampled_image ===
8416  template <>
8418  {
8419  enum
8420  {
8421  value = true
8422  };
8423  };
8424  template <>
8426  {
8427  enum
8428  {
8429  value = true
8430  };
8431  };
8432 
8433  //=== VK_NV_external_memory ===
8434  template <>
8436  {
8437  enum
8438  {
8439  value = true
8440  };
8441  };
8442  template <>
8444  {
8445  enum
8446  {
8447  value = true
8448  };
8449  };
8450 
8451 # if defined( VK_USE_PLATFORM_WIN32_KHR )
8452  //=== VK_NV_external_memory_win32 ===
8453  template <>
8454  struct StructExtends<ImportMemoryWin32HandleInfoNV, MemoryAllocateInfo>
8455  {
8456  enum
8457  {
8458  value = true
8459  };
8460  };
8461  template <>
8462  struct StructExtends<ExportMemoryWin32HandleInfoNV, MemoryAllocateInfo>
8463  {
8464  enum
8465  {
8466  value = true
8467  };
8468  };
8469 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
8470 
8471 # if defined( VK_USE_PLATFORM_WIN32_KHR )
8472  //=== VK_NV_win32_keyed_mutex ===
8473  template <>
8474  struct StructExtends<Win32KeyedMutexAcquireReleaseInfoNV, SubmitInfo>
8475  {
8476  enum
8477  {
8478  value = true
8479  };
8480  };
8481  template <>
8482  struct StructExtends<Win32KeyedMutexAcquireReleaseInfoNV, SubmitInfo2>
8483  {
8484  enum
8485  {
8486  value = true
8487  };
8488  };
8489 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
8490 
8491  //=== VK_EXT_validation_flags ===
8492  template <>
8494  {
8495  enum
8496  {
8497  value = true
8498  };
8499  };
8500 
8501  //=== VK_EXT_astc_decode_mode ===
8502  template <>
8504  {
8505  enum
8506  {
8507  value = true
8508  };
8509  };
8510  template <>
8512  {
8513  enum
8514  {
8515  value = true
8516  };
8517  };
8518  template <>
8520  {
8521  enum
8522  {
8523  value = true
8524  };
8525  };
8526 
8527  //=== VK_EXT_pipeline_robustness ===
8528  template <>
8530  {
8531  enum
8532  {
8533  value = true
8534  };
8535  };
8536  template <>
8538  {
8539  enum
8540  {
8541  value = true
8542  };
8543  };
8544  template <>
8546  {
8547  enum
8548  {
8549  value = true
8550  };
8551  };
8552  template <>
8554  {
8555  enum
8556  {
8557  value = true
8558  };
8559  };
8560  template <>
8562  {
8563  enum
8564  {
8565  value = true
8566  };
8567  };
8568  template <>
8570  {
8571  enum
8572  {
8573  value = true
8574  };
8575  };
8576  template <>
8578  {
8579  enum
8580  {
8581  value = true
8582  };
8583  };
8584 
8585 # if defined( VK_USE_PLATFORM_WIN32_KHR )
8586  //=== VK_KHR_external_memory_win32 ===
8587  template <>
8588  struct StructExtends<ImportMemoryWin32HandleInfoKHR, MemoryAllocateInfo>
8589  {
8590  enum
8591  {
8592  value = true
8593  };
8594  };
8595  template <>
8596  struct StructExtends<ExportMemoryWin32HandleInfoKHR, MemoryAllocateInfo>
8597  {
8598  enum
8599  {
8600  value = true
8601  };
8602  };
8603 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
8604 
8605  //=== VK_KHR_external_memory_fd ===
8606  template <>
8608  {
8609  enum
8610  {
8611  value = true
8612  };
8613  };
8614 
8615 # if defined( VK_USE_PLATFORM_WIN32_KHR )
8616  //=== VK_KHR_win32_keyed_mutex ===
8617  template <>
8618  struct StructExtends<Win32KeyedMutexAcquireReleaseInfoKHR, SubmitInfo>
8619  {
8620  enum
8621  {
8622  value = true
8623  };
8624  };
8625  template <>
8626  struct StructExtends<Win32KeyedMutexAcquireReleaseInfoKHR, SubmitInfo2>
8627  {
8628  enum
8629  {
8630  value = true
8631  };
8632  };
8633 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
8634 
8635 # if defined( VK_USE_PLATFORM_WIN32_KHR )
8636  //=== VK_KHR_external_semaphore_win32 ===
8637  template <>
8638  struct StructExtends<ExportSemaphoreWin32HandleInfoKHR, SemaphoreCreateInfo>
8639  {
8640  enum
8641  {
8642  value = true
8643  };
8644  };
8645  template <>
8646  struct StructExtends<D3D12FenceSubmitInfoKHR, SubmitInfo>
8647  {
8648  enum
8649  {
8650  value = true
8651  };
8652  };
8653 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
8654 
8655  //=== VK_KHR_push_descriptor ===
8656  template <>
8658  {
8659  enum
8660  {
8661  value = true
8662  };
8663  };
8664 
8665  //=== VK_EXT_conditional_rendering ===
8666  template <>
8668  {
8669  enum
8670  {
8671  value = true
8672  };
8673  };
8674  template <>
8676  {
8677  enum
8678  {
8679  value = true
8680  };
8681  };
8682  template <>
8684  {
8685  enum
8686  {
8687  value = true
8688  };
8689  };
8690 
8691  //=== VK_KHR_incremental_present ===
8692  template <>
8694  {
8695  enum
8696  {
8697  value = true
8698  };
8699  };
8700 
8701  //=== VK_NV_clip_space_w_scaling ===
8702  template <>
8704  {
8705  enum
8706  {
8707  value = true
8708  };
8709  };
8710 
8711  //=== VK_EXT_display_control ===
8712  template <>
8714  {
8715  enum
8716  {
8717  value = true
8718  };
8719  };
8720 
8721  //=== VK_GOOGLE_display_timing ===
8722  template <>
8724  {
8725  enum
8726  {
8727  value = true
8728  };
8729  };
8730 
8731  //=== VK_NVX_multiview_per_view_attributes ===
8732  template <>
8734  {
8735  enum
8736  {
8737  value = true
8738  };
8739  };
8740 
8741  //=== VK_NV_viewport_swizzle ===
8742  template <>
8744  {
8745  enum
8746  {
8747  value = true
8748  };
8749  };
8750 
8751  //=== VK_EXT_discard_rectangles ===
8752  template <>
8754  {
8755  enum
8756  {
8757  value = true
8758  };
8759  };
8760  template <>
8762  {
8763  enum
8764  {
8765  value = true
8766  };
8767  };
8768 
8769  //=== VK_EXT_conservative_rasterization ===
8770  template <>
8772  {
8773  enum
8774  {
8775  value = true
8776  };
8777  };
8778  template <>
8780  {
8781  enum
8782  {
8783  value = true
8784  };
8785  };
8786 
8787  //=== VK_EXT_depth_clip_enable ===
8788  template <>
8790  {
8791  enum
8792  {
8793  value = true
8794  };
8795  };
8796  template <>
8798  {
8799  enum
8800  {
8801  value = true
8802  };
8803  };
8804  template <>
8806  {
8807  enum
8808  {
8809  value = true
8810  };
8811  };
8812 
8813  //=== VK_KHR_shared_presentable_image ===
8814  template <>
8816  {
8817  enum
8818  {
8819  value = true
8820  };
8821  };
8822 
8823 # if defined( VK_USE_PLATFORM_WIN32_KHR )
8824  //=== VK_KHR_external_fence_win32 ===
8825  template <>
8826  struct StructExtends<ExportFenceWin32HandleInfoKHR, FenceCreateInfo>
8827  {
8828  enum
8829  {
8830  value = true
8831  };
8832  };
8833 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
8834 
8835  //=== VK_KHR_performance_query ===
8836  template <>
8838  {
8839  enum
8840  {
8841  value = true
8842  };
8843  };
8844  template <>
8846  {
8847  enum
8848  {
8849  value = true
8850  };
8851  };
8852  template <>
8854  {
8855  enum
8856  {
8857  value = true
8858  };
8859  };
8860  template <>
8862  {
8863  enum
8864  {
8865  value = true
8866  };
8867  };
8868  template <>
8870  {
8871  enum
8872  {
8873  value = true
8874  };
8875  };
8876  template <>
8878  {
8879  enum
8880  {
8881  value = true
8882  };
8883  };
8884 
8885  //=== VK_EXT_debug_utils ===
8886  template <>
8888  {
8889  enum
8890  {
8891  value = true
8892  };
8893  };
8894  template <>
8896  {
8897  enum
8898  {
8899  value = true
8900  };
8901  };
8902 
8903 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
8904  //=== VK_ANDROID_external_memory_android_hardware_buffer ===
8905  template <>
8906  struct StructExtends<AndroidHardwareBufferUsageANDROID, ImageFormatProperties2>
8907  {
8908  enum
8909  {
8910  value = true
8911  };
8912  };
8913  template <>
8914  struct StructExtends<AndroidHardwareBufferFormatPropertiesANDROID, AndroidHardwareBufferPropertiesANDROID>
8915  {
8916  enum
8917  {
8918  value = true
8919  };
8920  };
8921  template <>
8922  struct StructExtends<ImportAndroidHardwareBufferInfoANDROID, MemoryAllocateInfo>
8923  {
8924  enum
8925  {
8926  value = true
8927  };
8928  };
8929  template <>
8930  struct StructExtends<ExternalFormatANDROID, ImageCreateInfo>
8931  {
8932  enum
8933  {
8934  value = true
8935  };
8936  };
8937  template <>
8938  struct StructExtends<ExternalFormatANDROID, SamplerYcbcrConversionCreateInfo>
8939  {
8940  enum
8941  {
8942  value = true
8943  };
8944  };
8945  template <>
8946  struct StructExtends<AndroidHardwareBufferFormatProperties2ANDROID, AndroidHardwareBufferPropertiesANDROID>
8947  {
8948  enum
8949  {
8950  value = true
8951  };
8952  };
8953 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
8954 
8955  //=== VK_EXT_sample_locations ===
8956  template <>
8958  {
8959  enum
8960  {
8961  value = true
8962  };
8963  };
8964  template <>
8966  {
8967  enum
8968  {
8969  value = true
8970  };
8971  };
8972  template <>
8974  {
8975  enum
8976  {
8977  value = true
8978  };
8979  };
8980  template <>
8982  {
8983  enum
8984  {
8985  value = true
8986  };
8987  };
8988  template <>
8990  {
8991  enum
8992  {
8993  value = true
8994  };
8995  };
8996 
8997  //=== VK_EXT_blend_operation_advanced ===
8998  template <>
9000  {
9001  enum
9002  {
9003  value = true
9004  };
9005  };
9006  template <>
9008  {
9009  enum
9010  {
9011  value = true
9012  };
9013  };
9014  template <>
9016  {
9017  enum
9018  {
9019  value = true
9020  };
9021  };
9022  template <>
9024  {
9025  enum
9026  {
9027  value = true
9028  };
9029  };
9030 
9031  //=== VK_NV_fragment_coverage_to_color ===
9032  template <>
9034  {
9035  enum
9036  {
9037  value = true
9038  };
9039  };
9040 
9041  //=== VK_KHR_acceleration_structure ===
9042  template <>
9044  {
9045  enum
9046  {
9047  value = true
9048  };
9049  };
9050  template <>
9052  {
9053  enum
9054  {
9055  value = true
9056  };
9057  };
9058  template <>
9060  {
9061  enum
9062  {
9063  value = true
9064  };
9065  };
9066  template <>
9068  {
9069  enum
9070  {
9071  value = true
9072  };
9073  };
9074 
9075  //=== VK_NV_framebuffer_mixed_samples ===
9076  template <>
9078  {
9079  enum
9080  {
9081  value = true
9082  };
9083  };
9084 
9085  //=== VK_NV_shader_sm_builtins ===
9086  template <>
9088  {
9089  enum
9090  {
9091  value = true
9092  };
9093  };
9094  template <>
9096  {
9097  enum
9098  {
9099  value = true
9100  };
9101  };
9102  template <>
9104  {
9105  enum
9106  {
9107  value = true
9108  };
9109  };
9110 
9111  //=== VK_EXT_image_drm_format_modifier ===
9112  template <>
9114  {
9115  enum
9116  {
9117  value = true
9118  };
9119  };
9120  template <>
9122  {
9123  enum
9124  {
9125  value = true
9126  };
9127  };
9128  template <>
9130  {
9131  enum
9132  {
9133  value = true
9134  };
9135  };
9136  template <>
9138  {
9139  enum
9140  {
9141  value = true
9142  };
9143  };
9144  template <>
9146  {
9147  enum
9148  {
9149  value = true
9150  };
9151  };
9152 
9153  //=== VK_EXT_validation_cache ===
9154  template <>
9156  {
9157  enum
9158  {
9159  value = true
9160  };
9161  };
9162  template <>
9164  {
9165  enum
9166  {
9167  value = true
9168  };
9169  };
9170 
9171 # if defined( VK_ENABLE_BETA_EXTENSIONS )
9172  //=== VK_KHR_portability_subset ===
9173  template <>
9174  struct StructExtends<PhysicalDevicePortabilitySubsetFeaturesKHR, PhysicalDeviceFeatures2>
9175  {
9176  enum
9177  {
9178  value = true
9179  };
9180  };
9181  template <>
9182  struct StructExtends<PhysicalDevicePortabilitySubsetFeaturesKHR, DeviceCreateInfo>
9183  {
9184  enum
9185  {
9186  value = true
9187  };
9188  };
9189  template <>
9190  struct StructExtends<PhysicalDevicePortabilitySubsetPropertiesKHR, PhysicalDeviceProperties2>
9191  {
9192  enum
9193  {
9194  value = true
9195  };
9196  };
9197 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
9198 
9199  //=== VK_NV_shading_rate_image ===
9200  template <>
9202  {
9203  enum
9204  {
9205  value = true
9206  };
9207  };
9208  template <>
9210  {
9211  enum
9212  {
9213  value = true
9214  };
9215  };
9216  template <>
9218  {
9219  enum
9220  {
9221  value = true
9222  };
9223  };
9224  template <>
9226  {
9227  enum
9228  {
9229  value = true
9230  };
9231  };
9232  template <>
9234  {
9235  enum
9236  {
9237  value = true
9238  };
9239  };
9240 
9241  //=== VK_NV_ray_tracing ===
9242  template <>
9244  {
9245  enum
9246  {
9247  value = true
9248  };
9249  };
9250  template <>
9252  {
9253  enum
9254  {
9255  value = true
9256  };
9257  };
9258 
9259  //=== VK_NV_representative_fragment_test ===
9260  template <>
9262  {
9263  enum
9264  {
9265  value = true
9266  };
9267  };
9268  template <>
9270  {
9271  enum
9272  {
9273  value = true
9274  };
9275  };
9276  template <>
9278  {
9279  enum
9280  {
9281  value = true
9282  };
9283  };
9284 
9285  //=== VK_EXT_filter_cubic ===
9286  template <>
9288  {
9289  enum
9290  {
9291  value = true
9292  };
9293  };
9294  template <>
9296  {
9297  enum
9298  {
9299  value = true
9300  };
9301  };
9302 
9303  //=== VK_EXT_external_memory_host ===
9304  template <>
9306  {
9307  enum
9308  {
9309  value = true
9310  };
9311  };
9312  template <>
9314  {
9315  enum
9316  {
9317  value = true
9318  };
9319  };
9320 
9321  //=== VK_KHR_shader_clock ===
9322  template <>
9324  {
9325  enum
9326  {
9327  value = true
9328  };
9329  };
9330  template <>
9332  {
9333  enum
9334  {
9335  value = true
9336  };
9337  };
9338 
9339  //=== VK_AMD_pipeline_compiler_control ===
9340  template <>
9342  {
9343  enum
9344  {
9345  value = true
9346  };
9347  };
9348  template <>
9350  {
9351  enum
9352  {
9353  value = true
9354  };
9355  };
9356 
9357  //=== VK_AMD_shader_core_properties ===
9358  template <>
9360  {
9361  enum
9362  {
9363  value = true
9364  };
9365  };
9366 
9367 # if defined( VK_ENABLE_BETA_EXTENSIONS )
9368  //=== VK_EXT_video_decode_h265 ===
9369  template <>
9370  struct StructExtends<VideoDecodeH265ProfileInfoEXT, VideoProfileInfoKHR>
9371  {
9372  enum
9373  {
9374  value = true
9375  };
9376  };
9377  template <>
9378  struct StructExtends<VideoDecodeH265ProfileInfoEXT, QueryPoolCreateInfo>
9379  {
9380  enum
9381  {
9382  value = true
9383  };
9384  };
9385  template <>
9386  struct StructExtends<VideoDecodeH265CapabilitiesEXT, VideoCapabilitiesKHR>
9387  {
9388  enum
9389  {
9390  value = true
9391  };
9392  };
9393  template <>
9394  struct StructExtends<VideoDecodeH265SessionParametersCreateInfoEXT, VideoSessionParametersCreateInfoKHR>
9395  {
9396  enum
9397  {
9398  value = true
9399  };
9400  };
9401  template <>
9402  struct StructExtends<VideoDecodeH265SessionParametersAddInfoEXT, VideoSessionParametersUpdateInfoKHR>
9403  {
9404  enum
9405  {
9406  value = true
9407  };
9408  };
9409  template <>
9410  struct StructExtends<VideoDecodeH265PictureInfoEXT, VideoDecodeInfoKHR>
9411  {
9412  enum
9413  {
9414  value = true
9415  };
9416  };
9417  template <>
9418  struct StructExtends<VideoDecodeH265DpbSlotInfoEXT, VideoReferenceSlotInfoKHR>
9419  {
9420  enum
9421  {
9422  value = true
9423  };
9424  };
9425 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
9426 
9427  //=== VK_KHR_global_priority ===
9428  template <>
9430  {
9431  enum
9432  {
9433  value = true
9434  };
9435  };
9436  template <>
9438  {
9439  enum
9440  {
9441  value = true
9442  };
9443  };
9444  template <>
9446  {
9447  enum
9448  {
9449  value = true
9450  };
9451  };
9452  template <>
9454  {
9455  enum
9456  {
9457  value = true
9458  };
9459  };
9460 
9461  //=== VK_AMD_memory_overallocation_behavior ===
9462  template <>
9464  {
9465  enum
9466  {
9467  value = true
9468  };
9469  };
9470 
9471  //=== VK_EXT_vertex_attribute_divisor ===
9472  template <>
9474  {
9475  enum
9476  {
9477  value = true
9478  };
9479  };
9480  template <>
9482  {
9483  enum
9484  {
9485  value = true
9486  };
9487  };
9488  template <>
9490  {
9491  enum
9492  {
9493  value = true
9494  };
9495  };
9496  template <>
9498  {
9499  enum
9500  {
9501  value = true
9502  };
9503  };
9504 
9505 # if defined( VK_USE_PLATFORM_GGP )
9506  //=== VK_GGP_frame_token ===
9507  template <>
9508  struct StructExtends<PresentFrameTokenGGP, PresentInfoKHR>
9509  {
9510  enum
9511  {
9512  value = true
9513  };
9514  };
9515 # endif /*VK_USE_PLATFORM_GGP*/
9516 
9517  //=== VK_NV_compute_shader_derivatives ===
9518  template <>
9520  {
9521  enum
9522  {
9523  value = true
9524  };
9525  };
9526  template <>
9528  {
9529  enum
9530  {
9531  value = true
9532  };
9533  };
9534 
9535  //=== VK_NV_mesh_shader ===
9536  template <>
9538  {
9539  enum
9540  {
9541  value = true
9542  };
9543  };
9544  template <>
9546  {
9547  enum
9548  {
9549  value = true
9550  };
9551  };
9552  template <>
9554  {
9555  enum
9556  {
9557  value = true
9558  };
9559  };
9560 
9561  //=== VK_NV_shader_image_footprint ===
9562  template <>
9564  {
9565  enum
9566  {
9567  value = true
9568  };
9569  };
9570  template <>
9572  {
9573  enum
9574  {
9575  value = true
9576  };
9577  };
9578 
9579  //=== VK_NV_scissor_exclusive ===
9580  template <>
9582  {
9583  enum
9584  {
9585  value = true
9586  };
9587  };
9588  template <>
9590  {
9591  enum
9592  {
9593  value = true
9594  };
9595  };
9596  template <>
9598  {
9599  enum
9600  {
9601  value = true
9602  };
9603  };
9604 
9605  //=== VK_NV_device_diagnostic_checkpoints ===
9606  template <>
9608  {
9609  enum
9610  {
9611  value = true
9612  };
9613  };
9614 
9615  //=== VK_INTEL_shader_integer_functions2 ===
9616  template <>
9618  {
9619  enum
9620  {
9621  value = true
9622  };
9623  };
9624  template <>
9626  {
9627  enum
9628  {
9629  value = true
9630  };
9631  };
9632 
9633  //=== VK_INTEL_performance_query ===
9634  template <>
9636  {
9637  enum
9638  {
9639  value = true
9640  };
9641  };
9642 
9643  //=== VK_EXT_pci_bus_info ===
9644  template <>
9646  {
9647  enum
9648  {
9649  value = true
9650  };
9651  };
9652 
9653  //=== VK_AMD_display_native_hdr ===
9654  template <>
9656  {
9657  enum
9658  {
9659  value = true
9660  };
9661  };
9662  template <>
9664  {
9665  enum
9666  {
9667  value = true
9668  };
9669  };
9670 
9671  //=== VK_EXT_fragment_density_map ===
9672  template <>
9674  {
9675  enum
9676  {
9677  value = true
9678  };
9679  };
9680  template <>
9682  {
9683  enum
9684  {
9685  value = true
9686  };
9687  };
9688  template <>
9690  {
9691  enum
9692  {
9693  value = true
9694  };
9695  };
9696  template <>
9698  {
9699  enum
9700  {
9701  value = true
9702  };
9703  };
9704  template <>
9706  {
9707  enum
9708  {
9709  value = true
9710  };
9711  };
9712 
9713  //=== VK_KHR_fragment_shading_rate ===
9714  template <>
9716  {
9717  enum
9718  {
9719  value = true
9720  };
9721  };
9722  template <>
9724  {
9725  enum
9726  {
9727  value = true
9728  };
9729  };
9730  template <>
9732  {
9733  enum
9734  {
9735  value = true
9736  };
9737  };
9738  template <>
9740  {
9741  enum
9742  {
9743  value = true
9744  };
9745  };
9746  template <>
9748  {
9749  enum
9750  {
9751  value = true
9752  };
9753  };
9754 
9755  //=== VK_AMD_shader_core_properties2 ===
9756  template <>
9758  {
9759  enum
9760  {
9761  value = true
9762  };
9763  };
9764 
9765  //=== VK_AMD_device_coherent_memory ===
9766  template <>
9768  {
9769  enum
9770  {
9771  value = true
9772  };
9773  };
9774  template <>
9776  {
9777  enum
9778  {
9779  value = true
9780  };
9781  };
9782 
9783  //=== VK_EXT_shader_image_atomic_int64 ===
9784  template <>
9786  {
9787  enum
9788  {
9789  value = true
9790  };
9791  };
9792  template <>
9794  {
9795  enum
9796  {
9797  value = true
9798  };
9799  };
9800 
9801  //=== VK_EXT_memory_budget ===
9802  template <>
9804  {
9805  enum
9806  {
9807  value = true
9808  };
9809  };
9810 
9811  //=== VK_EXT_memory_priority ===
9812  template <>
9814  {
9815  enum
9816  {
9817  value = true
9818  };
9819  };
9820  template <>
9822  {
9823  enum
9824  {
9825  value = true
9826  };
9827  };
9828  template <>
9830  {
9831  enum
9832  {
9833  value = true
9834  };
9835  };
9836 
9837  //=== VK_KHR_surface_protected_capabilities ===
9838  template <>
9840  {
9841  enum
9842  {
9843  value = true
9844  };
9845  };
9846 
9847  //=== VK_NV_dedicated_allocation_image_aliasing ===
9848  template <>
9850  {
9851  enum
9852  {
9853  value = true
9854  };
9855  };
9856  template <>
9858  {
9859  enum
9860  {
9861  value = true
9862  };
9863  };
9864 
9865  //=== VK_EXT_buffer_device_address ===
9866  template <>
9868  {
9869  enum
9870  {
9871  value = true
9872  };
9873  };
9874  template <>
9876  {
9877  enum
9878  {
9879  value = true
9880  };
9881  };
9882  template <>
9884  {
9885  enum
9886  {
9887  value = true
9888  };
9889  };
9890 
9891  //=== VK_EXT_validation_features ===
9892  template <>
9894  {
9895  enum
9896  {
9897  value = true
9898  };
9899  };
9900 
9901  //=== VK_KHR_present_wait ===
9902  template <>
9904  {
9905  enum
9906  {
9907  value = true
9908  };
9909  };
9910  template <>
9912  {
9913  enum
9914  {
9915  value = true
9916  };
9917  };
9918 
9919  //=== VK_NV_cooperative_matrix ===
9920  template <>
9922  {
9923  enum
9924  {
9925  value = true
9926  };
9927  };
9928  template <>
9930  {
9931  enum
9932  {
9933  value = true
9934  };
9935  };
9936  template <>
9938  {
9939  enum
9940  {
9941  value = true
9942  };
9943  };
9944 
9945  //=== VK_NV_coverage_reduction_mode ===
9946  template <>
9948  {
9949  enum
9950  {
9951  value = true
9952  };
9953  };
9954  template <>
9956  {
9957  enum
9958  {
9959  value = true
9960  };
9961  };
9962  template <>
9964  {
9965  enum
9966  {
9967  value = true
9968  };
9969  };
9970 
9971  //=== VK_EXT_fragment_shader_interlock ===
9972  template <>
9974  {
9975  enum
9976  {
9977  value = true
9978  };
9979  };
9980  template <>
9982  {
9983  enum
9984  {
9985  value = true
9986  };
9987  };
9988 
9989  //=== VK_EXT_ycbcr_image_arrays ===
9990  template <>
9992  {
9993  enum
9994  {
9995  value = true
9996  };
9997  };
9998  template <>
10000  {
10001  enum
10002  {
10003  value = true
10004  };
10005  };
10006 
10007  //=== VK_EXT_provoking_vertex ===
10008  template <>
10010  {
10011  enum
10012  {
10013  value = true
10014  };
10015  };
10016  template <>
10018  {
10019  enum
10020  {
10021  value = true
10022  };
10023  };
10024  template <>
10026  {
10027  enum
10028  {
10029  value = true
10030  };
10031  };
10032  template <>
10034  {
10035  enum
10036  {
10037  value = true
10038  };
10039  };
10040 
10041 # if defined( VK_USE_PLATFORM_WIN32_KHR )
10042  //=== VK_EXT_full_screen_exclusive ===
10043  template <>
10044  struct StructExtends<SurfaceFullScreenExclusiveInfoEXT, PhysicalDeviceSurfaceInfo2KHR>
10045  {
10046  enum
10047  {
10048  value = true
10049  };
10050  };
10051  template <>
10052  struct StructExtends<SurfaceFullScreenExclusiveInfoEXT, SwapchainCreateInfoKHR>
10053  {
10054  enum
10055  {
10056  value = true
10057  };
10058  };
10059  template <>
10060  struct StructExtends<SurfaceCapabilitiesFullScreenExclusiveEXT, SurfaceCapabilities2KHR>
10061  {
10062  enum
10063  {
10064  value = true
10065  };
10066  };
10067  template <>
10068  struct StructExtends<SurfaceFullScreenExclusiveWin32InfoEXT, PhysicalDeviceSurfaceInfo2KHR>
10069  {
10070  enum
10071  {
10072  value = true
10073  };
10074  };
10075  template <>
10076  struct StructExtends<SurfaceFullScreenExclusiveWin32InfoEXT, SwapchainCreateInfoKHR>
10077  {
10078  enum
10079  {
10080  value = true
10081  };
10082  };
10083 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
10084 
10085  //=== VK_EXT_line_rasterization ===
10086  template <>
10088  {
10089  enum
10090  {
10091  value = true
10092  };
10093  };
10094  template <>
10096  {
10097  enum
10098  {
10099  value = true
10100  };
10101  };
10102  template <>
10104  {
10105  enum
10106  {
10107  value = true
10108  };
10109  };
10110  template <>
10112  {
10113  enum
10114  {
10115  value = true
10116  };
10117  };
10118 
10119  //=== VK_EXT_shader_atomic_float ===
10120  template <>
10122  {
10123  enum
10124  {
10125  value = true
10126  };
10127  };
10128  template <>
10130  {
10131  enum
10132  {
10133  value = true
10134  };
10135  };
10136 
10137  //=== VK_EXT_index_type_uint8 ===
10138  template <>
10140  {
10141  enum
10142  {
10143  value = true
10144  };
10145  };
10146  template <>
10148  {
10149  enum
10150  {
10151  value = true
10152  };
10153  };
10154 
10155  //=== VK_EXT_extended_dynamic_state ===
10156  template <>
10158  {
10159  enum
10160  {
10161  value = true
10162  };
10163  };
10164  template <>
10166  {
10167  enum
10168  {
10169  value = true
10170  };
10171  };
10172 
10173  //=== VK_KHR_pipeline_executable_properties ===
10174  template <>
10176  {
10177  enum
10178  {
10179  value = true
10180  };
10181  };
10182  template <>
10184  {
10185  enum
10186  {
10187  value = true
10188  };
10189  };
10190 
10191  //=== VK_EXT_shader_atomic_float2 ===
10192  template <>
10194  {
10195  enum
10196  {
10197  value = true
10198  };
10199  };
10200  template <>
10202  {
10203  enum
10204  {
10205  value = true
10206  };
10207  };
10208 
10209  //=== VK_NV_device_generated_commands ===
10210  template <>
10212  {
10213  enum
10214  {
10215  value = true
10216  };
10217  };
10218  template <>
10220  {
10221  enum
10222  {
10223  value = true
10224  };
10225  };
10226  template <>
10228  {
10229  enum
10230  {
10231  value = true
10232  };
10233  };
10234  template <>
10236  {
10237  enum
10238  {
10239  value = true
10240  };
10241  };
10242 
10243  //=== VK_NV_inherited_viewport_scissor ===
10244  template <>
10246  {
10247  enum
10248  {
10249  value = true
10250  };
10251  };
10252  template <>
10254  {
10255  enum
10256  {
10257  value = true
10258  };
10259  };
10260  template <>
10262  {
10263  enum
10264  {
10265  value = true
10266  };
10267  };
10268 
10269  //=== VK_EXT_texel_buffer_alignment ===
10270  template <>
10272  {
10273  enum
10274  {
10275  value = true
10276  };
10277  };
10278  template <>
10280  {
10281  enum
10282  {
10283  value = true
10284  };
10285  };
10286 
10287  //=== VK_QCOM_render_pass_transform ===
10288  template <>
10290  {
10291  enum
10292  {
10293  value = true
10294  };
10295  };
10296  template <>
10298  {
10299  enum
10300  {
10301  value = true
10302  };
10303  };
10304 
10305  //=== VK_EXT_device_memory_report ===
10306  template <>
10308  {
10309  enum
10310  {
10311  value = true
10312  };
10313  };
10314  template <>
10316  {
10317  enum
10318  {
10319  value = true
10320  };
10321  };
10322  template <>
10324  {
10325  enum
10326  {
10327  value = true
10328  };
10329  };
10330 
10331  //=== VK_EXT_robustness2 ===
10332  template <>
10334  {
10335  enum
10336  {
10337  value = true
10338  };
10339  };
10340  template <>
10342  {
10343  enum
10344  {
10345  value = true
10346  };
10347  };
10348  template <>
10350  {
10351  enum
10352  {
10353  value = true
10354  };
10355  };
10356 
10357  //=== VK_EXT_custom_border_color ===
10358  template <>
10360  {
10361  enum
10362  {
10363  value = true
10364  };
10365  };
10366  template <>
10368  {
10369  enum
10370  {
10371  value = true
10372  };
10373  };
10374  template <>
10376  {
10377  enum
10378  {
10379  value = true
10380  };
10381  };
10382  template <>
10384  {
10385  enum
10386  {
10387  value = true
10388  };
10389  };
10390 
10391  //=== VK_KHR_pipeline_library ===
10392  template <>
10394  {
10395  enum
10396  {
10397  value = true
10398  };
10399  };
10400 
10401  //=== VK_NV_present_barrier ===
10402  template <>
10404  {
10405  enum
10406  {
10407  value = true
10408  };
10409  };
10410  template <>
10412  {
10413  enum
10414  {
10415  value = true
10416  };
10417  };
10418  template <>
10420  {
10421  enum
10422  {
10423  value = true
10424  };
10425  };
10426  template <>
10428  {
10429  enum
10430  {
10431  value = true
10432  };
10433  };
10434 
10435  //=== VK_KHR_present_id ===
10436  template <>
10438  {
10439  enum
10440  {
10441  value = true
10442  };
10443  };
10444  template <>
10446  {
10447  enum
10448  {
10449  value = true
10450  };
10451  };
10452  template <>
10454  {
10455  enum
10456  {
10457  value = true
10458  };
10459  };
10460 
10461 # if defined( VK_ENABLE_BETA_EXTENSIONS )
10462  //=== VK_KHR_video_encode_queue ===
10463  template <>
10464  struct StructExtends<VideoEncodeCapabilitiesKHR, VideoCapabilitiesKHR>
10465  {
10466  enum
10467  {
10468  value = true
10469  };
10470  };
10471  template <>
10472  struct StructExtends<VideoEncodeUsageInfoKHR, VideoProfileInfoKHR>
10473  {
10474  enum
10475  {
10476  value = true
10477  };
10478  };
10479  template <>
10480  struct StructExtends<VideoEncodeUsageInfoKHR, QueryPoolCreateInfo>
10481  {
10482  enum
10483  {
10484  value = true
10485  };
10486  };
10487  template <>
10488  struct StructExtends<VideoEncodeRateControlInfoKHR, VideoCodingControlInfoKHR>
10489  {
10490  enum
10491  {
10492  value = true
10493  };
10494  };
10495  template <>
10496  struct StructExtends<VideoEncodeRateControlLayerInfoKHR, VideoCodingControlInfoKHR>
10497  {
10498  enum
10499  {
10500  value = true
10501  };
10502  };
10503 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
10504 
10505  //=== VK_NV_device_diagnostics_config ===
10506  template <>
10508  {
10509  enum
10510  {
10511  value = true
10512  };
10513  };
10514  template <>
10516  {
10517  enum
10518  {
10519  value = true
10520  };
10521  };
10522  template <>
10524  {
10525  enum
10526  {
10527  value = true
10528  };
10529  };
10530 
10531 # if defined( VK_USE_PLATFORM_METAL_EXT )
10532  //=== VK_EXT_metal_objects ===
10533  template <>
10534  struct StructExtends<ExportMetalObjectCreateInfoEXT, InstanceCreateInfo>
10535  {
10536  enum
10537  {
10538  value = true
10539  };
10540  };
10541  template <>
10542  struct StructExtends<ExportMetalObjectCreateInfoEXT, MemoryAllocateInfo>
10543  {
10544  enum
10545  {
10546  value = true
10547  };
10548  };
10549  template <>
10550  struct StructExtends<ExportMetalObjectCreateInfoEXT, ImageCreateInfo>
10551  {
10552  enum
10553  {
10554  value = true
10555  };
10556  };
10557  template <>
10558  struct StructExtends<ExportMetalObjectCreateInfoEXT, ImageViewCreateInfo>
10559  {
10560  enum
10561  {
10562  value = true
10563  };
10564  };
10565  template <>
10566  struct StructExtends<ExportMetalObjectCreateInfoEXT, BufferViewCreateInfo>
10567  {
10568  enum
10569  {
10570  value = true
10571  };
10572  };
10573  template <>
10574  struct StructExtends<ExportMetalObjectCreateInfoEXT, SemaphoreCreateInfo>
10575  {
10576  enum
10577  {
10578  value = true
10579  };
10580  };
10581  template <>
10582  struct StructExtends<ExportMetalObjectCreateInfoEXT, EventCreateInfo>
10583  {
10584  enum
10585  {
10586  value = true
10587  };
10588  };
10589  template <>
10590  struct StructExtends<ExportMetalDeviceInfoEXT, ExportMetalObjectsInfoEXT>
10591  {
10592  enum
10593  {
10594  value = true
10595  };
10596  };
10597  template <>
10598  struct StructExtends<ExportMetalCommandQueueInfoEXT, ExportMetalObjectsInfoEXT>
10599  {
10600  enum
10601  {
10602  value = true
10603  };
10604  };
10605  template <>
10606  struct StructExtends<ExportMetalBufferInfoEXT, ExportMetalObjectsInfoEXT>
10607  {
10608  enum
10609  {
10610  value = true
10611  };
10612  };
10613  template <>
10614  struct StructExtends<ImportMetalBufferInfoEXT, MemoryAllocateInfo>
10615  {
10616  enum
10617  {
10618  value = true
10619  };
10620  };
10621  template <>
10622  struct StructExtends<ExportMetalTextureInfoEXT, ExportMetalObjectsInfoEXT>
10623  {
10624  enum
10625  {
10626  value = true
10627  };
10628  };
10629  template <>
10630  struct StructExtends<ImportMetalTextureInfoEXT, ImageCreateInfo>
10631  {
10632  enum
10633  {
10634  value = true
10635  };
10636  };
10637  template <>
10638  struct StructExtends<ExportMetalIOSurfaceInfoEXT, ExportMetalObjectsInfoEXT>
10639  {
10640  enum
10641  {
10642  value = true
10643  };
10644  };
10645  template <>
10646  struct StructExtends<ImportMetalIOSurfaceInfoEXT, ImageCreateInfo>
10647  {
10648  enum
10649  {
10650  value = true
10651  };
10652  };
10653  template <>
10654  struct StructExtends<ExportMetalSharedEventInfoEXT, ExportMetalObjectsInfoEXT>
10655  {
10656  enum
10657  {
10658  value = true
10659  };
10660  };
10661  template <>
10662  struct StructExtends<ImportMetalSharedEventInfoEXT, SemaphoreCreateInfo>
10663  {
10664  enum
10665  {
10666  value = true
10667  };
10668  };
10669  template <>
10670  struct StructExtends<ImportMetalSharedEventInfoEXT, EventCreateInfo>
10671  {
10672  enum
10673  {
10674  value = true
10675  };
10676  };
10677 # endif /*VK_USE_PLATFORM_METAL_EXT*/
10678 
10679  //=== VK_KHR_synchronization2 ===
10680  template <>
10682  {
10683  enum
10684  {
10685  value = true
10686  };
10687  };
10688 
10689  //=== VK_EXT_descriptor_buffer ===
10690  template <>
10692  {
10693  enum
10694  {
10695  value = true
10696  };
10697  };
10698  template <>
10700  {
10701  enum
10702  {
10703  value = true
10704  };
10705  };
10706  template <>
10708  {
10709  enum
10710  {
10711  value = true
10712  };
10713  };
10714  template <>
10716  {
10717  enum
10718  {
10719  value = true
10720  };
10721  };
10722  template <>
10724  {
10725  enum
10726  {
10727  value = true
10728  };
10729  };
10730  template <>
10732  {
10733  enum
10734  {
10735  value = true
10736  };
10737  };
10738  template <>
10740  {
10741  enum
10742  {
10743  value = true
10744  };
10745  };
10746  template <>
10748  {
10749  enum
10750  {
10751  value = true
10752  };
10753  };
10754  template <>
10756  {
10757  enum
10758  {
10759  value = true
10760  };
10761  };
10762  template <>
10764  {
10765  enum
10766  {
10767  value = true
10768  };
10769  };
10770  template <>
10772  {
10773  enum
10774  {
10775  value = true
10776  };
10777  };
10778 
10779  //=== VK_EXT_graphics_pipeline_library ===
10780  template <>
10782  {
10783  enum
10784  {
10785  value = true
10786  };
10787  };
10788  template <>
10790  {
10791  enum
10792  {
10793  value = true
10794  };
10795  };
10796  template <>
10798  {
10799  enum
10800  {
10801  value = true
10802  };
10803  };
10804  template <>
10806  {
10807  enum
10808  {
10809  value = true
10810  };
10811  };
10812 
10813  //=== VK_AMD_shader_early_and_late_fragment_tests ===
10814  template <>
10816  {
10817  enum
10818  {
10819  value = true
10820  };
10821  };
10822  template <>
10824  {
10825  enum
10826  {
10827  value = true
10828  };
10829  };
10830 
10831  //=== VK_KHR_fragment_shader_barycentric ===
10832  template <>
10834  {
10835  enum
10836  {
10837  value = true
10838  };
10839  };
10840  template <>
10842  {
10843  enum
10844  {
10845  value = true
10846  };
10847  };
10848  template <>
10850  {
10851  enum
10852  {
10853  value = true
10854  };
10855  };
10856 
10857  //=== VK_KHR_shader_subgroup_uniform_control_flow ===
10858  template <>
10860  {
10861  enum
10862  {
10863  value = true
10864  };
10865  };
10866  template <>
10868  {
10869  enum
10870  {
10871  value = true
10872  };
10873  };
10874 
10875  //=== VK_NV_fragment_shading_rate_enums ===
10876  template <>
10878  {
10879  enum
10880  {
10881  value = true
10882  };
10883  };
10884  template <>
10886  {
10887  enum
10888  {
10889  value = true
10890  };
10891  };
10892  template <>
10894  {
10895  enum
10896  {
10897  value = true
10898  };
10899  };
10900  template <>
10902  {
10903  enum
10904  {
10905  value = true
10906  };
10907  };
10908 
10909  //=== VK_NV_ray_tracing_motion_blur ===
10910  template <>
10912  {
10913  enum
10914  {
10915  value = true
10916  };
10917  };
10918  template <>
10920  {
10921  enum
10922  {
10923  value = true
10924  };
10925  };
10926  template <>
10928  {
10929  enum
10930  {
10931  value = true
10932  };
10933  };
10934  template <>
10936  {
10937  enum
10938  {
10939  value = true
10940  };
10941  };
10942 
10943  //=== VK_EXT_mesh_shader ===
10944  template <>
10946  {
10947  enum
10948  {
10949  value = true
10950  };
10951  };
10952  template <>
10954  {
10955  enum
10956  {
10957  value = true
10958  };
10959  };
10960  template <>
10962  {
10963  enum
10964  {
10965  value = true
10966  };
10967  };
10968 
10969  //=== VK_EXT_ycbcr_2plane_444_formats ===
10970  template <>
10972  {
10973  enum
10974  {
10975  value = true
10976  };
10977  };
10978  template <>
10980  {
10981  enum
10982  {
10983  value = true
10984  };
10985  };
10986 
10987  //=== VK_EXT_fragment_density_map2 ===
10988  template <>
10990  {
10991  enum
10992  {
10993  value = true
10994  };
10995  };
10996  template <>
10998  {
10999  enum
11000  {
11001  value = true
11002  };
11003  };
11004  template <>
11006  {
11007  enum
11008  {
11009  value = true
11010  };
11011  };
11012 
11013  //=== VK_QCOM_rotated_copy_commands ===
11014  template <>
11016  {
11017  enum
11018  {
11019  value = true
11020  };
11021  };
11022  template <>
11024  {
11025  enum
11026  {
11027  value = true
11028  };
11029  };
11030 
11031  //=== VK_KHR_workgroup_memory_explicit_layout ===
11032  template <>
11034  {
11035  enum
11036  {
11037  value = true
11038  };
11039  };
11040  template <>
11042  {
11043  enum
11044  {
11045  value = true
11046  };
11047  };
11048 
11049  //=== VK_EXT_image_compression_control ===
11050  template <>
11052  {
11053  enum
11054  {
11055  value = true
11056  };
11057  };
11058  template <>
11060  {
11061  enum
11062  {
11063  value = true
11064  };
11065  };
11066  template <>
11068  {
11069  enum
11070  {
11071  value = true
11072  };
11073  };
11074  template <>
11076  {
11077  enum
11078  {
11079  value = true
11080  };
11081  };
11082  template <>
11084  {
11085  enum
11086  {
11087  value = true
11088  };
11089  };
11090  template <>
11092  {
11093  enum
11094  {
11095  value = true
11096  };
11097  };
11098  template <>
11100  {
11101  enum
11102  {
11103  value = true
11104  };
11105  };
11106  template <>
11108  {
11109  enum
11110  {
11111  value = true
11112  };
11113  };
11114 
11115  //=== VK_EXT_attachment_feedback_loop_layout ===
11116  template <>
11118  {
11119  enum
11120  {
11121  value = true
11122  };
11123  };
11124  template <>
11126  {
11127  enum
11128  {
11129  value = true
11130  };
11131  };
11132 
11133  //=== VK_EXT_4444_formats ===
11134  template <>
11136  {
11137  enum
11138  {
11139  value = true
11140  };
11141  };
11142  template <>
11144  {
11145  enum
11146  {
11147  value = true
11148  };
11149  };
11150 
11151  //=== VK_EXT_device_fault ===
11152  template <>
11154  {
11155  enum
11156  {
11157  value = true
11158  };
11159  };
11160  template <>
11162  {
11163  enum
11164  {
11165  value = true
11166  };
11167  };
11168 
11169  //=== VK_EXT_rgba10x6_formats ===
11170  template <>
11172  {
11173  enum
11174  {
11175  value = true
11176  };
11177  };
11178  template <>
11180  {
11181  enum
11182  {
11183  value = true
11184  };
11185  };
11186 
11187  //=== VK_KHR_ray_tracing_pipeline ===
11188  template <>
11190  {
11191  enum
11192  {
11193  value = true
11194  };
11195  };
11196  template <>
11198  {
11199  enum
11200  {
11201  value = true
11202  };
11203  };
11204  template <>
11206  {
11207  enum
11208  {
11209  value = true
11210  };
11211  };
11212 
11213  //=== VK_KHR_ray_query ===
11214  template <>
11216  {
11217  enum
11218  {
11219  value = true
11220  };
11221  };
11222  template <>
11224  {
11225  enum
11226  {
11227  value = true
11228  };
11229  };
11230 
11231  //=== VK_EXT_vertex_input_dynamic_state ===
11232  template <>
11234  {
11235  enum
11236  {
11237  value = true
11238  };
11239  };
11240  template <>
11242  {
11243  enum
11244  {
11245  value = true
11246  };
11247  };
11248 
11249  //=== VK_EXT_physical_device_drm ===
11250  template <>
11252  {
11253  enum
11254  {
11255  value = true
11256  };
11257  };
11258 
11259  //=== VK_EXT_device_address_binding_report ===
11260  template <>
11262  {
11263  enum
11264  {
11265  value = true
11266  };
11267  };
11268  template <>
11270  {
11271  enum
11272  {
11273  value = true
11274  };
11275  };
11276  template <>
11278  {
11279  enum
11280  {
11281  value = true
11282  };
11283  };
11284 
11285  //=== VK_EXT_depth_clip_control ===
11286  template <>
11288  {
11289  enum
11290  {
11291  value = true
11292  };
11293  };
11294  template <>
11296  {
11297  enum
11298  {
11299  value = true
11300  };
11301  };
11302  template <>
11304  {
11305  enum
11306  {
11307  value = true
11308  };
11309  };
11310 
11311  //=== VK_EXT_primitive_topology_list_restart ===
11312  template <>
11314  {
11315  enum
11316  {
11317  value = true
11318  };
11319  };
11320  template <>
11322  {
11323  enum
11324  {
11325  value = true
11326  };
11327  };
11328 
11329 # if defined( VK_USE_PLATFORM_FUCHSIA )
11330  //=== VK_FUCHSIA_external_memory ===
11331  template <>
11332  struct StructExtends<ImportMemoryZirconHandleInfoFUCHSIA, MemoryAllocateInfo>
11333  {
11334  enum
11335  {
11336  value = true
11337  };
11338  };
11339 # endif /*VK_USE_PLATFORM_FUCHSIA*/
11340 
11341 # if defined( VK_USE_PLATFORM_FUCHSIA )
11342  //=== VK_FUCHSIA_buffer_collection ===
11343  template <>
11344  struct StructExtends<ImportMemoryBufferCollectionFUCHSIA, MemoryAllocateInfo>
11345  {
11346  enum
11347  {
11348  value = true
11349  };
11350  };
11351  template <>
11352  struct StructExtends<BufferCollectionImageCreateInfoFUCHSIA, ImageCreateInfo>
11353  {
11354  enum
11355  {
11356  value = true
11357  };
11358  };
11359  template <>
11360  struct StructExtends<BufferCollectionBufferCreateInfoFUCHSIA, BufferCreateInfo>
11361  {
11362  enum
11363  {
11364  value = true
11365  };
11366  };
11367 # endif /*VK_USE_PLATFORM_FUCHSIA*/
11368 
11369  //=== VK_HUAWEI_subpass_shading ===
11370  template <>
11372  {
11373  enum
11374  {
11375  value = true
11376  };
11377  };
11378  template <>
11380  {
11381  enum
11382  {
11383  value = true
11384  };
11385  };
11386  template <>
11388  {
11389  enum
11390  {
11391  value = true
11392  };
11393  };
11394  template <>
11396  {
11397  enum
11398  {
11399  value = true
11400  };
11401  };
11402 
11403  //=== VK_HUAWEI_invocation_mask ===
11404  template <>
11406  {
11407  enum
11408  {
11409  value = true
11410  };
11411  };
11412  template <>
11414  {
11415  enum
11416  {
11417  value = true
11418  };
11419  };
11420 
11421  //=== VK_NV_external_memory_rdma ===
11422  template <>
11424  {
11425  enum
11426  {
11427  value = true
11428  };
11429  };
11430  template <>
11432  {
11433  enum
11434  {
11435  value = true
11436  };
11437  };
11438 
11439  //=== VK_EXT_pipeline_properties ===
11440  template <>
11442  {
11443  enum
11444  {
11445  value = true
11446  };
11447  };
11448  template <>
11450  {
11451  enum
11452  {
11453  value = true
11454  };
11455  };
11456 
11457  //=== VK_EXT_multisampled_render_to_single_sampled ===
11458  template <>
11460  {
11461  enum
11462  {
11463  value = true
11464  };
11465  };
11466  template <>
11468  {
11469  enum
11470  {
11471  value = true
11472  };
11473  };
11474  template <>
11476  {
11477  enum
11478  {
11479  value = true
11480  };
11481  };
11482  template <>
11484  {
11485  enum
11486  {
11487  value = true
11488  };
11489  };
11490  template <>
11492  {
11493  enum
11494  {
11495  value = true
11496  };
11497  };
11498 
11499  //=== VK_EXT_extended_dynamic_state2 ===
11500  template <>
11502  {
11503  enum
11504  {
11505  value = true
11506  };
11507  };
11508  template <>
11510  {
11511  enum
11512  {
11513  value = true
11514  };
11515  };
11516 
11517  //=== VK_EXT_color_write_enable ===
11518  template <>
11520  {
11521  enum
11522  {
11523  value = true
11524  };
11525  };
11526  template <>
11528  {
11529  enum
11530  {
11531  value = true
11532  };
11533  };
11534  template <>
11536  {
11537  enum
11538  {
11539  value = true
11540  };
11541  };
11542 
11543  //=== VK_EXT_primitives_generated_query ===
11544  template <>
11546  {
11547  enum
11548  {
11549  value = true
11550  };
11551  };
11552  template <>
11554  {
11555  enum
11556  {
11557  value = true
11558  };
11559  };
11560 
11561  //=== VK_KHR_ray_tracing_maintenance1 ===
11562  template <>
11564  {
11565  enum
11566  {
11567  value = true
11568  };
11569  };
11570  template <>
11572  {
11573  enum
11574  {
11575  value = true
11576  };
11577  };
11578 
11579  //=== VK_EXT_image_view_min_lod ===
11580  template <>
11582  {
11583  enum
11584  {
11585  value = true
11586  };
11587  };
11588  template <>
11590  {
11591  enum
11592  {
11593  value = true
11594  };
11595  };
11596  template <>
11598  {
11599  enum
11600  {
11601  value = true
11602  };
11603  };
11604 
11605  //=== VK_EXT_multi_draw ===
11606  template <>
11608  {
11609  enum
11610  {
11611  value = true
11612  };
11613  };
11614  template <>
11616  {
11617  enum
11618  {
11619  value = true
11620  };
11621  };
11622  template <>
11624  {
11625  enum
11626  {
11627  value = true
11628  };
11629  };
11630 
11631  //=== VK_EXT_image_2d_view_of_3d ===
11632  template <>
11634  {
11635  enum
11636  {
11637  value = true
11638  };
11639  };
11640  template <>
11642  {
11643  enum
11644  {
11645  value = true
11646  };
11647  };
11648 
11649  //=== VK_EXT_opacity_micromap ===
11650  template <>
11652  {
11653  enum
11654  {
11655  value = true
11656  };
11657  };
11658  template <>
11660  {
11661  enum
11662  {
11663  value = true
11664  };
11665  };
11666  template <>
11668  {
11669  enum
11670  {
11671  value = true
11672  };
11673  };
11674  template <>
11676  {
11677  enum
11678  {
11679  value = true
11680  };
11681  };
11682 
11683  //=== VK_EXT_border_color_swizzle ===
11684  template <>
11686  {
11687  enum
11688  {
11689  value = true
11690  };
11691  };
11692  template <>
11694  {
11695  enum
11696  {
11697  value = true
11698  };
11699  };
11700  template <>
11702  {
11703  enum
11704  {
11705  value = true
11706  };
11707  };
11708 
11709  //=== VK_EXT_pageable_device_local_memory ===
11710  template <>
11712  {
11713  enum
11714  {
11715  value = true
11716  };
11717  };
11718  template <>
11720  {
11721  enum
11722  {
11723  value = true
11724  };
11725  };
11726 
11727  //=== VK_VALVE_descriptor_set_host_mapping ===
11728  template <>
11730  {
11731  enum
11732  {
11733  value = true
11734  };
11735  };
11736  template <>
11738  {
11739  enum
11740  {
11741  value = true
11742  };
11743  };
11744 
11745  //=== VK_EXT_depth_clamp_zero_one ===
11746  template <>
11748  {
11749  enum
11750  {
11751  value = true
11752  };
11753  };
11754  template <>
11756  {
11757  enum
11758  {
11759  value = true
11760  };
11761  };
11762 
11763  //=== VK_EXT_non_seamless_cube_map ===
11764  template <>
11766  {
11767  enum
11768  {
11769  value = true
11770  };
11771  };
11772  template <>
11774  {
11775  enum
11776  {
11777  value = true
11778  };
11779  };
11780 
11781  //=== VK_QCOM_fragment_density_map_offset ===
11782  template <>
11784  {
11785  enum
11786  {
11787  value = true
11788  };
11789  };
11790  template <>
11792  {
11793  enum
11794  {
11795  value = true
11796  };
11797  };
11798  template <>
11800  {
11801  enum
11802  {
11803  value = true
11804  };
11805  };
11806  template <>
11808  {
11809  enum
11810  {
11811  value = true
11812  };
11813  };
11814 
11815  //=== VK_NV_copy_memory_indirect ===
11816  template <>
11818  {
11819  enum
11820  {
11821  value = true
11822  };
11823  };
11824  template <>
11826  {
11827  enum
11828  {
11829  value = true
11830  };
11831  };
11832  template <>
11834  {
11835  enum
11836  {
11837  value = true
11838  };
11839  };
11840 
11841  //=== VK_NV_memory_decompression ===
11842  template <>
11844  {
11845  enum
11846  {
11847  value = true
11848  };
11849  };
11850  template <>
11852  {
11853  enum
11854  {
11855  value = true
11856  };
11857  };
11858  template <>
11860  {
11861  enum
11862  {
11863  value = true
11864  };
11865  };
11866 
11867  //=== VK_NV_linear_color_attachment ===
11868  template <>
11870  {
11871  enum
11872  {
11873  value = true
11874  };
11875  };
11876  template <>
11878  {
11879  enum
11880  {
11881  value = true
11882  };
11883  };
11884 
11885  //=== VK_EXT_image_compression_control_swapchain ===
11886  template <>
11888  {
11889  enum
11890  {
11891  value = true
11892  };
11893  };
11894  template <>
11896  {
11897  enum
11898  {
11899  value = true
11900  };
11901  };
11902 
11903  //=== VK_QCOM_image_processing ===
11904  template <>
11906  {
11907  enum
11908  {
11909  value = true
11910  };
11911  };
11912  template <>
11914  {
11915  enum
11916  {
11917  value = true
11918  };
11919  };
11920  template <>
11922  {
11923  enum
11924  {
11925  value = true
11926  };
11927  };
11928  template <>
11930  {
11931  enum
11932  {
11933  value = true
11934  };
11935  };
11936 
11937  //=== VK_EXT_extended_dynamic_state3 ===
11938  template <>
11940  {
11941  enum
11942  {
11943  value = true
11944  };
11945  };
11946  template <>
11948  {
11949  enum
11950  {
11951  value = true
11952  };
11953  };
11954  template <>
11956  {
11957  enum
11958  {
11959  value = true
11960  };
11961  };
11962 
11963  //=== VK_EXT_subpass_merge_feedback ===
11964  template <>
11966  {
11967  enum
11968  {
11969  value = true
11970  };
11971  };
11972  template <>
11974  {
11975  enum
11976  {
11977  value = true
11978  };
11979  };
11980  template <>
11982  {
11983  enum
11984  {
11985  value = true
11986  };
11987  };
11988  template <>
11990  {
11991  enum
11992  {
11993  value = true
11994  };
11995  };
11996  template <>
11998  {
11999  enum
12000  {
12001  value = true
12002  };
12003  };
12004  template <>
12006  {
12007  enum
12008  {
12009  value = true
12010  };
12011  };
12012 
12013  //=== VK_LUNARG_direct_driver_loading ===
12014  template <>
12016  {
12017  enum
12018  {
12019  value = true
12020  };
12021  };
12022 
12023  //=== VK_EXT_shader_module_identifier ===
12024  template <>
12026  {
12027  enum
12028  {
12029  value = true
12030  };
12031  };
12032  template <>
12034  {
12035  enum
12036  {
12037  value = true
12038  };
12039  };
12040  template <>
12042  {
12043  enum
12044  {
12045  value = true
12046  };
12047  };
12048  template <>
12050  {
12051  enum
12052  {
12053  value = true
12054  };
12055  };
12056 
12057  //=== VK_EXT_rasterization_order_attachment_access ===
12058  template <>
12060  {
12061  enum
12062  {
12063  value = true
12064  };
12065  };
12066  template <>
12068  {
12069  enum
12070  {
12071  value = true
12072  };
12073  };
12074 
12075  //=== VK_NV_optical_flow ===
12076  template <>
12078  {
12079  enum
12080  {
12081  value = true
12082  };
12083  };
12084  template <>
12086  {
12087  enum
12088  {
12089  value = true
12090  };
12091  };
12092  template <>
12094  {
12095  enum
12096  {
12097  value = true
12098  };
12099  };
12100  template <>
12102  {
12103  enum
12104  {
12105  value = true
12106  };
12107  };
12108  template <>
12110  {
12111  enum
12112  {
12113  value = true
12114  };
12115  };
12116  template <>
12118  {
12119  enum
12120  {
12121  value = true
12122  };
12123  };
12124 
12125  //=== VK_EXT_legacy_dithering ===
12126  template <>
12128  {
12129  enum
12130  {
12131  value = true
12132  };
12133  };
12134  template <>
12136  {
12137  enum
12138  {
12139  value = true
12140  };
12141  };
12142 
12143  //=== VK_EXT_pipeline_protected_access ===
12144  template <>
12146  {
12147  enum
12148  {
12149  value = true
12150  };
12151  };
12152  template <>
12154  {
12155  enum
12156  {
12157  value = true
12158  };
12159  };
12160 
12161  //=== VK_QCOM_tile_properties ===
12162  template <>
12164  {
12165  enum
12166  {
12167  value = true
12168  };
12169  };
12170  template <>
12172  {
12173  enum
12174  {
12175  value = true
12176  };
12177  };
12178 
12179  //=== VK_SEC_amigo_profiling ===
12180  template <>
12182  {
12183  enum
12184  {
12185  value = true
12186  };
12187  };
12188  template <>
12190  {
12191  enum
12192  {
12193  value = true
12194  };
12195  };
12196  template <>
12198  {
12199  enum
12200  {
12201  value = true
12202  };
12203  };
12204 
12205  //=== VK_QCOM_multiview_per_view_viewports ===
12206  template <>
12208  {
12209  enum
12210  {
12211  value = true
12212  };
12213  };
12214  template <>
12216  {
12217  enum
12218  {
12219  value = true
12220  };
12221  };
12222 
12223  //=== VK_NV_ray_tracing_invocation_reorder ===
12224  template <>
12226  {
12227  enum
12228  {
12229  value = true
12230  };
12231  };
12232  template <>
12234  {
12235  enum
12236  {
12237  value = true
12238  };
12239  };
12240  template <>
12242  {
12243  enum
12244  {
12245  value = true
12246  };
12247  };
12248 
12249  //=== VK_EXT_mutable_descriptor_type ===
12250  template <>
12252  {
12253  enum
12254  {
12255  value = true
12256  };
12257  };
12258  template <>
12260  {
12261  enum
12262  {
12263  value = true
12264  };
12265  };
12266  template <>
12268  {
12269  enum
12270  {
12271  value = true
12272  };
12273  };
12274  template <>
12276  {
12277  enum
12278  {
12279  value = true
12280  };
12281  };
12282 
12283  //=== VK_ARM_shader_core_builtins ===
12284  template <>
12286  {
12287  enum
12288  {
12289  value = true
12290  };
12291  };
12292  template <>
12294  {
12295  enum
12296  {
12297  value = true
12298  };
12299  };
12300  template <>
12302  {
12303  enum
12304  {
12305  value = true
12306  };
12307  };
12308 
12309 #endif // VULKAN_HPP_DISABLE_ENHANCED_MODE
12310 
12311 #if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
12313  {
12314  public:
12315 # ifdef VULKAN_HPP_NO_EXCEPTIONS
12316  DynamicLoader( std::string const & vulkanLibraryName = {} ) VULKAN_HPP_NOEXCEPT
12317 # else
12318  DynamicLoader( std::string const & vulkanLibraryName = {} )
12319 # endif
12320  {
12321  if ( !vulkanLibraryName.empty() )
12322  {
12323 # if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNXNTO__ ) || defined( __Fuchsia__ )
12324  m_library = dlopen( vulkanLibraryName.c_str(), RTLD_NOW | RTLD_LOCAL );
12325 # elif defined( _WIN32 )
12326  m_library = ::LoadLibraryA( vulkanLibraryName.c_str() );
12327 # else
12328 # error unsupported platform
12329 # endif
12330  }
12331  else
12332  {
12333 # if defined( __unix__ ) || defined( __QNXNTO__ ) || defined( __Fuchsia__ )
12334  m_library = dlopen( "libvulkan.so", RTLD_NOW | RTLD_LOCAL );
12335  if ( m_library == nullptr )
12336  {
12337  m_library = dlopen( "libvulkan.so.1", RTLD_NOW | RTLD_LOCAL );
12338  }
12339 # elif defined( __APPLE__ )
12340  m_library = dlopen( "libvulkan.dylib", RTLD_NOW | RTLD_LOCAL );
12341 # elif defined( _WIN32 )
12342  m_library = ::LoadLibraryA( "vulkan-1.dll" );
12343 # else
12344 # error unsupported platform
12345 # endif
12346  }
12347 
12348 # ifndef VULKAN_HPP_NO_EXCEPTIONS
12349  if ( m_library == nullptr )
12350  {
12351  // NOTE there should be an InitializationFailedError, but msvc insists on the symbol does not exist within the scope of this function.
12352  throw std::runtime_error( "Failed to load vulkan library!" );
12353  }
12354 # endif
12355  }
12356 
12357  DynamicLoader( DynamicLoader const & ) = delete;
12358 
12359  DynamicLoader( DynamicLoader && other ) VULKAN_HPP_NOEXCEPT : m_library( other.m_library )
12360  {
12361  other.m_library = nullptr;
12362  }
12363 
12364  DynamicLoader & operator=( DynamicLoader const & ) = delete;
12365 
12367  {
12368  std::swap( m_library, other.m_library );
12369  return *this;
12370  }
12371 
12373  {
12374  if ( m_library )
12375  {
12376 # if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNXNTO__ ) || defined( __Fuchsia__ )
12377  dlclose( m_library );
12378 # elif defined( _WIN32 )
12379  ::FreeLibrary( m_library );
12380 # else
12381 # error unsupported platform
12382 # endif
12383  }
12384  }
12385 
12386  template <typename T>
12387  T getProcAddress( const char * function ) const VULKAN_HPP_NOEXCEPT
12388  {
12389 # if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNXNTO__ ) || defined( __Fuchsia__ )
12390  return (T)dlsym( m_library, function );
12391 # elif defined( _WIN32 )
12392  return ( T )::GetProcAddress( m_library, function );
12393 # else
12394 # error unsupported platform
12395 # endif
12396  }
12397 
12399  {
12400  return m_library != nullptr;
12401  }
12402 
12403  private:
12404 # if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNXNTO__ ) || defined( __Fuchsia__ )
12405  void * m_library;
12406 # elif defined( _WIN32 )
12407  ::HINSTANCE m_library;
12408 # else
12409 # error unsupported platform
12410 # endif
12411  };
12412 #endif
12413 
12414  using PFN_dummy = void ( * )();
12415 
12417  {
12418  public:
12419  //=== VK_VERSION_1_0 ===
12557 
12558  //=== VK_VERSION_1_1 ===
12587 
12588  //=== VK_VERSION_1_2 ===
12602 
12603  //=== VK_VERSION_1_3 ===
12641 
12642  //=== VK_KHR_surface ===
12648 
12649  //=== VK_KHR_swapchain ===
12659 
12660  //=== VK_KHR_display ===
12668 
12669  //=== VK_KHR_display_swapchain ===
12671 
12672 #if defined( VK_USE_PLATFORM_XLIB_KHR )
12673  //=== VK_KHR_xlib_surface ===
12676 #else
12679 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
12680 
12681 #if defined( VK_USE_PLATFORM_XCB_KHR )
12682  //=== VK_KHR_xcb_surface ===
12685 #else
12688 #endif /*VK_USE_PLATFORM_XCB_KHR*/
12689 
12690 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )
12691  //=== VK_KHR_wayland_surface ===
12694 #else
12697 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
12698 
12699 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
12700  //=== VK_KHR_android_surface ===
12702 #else
12704 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
12705 
12706 #if defined( VK_USE_PLATFORM_WIN32_KHR )
12707  //=== VK_KHR_win32_surface ===
12710 #else
12713 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
12714 
12715  //=== VK_EXT_debug_report ===
12719 
12720  //=== VK_EXT_debug_marker ===
12726 
12727 #if defined( VK_ENABLE_BETA_EXTENSIONS )
12728  //=== VK_KHR_video_queue ===
12741 #else
12754 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
12755 
12756 #if defined( VK_ENABLE_BETA_EXTENSIONS )
12757  //=== VK_KHR_video_decode_queue ===
12759 #else
12761 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
12762 
12763  //=== VK_EXT_transform_feedback ===
12770 
12771  //=== VK_NVX_binary_import ===
12777 
12778  //=== VK_NVX_image_view_handle ===
12781 
12782  //=== VK_AMD_draw_indirect_count ===
12785 
12786  //=== VK_AMD_shader_info ===
12788 
12789  //=== VK_KHR_dynamic_rendering ===
12792 
12793 #if defined( VK_USE_PLATFORM_GGP )
12794  //=== VK_GGP_stream_descriptor_surface ===
12796 #else
12798 #endif /*VK_USE_PLATFORM_GGP*/
12799 
12800  //=== VK_NV_external_memory_capabilities ===
12802 
12803 #if defined( VK_USE_PLATFORM_WIN32_KHR )
12804  //=== VK_NV_external_memory_win32 ===
12806 #else
12808 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
12809 
12810  //=== VK_KHR_get_physical_device_properties2 ===
12818 
12819  //=== VK_KHR_device_group ===
12823 
12824 #if defined( VK_USE_PLATFORM_VI_NN )
12825  //=== VK_NN_vi_surface ===
12827 #else
12829 #endif /*VK_USE_PLATFORM_VI_NN*/
12830 
12831  //=== VK_KHR_maintenance1 ===
12833 
12834  //=== VK_KHR_device_group_creation ===
12836 
12837  //=== VK_KHR_external_memory_capabilities ===
12839 
12840 #if defined( VK_USE_PLATFORM_WIN32_KHR )
12841  //=== VK_KHR_external_memory_win32 ===
12844 #else
12847 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
12848 
12849  //=== VK_KHR_external_memory_fd ===
12852 
12853  //=== VK_KHR_external_semaphore_capabilities ===
12855 
12856 #if defined( VK_USE_PLATFORM_WIN32_KHR )
12857  //=== VK_KHR_external_semaphore_win32 ===
12860 #else
12863 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
12864 
12865  //=== VK_KHR_external_semaphore_fd ===
12868 
12869  //=== VK_KHR_push_descriptor ===
12872 
12873  //=== VK_EXT_conditional_rendering ===
12876 
12877  //=== VK_KHR_descriptor_update_template ===
12881 
12882  //=== VK_NV_clip_space_w_scaling ===
12884 
12885  //=== VK_EXT_direct_mode_display ===
12887 
12888 #if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
12889  //=== VK_EXT_acquire_xlib_display ===
12892 #else
12895 #endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
12896 
12897  //=== VK_EXT_display_surface_counter ===
12899 
12900  //=== VK_EXT_display_control ===
12905 
12906  //=== VK_GOOGLE_display_timing ===
12909 
12910  //=== VK_EXT_discard_rectangles ===
12912 
12913  //=== VK_EXT_hdr_metadata ===
12915 
12916  //=== VK_KHR_create_renderpass2 ===
12921 
12922  //=== VK_KHR_shared_presentable_image ===
12924 
12925  //=== VK_KHR_external_fence_capabilities ===
12927 
12928 #if defined( VK_USE_PLATFORM_WIN32_KHR )
12929  //=== VK_KHR_external_fence_win32 ===
12932 #else
12935 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
12936 
12937  //=== VK_KHR_external_fence_fd ===
12940 
12941  //=== VK_KHR_performance_query ===
12946 
12947  //=== VK_KHR_get_surface_capabilities2 ===
12950 
12951  //=== VK_KHR_get_display_properties2 ===
12956 
12957 #if defined( VK_USE_PLATFORM_IOS_MVK )
12958  //=== VK_MVK_ios_surface ===
12960 #else
12962 #endif /*VK_USE_PLATFORM_IOS_MVK*/
12963 
12964 #if defined( VK_USE_PLATFORM_MACOS_MVK )
12965  //=== VK_MVK_macos_surface ===
12967 #else
12969 #endif /*VK_USE_PLATFORM_MACOS_MVK*/
12970 
12971  //=== VK_EXT_debug_utils ===
12983 
12984 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
12985  //=== VK_ANDROID_external_memory_android_hardware_buffer ===
12988 #else
12991 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
12992 
12993  //=== VK_EXT_sample_locations ===
12996 
12997  //=== VK_KHR_get_memory_requirements2 ===
13001 
13002  //=== VK_KHR_acceleration_structure ===
13019 
13020  //=== VK_KHR_sampler_ycbcr_conversion ===
13023 
13024  //=== VK_KHR_bind_memory2 ===
13027 
13028  //=== VK_EXT_image_drm_format_modifier ===
13030 
13031  //=== VK_EXT_validation_cache ===
13036 
13037  //=== VK_NV_shading_rate_image ===
13041 
13042  //=== VK_NV_ray_tracing ===
13055 
13056  //=== VK_KHR_maintenance3 ===
13058 
13059  //=== VK_KHR_draw_indirect_count ===
13062 
13063  //=== VK_EXT_external_memory_host ===
13065 
13066  //=== VK_AMD_buffer_marker ===
13068 
13069  //=== VK_EXT_calibrated_timestamps ===
13072 
13073  //=== VK_NV_mesh_shader ===
13077 
13078  //=== VK_NV_scissor_exclusive ===
13080 
13081  //=== VK_NV_device_diagnostic_checkpoints ===
13084 
13085  //=== VK_KHR_timeline_semaphore ===
13089 
13090  //=== VK_INTEL_performance_query ===
13100 
13101  //=== VK_AMD_display_native_hdr ===
13103 
13104 #if defined( VK_USE_PLATFORM_FUCHSIA )
13105  //=== VK_FUCHSIA_imagepipe_surface ===
13107 #else
13109 #endif /*VK_USE_PLATFORM_FUCHSIA*/
13110 
13111 #if defined( VK_USE_PLATFORM_METAL_EXT )
13112  //=== VK_EXT_metal_surface ===
13114 #else
13116 #endif /*VK_USE_PLATFORM_METAL_EXT*/
13117 
13118  //=== VK_KHR_fragment_shading_rate ===
13121 
13122  //=== VK_EXT_buffer_device_address ===
13124 
13125  //=== VK_EXT_tooling_info ===
13127 
13128  //=== VK_KHR_present_wait ===
13130 
13131  //=== VK_NV_cooperative_matrix ===
13133 
13134  //=== VK_NV_coverage_reduction_mode ===
13136 
13137 #if defined( VK_USE_PLATFORM_WIN32_KHR )
13138  //=== VK_EXT_full_screen_exclusive ===
13143 #else
13148 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
13149 
13150  //=== VK_EXT_headless_surface ===
13152 
13153  //=== VK_KHR_buffer_device_address ===
13157 
13158  //=== VK_EXT_line_rasterization ===
13160 
13161  //=== VK_EXT_host_query_reset ===
13163 
13164  //=== VK_EXT_extended_dynamic_state ===
13177 
13178  //=== VK_KHR_deferred_host_operations ===
13184 
13185  //=== VK_KHR_pipeline_executable_properties ===
13189 
13190  //=== VK_NV_device_generated_commands ===
13197 
13198  //=== VK_EXT_acquire_drm_display ===
13201 
13202  //=== VK_EXT_private_data ===
13207 
13208 #if defined( VK_ENABLE_BETA_EXTENSIONS )
13209  //=== VK_KHR_video_encode_queue ===
13211 #else
13213 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
13214 
13215 #if defined( VK_USE_PLATFORM_METAL_EXT )
13216  //=== VK_EXT_metal_objects ===
13218 #else
13220 #endif /*VK_USE_PLATFORM_METAL_EXT*/
13221 
13222  //=== VK_KHR_synchronization2 ===
13231 
13232  //=== VK_EXT_descriptor_buffer ===
13244 
13245  //=== VK_NV_fragment_shading_rate_enums ===
13247 
13248  //=== VK_EXT_mesh_shader ===
13252 
13253  //=== VK_KHR_copy_commands2 ===
13260 
13261  //=== VK_EXT_image_compression_control ===
13263 
13264  //=== VK_EXT_device_fault ===
13266 
13267 #if defined( VK_USE_PLATFORM_WIN32_KHR )
13268  //=== VK_NV_acquire_winrt_display ===
13271 #else
13274 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
13275 
13276 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
13277  //=== VK_EXT_directfb_surface ===
13280 #else
13283 #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
13284 
13285  //=== VK_KHR_ray_tracing_pipeline ===
13293 
13294  //=== VK_EXT_vertex_input_dynamic_state ===
13296 
13297 #if defined( VK_USE_PLATFORM_FUCHSIA )
13298  //=== VK_FUCHSIA_external_memory ===
13301 #else
13304 #endif /*VK_USE_PLATFORM_FUCHSIA*/
13305 
13306 #if defined( VK_USE_PLATFORM_FUCHSIA )
13307  //=== VK_FUCHSIA_external_semaphore ===
13310 #else
13313 #endif /*VK_USE_PLATFORM_FUCHSIA*/
13314 
13315 #if defined( VK_USE_PLATFORM_FUCHSIA )
13316  //=== VK_FUCHSIA_buffer_collection ===
13322 #else
13328 #endif /*VK_USE_PLATFORM_FUCHSIA*/
13329 
13330  //=== VK_HUAWEI_subpass_shading ===
13333 
13334  //=== VK_HUAWEI_invocation_mask ===
13336 
13337  //=== VK_NV_external_memory_rdma ===
13339 
13340  //=== VK_EXT_pipeline_properties ===
13342 
13343  //=== VK_EXT_extended_dynamic_state2 ===
13349 
13350 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
13351  //=== VK_QNX_screen_surface ===
13354 #else
13357 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
13358 
13359  //=== VK_EXT_color_write_enable ===
13361 
13362  //=== VK_KHR_ray_tracing_maintenance1 ===
13364 
13365  //=== VK_EXT_multi_draw ===
13368 
13369  //=== VK_EXT_opacity_micromap ===
13384 
13385  //=== VK_EXT_pageable_device_local_memory ===
13387 
13388  //=== VK_KHR_maintenance4 ===
13392 
13393  //=== VK_VALVE_descriptor_set_host_mapping ===
13396 
13397  //=== VK_NV_copy_memory_indirect ===
13400 
13401  //=== VK_NV_memory_decompression ===
13404 
13405  //=== VK_EXT_extended_dynamic_state3 ===
13437 
13438  //=== VK_EXT_shader_module_identifier ===
13441 
13442  //=== VK_NV_optical_flow ===
13448 
13449  //=== VK_QCOM_tile_properties ===
13452 
13453  public:
13456 
13458  {
13459  init( getInstanceProcAddr );
13460  }
13461 
13463  {
13464  VULKAN_HPP_ASSERT( getInstanceProcAddr );
13465 
13466  vkGetInstanceProcAddr = getInstanceProcAddr;
13467 
13468  //=== VK_VERSION_1_0 ===
13469  vkCreateInstance = PFN_vkCreateInstance( vkGetInstanceProcAddr( NULL, "vkCreateInstance" ) );
13471  PFN_vkEnumerateInstanceExtensionProperties( vkGetInstanceProcAddr( NULL, "vkEnumerateInstanceExtensionProperties" ) );
13472  vkEnumerateInstanceLayerProperties = PFN_vkEnumerateInstanceLayerProperties( vkGetInstanceProcAddr( NULL, "vkEnumerateInstanceLayerProperties" ) );
13473 
13474  //=== VK_VERSION_1_1 ===
13475  vkEnumerateInstanceVersion = PFN_vkEnumerateInstanceVersion( vkGetInstanceProcAddr( NULL, "vkEnumerateInstanceVersion" ) );
13476  }
13477 
13478  // This interface does not require a linked vulkan library.
13479  DispatchLoaderDynamic( VkInstance instance,
13480  PFN_vkGetInstanceProcAddr getInstanceProcAddr,
13481  VkDevice device = {},
13482  PFN_vkGetDeviceProcAddr getDeviceProcAddr = nullptr ) VULKAN_HPP_NOEXCEPT
13483  {
13484  init( instance, getInstanceProcAddr, device, getDeviceProcAddr );
13485  }
13486 
13487  // This interface does not require a linked vulkan library.
13488  void init( VkInstance instance,
13489  PFN_vkGetInstanceProcAddr getInstanceProcAddr,
13490  VkDevice device = {},
13491  PFN_vkGetDeviceProcAddr /*getDeviceProcAddr*/ = nullptr ) VULKAN_HPP_NOEXCEPT
13492  {
13493  VULKAN_HPP_ASSERT( instance && getInstanceProcAddr );
13494  vkGetInstanceProcAddr = getInstanceProcAddr;
13495  init( VULKAN_HPP_NAMESPACE::Instance( instance ) );
13496  if ( device )
13497  {
13498  init( VULKAN_HPP_NAMESPACE::Device( device ) );
13499  }
13500  }
13501 
13503  {
13504  VkInstance instance = static_cast<VkInstance>( instanceCpp );
13505 
13506  //=== VK_VERSION_1_0 ===
13507  vkDestroyInstance = PFN_vkDestroyInstance( vkGetInstanceProcAddr( instance, "vkDestroyInstance" ) );
13508  vkEnumeratePhysicalDevices = PFN_vkEnumeratePhysicalDevices( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDevices" ) );
13509  vkGetPhysicalDeviceFeatures = PFN_vkGetPhysicalDeviceFeatures( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures" ) );
13510  vkGetPhysicalDeviceFormatProperties = PFN_vkGetPhysicalDeviceFormatProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties" ) );
13512  PFN_vkGetPhysicalDeviceImageFormatProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties" ) );
13513  vkGetPhysicalDeviceProperties = PFN_vkGetPhysicalDeviceProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties" ) );
13515  PFN_vkGetPhysicalDeviceQueueFamilyProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties" ) );
13516  vkGetPhysicalDeviceMemoryProperties = PFN_vkGetPhysicalDeviceMemoryProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties" ) );
13517  vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr( vkGetInstanceProcAddr( instance, "vkGetDeviceProcAddr" ) );
13518  vkCreateDevice = PFN_vkCreateDevice( vkGetInstanceProcAddr( instance, "vkCreateDevice" ) );
13519  vkDestroyDevice = PFN_vkDestroyDevice( vkGetInstanceProcAddr( instance, "vkDestroyDevice" ) );
13521  PFN_vkEnumerateDeviceExtensionProperties( vkGetInstanceProcAddr( instance, "vkEnumerateDeviceExtensionProperties" ) );
13522  vkEnumerateDeviceLayerProperties = PFN_vkEnumerateDeviceLayerProperties( vkGetInstanceProcAddr( instance, "vkEnumerateDeviceLayerProperties" ) );
13523  vkGetDeviceQueue = PFN_vkGetDeviceQueue( vkGetInstanceProcAddr( instance, "vkGetDeviceQueue" ) );
13524  vkQueueSubmit = PFN_vkQueueSubmit( vkGetInstanceProcAddr( instance, "vkQueueSubmit" ) );
13525  vkQueueWaitIdle = PFN_vkQueueWaitIdle( vkGetInstanceProcAddr( instance, "vkQueueWaitIdle" ) );
13526  vkDeviceWaitIdle = PFN_vkDeviceWaitIdle( vkGetInstanceProcAddr( instance, "vkDeviceWaitIdle" ) );
13527  vkAllocateMemory = PFN_vkAllocateMemory( vkGetInstanceProcAddr( instance, "vkAllocateMemory" ) );
13528  vkFreeMemory = PFN_vkFreeMemory( vkGetInstanceProcAddr( instance, "vkFreeMemory" ) );
13529  vkMapMemory = PFN_vkMapMemory( vkGetInstanceProcAddr( instance, "vkMapMemory" ) );
13530  vkUnmapMemory = PFN_vkUnmapMemory( vkGetInstanceProcAddr( instance, "vkUnmapMemory" ) );
13531  vkFlushMappedMemoryRanges = PFN_vkFlushMappedMemoryRanges( vkGetInstanceProcAddr( instance, "vkFlushMappedMemoryRanges" ) );
13532  vkInvalidateMappedMemoryRanges = PFN_vkInvalidateMappedMemoryRanges( vkGetInstanceProcAddr( instance, "vkInvalidateMappedMemoryRanges" ) );
13533  vkGetDeviceMemoryCommitment = PFN_vkGetDeviceMemoryCommitment( vkGetInstanceProcAddr( instance, "vkGetDeviceMemoryCommitment" ) );
13534  vkBindBufferMemory = PFN_vkBindBufferMemory( vkGetInstanceProcAddr( instance, "vkBindBufferMemory" ) );
13535  vkBindImageMemory = PFN_vkBindImageMemory( vkGetInstanceProcAddr( instance, "vkBindImageMemory" ) );
13536  vkGetBufferMemoryRequirements = PFN_vkGetBufferMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetBufferMemoryRequirements" ) );
13537  vkGetImageMemoryRequirements = PFN_vkGetImageMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetImageMemoryRequirements" ) );
13538  vkGetImageSparseMemoryRequirements = PFN_vkGetImageSparseMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetImageSparseMemoryRequirements" ) );
13540  PFN_vkGetPhysicalDeviceSparseImageFormatProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties" ) );
13541  vkQueueBindSparse = PFN_vkQueueBindSparse( vkGetInstanceProcAddr( instance, "vkQueueBindSparse" ) );
13542  vkCreateFence = PFN_vkCreateFence( vkGetInstanceProcAddr( instance, "vkCreateFence" ) );
13543  vkDestroyFence = PFN_vkDestroyFence( vkGetInstanceProcAddr( instance, "vkDestroyFence" ) );
13544  vkResetFences = PFN_vkResetFences( vkGetInstanceProcAddr( instance, "vkResetFences" ) );
13545  vkGetFenceStatus = PFN_vkGetFenceStatus( vkGetInstanceProcAddr( instance, "vkGetFenceStatus" ) );
13546  vkWaitForFences = PFN_vkWaitForFences( vkGetInstanceProcAddr( instance, "vkWaitForFences" ) );
13547  vkCreateSemaphore = PFN_vkCreateSemaphore( vkGetInstanceProcAddr( instance, "vkCreateSemaphore" ) );
13548  vkDestroySemaphore = PFN_vkDestroySemaphore( vkGetInstanceProcAddr( instance, "vkDestroySemaphore" ) );
13549  vkCreateEvent = PFN_vkCreateEvent( vkGetInstanceProcAddr( instance, "vkCreateEvent" ) );
13550  vkDestroyEvent = PFN_vkDestroyEvent( vkGetInstanceProcAddr( instance, "vkDestroyEvent" ) );
13551  vkGetEventStatus = PFN_vkGetEventStatus( vkGetInstanceProcAddr( instance, "vkGetEventStatus" ) );
13552  vkSetEvent = PFN_vkSetEvent( vkGetInstanceProcAddr( instance, "vkSetEvent" ) );
13553  vkResetEvent = PFN_vkResetEvent( vkGetInstanceProcAddr( instance, "vkResetEvent" ) );
13554  vkCreateQueryPool = PFN_vkCreateQueryPool( vkGetInstanceProcAddr( instance, "vkCreateQueryPool" ) );
13555  vkDestroyQueryPool = PFN_vkDestroyQueryPool( vkGetInstanceProcAddr( instance, "vkDestroyQueryPool" ) );
13556  vkGetQueryPoolResults = PFN_vkGetQueryPoolResults( vkGetInstanceProcAddr( instance, "vkGetQueryPoolResults" ) );
13557  vkCreateBuffer = PFN_vkCreateBuffer( vkGetInstanceProcAddr( instance, "vkCreateBuffer" ) );
13558  vkDestroyBuffer = PFN_vkDestroyBuffer( vkGetInstanceProcAddr( instance, "vkDestroyBuffer" ) );
13559  vkCreateBufferView = PFN_vkCreateBufferView( vkGetInstanceProcAddr( instance, "vkCreateBufferView" ) );
13560  vkDestroyBufferView = PFN_vkDestroyBufferView( vkGetInstanceProcAddr( instance, "vkDestroyBufferView" ) );
13561  vkCreateImage = PFN_vkCreateImage( vkGetInstanceProcAddr( instance, "vkCreateImage" ) );
13562  vkDestroyImage = PFN_vkDestroyImage( vkGetInstanceProcAddr( instance, "vkDestroyImage" ) );
13563  vkGetImageSubresourceLayout = PFN_vkGetImageSubresourceLayout( vkGetInstanceProcAddr( instance, "vkGetImageSubresourceLayout" ) );
13564  vkCreateImageView = PFN_vkCreateImageView( vkGetInstanceProcAddr( instance, "vkCreateImageView" ) );
13565  vkDestroyImageView = PFN_vkDestroyImageView( vkGetInstanceProcAddr( instance, "vkDestroyImageView" ) );
13566  vkCreateShaderModule = PFN_vkCreateShaderModule( vkGetInstanceProcAddr( instance, "vkCreateShaderModule" ) );
13567  vkDestroyShaderModule = PFN_vkDestroyShaderModule( vkGetInstanceProcAddr( instance, "vkDestroyShaderModule" ) );
13568  vkCreatePipelineCache = PFN_vkCreatePipelineCache( vkGetInstanceProcAddr( instance, "vkCreatePipelineCache" ) );
13569  vkDestroyPipelineCache = PFN_vkDestroyPipelineCache( vkGetInstanceProcAddr( instance, "vkDestroyPipelineCache" ) );
13570  vkGetPipelineCacheData = PFN_vkGetPipelineCacheData( vkGetInstanceProcAddr( instance, "vkGetPipelineCacheData" ) );
13571  vkMergePipelineCaches = PFN_vkMergePipelineCaches( vkGetInstanceProcAddr( instance, "vkMergePipelineCaches" ) );
13572  vkCreateGraphicsPipelines = PFN_vkCreateGraphicsPipelines( vkGetInstanceProcAddr( instance, "vkCreateGraphicsPipelines" ) );
13573  vkCreateComputePipelines = PFN_vkCreateComputePipelines( vkGetInstanceProcAddr( instance, "vkCreateComputePipelines" ) );
13574  vkDestroyPipeline = PFN_vkDestroyPipeline( vkGetInstanceProcAddr( instance, "vkDestroyPipeline" ) );
13575  vkCreatePipelineLayout = PFN_vkCreatePipelineLayout( vkGetInstanceProcAddr( instance, "vkCreatePipelineLayout" ) );
13576  vkDestroyPipelineLayout = PFN_vkDestroyPipelineLayout( vkGetInstanceProcAddr( instance, "vkDestroyPipelineLayout" ) );
13577  vkCreateSampler = PFN_vkCreateSampler( vkGetInstanceProcAddr( instance, "vkCreateSampler" ) );
13578  vkDestroySampler = PFN_vkDestroySampler( vkGetInstanceProcAddr( instance, "vkDestroySampler" ) );
13579  vkCreateDescriptorSetLayout = PFN_vkCreateDescriptorSetLayout( vkGetInstanceProcAddr( instance, "vkCreateDescriptorSetLayout" ) );
13580  vkDestroyDescriptorSetLayout = PFN_vkDestroyDescriptorSetLayout( vkGetInstanceProcAddr( instance, "vkDestroyDescriptorSetLayout" ) );
13581  vkCreateDescriptorPool = PFN_vkCreateDescriptorPool( vkGetInstanceProcAddr( instance, "vkCreateDescriptorPool" ) );
13582  vkDestroyDescriptorPool = PFN_vkDestroyDescriptorPool( vkGetInstanceProcAddr( instance, "vkDestroyDescriptorPool" ) );
13583  vkResetDescriptorPool = PFN_vkResetDescriptorPool( vkGetInstanceProcAddr( instance, "vkResetDescriptorPool" ) );
13584  vkAllocateDescriptorSets = PFN_vkAllocateDescriptorSets( vkGetInstanceProcAddr( instance, "vkAllocateDescriptorSets" ) );
13585  vkFreeDescriptorSets = PFN_vkFreeDescriptorSets( vkGetInstanceProcAddr( instance, "vkFreeDescriptorSets" ) );
13586  vkUpdateDescriptorSets = PFN_vkUpdateDescriptorSets( vkGetInstanceProcAddr( instance, "vkUpdateDescriptorSets" ) );
13587  vkCreateFramebuffer = PFN_vkCreateFramebuffer( vkGetInstanceProcAddr( instance, "vkCreateFramebuffer" ) );
13588  vkDestroyFramebuffer = PFN_vkDestroyFramebuffer( vkGetInstanceProcAddr( instance, "vkDestroyFramebuffer" ) );
13589  vkCreateRenderPass = PFN_vkCreateRenderPass( vkGetInstanceProcAddr( instance, "vkCreateRenderPass" ) );
13590  vkDestroyRenderPass = PFN_vkDestroyRenderPass( vkGetInstanceProcAddr( instance, "vkDestroyRenderPass" ) );
13591  vkGetRenderAreaGranularity = PFN_vkGetRenderAreaGranularity( vkGetInstanceProcAddr( instance, "vkGetRenderAreaGranularity" ) );
13592  vkCreateCommandPool = PFN_vkCreateCommandPool( vkGetInstanceProcAddr( instance, "vkCreateCommandPool" ) );
13593  vkDestroyCommandPool = PFN_vkDestroyCommandPool( vkGetInstanceProcAddr( instance, "vkDestroyCommandPool" ) );
13594  vkResetCommandPool = PFN_vkResetCommandPool( vkGetInstanceProcAddr( instance, "vkResetCommandPool" ) );
13595  vkAllocateCommandBuffers = PFN_vkAllocateCommandBuffers( vkGetInstanceProcAddr( instance, "vkAllocateCommandBuffers" ) );
13596  vkFreeCommandBuffers = PFN_vkFreeCommandBuffers( vkGetInstanceProcAddr( instance, "vkFreeCommandBuffers" ) );
13597  vkBeginCommandBuffer = PFN_vkBeginCommandBuffer( vkGetInstanceProcAddr( instance, "vkBeginCommandBuffer" ) );
13598  vkEndCommandBuffer = PFN_vkEndCommandBuffer( vkGetInstanceProcAddr( instance, "vkEndCommandBuffer" ) );
13599  vkResetCommandBuffer = PFN_vkResetCommandBuffer( vkGetInstanceProcAddr( instance, "vkResetCommandBuffer" ) );
13600  vkCmdBindPipeline = PFN_vkCmdBindPipeline( vkGetInstanceProcAddr( instance, "vkCmdBindPipeline" ) );
13601  vkCmdSetViewport = PFN_vkCmdSetViewport( vkGetInstanceProcAddr( instance, "vkCmdSetViewport" ) );
13602  vkCmdSetScissor = PFN_vkCmdSetScissor( vkGetInstanceProcAddr( instance, "vkCmdSetScissor" ) );
13603  vkCmdSetLineWidth = PFN_vkCmdSetLineWidth( vkGetInstanceProcAddr( instance, "vkCmdSetLineWidth" ) );
13604  vkCmdSetDepthBias = PFN_vkCmdSetDepthBias( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBias" ) );
13605  vkCmdSetBlendConstants = PFN_vkCmdSetBlendConstants( vkGetInstanceProcAddr( instance, "vkCmdSetBlendConstants" ) );
13606  vkCmdSetDepthBounds = PFN_vkCmdSetDepthBounds( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBounds" ) );
13607  vkCmdSetStencilCompareMask = PFN_vkCmdSetStencilCompareMask( vkGetInstanceProcAddr( instance, "vkCmdSetStencilCompareMask" ) );
13608  vkCmdSetStencilWriteMask = PFN_vkCmdSetStencilWriteMask( vkGetInstanceProcAddr( instance, "vkCmdSetStencilWriteMask" ) );
13609  vkCmdSetStencilReference = PFN_vkCmdSetStencilReference( vkGetInstanceProcAddr( instance, "vkCmdSetStencilReference" ) );
13610  vkCmdBindDescriptorSets = PFN_vkCmdBindDescriptorSets( vkGetInstanceProcAddr( instance, "vkCmdBindDescriptorSets" ) );
13611  vkCmdBindIndexBuffer = PFN_vkCmdBindIndexBuffer( vkGetInstanceProcAddr( instance, "vkCmdBindIndexBuffer" ) );
13612  vkCmdBindVertexBuffers = PFN_vkCmdBindVertexBuffers( vkGetInstanceProcAddr( instance, "vkCmdBindVertexBuffers" ) );
13613  vkCmdDraw = PFN_vkCmdDraw( vkGetInstanceProcAddr( instance, "vkCmdDraw" ) );
13614  vkCmdDrawIndexed = PFN_vkCmdDrawIndexed( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexed" ) );
13615  vkCmdDrawIndirect = PFN_vkCmdDrawIndirect( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirect" ) );
13616  vkCmdDrawIndexedIndirect = PFN_vkCmdDrawIndexedIndirect( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirect" ) );
13617  vkCmdDispatch = PFN_vkCmdDispatch( vkGetInstanceProcAddr( instance, "vkCmdDispatch" ) );
13618  vkCmdDispatchIndirect = PFN_vkCmdDispatchIndirect( vkGetInstanceProcAddr( instance, "vkCmdDispatchIndirect" ) );
13619  vkCmdCopyBuffer = PFN_vkCmdCopyBuffer( vkGetInstanceProcAddr( instance, "vkCmdCopyBuffer" ) );
13620  vkCmdCopyImage = PFN_vkCmdCopyImage( vkGetInstanceProcAddr( instance, "vkCmdCopyImage" ) );
13621  vkCmdBlitImage = PFN_vkCmdBlitImage( vkGetInstanceProcAddr( instance, "vkCmdBlitImage" ) );
13622  vkCmdCopyBufferToImage = PFN_vkCmdCopyBufferToImage( vkGetInstanceProcAddr( instance, "vkCmdCopyBufferToImage" ) );
13623  vkCmdCopyImageToBuffer = PFN_vkCmdCopyImageToBuffer( vkGetInstanceProcAddr( instance, "vkCmdCopyImageToBuffer" ) );
13624  vkCmdUpdateBuffer = PFN_vkCmdUpdateBuffer( vkGetInstanceProcAddr( instance, "vkCmdUpdateBuffer" ) );
13625  vkCmdFillBuffer = PFN_vkCmdFillBuffer( vkGetInstanceProcAddr( instance, "vkCmdFillBuffer" ) );
13626  vkCmdClearColorImage = PFN_vkCmdClearColorImage( vkGetInstanceProcAddr( instance, "vkCmdClearColorImage" ) );
13627  vkCmdClearDepthStencilImage = PFN_vkCmdClearDepthStencilImage( vkGetInstanceProcAddr( instance, "vkCmdClearDepthStencilImage" ) );
13628  vkCmdClearAttachments = PFN_vkCmdClearAttachments( vkGetInstanceProcAddr( instance, "vkCmdClearAttachments" ) );
13629  vkCmdResolveImage = PFN_vkCmdResolveImage( vkGetInstanceProcAddr( instance, "vkCmdResolveImage" ) );
13630  vkCmdSetEvent = PFN_vkCmdSetEvent( vkGetInstanceProcAddr( instance, "vkCmdSetEvent" ) );
13631  vkCmdResetEvent = PFN_vkCmdResetEvent( vkGetInstanceProcAddr( instance, "vkCmdResetEvent" ) );
13632  vkCmdWaitEvents = PFN_vkCmdWaitEvents( vkGetInstanceProcAddr( instance, "vkCmdWaitEvents" ) );
13633  vkCmdPipelineBarrier = PFN_vkCmdPipelineBarrier( vkGetInstanceProcAddr( instance, "vkCmdPipelineBarrier" ) );
13634  vkCmdBeginQuery = PFN_vkCmdBeginQuery( vkGetInstanceProcAddr( instance, "vkCmdBeginQuery" ) );
13635  vkCmdEndQuery = PFN_vkCmdEndQuery( vkGetInstanceProcAddr( instance, "vkCmdEndQuery" ) );
13636  vkCmdResetQueryPool = PFN_vkCmdResetQueryPool( vkGetInstanceProcAddr( instance, "vkCmdResetQueryPool" ) );
13637  vkCmdWriteTimestamp = PFN_vkCmdWriteTimestamp( vkGetInstanceProcAddr( instance, "vkCmdWriteTimestamp" ) );
13638  vkCmdCopyQueryPoolResults = PFN_vkCmdCopyQueryPoolResults( vkGetInstanceProcAddr( instance, "vkCmdCopyQueryPoolResults" ) );
13639  vkCmdPushConstants = PFN_vkCmdPushConstants( vkGetInstanceProcAddr( instance, "vkCmdPushConstants" ) );
13640  vkCmdBeginRenderPass = PFN_vkCmdBeginRenderPass( vkGetInstanceProcAddr( instance, "vkCmdBeginRenderPass" ) );
13641  vkCmdNextSubpass = PFN_vkCmdNextSubpass( vkGetInstanceProcAddr( instance, "vkCmdNextSubpass" ) );
13642  vkCmdEndRenderPass = PFN_vkCmdEndRenderPass( vkGetInstanceProcAddr( instance, "vkCmdEndRenderPass" ) );
13643  vkCmdExecuteCommands = PFN_vkCmdExecuteCommands( vkGetInstanceProcAddr( instance, "vkCmdExecuteCommands" ) );
13644 
13645  //=== VK_VERSION_1_1 ===
13646  vkBindBufferMemory2 = PFN_vkBindBufferMemory2( vkGetInstanceProcAddr( instance, "vkBindBufferMemory2" ) );
13647  vkBindImageMemory2 = PFN_vkBindImageMemory2( vkGetInstanceProcAddr( instance, "vkBindImageMemory2" ) );
13648  vkGetDeviceGroupPeerMemoryFeatures = PFN_vkGetDeviceGroupPeerMemoryFeatures( vkGetInstanceProcAddr( instance, "vkGetDeviceGroupPeerMemoryFeatures" ) );
13649  vkCmdSetDeviceMask = PFN_vkCmdSetDeviceMask( vkGetInstanceProcAddr( instance, "vkCmdSetDeviceMask" ) );
13650  vkCmdDispatchBase = PFN_vkCmdDispatchBase( vkGetInstanceProcAddr( instance, "vkCmdDispatchBase" ) );
13651  vkEnumeratePhysicalDeviceGroups = PFN_vkEnumeratePhysicalDeviceGroups( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceGroups" ) );
13652  vkGetImageMemoryRequirements2 = PFN_vkGetImageMemoryRequirements2( vkGetInstanceProcAddr( instance, "vkGetImageMemoryRequirements2" ) );
13653  vkGetBufferMemoryRequirements2 = PFN_vkGetBufferMemoryRequirements2( vkGetInstanceProcAddr( instance, "vkGetBufferMemoryRequirements2" ) );
13654  vkGetImageSparseMemoryRequirements2 = PFN_vkGetImageSparseMemoryRequirements2( vkGetInstanceProcAddr( instance, "vkGetImageSparseMemoryRequirements2" ) );
13655  vkGetPhysicalDeviceFeatures2 = PFN_vkGetPhysicalDeviceFeatures2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures2" ) );
13656  vkGetPhysicalDeviceProperties2 = PFN_vkGetPhysicalDeviceProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties2" ) );
13658  PFN_vkGetPhysicalDeviceFormatProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties2" ) );
13660  PFN_vkGetPhysicalDeviceImageFormatProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties2" ) );
13662  PFN_vkGetPhysicalDeviceQueueFamilyProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties2" ) );
13664  PFN_vkGetPhysicalDeviceMemoryProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties2" ) );
13666  PFN_vkGetPhysicalDeviceSparseImageFormatProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties2" ) );
13667  vkTrimCommandPool = PFN_vkTrimCommandPool( vkGetInstanceProcAddr( instance, "vkTrimCommandPool" ) );
13668  vkGetDeviceQueue2 = PFN_vkGetDeviceQueue2( vkGetInstanceProcAddr( instance, "vkGetDeviceQueue2" ) );
13669  vkCreateSamplerYcbcrConversion = PFN_vkCreateSamplerYcbcrConversion( vkGetInstanceProcAddr( instance, "vkCreateSamplerYcbcrConversion" ) );
13670  vkDestroySamplerYcbcrConversion = PFN_vkDestroySamplerYcbcrConversion( vkGetInstanceProcAddr( instance, "vkDestroySamplerYcbcrConversion" ) );
13671  vkCreateDescriptorUpdateTemplate = PFN_vkCreateDescriptorUpdateTemplate( vkGetInstanceProcAddr( instance, "vkCreateDescriptorUpdateTemplate" ) );
13672  vkDestroyDescriptorUpdateTemplate = PFN_vkDestroyDescriptorUpdateTemplate( vkGetInstanceProcAddr( instance, "vkDestroyDescriptorUpdateTemplate" ) );
13673  vkUpdateDescriptorSetWithTemplate = PFN_vkUpdateDescriptorSetWithTemplate( vkGetInstanceProcAddr( instance, "vkUpdateDescriptorSetWithTemplate" ) );
13675  PFN_vkGetPhysicalDeviceExternalBufferProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalBufferProperties" ) );
13677  PFN_vkGetPhysicalDeviceExternalFenceProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalFenceProperties" ) );
13679  PFN_vkGetPhysicalDeviceExternalSemaphoreProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalSemaphoreProperties" ) );
13680  vkGetDescriptorSetLayoutSupport = PFN_vkGetDescriptorSetLayoutSupport( vkGetInstanceProcAddr( instance, "vkGetDescriptorSetLayoutSupport" ) );
13681 
13682  //=== VK_VERSION_1_2 ===
13683  vkCmdDrawIndirectCount = PFN_vkCmdDrawIndirectCount( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectCount" ) );
13684  vkCmdDrawIndexedIndirectCount = PFN_vkCmdDrawIndexedIndirectCount( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirectCount" ) );
13685  vkCreateRenderPass2 = PFN_vkCreateRenderPass2( vkGetInstanceProcAddr( instance, "vkCreateRenderPass2" ) );
13686  vkCmdBeginRenderPass2 = PFN_vkCmdBeginRenderPass2( vkGetInstanceProcAddr( instance, "vkCmdBeginRenderPass2" ) );
13687  vkCmdNextSubpass2 = PFN_vkCmdNextSubpass2( vkGetInstanceProcAddr( instance, "vkCmdNextSubpass2" ) );
13688  vkCmdEndRenderPass2 = PFN_vkCmdEndRenderPass2( vkGetInstanceProcAddr( instance, "vkCmdEndRenderPass2" ) );
13689  vkResetQueryPool = PFN_vkResetQueryPool( vkGetInstanceProcAddr( instance, "vkResetQueryPool" ) );
13690  vkGetSemaphoreCounterValue = PFN_vkGetSemaphoreCounterValue( vkGetInstanceProcAddr( instance, "vkGetSemaphoreCounterValue" ) );
13691  vkWaitSemaphores = PFN_vkWaitSemaphores( vkGetInstanceProcAddr( instance, "vkWaitSemaphores" ) );
13692  vkSignalSemaphore = PFN_vkSignalSemaphore( vkGetInstanceProcAddr( instance, "vkSignalSemaphore" ) );
13693  vkGetBufferDeviceAddress = PFN_vkGetBufferDeviceAddress( vkGetInstanceProcAddr( instance, "vkGetBufferDeviceAddress" ) );
13694  vkGetBufferOpaqueCaptureAddress = PFN_vkGetBufferOpaqueCaptureAddress( vkGetInstanceProcAddr( instance, "vkGetBufferOpaqueCaptureAddress" ) );
13696  PFN_vkGetDeviceMemoryOpaqueCaptureAddress( vkGetInstanceProcAddr( instance, "vkGetDeviceMemoryOpaqueCaptureAddress" ) );
13697 
13698  //=== VK_VERSION_1_3 ===
13699  vkGetPhysicalDeviceToolProperties = PFN_vkGetPhysicalDeviceToolProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceToolProperties" ) );
13700  vkCreatePrivateDataSlot = PFN_vkCreatePrivateDataSlot( vkGetInstanceProcAddr( instance, "vkCreatePrivateDataSlot" ) );
13701  vkDestroyPrivateDataSlot = PFN_vkDestroyPrivateDataSlot( vkGetInstanceProcAddr( instance, "vkDestroyPrivateDataSlot" ) );
13702  vkSetPrivateData = PFN_vkSetPrivateData( vkGetInstanceProcAddr( instance, "vkSetPrivateData" ) );
13703  vkGetPrivateData = PFN_vkGetPrivateData( vkGetInstanceProcAddr( instance, "vkGetPrivateData" ) );
13704  vkCmdSetEvent2 = PFN_vkCmdSetEvent2( vkGetInstanceProcAddr( instance, "vkCmdSetEvent2" ) );
13705  vkCmdResetEvent2 = PFN_vkCmdResetEvent2( vkGetInstanceProcAddr( instance, "vkCmdResetEvent2" ) );
13706  vkCmdWaitEvents2 = PFN_vkCmdWaitEvents2( vkGetInstanceProcAddr( instance, "vkCmdWaitEvents2" ) );
13707  vkCmdPipelineBarrier2 = PFN_vkCmdPipelineBarrier2( vkGetInstanceProcAddr( instance, "vkCmdPipelineBarrier2" ) );
13708  vkCmdWriteTimestamp2 = PFN_vkCmdWriteTimestamp2( vkGetInstanceProcAddr( instance, "vkCmdWriteTimestamp2" ) );
13709  vkQueueSubmit2 = PFN_vkQueueSubmit2( vkGetInstanceProcAddr( instance, "vkQueueSubmit2" ) );
13710  vkCmdCopyBuffer2 = PFN_vkCmdCopyBuffer2( vkGetInstanceProcAddr( instance, "vkCmdCopyBuffer2" ) );
13711  vkCmdCopyImage2 = PFN_vkCmdCopyImage2( vkGetInstanceProcAddr( instance, "vkCmdCopyImage2" ) );
13712  vkCmdCopyBufferToImage2 = PFN_vkCmdCopyBufferToImage2( vkGetInstanceProcAddr( instance, "vkCmdCopyBufferToImage2" ) );
13713  vkCmdCopyImageToBuffer2 = PFN_vkCmdCopyImageToBuffer2( vkGetInstanceProcAddr( instance, "vkCmdCopyImageToBuffer2" ) );
13714  vkCmdBlitImage2 = PFN_vkCmdBlitImage2( vkGetInstanceProcAddr( instance, "vkCmdBlitImage2" ) );
13715  vkCmdResolveImage2 = PFN_vkCmdResolveImage2( vkGetInstanceProcAddr( instance, "vkCmdResolveImage2" ) );
13716  vkCmdBeginRendering = PFN_vkCmdBeginRendering( vkGetInstanceProcAddr( instance, "vkCmdBeginRendering" ) );
13717  vkCmdEndRendering = PFN_vkCmdEndRendering( vkGetInstanceProcAddr( instance, "vkCmdEndRendering" ) );
13718  vkCmdSetCullMode = PFN_vkCmdSetCullMode( vkGetInstanceProcAddr( instance, "vkCmdSetCullMode" ) );
13719  vkCmdSetFrontFace = PFN_vkCmdSetFrontFace( vkGetInstanceProcAddr( instance, "vkCmdSetFrontFace" ) );
13720  vkCmdSetPrimitiveTopology = PFN_vkCmdSetPrimitiveTopology( vkGetInstanceProcAddr( instance, "vkCmdSetPrimitiveTopology" ) );
13721  vkCmdSetViewportWithCount = PFN_vkCmdSetViewportWithCount( vkGetInstanceProcAddr( instance, "vkCmdSetViewportWithCount" ) );
13722  vkCmdSetScissorWithCount = PFN_vkCmdSetScissorWithCount( vkGetInstanceProcAddr( instance, "vkCmdSetScissorWithCount" ) );
13723  vkCmdBindVertexBuffers2 = PFN_vkCmdBindVertexBuffers2( vkGetInstanceProcAddr( instance, "vkCmdBindVertexBuffers2" ) );
13724  vkCmdSetDepthTestEnable = PFN_vkCmdSetDepthTestEnable( vkGetInstanceProcAddr( instance, "vkCmdSetDepthTestEnable" ) );
13725  vkCmdSetDepthWriteEnable = PFN_vkCmdSetDepthWriteEnable( vkGetInstanceProcAddr( instance, "vkCmdSetDepthWriteEnable" ) );
13726  vkCmdSetDepthCompareOp = PFN_vkCmdSetDepthCompareOp( vkGetInstanceProcAddr( instance, "vkCmdSetDepthCompareOp" ) );
13727  vkCmdSetDepthBoundsTestEnable = PFN_vkCmdSetDepthBoundsTestEnable( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBoundsTestEnable" ) );
13728  vkCmdSetStencilTestEnable = PFN_vkCmdSetStencilTestEnable( vkGetInstanceProcAddr( instance, "vkCmdSetStencilTestEnable" ) );
13729  vkCmdSetStencilOp = PFN_vkCmdSetStencilOp( vkGetInstanceProcAddr( instance, "vkCmdSetStencilOp" ) );
13730  vkCmdSetRasterizerDiscardEnable = PFN_vkCmdSetRasterizerDiscardEnable( vkGetInstanceProcAddr( instance, "vkCmdSetRasterizerDiscardEnable" ) );
13731  vkCmdSetDepthBiasEnable = PFN_vkCmdSetDepthBiasEnable( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBiasEnable" ) );
13732  vkCmdSetPrimitiveRestartEnable = PFN_vkCmdSetPrimitiveRestartEnable( vkGetInstanceProcAddr( instance, "vkCmdSetPrimitiveRestartEnable" ) );
13733  vkGetDeviceBufferMemoryRequirements = PFN_vkGetDeviceBufferMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetDeviceBufferMemoryRequirements" ) );
13734  vkGetDeviceImageMemoryRequirements = PFN_vkGetDeviceImageMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetDeviceImageMemoryRequirements" ) );
13736  PFN_vkGetDeviceImageSparseMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetDeviceImageSparseMemoryRequirements" ) );
13737 
13738  //=== VK_KHR_surface ===
13739  vkDestroySurfaceKHR = PFN_vkDestroySurfaceKHR( vkGetInstanceProcAddr( instance, "vkDestroySurfaceKHR" ) );
13741  PFN_vkGetPhysicalDeviceSurfaceSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceSupportKHR" ) );
13743  PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR" ) );
13745  PFN_vkGetPhysicalDeviceSurfaceFormatsKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceFormatsKHR" ) );
13747  PFN_vkGetPhysicalDeviceSurfacePresentModesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfacePresentModesKHR" ) );
13748 
13749  //=== VK_KHR_swapchain ===
13750  vkCreateSwapchainKHR = PFN_vkCreateSwapchainKHR( vkGetInstanceProcAddr( instance, "vkCreateSwapchainKHR" ) );
13751  vkDestroySwapchainKHR = PFN_vkDestroySwapchainKHR( vkGetInstanceProcAddr( instance, "vkDestroySwapchainKHR" ) );
13752  vkGetSwapchainImagesKHR = PFN_vkGetSwapchainImagesKHR( vkGetInstanceProcAddr( instance, "vkGetSwapchainImagesKHR" ) );
13753  vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR( vkGetInstanceProcAddr( instance, "vkAcquireNextImageKHR" ) );
13754  vkQueuePresentKHR = PFN_vkQueuePresentKHR( vkGetInstanceProcAddr( instance, "vkQueuePresentKHR" ) );
13756  PFN_vkGetDeviceGroupPresentCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceGroupPresentCapabilitiesKHR" ) );
13758  PFN_vkGetDeviceGroupSurfacePresentModesKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceGroupSurfacePresentModesKHR" ) );
13760  PFN_vkGetPhysicalDevicePresentRectanglesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDevicePresentRectanglesKHR" ) );
13761  vkAcquireNextImage2KHR = PFN_vkAcquireNextImage2KHR( vkGetInstanceProcAddr( instance, "vkAcquireNextImage2KHR" ) );
13762 
13763  //=== VK_KHR_display ===
13765  PFN_vkGetPhysicalDeviceDisplayPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPropertiesKHR" ) );
13767  PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR" ) );
13769  PFN_vkGetDisplayPlaneSupportedDisplaysKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneSupportedDisplaysKHR" ) );
13770  vkGetDisplayModePropertiesKHR = PFN_vkGetDisplayModePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayModePropertiesKHR" ) );
13771  vkCreateDisplayModeKHR = PFN_vkCreateDisplayModeKHR( vkGetInstanceProcAddr( instance, "vkCreateDisplayModeKHR" ) );
13772  vkGetDisplayPlaneCapabilitiesKHR = PFN_vkGetDisplayPlaneCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneCapabilitiesKHR" ) );
13773  vkCreateDisplayPlaneSurfaceKHR = PFN_vkCreateDisplayPlaneSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateDisplayPlaneSurfaceKHR" ) );
13774 
13775  //=== VK_KHR_display_swapchain ===
13776  vkCreateSharedSwapchainsKHR = PFN_vkCreateSharedSwapchainsKHR( vkGetInstanceProcAddr( instance, "vkCreateSharedSwapchainsKHR" ) );
13777 
13778 #if defined( VK_USE_PLATFORM_XLIB_KHR )
13779  //=== VK_KHR_xlib_surface ===
13780  vkCreateXlibSurfaceKHR = PFN_vkCreateXlibSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateXlibSurfaceKHR" ) );
13782  PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceXlibPresentationSupportKHR" ) );
13783 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
13784 
13785 #if defined( VK_USE_PLATFORM_XCB_KHR )
13786  //=== VK_KHR_xcb_surface ===
13787  vkCreateXcbSurfaceKHR = PFN_vkCreateXcbSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateXcbSurfaceKHR" ) );
13789  PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceXcbPresentationSupportKHR" ) );
13790 #endif /*VK_USE_PLATFORM_XCB_KHR*/
13791 
13792 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )
13793  //=== VK_KHR_wayland_surface ===
13794  vkCreateWaylandSurfaceKHR = PFN_vkCreateWaylandSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateWaylandSurfaceKHR" ) );
13796  PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceWaylandPresentationSupportKHR" ) );
13797 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
13798 
13799 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
13800  //=== VK_KHR_android_surface ===
13801  vkCreateAndroidSurfaceKHR = PFN_vkCreateAndroidSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateAndroidSurfaceKHR" ) );
13802 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
13803 
13804 #if defined( VK_USE_PLATFORM_WIN32_KHR )
13805  //=== VK_KHR_win32_surface ===
13806  vkCreateWin32SurfaceKHR = PFN_vkCreateWin32SurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateWin32SurfaceKHR" ) );
13808  PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceWin32PresentationSupportKHR" ) );
13809 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
13810 
13811  //=== VK_EXT_debug_report ===
13812  vkCreateDebugReportCallbackEXT = PFN_vkCreateDebugReportCallbackEXT( vkGetInstanceProcAddr( instance, "vkCreateDebugReportCallbackEXT" ) );
13813  vkDestroyDebugReportCallbackEXT = PFN_vkDestroyDebugReportCallbackEXT( vkGetInstanceProcAddr( instance, "vkDestroyDebugReportCallbackEXT" ) );
13814  vkDebugReportMessageEXT = PFN_vkDebugReportMessageEXT( vkGetInstanceProcAddr( instance, "vkDebugReportMessageEXT" ) );
13815 
13816  //=== VK_EXT_debug_marker ===
13817  vkDebugMarkerSetObjectTagEXT = PFN_vkDebugMarkerSetObjectTagEXT( vkGetInstanceProcAddr( instance, "vkDebugMarkerSetObjectTagEXT" ) );
13818  vkDebugMarkerSetObjectNameEXT = PFN_vkDebugMarkerSetObjectNameEXT( vkGetInstanceProcAddr( instance, "vkDebugMarkerSetObjectNameEXT" ) );
13819  vkCmdDebugMarkerBeginEXT = PFN_vkCmdDebugMarkerBeginEXT( vkGetInstanceProcAddr( instance, "vkCmdDebugMarkerBeginEXT" ) );
13820  vkCmdDebugMarkerEndEXT = PFN_vkCmdDebugMarkerEndEXT( vkGetInstanceProcAddr( instance, "vkCmdDebugMarkerEndEXT" ) );
13821  vkCmdDebugMarkerInsertEXT = PFN_vkCmdDebugMarkerInsertEXT( vkGetInstanceProcAddr( instance, "vkCmdDebugMarkerInsertEXT" ) );
13822 
13823 #if defined( VK_ENABLE_BETA_EXTENSIONS )
13824  //=== VK_KHR_video_queue ===
13826  PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceVideoCapabilitiesKHR" ) );
13828  PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceVideoFormatPropertiesKHR" ) );
13829  vkCreateVideoSessionKHR = PFN_vkCreateVideoSessionKHR( vkGetInstanceProcAddr( instance, "vkCreateVideoSessionKHR" ) );
13830  vkDestroyVideoSessionKHR = PFN_vkDestroyVideoSessionKHR( vkGetInstanceProcAddr( instance, "vkDestroyVideoSessionKHR" ) );
13832  PFN_vkGetVideoSessionMemoryRequirementsKHR( vkGetInstanceProcAddr( instance, "vkGetVideoSessionMemoryRequirementsKHR" ) );
13833  vkBindVideoSessionMemoryKHR = PFN_vkBindVideoSessionMemoryKHR( vkGetInstanceProcAddr( instance, "vkBindVideoSessionMemoryKHR" ) );
13834  vkCreateVideoSessionParametersKHR = PFN_vkCreateVideoSessionParametersKHR( vkGetInstanceProcAddr( instance, "vkCreateVideoSessionParametersKHR" ) );
13835  vkUpdateVideoSessionParametersKHR = PFN_vkUpdateVideoSessionParametersKHR( vkGetInstanceProcAddr( instance, "vkUpdateVideoSessionParametersKHR" ) );
13836  vkDestroyVideoSessionParametersKHR = PFN_vkDestroyVideoSessionParametersKHR( vkGetInstanceProcAddr( instance, "vkDestroyVideoSessionParametersKHR" ) );
13837  vkCmdBeginVideoCodingKHR = PFN_vkCmdBeginVideoCodingKHR( vkGetInstanceProcAddr( instance, "vkCmdBeginVideoCodingKHR" ) );
13838  vkCmdEndVideoCodingKHR = PFN_vkCmdEndVideoCodingKHR( vkGetInstanceProcAddr( instance, "vkCmdEndVideoCodingKHR" ) );
13839  vkCmdControlVideoCodingKHR = PFN_vkCmdControlVideoCodingKHR( vkGetInstanceProcAddr( instance, "vkCmdControlVideoCodingKHR" ) );
13840 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
13841 
13842 #if defined( VK_ENABLE_BETA_EXTENSIONS )
13843  //=== VK_KHR_video_decode_queue ===
13844  vkCmdDecodeVideoKHR = PFN_vkCmdDecodeVideoKHR( vkGetInstanceProcAddr( instance, "vkCmdDecodeVideoKHR" ) );
13845 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
13846 
13847  //=== VK_EXT_transform_feedback ===
13849  PFN_vkCmdBindTransformFeedbackBuffersEXT( vkGetInstanceProcAddr( instance, "vkCmdBindTransformFeedbackBuffersEXT" ) );
13850  vkCmdBeginTransformFeedbackEXT = PFN_vkCmdBeginTransformFeedbackEXT( vkGetInstanceProcAddr( instance, "vkCmdBeginTransformFeedbackEXT" ) );
13851  vkCmdEndTransformFeedbackEXT = PFN_vkCmdEndTransformFeedbackEXT( vkGetInstanceProcAddr( instance, "vkCmdEndTransformFeedbackEXT" ) );
13852  vkCmdBeginQueryIndexedEXT = PFN_vkCmdBeginQueryIndexedEXT( vkGetInstanceProcAddr( instance, "vkCmdBeginQueryIndexedEXT" ) );
13853  vkCmdEndQueryIndexedEXT = PFN_vkCmdEndQueryIndexedEXT( vkGetInstanceProcAddr( instance, "vkCmdEndQueryIndexedEXT" ) );
13854  vkCmdDrawIndirectByteCountEXT = PFN_vkCmdDrawIndirectByteCountEXT( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectByteCountEXT" ) );
13855 
13856  //=== VK_NVX_binary_import ===
13857  vkCreateCuModuleNVX = PFN_vkCreateCuModuleNVX( vkGetInstanceProcAddr( instance, "vkCreateCuModuleNVX" ) );
13858  vkCreateCuFunctionNVX = PFN_vkCreateCuFunctionNVX( vkGetInstanceProcAddr( instance, "vkCreateCuFunctionNVX" ) );
13859  vkDestroyCuModuleNVX = PFN_vkDestroyCuModuleNVX( vkGetInstanceProcAddr( instance, "vkDestroyCuModuleNVX" ) );
13860  vkDestroyCuFunctionNVX = PFN_vkDestroyCuFunctionNVX( vkGetInstanceProcAddr( instance, "vkDestroyCuFunctionNVX" ) );
13861  vkCmdCuLaunchKernelNVX = PFN_vkCmdCuLaunchKernelNVX( vkGetInstanceProcAddr( instance, "vkCmdCuLaunchKernelNVX" ) );
13862 
13863  //=== VK_NVX_image_view_handle ===
13864  vkGetImageViewHandleNVX = PFN_vkGetImageViewHandleNVX( vkGetInstanceProcAddr( instance, "vkGetImageViewHandleNVX" ) );
13865  vkGetImageViewAddressNVX = PFN_vkGetImageViewAddressNVX( vkGetInstanceProcAddr( instance, "vkGetImageViewAddressNVX" ) );
13866 
13867  //=== VK_AMD_draw_indirect_count ===
13868  vkCmdDrawIndirectCountAMD = PFN_vkCmdDrawIndirectCountAMD( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectCountAMD" ) );
13869  if ( !vkCmdDrawIndirectCount )
13871  vkCmdDrawIndexedIndirectCountAMD = PFN_vkCmdDrawIndexedIndirectCountAMD( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirectCountAMD" ) );
13874 
13875  //=== VK_AMD_shader_info ===
13876  vkGetShaderInfoAMD = PFN_vkGetShaderInfoAMD( vkGetInstanceProcAddr( instance, "vkGetShaderInfoAMD" ) );
13877 
13878  //=== VK_KHR_dynamic_rendering ===
13879  vkCmdBeginRenderingKHR = PFN_vkCmdBeginRenderingKHR( vkGetInstanceProcAddr( instance, "vkCmdBeginRenderingKHR" ) );
13880  if ( !vkCmdBeginRendering )
13882  vkCmdEndRenderingKHR = PFN_vkCmdEndRenderingKHR( vkGetInstanceProcAddr( instance, "vkCmdEndRenderingKHR" ) );
13883  if ( !vkCmdEndRendering )
13885 
13886 #if defined( VK_USE_PLATFORM_GGP )
13887  //=== VK_GGP_stream_descriptor_surface ===
13888  vkCreateStreamDescriptorSurfaceGGP = PFN_vkCreateStreamDescriptorSurfaceGGP( vkGetInstanceProcAddr( instance, "vkCreateStreamDescriptorSurfaceGGP" ) );
13889 #endif /*VK_USE_PLATFORM_GGP*/
13890 
13891  //=== VK_NV_external_memory_capabilities ===
13893  PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV" ) );
13894 
13895 #if defined( VK_USE_PLATFORM_WIN32_KHR )
13896  //=== VK_NV_external_memory_win32 ===
13897  vkGetMemoryWin32HandleNV = PFN_vkGetMemoryWin32HandleNV( vkGetInstanceProcAddr( instance, "vkGetMemoryWin32HandleNV" ) );
13898 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
13899 
13900  //=== VK_KHR_get_physical_device_properties2 ===
13901  vkGetPhysicalDeviceFeatures2KHR = PFN_vkGetPhysicalDeviceFeatures2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures2KHR" ) );
13904  vkGetPhysicalDeviceProperties2KHR = PFN_vkGetPhysicalDeviceProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties2KHR" ) );
13908  PFN_vkGetPhysicalDeviceFormatProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties2KHR" ) );
13912  PFN_vkGetPhysicalDeviceImageFormatProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties2KHR" ) );
13916  PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties2KHR" ) );
13920  PFN_vkGetPhysicalDeviceMemoryProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties2KHR" ) );
13924  PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR" ) );
13927 
13928  //=== VK_KHR_device_group ===
13930  PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceGroupPeerMemoryFeaturesKHR" ) );
13933  vkCmdSetDeviceMaskKHR = PFN_vkCmdSetDeviceMaskKHR( vkGetInstanceProcAddr( instance, "vkCmdSetDeviceMaskKHR" ) );
13934  if ( !vkCmdSetDeviceMask )
13936  vkCmdDispatchBaseKHR = PFN_vkCmdDispatchBaseKHR( vkGetInstanceProcAddr( instance, "vkCmdDispatchBaseKHR" ) );
13937  if ( !vkCmdDispatchBase )
13939 
13940 #if defined( VK_USE_PLATFORM_VI_NN )
13941  //=== VK_NN_vi_surface ===
13942  vkCreateViSurfaceNN = PFN_vkCreateViSurfaceNN( vkGetInstanceProcAddr( instance, "vkCreateViSurfaceNN" ) );
13943 #endif /*VK_USE_PLATFORM_VI_NN*/
13944 
13945  //=== VK_KHR_maintenance1 ===
13946  vkTrimCommandPoolKHR = PFN_vkTrimCommandPoolKHR( vkGetInstanceProcAddr( instance, "vkTrimCommandPoolKHR" ) );
13947  if ( !vkTrimCommandPool )
13949 
13950  //=== VK_KHR_device_group_creation ===
13951  vkEnumeratePhysicalDeviceGroupsKHR = PFN_vkEnumeratePhysicalDeviceGroupsKHR( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceGroupsKHR" ) );
13954 
13955  //=== VK_KHR_external_memory_capabilities ===
13957  PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalBufferPropertiesKHR" ) );
13960 
13961 #if defined( VK_USE_PLATFORM_WIN32_KHR )
13962  //=== VK_KHR_external_memory_win32 ===
13963  vkGetMemoryWin32HandleKHR = PFN_vkGetMemoryWin32HandleKHR( vkGetInstanceProcAddr( instance, "vkGetMemoryWin32HandleKHR" ) );
13964  vkGetMemoryWin32HandlePropertiesKHR = PFN_vkGetMemoryWin32HandlePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetMemoryWin32HandlePropertiesKHR" ) );
13965 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
13966 
13967  //=== VK_KHR_external_memory_fd ===
13968  vkGetMemoryFdKHR = PFN_vkGetMemoryFdKHR( vkGetInstanceProcAddr( instance, "vkGetMemoryFdKHR" ) );
13969  vkGetMemoryFdPropertiesKHR = PFN_vkGetMemoryFdPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetMemoryFdPropertiesKHR" ) );
13970 
13971  //=== VK_KHR_external_semaphore_capabilities ===
13973  PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR" ) );
13976 
13977 #if defined( VK_USE_PLATFORM_WIN32_KHR )
13978  //=== VK_KHR_external_semaphore_win32 ===
13979  vkImportSemaphoreWin32HandleKHR = PFN_vkImportSemaphoreWin32HandleKHR( vkGetInstanceProcAddr( instance, "vkImportSemaphoreWin32HandleKHR" ) );
13980  vkGetSemaphoreWin32HandleKHR = PFN_vkGetSemaphoreWin32HandleKHR( vkGetInstanceProcAddr( instance, "vkGetSemaphoreWin32HandleKHR" ) );
13981 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
13982 
13983  //=== VK_KHR_external_semaphore_fd ===
13984  vkImportSemaphoreFdKHR = PFN_vkImportSemaphoreFdKHR( vkGetInstanceProcAddr( instance, "vkImportSemaphoreFdKHR" ) );
13985  vkGetSemaphoreFdKHR = PFN_vkGetSemaphoreFdKHR( vkGetInstanceProcAddr( instance, "vkGetSemaphoreFdKHR" ) );
13986 
13987  //=== VK_KHR_push_descriptor ===
13988  vkCmdPushDescriptorSetKHR = PFN_vkCmdPushDescriptorSetKHR( vkGetInstanceProcAddr( instance, "vkCmdPushDescriptorSetKHR" ) );
13990  PFN_vkCmdPushDescriptorSetWithTemplateKHR( vkGetInstanceProcAddr( instance, "vkCmdPushDescriptorSetWithTemplateKHR" ) );
13991 
13992  //=== VK_EXT_conditional_rendering ===
13993  vkCmdBeginConditionalRenderingEXT = PFN_vkCmdBeginConditionalRenderingEXT( vkGetInstanceProcAddr( instance, "vkCmdBeginConditionalRenderingEXT" ) );
13994  vkCmdEndConditionalRenderingEXT = PFN_vkCmdEndConditionalRenderingEXT( vkGetInstanceProcAddr( instance, "vkCmdEndConditionalRenderingEXT" ) );
13995 
13996  //=== VK_KHR_descriptor_update_template ===
13997  vkCreateDescriptorUpdateTemplateKHR = PFN_vkCreateDescriptorUpdateTemplateKHR( vkGetInstanceProcAddr( instance, "vkCreateDescriptorUpdateTemplateKHR" ) );
14001  PFN_vkDestroyDescriptorUpdateTemplateKHR( vkGetInstanceProcAddr( instance, "vkDestroyDescriptorUpdateTemplateKHR" ) );
14005  PFN_vkUpdateDescriptorSetWithTemplateKHR( vkGetInstanceProcAddr( instance, "vkUpdateDescriptorSetWithTemplateKHR" ) );
14008 
14009  //=== VK_NV_clip_space_w_scaling ===
14010  vkCmdSetViewportWScalingNV = PFN_vkCmdSetViewportWScalingNV( vkGetInstanceProcAddr( instance, "vkCmdSetViewportWScalingNV" ) );
14011 
14012  //=== VK_EXT_direct_mode_display ===
14013  vkReleaseDisplayEXT = PFN_vkReleaseDisplayEXT( vkGetInstanceProcAddr( instance, "vkReleaseDisplayEXT" ) );
14014 
14015 #if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
14016  //=== VK_EXT_acquire_xlib_display ===
14017  vkAcquireXlibDisplayEXT = PFN_vkAcquireXlibDisplayEXT( vkGetInstanceProcAddr( instance, "vkAcquireXlibDisplayEXT" ) );
14018  vkGetRandROutputDisplayEXT = PFN_vkGetRandROutputDisplayEXT( vkGetInstanceProcAddr( instance, "vkGetRandROutputDisplayEXT" ) );
14019 #endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
14020 
14021  //=== VK_EXT_display_surface_counter ===
14023  PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilities2EXT" ) );
14024 
14025  //=== VK_EXT_display_control ===
14026  vkDisplayPowerControlEXT = PFN_vkDisplayPowerControlEXT( vkGetInstanceProcAddr( instance, "vkDisplayPowerControlEXT" ) );
14027  vkRegisterDeviceEventEXT = PFN_vkRegisterDeviceEventEXT( vkGetInstanceProcAddr( instance, "vkRegisterDeviceEventEXT" ) );
14028  vkRegisterDisplayEventEXT = PFN_vkRegisterDisplayEventEXT( vkGetInstanceProcAddr( instance, "vkRegisterDisplayEventEXT" ) );
14029  vkGetSwapchainCounterEXT = PFN_vkGetSwapchainCounterEXT( vkGetInstanceProcAddr( instance, "vkGetSwapchainCounterEXT" ) );
14030 
14031  //=== VK_GOOGLE_display_timing ===
14032  vkGetRefreshCycleDurationGOOGLE = PFN_vkGetRefreshCycleDurationGOOGLE( vkGetInstanceProcAddr( instance, "vkGetRefreshCycleDurationGOOGLE" ) );
14033  vkGetPastPresentationTimingGOOGLE = PFN_vkGetPastPresentationTimingGOOGLE( vkGetInstanceProcAddr( instance, "vkGetPastPresentationTimingGOOGLE" ) );
14034 
14035  //=== VK_EXT_discard_rectangles ===
14036  vkCmdSetDiscardRectangleEXT = PFN_vkCmdSetDiscardRectangleEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDiscardRectangleEXT" ) );
14037 
14038  //=== VK_EXT_hdr_metadata ===
14039  vkSetHdrMetadataEXT = PFN_vkSetHdrMetadataEXT( vkGetInstanceProcAddr( instance, "vkSetHdrMetadataEXT" ) );
14040 
14041  //=== VK_KHR_create_renderpass2 ===
14042  vkCreateRenderPass2KHR = PFN_vkCreateRenderPass2KHR( vkGetInstanceProcAddr( instance, "vkCreateRenderPass2KHR" ) );
14043  if ( !vkCreateRenderPass2 )
14045  vkCmdBeginRenderPass2KHR = PFN_vkCmdBeginRenderPass2KHR( vkGetInstanceProcAddr( instance, "vkCmdBeginRenderPass2KHR" ) );
14046  if ( !vkCmdBeginRenderPass2 )
14048  vkCmdNextSubpass2KHR = PFN_vkCmdNextSubpass2KHR( vkGetInstanceProcAddr( instance, "vkCmdNextSubpass2KHR" ) );
14049  if ( !vkCmdNextSubpass2 )
14051  vkCmdEndRenderPass2KHR = PFN_vkCmdEndRenderPass2KHR( vkGetInstanceProcAddr( instance, "vkCmdEndRenderPass2KHR" ) );
14052  if ( !vkCmdEndRenderPass2 )
14054 
14055  //=== VK_KHR_shared_presentable_image ===
14056  vkGetSwapchainStatusKHR = PFN_vkGetSwapchainStatusKHR( vkGetInstanceProcAddr( instance, "vkGetSwapchainStatusKHR" ) );
14057 
14058  //=== VK_KHR_external_fence_capabilities ===
14060  PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalFencePropertiesKHR" ) );
14063 
14064 #if defined( VK_USE_PLATFORM_WIN32_KHR )
14065  //=== VK_KHR_external_fence_win32 ===
14066  vkImportFenceWin32HandleKHR = PFN_vkImportFenceWin32HandleKHR( vkGetInstanceProcAddr( instance, "vkImportFenceWin32HandleKHR" ) );
14067  vkGetFenceWin32HandleKHR = PFN_vkGetFenceWin32HandleKHR( vkGetInstanceProcAddr( instance, "vkGetFenceWin32HandleKHR" ) );
14068 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
14069 
14070  //=== VK_KHR_external_fence_fd ===
14071  vkImportFenceFdKHR = PFN_vkImportFenceFdKHR( vkGetInstanceProcAddr( instance, "vkImportFenceFdKHR" ) );
14072  vkGetFenceFdKHR = PFN_vkGetFenceFdKHR( vkGetInstanceProcAddr( instance, "vkGetFenceFdKHR" ) );
14073 
14074  //=== VK_KHR_performance_query ===
14076  vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR" ) );
14078  vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR" ) );
14079  vkAcquireProfilingLockKHR = PFN_vkAcquireProfilingLockKHR( vkGetInstanceProcAddr( instance, "vkAcquireProfilingLockKHR" ) );
14080  vkReleaseProfilingLockKHR = PFN_vkReleaseProfilingLockKHR( vkGetInstanceProcAddr( instance, "vkReleaseProfilingLockKHR" ) );
14081 
14082  //=== VK_KHR_get_surface_capabilities2 ===
14084  PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilities2KHR" ) );
14086  PFN_vkGetPhysicalDeviceSurfaceFormats2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceFormats2KHR" ) );
14087 
14088  //=== VK_KHR_get_display_properties2 ===
14090  PFN_vkGetPhysicalDeviceDisplayProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayProperties2KHR" ) );
14092  PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPlaneProperties2KHR" ) );
14093  vkGetDisplayModeProperties2KHR = PFN_vkGetDisplayModeProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetDisplayModeProperties2KHR" ) );
14094  vkGetDisplayPlaneCapabilities2KHR = PFN_vkGetDisplayPlaneCapabilities2KHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneCapabilities2KHR" ) );
14095 
14096 #if defined( VK_USE_PLATFORM_IOS_MVK )
14097  //=== VK_MVK_ios_surface ===
14098  vkCreateIOSSurfaceMVK = PFN_vkCreateIOSSurfaceMVK( vkGetInstanceProcAddr( instance, "vkCreateIOSSurfaceMVK" ) );
14099 #endif /*VK_USE_PLATFORM_IOS_MVK*/
14100 
14101 #if defined( VK_USE_PLATFORM_MACOS_MVK )
14102  //=== VK_MVK_macos_surface ===
14103  vkCreateMacOSSurfaceMVK = PFN_vkCreateMacOSSurfaceMVK( vkGetInstanceProcAddr( instance, "vkCreateMacOSSurfaceMVK" ) );
14104 #endif /*VK_USE_PLATFORM_MACOS_MVK*/
14105 
14106  //=== VK_EXT_debug_utils ===
14107  vkSetDebugUtilsObjectNameEXT = PFN_vkSetDebugUtilsObjectNameEXT( vkGetInstanceProcAddr( instance, "vkSetDebugUtilsObjectNameEXT" ) );
14108  vkSetDebugUtilsObjectTagEXT = PFN_vkSetDebugUtilsObjectTagEXT( vkGetInstanceProcAddr( instance, "vkSetDebugUtilsObjectTagEXT" ) );
14109  vkQueueBeginDebugUtilsLabelEXT = PFN_vkQueueBeginDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkQueueBeginDebugUtilsLabelEXT" ) );
14110  vkQueueEndDebugUtilsLabelEXT = PFN_vkQueueEndDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkQueueEndDebugUtilsLabelEXT" ) );
14111  vkQueueInsertDebugUtilsLabelEXT = PFN_vkQueueInsertDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkQueueInsertDebugUtilsLabelEXT" ) );
14112  vkCmdBeginDebugUtilsLabelEXT = PFN_vkCmdBeginDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkCmdBeginDebugUtilsLabelEXT" ) );
14113  vkCmdEndDebugUtilsLabelEXT = PFN_vkCmdEndDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkCmdEndDebugUtilsLabelEXT" ) );
14114  vkCmdInsertDebugUtilsLabelEXT = PFN_vkCmdInsertDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkCmdInsertDebugUtilsLabelEXT" ) );
14115  vkCreateDebugUtilsMessengerEXT = PFN_vkCreateDebugUtilsMessengerEXT( vkGetInstanceProcAddr( instance, "vkCreateDebugUtilsMessengerEXT" ) );
14116  vkDestroyDebugUtilsMessengerEXT = PFN_vkDestroyDebugUtilsMessengerEXT( vkGetInstanceProcAddr( instance, "vkDestroyDebugUtilsMessengerEXT" ) );
14117  vkSubmitDebugUtilsMessageEXT = PFN_vkSubmitDebugUtilsMessageEXT( vkGetInstanceProcAddr( instance, "vkSubmitDebugUtilsMessageEXT" ) );
14118 
14119 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
14120  //=== VK_ANDROID_external_memory_android_hardware_buffer ===
14122  PFN_vkGetAndroidHardwareBufferPropertiesANDROID( vkGetInstanceProcAddr( instance, "vkGetAndroidHardwareBufferPropertiesANDROID" ) );
14124  PFN_vkGetMemoryAndroidHardwareBufferANDROID( vkGetInstanceProcAddr( instance, "vkGetMemoryAndroidHardwareBufferANDROID" ) );
14125 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
14126 
14127  //=== VK_EXT_sample_locations ===
14128  vkCmdSetSampleLocationsEXT = PFN_vkCmdSetSampleLocationsEXT( vkGetInstanceProcAddr( instance, "vkCmdSetSampleLocationsEXT" ) );
14130  PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMultisamplePropertiesEXT" ) );
14131 
14132  //=== VK_KHR_get_memory_requirements2 ===
14133  vkGetImageMemoryRequirements2KHR = PFN_vkGetImageMemoryRequirements2KHR( vkGetInstanceProcAddr( instance, "vkGetImageMemoryRequirements2KHR" ) );
14136  vkGetBufferMemoryRequirements2KHR = PFN_vkGetBufferMemoryRequirements2KHR( vkGetInstanceProcAddr( instance, "vkGetBufferMemoryRequirements2KHR" ) );
14140  PFN_vkGetImageSparseMemoryRequirements2KHR( vkGetInstanceProcAddr( instance, "vkGetImageSparseMemoryRequirements2KHR" ) );
14143 
14144  //=== VK_KHR_acceleration_structure ===
14145  vkCreateAccelerationStructureKHR = PFN_vkCreateAccelerationStructureKHR( vkGetInstanceProcAddr( instance, "vkCreateAccelerationStructureKHR" ) );
14146  vkDestroyAccelerationStructureKHR = PFN_vkDestroyAccelerationStructureKHR( vkGetInstanceProcAddr( instance, "vkDestroyAccelerationStructureKHR" ) );
14147  vkCmdBuildAccelerationStructuresKHR = PFN_vkCmdBuildAccelerationStructuresKHR( vkGetInstanceProcAddr( instance, "vkCmdBuildAccelerationStructuresKHR" ) );
14149  PFN_vkCmdBuildAccelerationStructuresIndirectKHR( vkGetInstanceProcAddr( instance, "vkCmdBuildAccelerationStructuresIndirectKHR" ) );
14150  vkBuildAccelerationStructuresKHR = PFN_vkBuildAccelerationStructuresKHR( vkGetInstanceProcAddr( instance, "vkBuildAccelerationStructuresKHR" ) );
14151  vkCopyAccelerationStructureKHR = PFN_vkCopyAccelerationStructureKHR( vkGetInstanceProcAddr( instance, "vkCopyAccelerationStructureKHR" ) );
14153  PFN_vkCopyAccelerationStructureToMemoryKHR( vkGetInstanceProcAddr( instance, "vkCopyAccelerationStructureToMemoryKHR" ) );
14155  PFN_vkCopyMemoryToAccelerationStructureKHR( vkGetInstanceProcAddr( instance, "vkCopyMemoryToAccelerationStructureKHR" ) );
14157  PFN_vkWriteAccelerationStructuresPropertiesKHR( vkGetInstanceProcAddr( instance, "vkWriteAccelerationStructuresPropertiesKHR" ) );
14158  vkCmdCopyAccelerationStructureKHR = PFN_vkCmdCopyAccelerationStructureKHR( vkGetInstanceProcAddr( instance, "vkCmdCopyAccelerationStructureKHR" ) );
14160  PFN_vkCmdCopyAccelerationStructureToMemoryKHR( vkGetInstanceProcAddr( instance, "vkCmdCopyAccelerationStructureToMemoryKHR" ) );
14162  PFN_vkCmdCopyMemoryToAccelerationStructureKHR( vkGetInstanceProcAddr( instance, "vkCmdCopyMemoryToAccelerationStructureKHR" ) );
14164  PFN_vkGetAccelerationStructureDeviceAddressKHR( vkGetInstanceProcAddr( instance, "vkGetAccelerationStructureDeviceAddressKHR" ) );
14166  PFN_vkCmdWriteAccelerationStructuresPropertiesKHR( vkGetInstanceProcAddr( instance, "vkCmdWriteAccelerationStructuresPropertiesKHR" ) );
14168  PFN_vkGetDeviceAccelerationStructureCompatibilityKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceAccelerationStructureCompatibilityKHR" ) );
14170  PFN_vkGetAccelerationStructureBuildSizesKHR( vkGetInstanceProcAddr( instance, "vkGetAccelerationStructureBuildSizesKHR" ) );
14171 
14172  //=== VK_KHR_sampler_ycbcr_conversion ===
14173  vkCreateSamplerYcbcrConversionKHR = PFN_vkCreateSamplerYcbcrConversionKHR( vkGetInstanceProcAddr( instance, "vkCreateSamplerYcbcrConversionKHR" ) );
14176  vkDestroySamplerYcbcrConversionKHR = PFN_vkDestroySamplerYcbcrConversionKHR( vkGetInstanceProcAddr( instance, "vkDestroySamplerYcbcrConversionKHR" ) );
14179 
14180  //=== VK_KHR_bind_memory2 ===
14181  vkBindBufferMemory2KHR = PFN_vkBindBufferMemory2KHR( vkGetInstanceProcAddr( instance, "vkBindBufferMemory2KHR" ) );
14182  if ( !vkBindBufferMemory2 )
14184  vkBindImageMemory2KHR = PFN_vkBindImageMemory2KHR( vkGetInstanceProcAddr( instance, "vkBindImageMemory2KHR" ) );
14185  if ( !vkBindImageMemory2 )
14187 
14188  //=== VK_EXT_image_drm_format_modifier ===
14190  PFN_vkGetImageDrmFormatModifierPropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetImageDrmFormatModifierPropertiesEXT" ) );
14191 
14192  //=== VK_EXT_validation_cache ===
14193  vkCreateValidationCacheEXT = PFN_vkCreateValidationCacheEXT( vkGetInstanceProcAddr( instance, "vkCreateValidationCacheEXT" ) );
14194  vkDestroyValidationCacheEXT = PFN_vkDestroyValidationCacheEXT( vkGetInstanceProcAddr( instance, "vkDestroyValidationCacheEXT" ) );
14195  vkMergeValidationCachesEXT = PFN_vkMergeValidationCachesEXT( vkGetInstanceProcAddr( instance, "vkMergeValidationCachesEXT" ) );
14196  vkGetValidationCacheDataEXT = PFN_vkGetValidationCacheDataEXT( vkGetInstanceProcAddr( instance, "vkGetValidationCacheDataEXT" ) );
14197 
14198  //=== VK_NV_shading_rate_image ===
14199  vkCmdBindShadingRateImageNV = PFN_vkCmdBindShadingRateImageNV( vkGetInstanceProcAddr( instance, "vkCmdBindShadingRateImageNV" ) );
14201  PFN_vkCmdSetViewportShadingRatePaletteNV( vkGetInstanceProcAddr( instance, "vkCmdSetViewportShadingRatePaletteNV" ) );
14202  vkCmdSetCoarseSampleOrderNV = PFN_vkCmdSetCoarseSampleOrderNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoarseSampleOrderNV" ) );
14203 
14204  //=== VK_NV_ray_tracing ===
14205  vkCreateAccelerationStructureNV = PFN_vkCreateAccelerationStructureNV( vkGetInstanceProcAddr( instance, "vkCreateAccelerationStructureNV" ) );
14206  vkDestroyAccelerationStructureNV = PFN_vkDestroyAccelerationStructureNV( vkGetInstanceProcAddr( instance, "vkDestroyAccelerationStructureNV" ) );
14208  PFN_vkGetAccelerationStructureMemoryRequirementsNV( vkGetInstanceProcAddr( instance, "vkGetAccelerationStructureMemoryRequirementsNV" ) );
14209  vkBindAccelerationStructureMemoryNV = PFN_vkBindAccelerationStructureMemoryNV( vkGetInstanceProcAddr( instance, "vkBindAccelerationStructureMemoryNV" ) );
14210  vkCmdBuildAccelerationStructureNV = PFN_vkCmdBuildAccelerationStructureNV( vkGetInstanceProcAddr( instance, "vkCmdBuildAccelerationStructureNV" ) );
14211  vkCmdCopyAccelerationStructureNV = PFN_vkCmdCopyAccelerationStructureNV( vkGetInstanceProcAddr( instance, "vkCmdCopyAccelerationStructureNV" ) );
14212  vkCmdTraceRaysNV = PFN_vkCmdTraceRaysNV( vkGetInstanceProcAddr( instance, "vkCmdTraceRaysNV" ) );
14213  vkCreateRayTracingPipelinesNV = PFN_vkCreateRayTracingPipelinesNV( vkGetInstanceProcAddr( instance, "vkCreateRayTracingPipelinesNV" ) );
14214  vkGetRayTracingShaderGroupHandlesNV = PFN_vkGetRayTracingShaderGroupHandlesNV( vkGetInstanceProcAddr( instance, "vkGetRayTracingShaderGroupHandlesNV" ) );
14217  vkGetAccelerationStructureHandleNV = PFN_vkGetAccelerationStructureHandleNV( vkGetInstanceProcAddr( instance, "vkGetAccelerationStructureHandleNV" ) );
14219  PFN_vkCmdWriteAccelerationStructuresPropertiesNV( vkGetInstanceProcAddr( instance, "vkCmdWriteAccelerationStructuresPropertiesNV" ) );
14220  vkCompileDeferredNV = PFN_vkCompileDeferredNV( vkGetInstanceProcAddr( instance, "vkCompileDeferredNV" ) );
14221 
14222  //=== VK_KHR_maintenance3 ===
14223  vkGetDescriptorSetLayoutSupportKHR = PFN_vkGetDescriptorSetLayoutSupportKHR( vkGetInstanceProcAddr( instance, "vkGetDescriptorSetLayoutSupportKHR" ) );
14226 
14227  //=== VK_KHR_draw_indirect_count ===
14228  vkCmdDrawIndirectCountKHR = PFN_vkCmdDrawIndirectCountKHR( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectCountKHR" ) );
14229  if ( !vkCmdDrawIndirectCount )
14231  vkCmdDrawIndexedIndirectCountKHR = PFN_vkCmdDrawIndexedIndirectCountKHR( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirectCountKHR" ) );
14234 
14235  //=== VK_EXT_external_memory_host ===
14236  vkGetMemoryHostPointerPropertiesEXT = PFN_vkGetMemoryHostPointerPropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetMemoryHostPointerPropertiesEXT" ) );
14237 
14238  //=== VK_AMD_buffer_marker ===
14239  vkCmdWriteBufferMarkerAMD = PFN_vkCmdWriteBufferMarkerAMD( vkGetInstanceProcAddr( instance, "vkCmdWriteBufferMarkerAMD" ) );
14240 
14241  //=== VK_EXT_calibrated_timestamps ===
14243  PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT" ) );
14244  vkGetCalibratedTimestampsEXT = PFN_vkGetCalibratedTimestampsEXT( vkGetInstanceProcAddr( instance, "vkGetCalibratedTimestampsEXT" ) );
14245 
14246  //=== VK_NV_mesh_shader ===
14247  vkCmdDrawMeshTasksNV = PFN_vkCmdDrawMeshTasksNV( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksNV" ) );
14248  vkCmdDrawMeshTasksIndirectNV = PFN_vkCmdDrawMeshTasksIndirectNV( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksIndirectNV" ) );
14249  vkCmdDrawMeshTasksIndirectCountNV = PFN_vkCmdDrawMeshTasksIndirectCountNV( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksIndirectCountNV" ) );
14250 
14251  //=== VK_NV_scissor_exclusive ===
14252  vkCmdSetExclusiveScissorNV = PFN_vkCmdSetExclusiveScissorNV( vkGetInstanceProcAddr( instance, "vkCmdSetExclusiveScissorNV" ) );
14253 
14254  //=== VK_NV_device_diagnostic_checkpoints ===
14255  vkCmdSetCheckpointNV = PFN_vkCmdSetCheckpointNV( vkGetInstanceProcAddr( instance, "vkCmdSetCheckpointNV" ) );
14256  vkGetQueueCheckpointDataNV = PFN_vkGetQueueCheckpointDataNV( vkGetInstanceProcAddr( instance, "vkGetQueueCheckpointDataNV" ) );
14257 
14258  //=== VK_KHR_timeline_semaphore ===
14259  vkGetSemaphoreCounterValueKHR = PFN_vkGetSemaphoreCounterValueKHR( vkGetInstanceProcAddr( instance, "vkGetSemaphoreCounterValueKHR" ) );
14262  vkWaitSemaphoresKHR = PFN_vkWaitSemaphoresKHR( vkGetInstanceProcAddr( instance, "vkWaitSemaphoresKHR" ) );
14263  if ( !vkWaitSemaphores )
14265  vkSignalSemaphoreKHR = PFN_vkSignalSemaphoreKHR( vkGetInstanceProcAddr( instance, "vkSignalSemaphoreKHR" ) );
14266  if ( !vkSignalSemaphore )
14268 
14269  //=== VK_INTEL_performance_query ===
14270  vkInitializePerformanceApiINTEL = PFN_vkInitializePerformanceApiINTEL( vkGetInstanceProcAddr( instance, "vkInitializePerformanceApiINTEL" ) );
14271  vkUninitializePerformanceApiINTEL = PFN_vkUninitializePerformanceApiINTEL( vkGetInstanceProcAddr( instance, "vkUninitializePerformanceApiINTEL" ) );
14272  vkCmdSetPerformanceMarkerINTEL = PFN_vkCmdSetPerformanceMarkerINTEL( vkGetInstanceProcAddr( instance, "vkCmdSetPerformanceMarkerINTEL" ) );
14274  PFN_vkCmdSetPerformanceStreamMarkerINTEL( vkGetInstanceProcAddr( instance, "vkCmdSetPerformanceStreamMarkerINTEL" ) );
14275  vkCmdSetPerformanceOverrideINTEL = PFN_vkCmdSetPerformanceOverrideINTEL( vkGetInstanceProcAddr( instance, "vkCmdSetPerformanceOverrideINTEL" ) );
14277  PFN_vkAcquirePerformanceConfigurationINTEL( vkGetInstanceProcAddr( instance, "vkAcquirePerformanceConfigurationINTEL" ) );
14279  PFN_vkReleasePerformanceConfigurationINTEL( vkGetInstanceProcAddr( instance, "vkReleasePerformanceConfigurationINTEL" ) );
14281  PFN_vkQueueSetPerformanceConfigurationINTEL( vkGetInstanceProcAddr( instance, "vkQueueSetPerformanceConfigurationINTEL" ) );
14282  vkGetPerformanceParameterINTEL = PFN_vkGetPerformanceParameterINTEL( vkGetInstanceProcAddr( instance, "vkGetPerformanceParameterINTEL" ) );
14283 
14284  //=== VK_AMD_display_native_hdr ===
14285  vkSetLocalDimmingAMD = PFN_vkSetLocalDimmingAMD( vkGetInstanceProcAddr( instance, "vkSetLocalDimmingAMD" ) );
14286 
14287 #if defined( VK_USE_PLATFORM_FUCHSIA )
14288  //=== VK_FUCHSIA_imagepipe_surface ===
14289  vkCreateImagePipeSurfaceFUCHSIA = PFN_vkCreateImagePipeSurfaceFUCHSIA( vkGetInstanceProcAddr( instance, "vkCreateImagePipeSurfaceFUCHSIA" ) );
14290 #endif /*VK_USE_PLATFORM_FUCHSIA*/
14291 
14292 #if defined( VK_USE_PLATFORM_METAL_EXT )
14293  //=== VK_EXT_metal_surface ===
14294  vkCreateMetalSurfaceEXT = PFN_vkCreateMetalSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateMetalSurfaceEXT" ) );
14295 #endif /*VK_USE_PLATFORM_METAL_EXT*/
14296 
14297  //=== VK_KHR_fragment_shading_rate ===
14299  PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFragmentShadingRatesKHR" ) );
14300  vkCmdSetFragmentShadingRateKHR = PFN_vkCmdSetFragmentShadingRateKHR( vkGetInstanceProcAddr( instance, "vkCmdSetFragmentShadingRateKHR" ) );
14301 
14302  //=== VK_EXT_buffer_device_address ===
14303  vkGetBufferDeviceAddressEXT = PFN_vkGetBufferDeviceAddressEXT( vkGetInstanceProcAddr( instance, "vkGetBufferDeviceAddressEXT" ) );
14304  if ( !vkGetBufferDeviceAddress )
14306 
14307  //=== VK_EXT_tooling_info ===
14309  PFN_vkGetPhysicalDeviceToolPropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceToolPropertiesEXT" ) );
14312 
14313  //=== VK_KHR_present_wait ===
14314  vkWaitForPresentKHR = PFN_vkWaitForPresentKHR( vkGetInstanceProcAddr( instance, "vkWaitForPresentKHR" ) );
14315 
14316  //=== VK_NV_cooperative_matrix ===
14318  PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV" ) );
14319 
14320  //=== VK_NV_coverage_reduction_mode ===
14322  vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" ) );
14323 
14324 #if defined( VK_USE_PLATFORM_WIN32_KHR )
14325  //=== VK_EXT_full_screen_exclusive ===
14327  PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfacePresentModes2EXT" ) );
14328  vkAcquireFullScreenExclusiveModeEXT = PFN_vkAcquireFullScreenExclusiveModeEXT( vkGetInstanceProcAddr( instance, "vkAcquireFullScreenExclusiveModeEXT" ) );
14329  vkReleaseFullScreenExclusiveModeEXT = PFN_vkReleaseFullScreenExclusiveModeEXT( vkGetInstanceProcAddr( instance, "vkReleaseFullScreenExclusiveModeEXT" ) );
14331  PFN_vkGetDeviceGroupSurfacePresentModes2EXT( vkGetInstanceProcAddr( instance, "vkGetDeviceGroupSurfacePresentModes2EXT" ) );
14332 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
14333 
14334  //=== VK_EXT_headless_surface ===
14335  vkCreateHeadlessSurfaceEXT = PFN_vkCreateHeadlessSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateHeadlessSurfaceEXT" ) );
14336 
14337  //=== VK_KHR_buffer_device_address ===
14338  vkGetBufferDeviceAddressKHR = PFN_vkGetBufferDeviceAddressKHR( vkGetInstanceProcAddr( instance, "vkGetBufferDeviceAddressKHR" ) );
14339  if ( !vkGetBufferDeviceAddress )
14341  vkGetBufferOpaqueCaptureAddressKHR = PFN_vkGetBufferOpaqueCaptureAddressKHR( vkGetInstanceProcAddr( instance, "vkGetBufferOpaqueCaptureAddressKHR" ) );
14345  PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceMemoryOpaqueCaptureAddressKHR" ) );
14348 
14349  //=== VK_EXT_line_rasterization ===
14350  vkCmdSetLineStippleEXT = PFN_vkCmdSetLineStippleEXT( vkGetInstanceProcAddr( instance, "vkCmdSetLineStippleEXT" ) );
14351 
14352  //=== VK_EXT_host_query_reset ===
14353  vkResetQueryPoolEXT = PFN_vkResetQueryPoolEXT( vkGetInstanceProcAddr( instance, "vkResetQueryPoolEXT" ) );
14354  if ( !vkResetQueryPool )
14356 
14357  //=== VK_EXT_extended_dynamic_state ===
14358  vkCmdSetCullModeEXT = PFN_vkCmdSetCullModeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetCullModeEXT" ) );
14359  if ( !vkCmdSetCullMode )
14361  vkCmdSetFrontFaceEXT = PFN_vkCmdSetFrontFaceEXT( vkGetInstanceProcAddr( instance, "vkCmdSetFrontFaceEXT" ) );
14362  if ( !vkCmdSetFrontFace )
14364  vkCmdSetPrimitiveTopologyEXT = PFN_vkCmdSetPrimitiveTopologyEXT( vkGetInstanceProcAddr( instance, "vkCmdSetPrimitiveTopologyEXT" ) );
14367  vkCmdSetViewportWithCountEXT = PFN_vkCmdSetViewportWithCountEXT( vkGetInstanceProcAddr( instance, "vkCmdSetViewportWithCountEXT" ) );
14370  vkCmdSetScissorWithCountEXT = PFN_vkCmdSetScissorWithCountEXT( vkGetInstanceProcAddr( instance, "vkCmdSetScissorWithCountEXT" ) );
14371  if ( !vkCmdSetScissorWithCount )
14373  vkCmdBindVertexBuffers2EXT = PFN_vkCmdBindVertexBuffers2EXT( vkGetInstanceProcAddr( instance, "vkCmdBindVertexBuffers2EXT" ) );
14374  if ( !vkCmdBindVertexBuffers2 )
14376  vkCmdSetDepthTestEnableEXT = PFN_vkCmdSetDepthTestEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthTestEnableEXT" ) );
14377  if ( !vkCmdSetDepthTestEnable )
14379  vkCmdSetDepthWriteEnableEXT = PFN_vkCmdSetDepthWriteEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthWriteEnableEXT" ) );
14380  if ( !vkCmdSetDepthWriteEnable )
14382  vkCmdSetDepthCompareOpEXT = PFN_vkCmdSetDepthCompareOpEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthCompareOpEXT" ) );
14383  if ( !vkCmdSetDepthCompareOp )
14385  vkCmdSetDepthBoundsTestEnableEXT = PFN_vkCmdSetDepthBoundsTestEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBoundsTestEnableEXT" ) );
14388  vkCmdSetStencilTestEnableEXT = PFN_vkCmdSetStencilTestEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetStencilTestEnableEXT" ) );
14391  vkCmdSetStencilOpEXT = PFN_vkCmdSetStencilOpEXT( vkGetInstanceProcAddr( instance, "vkCmdSetStencilOpEXT" ) );
14392  if ( !vkCmdSetStencilOp )
14394 
14395  //=== VK_KHR_deferred_host_operations ===
14396  vkCreateDeferredOperationKHR = PFN_vkCreateDeferredOperationKHR( vkGetInstanceProcAddr( instance, "vkCreateDeferredOperationKHR" ) );
14397  vkDestroyDeferredOperationKHR = PFN_vkDestroyDeferredOperationKHR( vkGetInstanceProcAddr( instance, "vkDestroyDeferredOperationKHR" ) );
14399  PFN_vkGetDeferredOperationMaxConcurrencyKHR( vkGetInstanceProcAddr( instance, "vkGetDeferredOperationMaxConcurrencyKHR" ) );
14400  vkGetDeferredOperationResultKHR = PFN_vkGetDeferredOperationResultKHR( vkGetInstanceProcAddr( instance, "vkGetDeferredOperationResultKHR" ) );
14401  vkDeferredOperationJoinKHR = PFN_vkDeferredOperationJoinKHR( vkGetInstanceProcAddr( instance, "vkDeferredOperationJoinKHR" ) );
14402 
14403  //=== VK_KHR_pipeline_executable_properties ===
14405  PFN_vkGetPipelineExecutablePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPipelineExecutablePropertiesKHR" ) );
14407  PFN_vkGetPipelineExecutableStatisticsKHR( vkGetInstanceProcAddr( instance, "vkGetPipelineExecutableStatisticsKHR" ) );
14409  PFN_vkGetPipelineExecutableInternalRepresentationsKHR( vkGetInstanceProcAddr( instance, "vkGetPipelineExecutableInternalRepresentationsKHR" ) );
14410 
14411  //=== VK_NV_device_generated_commands ===
14413  PFN_vkGetGeneratedCommandsMemoryRequirementsNV( vkGetInstanceProcAddr( instance, "vkGetGeneratedCommandsMemoryRequirementsNV" ) );
14414  vkCmdPreprocessGeneratedCommandsNV = PFN_vkCmdPreprocessGeneratedCommandsNV( vkGetInstanceProcAddr( instance, "vkCmdPreprocessGeneratedCommandsNV" ) );
14415  vkCmdExecuteGeneratedCommandsNV = PFN_vkCmdExecuteGeneratedCommandsNV( vkGetInstanceProcAddr( instance, "vkCmdExecuteGeneratedCommandsNV" ) );
14416  vkCmdBindPipelineShaderGroupNV = PFN_vkCmdBindPipelineShaderGroupNV( vkGetInstanceProcAddr( instance, "vkCmdBindPipelineShaderGroupNV" ) );
14417  vkCreateIndirectCommandsLayoutNV = PFN_vkCreateIndirectCommandsLayoutNV( vkGetInstanceProcAddr( instance, "vkCreateIndirectCommandsLayoutNV" ) );
14418  vkDestroyIndirectCommandsLayoutNV = PFN_vkDestroyIndirectCommandsLayoutNV( vkGetInstanceProcAddr( instance, "vkDestroyIndirectCommandsLayoutNV" ) );
14419 
14420  //=== VK_EXT_acquire_drm_display ===
14421  vkAcquireDrmDisplayEXT = PFN_vkAcquireDrmDisplayEXT( vkGetInstanceProcAddr( instance, "vkAcquireDrmDisplayEXT" ) );
14422  vkGetDrmDisplayEXT = PFN_vkGetDrmDisplayEXT( vkGetInstanceProcAddr( instance, "vkGetDrmDisplayEXT" ) );
14423 
14424  //=== VK_EXT_private_data ===
14425  vkCreatePrivateDataSlotEXT = PFN_vkCreatePrivateDataSlotEXT( vkGetInstanceProcAddr( instance, "vkCreatePrivateDataSlotEXT" ) );
14426  if ( !vkCreatePrivateDataSlot )
14428  vkDestroyPrivateDataSlotEXT = PFN_vkDestroyPrivateDataSlotEXT( vkGetInstanceProcAddr( instance, "vkDestroyPrivateDataSlotEXT" ) );
14429  if ( !vkDestroyPrivateDataSlot )
14431  vkSetPrivateDataEXT = PFN_vkSetPrivateDataEXT( vkGetInstanceProcAddr( instance, "vkSetPrivateDataEXT" ) );
14432  if ( !vkSetPrivateData )
14434  vkGetPrivateDataEXT = PFN_vkGetPrivateDataEXT( vkGetInstanceProcAddr( instance, "vkGetPrivateDataEXT" ) );
14435  if ( !vkGetPrivateData )
14437 
14438 #if defined( VK_ENABLE_BETA_EXTENSIONS )
14439  //=== VK_KHR_video_encode_queue ===
14440  vkCmdEncodeVideoKHR = PFN_vkCmdEncodeVideoKHR( vkGetInstanceProcAddr( instance, "vkCmdEncodeVideoKHR" ) );
14441 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
14442 
14443 #if defined( VK_USE_PLATFORM_METAL_EXT )
14444  //=== VK_EXT_metal_objects ===
14445  vkExportMetalObjectsEXT = PFN_vkExportMetalObjectsEXT( vkGetInstanceProcAddr( instance, "vkExportMetalObjectsEXT" ) );
14446 #endif /*VK_USE_PLATFORM_METAL_EXT*/
14447 
14448  //=== VK_KHR_synchronization2 ===
14449  vkCmdSetEvent2KHR = PFN_vkCmdSetEvent2KHR( vkGetInstanceProcAddr( instance, "vkCmdSetEvent2KHR" ) );
14450  if ( !vkCmdSetEvent2 )
14452  vkCmdResetEvent2KHR = PFN_vkCmdResetEvent2KHR( vkGetInstanceProcAddr( instance, "vkCmdResetEvent2KHR" ) );
14453  if ( !vkCmdResetEvent2 )
14455  vkCmdWaitEvents2KHR = PFN_vkCmdWaitEvents2KHR( vkGetInstanceProcAddr( instance, "vkCmdWaitEvents2KHR" ) );
14456  if ( !vkCmdWaitEvents2 )
14458  vkCmdPipelineBarrier2KHR = PFN_vkCmdPipelineBarrier2KHR( vkGetInstanceProcAddr( instance, "vkCmdPipelineBarrier2KHR" ) );
14459  if ( !vkCmdPipelineBarrier2 )
14461  vkCmdWriteTimestamp2KHR = PFN_vkCmdWriteTimestamp2KHR( vkGetInstanceProcAddr( instance, "vkCmdWriteTimestamp2KHR" ) );
14462  if ( !vkCmdWriteTimestamp2 )
14464  vkQueueSubmit2KHR = PFN_vkQueueSubmit2KHR( vkGetInstanceProcAddr( instance, "vkQueueSubmit2KHR" ) );
14465  if ( !vkQueueSubmit2 )
14467  vkCmdWriteBufferMarker2AMD = PFN_vkCmdWriteBufferMarker2AMD( vkGetInstanceProcAddr( instance, "vkCmdWriteBufferMarker2AMD" ) );
14468  vkGetQueueCheckpointData2NV = PFN_vkGetQueueCheckpointData2NV( vkGetInstanceProcAddr( instance, "vkGetQueueCheckpointData2NV" ) );
14469 
14470  //=== VK_EXT_descriptor_buffer ===
14471  vkGetDescriptorSetLayoutSizeEXT = PFN_vkGetDescriptorSetLayoutSizeEXT( vkGetInstanceProcAddr( instance, "vkGetDescriptorSetLayoutSizeEXT" ) );
14473  PFN_vkGetDescriptorSetLayoutBindingOffsetEXT( vkGetInstanceProcAddr( instance, "vkGetDescriptorSetLayoutBindingOffsetEXT" ) );
14474  vkGetDescriptorEXT = PFN_vkGetDescriptorEXT( vkGetInstanceProcAddr( instance, "vkGetDescriptorEXT" ) );
14475  vkCmdBindDescriptorBuffersEXT = PFN_vkCmdBindDescriptorBuffersEXT( vkGetInstanceProcAddr( instance, "vkCmdBindDescriptorBuffersEXT" ) );
14476  vkCmdSetDescriptorBufferOffsetsEXT = PFN_vkCmdSetDescriptorBufferOffsetsEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDescriptorBufferOffsetsEXT" ) );
14478  PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT( vkGetInstanceProcAddr( instance, "vkCmdBindDescriptorBufferEmbeddedSamplersEXT" ) );
14480  PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT( vkGetInstanceProcAddr( instance, "vkGetBufferOpaqueCaptureDescriptorDataEXT" ) );
14482  PFN_vkGetImageOpaqueCaptureDescriptorDataEXT( vkGetInstanceProcAddr( instance, "vkGetImageOpaqueCaptureDescriptorDataEXT" ) );
14484  PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT( vkGetInstanceProcAddr( instance, "vkGetImageViewOpaqueCaptureDescriptorDataEXT" ) );
14486  PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT( vkGetInstanceProcAddr( instance, "vkGetSamplerOpaqueCaptureDescriptorDataEXT" ) );
14488  vkGetInstanceProcAddr( instance, "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT" ) );
14489 
14490  //=== VK_NV_fragment_shading_rate_enums ===
14491  vkCmdSetFragmentShadingRateEnumNV = PFN_vkCmdSetFragmentShadingRateEnumNV( vkGetInstanceProcAddr( instance, "vkCmdSetFragmentShadingRateEnumNV" ) );
14492 
14493  //=== VK_EXT_mesh_shader ===
14494  vkCmdDrawMeshTasksEXT = PFN_vkCmdDrawMeshTasksEXT( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksEXT" ) );
14495  vkCmdDrawMeshTasksIndirectEXT = PFN_vkCmdDrawMeshTasksIndirectEXT( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksIndirectEXT" ) );
14496  vkCmdDrawMeshTasksIndirectCountEXT = PFN_vkCmdDrawMeshTasksIndirectCountEXT( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksIndirectCountEXT" ) );
14497 
14498  //=== VK_KHR_copy_commands2 ===
14499  vkCmdCopyBuffer2KHR = PFN_vkCmdCopyBuffer2KHR( vkGetInstanceProcAddr( instance, "vkCmdCopyBuffer2KHR" ) );
14500  if ( !vkCmdCopyBuffer2 )
14502  vkCmdCopyImage2KHR = PFN_vkCmdCopyImage2KHR( vkGetInstanceProcAddr( instance, "vkCmdCopyImage2KHR" ) );
14503  if ( !vkCmdCopyImage2 )
14505  vkCmdCopyBufferToImage2KHR = PFN_vkCmdCopyBufferToImage2KHR( vkGetInstanceProcAddr( instance, "vkCmdCopyBufferToImage2KHR" ) );
14506  if ( !vkCmdCopyBufferToImage2 )
14508  vkCmdCopyImageToBuffer2KHR = PFN_vkCmdCopyImageToBuffer2KHR( vkGetInstanceProcAddr( instance, "vkCmdCopyImageToBuffer2KHR" ) );
14509  if ( !vkCmdCopyImageToBuffer2 )
14511  vkCmdBlitImage2KHR = PFN_vkCmdBlitImage2KHR( vkGetInstanceProcAddr( instance, "vkCmdBlitImage2KHR" ) );
14512  if ( !vkCmdBlitImage2 )
14514  vkCmdResolveImage2KHR = PFN_vkCmdResolveImage2KHR( vkGetInstanceProcAddr( instance, "vkCmdResolveImage2KHR" ) );
14515  if ( !vkCmdResolveImage2 )
14517 
14518  //=== VK_EXT_image_compression_control ===
14519  vkGetImageSubresourceLayout2EXT = PFN_vkGetImageSubresourceLayout2EXT( vkGetInstanceProcAddr( instance, "vkGetImageSubresourceLayout2EXT" ) );
14520 
14521  //=== VK_EXT_device_fault ===
14522  vkGetDeviceFaultInfoEXT = PFN_vkGetDeviceFaultInfoEXT( vkGetInstanceProcAddr( instance, "vkGetDeviceFaultInfoEXT" ) );
14523 
14524 #if defined( VK_USE_PLATFORM_WIN32_KHR )
14525  //=== VK_NV_acquire_winrt_display ===
14526  vkAcquireWinrtDisplayNV = PFN_vkAcquireWinrtDisplayNV( vkGetInstanceProcAddr( instance, "vkAcquireWinrtDisplayNV" ) );
14527  vkGetWinrtDisplayNV = PFN_vkGetWinrtDisplayNV( vkGetInstanceProcAddr( instance, "vkGetWinrtDisplayNV" ) );
14528 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
14529 
14530 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
14531  //=== VK_EXT_directfb_surface ===
14532  vkCreateDirectFBSurfaceEXT = PFN_vkCreateDirectFBSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateDirectFBSurfaceEXT" ) );
14534  PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDirectFBPresentationSupportEXT" ) );
14535 #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
14536 
14537  //=== VK_KHR_ray_tracing_pipeline ===
14538  vkCmdTraceRaysKHR = PFN_vkCmdTraceRaysKHR( vkGetInstanceProcAddr( instance, "vkCmdTraceRaysKHR" ) );
14539  vkCreateRayTracingPipelinesKHR = PFN_vkCreateRayTracingPipelinesKHR( vkGetInstanceProcAddr( instance, "vkCreateRayTracingPipelinesKHR" ) );
14541  PFN_vkGetRayTracingShaderGroupHandlesKHR( vkGetInstanceProcAddr( instance, "vkGetRayTracingShaderGroupHandlesKHR" ) );
14543  PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( vkGetInstanceProcAddr( instance, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR" ) );
14544  vkCmdTraceRaysIndirectKHR = PFN_vkCmdTraceRaysIndirectKHR( vkGetInstanceProcAddr( instance, "vkCmdTraceRaysIndirectKHR" ) );
14546  PFN_vkGetRayTracingShaderGroupStackSizeKHR( vkGetInstanceProcAddr( instance, "vkGetRayTracingShaderGroupStackSizeKHR" ) );
14548  PFN_vkCmdSetRayTracingPipelineStackSizeKHR( vkGetInstanceProcAddr( instance, "vkCmdSetRayTracingPipelineStackSizeKHR" ) );
14549 
14550  //=== VK_EXT_vertex_input_dynamic_state ===
14551  vkCmdSetVertexInputEXT = PFN_vkCmdSetVertexInputEXT( vkGetInstanceProcAddr( instance, "vkCmdSetVertexInputEXT" ) );
14552 
14553 #if defined( VK_USE_PLATFORM_FUCHSIA )
14554  //=== VK_FUCHSIA_external_memory ===
14555  vkGetMemoryZirconHandleFUCHSIA = PFN_vkGetMemoryZirconHandleFUCHSIA( vkGetInstanceProcAddr( instance, "vkGetMemoryZirconHandleFUCHSIA" ) );
14557  PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA( vkGetInstanceProcAddr( instance, "vkGetMemoryZirconHandlePropertiesFUCHSIA" ) );
14558 #endif /*VK_USE_PLATFORM_FUCHSIA*/
14559 
14560 #if defined( VK_USE_PLATFORM_FUCHSIA )
14561  //=== VK_FUCHSIA_external_semaphore ===
14563  PFN_vkImportSemaphoreZirconHandleFUCHSIA( vkGetInstanceProcAddr( instance, "vkImportSemaphoreZirconHandleFUCHSIA" ) );
14564  vkGetSemaphoreZirconHandleFUCHSIA = PFN_vkGetSemaphoreZirconHandleFUCHSIA( vkGetInstanceProcAddr( instance, "vkGetSemaphoreZirconHandleFUCHSIA" ) );
14565 #endif /*VK_USE_PLATFORM_FUCHSIA*/
14566 
14567 #if defined( VK_USE_PLATFORM_FUCHSIA )
14568  //=== VK_FUCHSIA_buffer_collection ===
14569  vkCreateBufferCollectionFUCHSIA = PFN_vkCreateBufferCollectionFUCHSIA( vkGetInstanceProcAddr( instance, "vkCreateBufferCollectionFUCHSIA" ) );
14571  PFN_vkSetBufferCollectionImageConstraintsFUCHSIA( vkGetInstanceProcAddr( instance, "vkSetBufferCollectionImageConstraintsFUCHSIA" ) );
14573  PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA( vkGetInstanceProcAddr( instance, "vkSetBufferCollectionBufferConstraintsFUCHSIA" ) );
14574  vkDestroyBufferCollectionFUCHSIA = PFN_vkDestroyBufferCollectionFUCHSIA( vkGetInstanceProcAddr( instance, "vkDestroyBufferCollectionFUCHSIA" ) );
14576  PFN_vkGetBufferCollectionPropertiesFUCHSIA( vkGetInstanceProcAddr( instance, "vkGetBufferCollectionPropertiesFUCHSIA" ) );
14577 #endif /*VK_USE_PLATFORM_FUCHSIA*/
14578 
14579  //=== VK_HUAWEI_subpass_shading ===
14581  PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( vkGetInstanceProcAddr( instance, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI" ) );
14582  vkCmdSubpassShadingHUAWEI = PFN_vkCmdSubpassShadingHUAWEI( vkGetInstanceProcAddr( instance, "vkCmdSubpassShadingHUAWEI" ) );
14583 
14584  //=== VK_HUAWEI_invocation_mask ===
14585  vkCmdBindInvocationMaskHUAWEI = PFN_vkCmdBindInvocationMaskHUAWEI( vkGetInstanceProcAddr( instance, "vkCmdBindInvocationMaskHUAWEI" ) );
14586 
14587  //=== VK_NV_external_memory_rdma ===
14588  vkGetMemoryRemoteAddressNV = PFN_vkGetMemoryRemoteAddressNV( vkGetInstanceProcAddr( instance, "vkGetMemoryRemoteAddressNV" ) );
14589 
14590  //=== VK_EXT_pipeline_properties ===
14591  vkGetPipelinePropertiesEXT = PFN_vkGetPipelinePropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetPipelinePropertiesEXT" ) );
14592 
14593  //=== VK_EXT_extended_dynamic_state2 ===
14594  vkCmdSetPatchControlPointsEXT = PFN_vkCmdSetPatchControlPointsEXT( vkGetInstanceProcAddr( instance, "vkCmdSetPatchControlPointsEXT" ) );
14595  vkCmdSetRasterizerDiscardEnableEXT = PFN_vkCmdSetRasterizerDiscardEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetRasterizerDiscardEnableEXT" ) );
14598  vkCmdSetDepthBiasEnableEXT = PFN_vkCmdSetDepthBiasEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBiasEnableEXT" ) );
14599  if ( !vkCmdSetDepthBiasEnable )
14601  vkCmdSetLogicOpEXT = PFN_vkCmdSetLogicOpEXT( vkGetInstanceProcAddr( instance, "vkCmdSetLogicOpEXT" ) );
14602  vkCmdSetPrimitiveRestartEnableEXT = PFN_vkCmdSetPrimitiveRestartEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetPrimitiveRestartEnableEXT" ) );
14605 
14606 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
14607  //=== VK_QNX_screen_surface ===
14608  vkCreateScreenSurfaceQNX = PFN_vkCreateScreenSurfaceQNX( vkGetInstanceProcAddr( instance, "vkCreateScreenSurfaceQNX" ) );
14610  PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceScreenPresentationSupportQNX" ) );
14611 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
14612 
14613  //=== VK_EXT_color_write_enable ===
14614  vkCmdSetColorWriteEnableEXT = PFN_vkCmdSetColorWriteEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetColorWriteEnableEXT" ) );
14615 
14616  //=== VK_KHR_ray_tracing_maintenance1 ===
14617  vkCmdTraceRaysIndirect2KHR = PFN_vkCmdTraceRaysIndirect2KHR( vkGetInstanceProcAddr( instance, "vkCmdTraceRaysIndirect2KHR" ) );
14618 
14619  //=== VK_EXT_multi_draw ===
14620  vkCmdDrawMultiEXT = PFN_vkCmdDrawMultiEXT( vkGetInstanceProcAddr( instance, "vkCmdDrawMultiEXT" ) );
14621  vkCmdDrawMultiIndexedEXT = PFN_vkCmdDrawMultiIndexedEXT( vkGetInstanceProcAddr( instance, "vkCmdDrawMultiIndexedEXT" ) );
14622 
14623  //=== VK_EXT_opacity_micromap ===
14624  vkCreateMicromapEXT = PFN_vkCreateMicromapEXT( vkGetInstanceProcAddr( instance, "vkCreateMicromapEXT" ) );
14625  vkDestroyMicromapEXT = PFN_vkDestroyMicromapEXT( vkGetInstanceProcAddr( instance, "vkDestroyMicromapEXT" ) );
14626  vkCmdBuildMicromapsEXT = PFN_vkCmdBuildMicromapsEXT( vkGetInstanceProcAddr( instance, "vkCmdBuildMicromapsEXT" ) );
14627  vkBuildMicromapsEXT = PFN_vkBuildMicromapsEXT( vkGetInstanceProcAddr( instance, "vkBuildMicromapsEXT" ) );
14628  vkCopyMicromapEXT = PFN_vkCopyMicromapEXT( vkGetInstanceProcAddr( instance, "vkCopyMicromapEXT" ) );
14629  vkCopyMicromapToMemoryEXT = PFN_vkCopyMicromapToMemoryEXT( vkGetInstanceProcAddr( instance, "vkCopyMicromapToMemoryEXT" ) );
14630  vkCopyMemoryToMicromapEXT = PFN_vkCopyMemoryToMicromapEXT( vkGetInstanceProcAddr( instance, "vkCopyMemoryToMicromapEXT" ) );
14631  vkWriteMicromapsPropertiesEXT = PFN_vkWriteMicromapsPropertiesEXT( vkGetInstanceProcAddr( instance, "vkWriteMicromapsPropertiesEXT" ) );
14632  vkCmdCopyMicromapEXT = PFN_vkCmdCopyMicromapEXT( vkGetInstanceProcAddr( instance, "vkCmdCopyMicromapEXT" ) );
14633  vkCmdCopyMicromapToMemoryEXT = PFN_vkCmdCopyMicromapToMemoryEXT( vkGetInstanceProcAddr( instance, "vkCmdCopyMicromapToMemoryEXT" ) );
14634  vkCmdCopyMemoryToMicromapEXT = PFN_vkCmdCopyMemoryToMicromapEXT( vkGetInstanceProcAddr( instance, "vkCmdCopyMemoryToMicromapEXT" ) );
14635  vkCmdWriteMicromapsPropertiesEXT = PFN_vkCmdWriteMicromapsPropertiesEXT( vkGetInstanceProcAddr( instance, "vkCmdWriteMicromapsPropertiesEXT" ) );
14636  vkGetDeviceMicromapCompatibilityEXT = PFN_vkGetDeviceMicromapCompatibilityEXT( vkGetInstanceProcAddr( instance, "vkGetDeviceMicromapCompatibilityEXT" ) );
14637  vkGetMicromapBuildSizesEXT = PFN_vkGetMicromapBuildSizesEXT( vkGetInstanceProcAddr( instance, "vkGetMicromapBuildSizesEXT" ) );
14638 
14639  //=== VK_EXT_pageable_device_local_memory ===
14640  vkSetDeviceMemoryPriorityEXT = PFN_vkSetDeviceMemoryPriorityEXT( vkGetInstanceProcAddr( instance, "vkSetDeviceMemoryPriorityEXT" ) );
14641 
14642  //=== VK_KHR_maintenance4 ===
14644  PFN_vkGetDeviceBufferMemoryRequirementsKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceBufferMemoryRequirementsKHR" ) );
14648  PFN_vkGetDeviceImageMemoryRequirementsKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceImageMemoryRequirementsKHR" ) );
14652  PFN_vkGetDeviceImageSparseMemoryRequirementsKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceImageSparseMemoryRequirementsKHR" ) );
14655 
14656  //=== VK_VALVE_descriptor_set_host_mapping ===
14658  PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE( vkGetInstanceProcAddr( instance, "vkGetDescriptorSetLayoutHostMappingInfoVALVE" ) );
14659  vkGetDescriptorSetHostMappingVALVE = PFN_vkGetDescriptorSetHostMappingVALVE( vkGetInstanceProcAddr( instance, "vkGetDescriptorSetHostMappingVALVE" ) );
14660 
14661  //=== VK_NV_copy_memory_indirect ===
14662  vkCmdCopyMemoryIndirectNV = PFN_vkCmdCopyMemoryIndirectNV( vkGetInstanceProcAddr( instance, "vkCmdCopyMemoryIndirectNV" ) );
14663  vkCmdCopyMemoryToImageIndirectNV = PFN_vkCmdCopyMemoryToImageIndirectNV( vkGetInstanceProcAddr( instance, "vkCmdCopyMemoryToImageIndirectNV" ) );
14664 
14665  //=== VK_NV_memory_decompression ===
14666  vkCmdDecompressMemoryNV = PFN_vkCmdDecompressMemoryNV( vkGetInstanceProcAddr( instance, "vkCmdDecompressMemoryNV" ) );
14668  PFN_vkCmdDecompressMemoryIndirectCountNV( vkGetInstanceProcAddr( instance, "vkCmdDecompressMemoryIndirectCountNV" ) );
14669 
14670  //=== VK_EXT_extended_dynamic_state3 ===
14671  vkCmdSetTessellationDomainOriginEXT = PFN_vkCmdSetTessellationDomainOriginEXT( vkGetInstanceProcAddr( instance, "vkCmdSetTessellationDomainOriginEXT" ) );
14672  vkCmdSetDepthClampEnableEXT = PFN_vkCmdSetDepthClampEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthClampEnableEXT" ) );
14673  vkCmdSetPolygonModeEXT = PFN_vkCmdSetPolygonModeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetPolygonModeEXT" ) );
14674  vkCmdSetRasterizationSamplesEXT = PFN_vkCmdSetRasterizationSamplesEXT( vkGetInstanceProcAddr( instance, "vkCmdSetRasterizationSamplesEXT" ) );
14675  vkCmdSetSampleMaskEXT = PFN_vkCmdSetSampleMaskEXT( vkGetInstanceProcAddr( instance, "vkCmdSetSampleMaskEXT" ) );
14676  vkCmdSetAlphaToCoverageEnableEXT = PFN_vkCmdSetAlphaToCoverageEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetAlphaToCoverageEnableEXT" ) );
14677  vkCmdSetAlphaToOneEnableEXT = PFN_vkCmdSetAlphaToOneEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetAlphaToOneEnableEXT" ) );
14678  vkCmdSetLogicOpEnableEXT = PFN_vkCmdSetLogicOpEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetLogicOpEnableEXT" ) );
14679  vkCmdSetColorBlendEnableEXT = PFN_vkCmdSetColorBlendEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetColorBlendEnableEXT" ) );
14680  vkCmdSetColorBlendEquationEXT = PFN_vkCmdSetColorBlendEquationEXT( vkGetInstanceProcAddr( instance, "vkCmdSetColorBlendEquationEXT" ) );
14681  vkCmdSetColorWriteMaskEXT = PFN_vkCmdSetColorWriteMaskEXT( vkGetInstanceProcAddr( instance, "vkCmdSetColorWriteMaskEXT" ) );
14682  vkCmdSetRasterizationStreamEXT = PFN_vkCmdSetRasterizationStreamEXT( vkGetInstanceProcAddr( instance, "vkCmdSetRasterizationStreamEXT" ) );
14684  PFN_vkCmdSetConservativeRasterizationModeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetConservativeRasterizationModeEXT" ) );
14686  PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetExtraPrimitiveOverestimationSizeEXT" ) );
14687  vkCmdSetDepthClipEnableEXT = PFN_vkCmdSetDepthClipEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthClipEnableEXT" ) );
14688  vkCmdSetSampleLocationsEnableEXT = PFN_vkCmdSetSampleLocationsEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetSampleLocationsEnableEXT" ) );
14689  vkCmdSetColorBlendAdvancedEXT = PFN_vkCmdSetColorBlendAdvancedEXT( vkGetInstanceProcAddr( instance, "vkCmdSetColorBlendAdvancedEXT" ) );
14690  vkCmdSetProvokingVertexModeEXT = PFN_vkCmdSetProvokingVertexModeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetProvokingVertexModeEXT" ) );
14691  vkCmdSetLineRasterizationModeEXT = PFN_vkCmdSetLineRasterizationModeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetLineRasterizationModeEXT" ) );
14692  vkCmdSetLineStippleEnableEXT = PFN_vkCmdSetLineStippleEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetLineStippleEnableEXT" ) );
14694  PFN_vkCmdSetDepthClipNegativeOneToOneEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthClipNegativeOneToOneEXT" ) );
14695  vkCmdSetViewportWScalingEnableNV = PFN_vkCmdSetViewportWScalingEnableNV( vkGetInstanceProcAddr( instance, "vkCmdSetViewportWScalingEnableNV" ) );
14696  vkCmdSetViewportSwizzleNV = PFN_vkCmdSetViewportSwizzleNV( vkGetInstanceProcAddr( instance, "vkCmdSetViewportSwizzleNV" ) );
14697  vkCmdSetCoverageToColorEnableNV = PFN_vkCmdSetCoverageToColorEnableNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoverageToColorEnableNV" ) );
14698  vkCmdSetCoverageToColorLocationNV = PFN_vkCmdSetCoverageToColorLocationNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoverageToColorLocationNV" ) );
14699  vkCmdSetCoverageModulationModeNV = PFN_vkCmdSetCoverageModulationModeNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoverageModulationModeNV" ) );
14701  PFN_vkCmdSetCoverageModulationTableEnableNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoverageModulationTableEnableNV" ) );
14702  vkCmdSetCoverageModulationTableNV = PFN_vkCmdSetCoverageModulationTableNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoverageModulationTableNV" ) );
14703  vkCmdSetShadingRateImageEnableNV = PFN_vkCmdSetShadingRateImageEnableNV( vkGetInstanceProcAddr( instance, "vkCmdSetShadingRateImageEnableNV" ) );
14705  PFN_vkCmdSetRepresentativeFragmentTestEnableNV( vkGetInstanceProcAddr( instance, "vkCmdSetRepresentativeFragmentTestEnableNV" ) );
14706  vkCmdSetCoverageReductionModeNV = PFN_vkCmdSetCoverageReductionModeNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoverageReductionModeNV" ) );
14707 
14708  //=== VK_EXT_shader_module_identifier ===
14709  vkGetShaderModuleIdentifierEXT = PFN_vkGetShaderModuleIdentifierEXT( vkGetInstanceProcAddr( instance, "vkGetShaderModuleIdentifierEXT" ) );
14711  PFN_vkGetShaderModuleCreateInfoIdentifierEXT( vkGetInstanceProcAddr( instance, "vkGetShaderModuleCreateInfoIdentifierEXT" ) );
14712 
14713  //=== VK_NV_optical_flow ===
14715  PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceOpticalFlowImageFormatsNV" ) );
14716  vkCreateOpticalFlowSessionNV = PFN_vkCreateOpticalFlowSessionNV( vkGetInstanceProcAddr( instance, "vkCreateOpticalFlowSessionNV" ) );
14717  vkDestroyOpticalFlowSessionNV = PFN_vkDestroyOpticalFlowSessionNV( vkGetInstanceProcAddr( instance, "vkDestroyOpticalFlowSessionNV" ) );
14718  vkBindOpticalFlowSessionImageNV = PFN_vkBindOpticalFlowSessionImageNV( vkGetInstanceProcAddr( instance, "vkBindOpticalFlowSessionImageNV" ) );
14719  vkCmdOpticalFlowExecuteNV = PFN_vkCmdOpticalFlowExecuteNV( vkGetInstanceProcAddr( instance, "vkCmdOpticalFlowExecuteNV" ) );
14720 
14721  //=== VK_QCOM_tile_properties ===
14722  vkGetFramebufferTilePropertiesQCOM = PFN_vkGetFramebufferTilePropertiesQCOM( vkGetInstanceProcAddr( instance, "vkGetFramebufferTilePropertiesQCOM" ) );
14724  PFN_vkGetDynamicRenderingTilePropertiesQCOM( vkGetInstanceProcAddr( instance, "vkGetDynamicRenderingTilePropertiesQCOM" ) );
14725  }
14726 
14728  {
14729  VkDevice device = static_cast<VkDevice>( deviceCpp );
14730 
14731  //=== VK_VERSION_1_0 ===
14732  vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr( vkGetDeviceProcAddr( device, "vkGetDeviceProcAddr" ) );
14733  vkDestroyDevice = PFN_vkDestroyDevice( vkGetDeviceProcAddr( device, "vkDestroyDevice" ) );
14734  vkGetDeviceQueue = PFN_vkGetDeviceQueue( vkGetDeviceProcAddr( device, "vkGetDeviceQueue" ) );
14735  vkQueueSubmit = PFN_vkQueueSubmit( vkGetDeviceProcAddr( device, "vkQueueSubmit" ) );
14736  vkQueueWaitIdle = PFN_vkQueueWaitIdle( vkGetDeviceProcAddr( device, "vkQueueWaitIdle" ) );
14737  vkDeviceWaitIdle = PFN_vkDeviceWaitIdle( vkGetDeviceProcAddr( device, "vkDeviceWaitIdle" ) );
14738  vkAllocateMemory = PFN_vkAllocateMemory( vkGetDeviceProcAddr( device, "vkAllocateMemory" ) );
14739  vkFreeMemory = PFN_vkFreeMemory( vkGetDeviceProcAddr( device, "vkFreeMemory" ) );
14740  vkMapMemory = PFN_vkMapMemory( vkGetDeviceProcAddr( device, "vkMapMemory" ) );
14741  vkUnmapMemory = PFN_vkUnmapMemory( vkGetDeviceProcAddr( device, "vkUnmapMemory" ) );
14742  vkFlushMappedMemoryRanges = PFN_vkFlushMappedMemoryRanges( vkGetDeviceProcAddr( device, "vkFlushMappedMemoryRanges" ) );
14743  vkInvalidateMappedMemoryRanges = PFN_vkInvalidateMappedMemoryRanges( vkGetDeviceProcAddr( device, "vkInvalidateMappedMemoryRanges" ) );
14744  vkGetDeviceMemoryCommitment = PFN_vkGetDeviceMemoryCommitment( vkGetDeviceProcAddr( device, "vkGetDeviceMemoryCommitment" ) );
14745  vkBindBufferMemory = PFN_vkBindBufferMemory( vkGetDeviceProcAddr( device, "vkBindBufferMemory" ) );
14746  vkBindImageMemory = PFN_vkBindImageMemory( vkGetDeviceProcAddr( device, "vkBindImageMemory" ) );
14747  vkGetBufferMemoryRequirements = PFN_vkGetBufferMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements" ) );
14748  vkGetImageMemoryRequirements = PFN_vkGetImageMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements" ) );
14749  vkGetImageSparseMemoryRequirements = PFN_vkGetImageSparseMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements" ) );
14750  vkQueueBindSparse = PFN_vkQueueBindSparse( vkGetDeviceProcAddr( device, "vkQueueBindSparse" ) );
14751  vkCreateFence = PFN_vkCreateFence( vkGetDeviceProcAddr( device, "vkCreateFence" ) );
14752  vkDestroyFence = PFN_vkDestroyFence( vkGetDeviceProcAddr( device, "vkDestroyFence" ) );
14753  vkResetFences = PFN_vkResetFences( vkGetDeviceProcAddr( device, "vkResetFences" ) );
14754  vkGetFenceStatus = PFN_vkGetFenceStatus( vkGetDeviceProcAddr( device, "vkGetFenceStatus" ) );
14755  vkWaitForFences = PFN_vkWaitForFences( vkGetDeviceProcAddr( device, "vkWaitForFences" ) );
14756  vkCreateSemaphore = PFN_vkCreateSemaphore( vkGetDeviceProcAddr( device, "vkCreateSemaphore" ) );
14757  vkDestroySemaphore = PFN_vkDestroySemaphore( vkGetDeviceProcAddr( device, "vkDestroySemaphore" ) );
14758  vkCreateEvent = PFN_vkCreateEvent( vkGetDeviceProcAddr( device, "vkCreateEvent" ) );
14759  vkDestroyEvent = PFN_vkDestroyEvent( vkGetDeviceProcAddr( device, "vkDestroyEvent" ) );
14760  vkGetEventStatus = PFN_vkGetEventStatus( vkGetDeviceProcAddr( device, "vkGetEventStatus" ) );
14761  vkSetEvent = PFN_vkSetEvent( vkGetDeviceProcAddr( device, "vkSetEvent" ) );
14762  vkResetEvent = PFN_vkResetEvent( vkGetDeviceProcAddr( device, "vkResetEvent" ) );
14763  vkCreateQueryPool = PFN_vkCreateQueryPool( vkGetDeviceProcAddr( device, "vkCreateQueryPool" ) );
14764  vkDestroyQueryPool = PFN_vkDestroyQueryPool( vkGetDeviceProcAddr( device, "vkDestroyQueryPool" ) );
14765  vkGetQueryPoolResults = PFN_vkGetQueryPoolResults( vkGetDeviceProcAddr( device, "vkGetQueryPoolResults" ) );
14766  vkCreateBuffer = PFN_vkCreateBuffer( vkGetDeviceProcAddr( device, "vkCreateBuffer" ) );
14767  vkDestroyBuffer = PFN_vkDestroyBuffer( vkGetDeviceProcAddr( device, "vkDestroyBuffer" ) );
14768  vkCreateBufferView = PFN_vkCreateBufferView( vkGetDeviceProcAddr( device, "vkCreateBufferView" ) );
14769  vkDestroyBufferView = PFN_vkDestroyBufferView( vkGetDeviceProcAddr( device, "vkDestroyBufferView" ) );
14770  vkCreateImage = PFN_vkCreateImage( vkGetDeviceProcAddr( device, "vkCreateImage" ) );
14771  vkDestroyImage = PFN_vkDestroyImage( vkGetDeviceProcAddr( device, "vkDestroyImage" ) );
14772  vkGetImageSubresourceLayout = PFN_vkGetImageSubresourceLayout( vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout" ) );
14773  vkCreateImageView = PFN_vkCreateImageView( vkGetDeviceProcAddr( device, "vkCreateImageView" ) );
14774  vkDestroyImageView = PFN_vkDestroyImageView( vkGetDeviceProcAddr( device, "vkDestroyImageView" ) );
14775  vkCreateShaderModule = PFN_vkCreateShaderModule( vkGetDeviceProcAddr( device, "vkCreateShaderModule" ) );
14776  vkDestroyShaderModule = PFN_vkDestroyShaderModule( vkGetDeviceProcAddr( device, "vkDestroyShaderModule" ) );
14777  vkCreatePipelineCache = PFN_vkCreatePipelineCache( vkGetDeviceProcAddr( device, "vkCreatePipelineCache" ) );
14778  vkDestroyPipelineCache = PFN_vkDestroyPipelineCache( vkGetDeviceProcAddr( device, "vkDestroyPipelineCache" ) );
14779  vkGetPipelineCacheData = PFN_vkGetPipelineCacheData( vkGetDeviceProcAddr( device, "vkGetPipelineCacheData" ) );
14780  vkMergePipelineCaches = PFN_vkMergePipelineCaches( vkGetDeviceProcAddr( device, "vkMergePipelineCaches" ) );
14781  vkCreateGraphicsPipelines = PFN_vkCreateGraphicsPipelines( vkGetDeviceProcAddr( device, "vkCreateGraphicsPipelines" ) );
14782  vkCreateComputePipelines = PFN_vkCreateComputePipelines( vkGetDeviceProcAddr( device, "vkCreateComputePipelines" ) );
14783  vkDestroyPipeline = PFN_vkDestroyPipeline( vkGetDeviceProcAddr( device, "vkDestroyPipeline" ) );
14784  vkCreatePipelineLayout = PFN_vkCreatePipelineLayout( vkGetDeviceProcAddr( device, "vkCreatePipelineLayout" ) );
14785  vkDestroyPipelineLayout = PFN_vkDestroyPipelineLayout( vkGetDeviceProcAddr( device, "vkDestroyPipelineLayout" ) );
14786  vkCreateSampler = PFN_vkCreateSampler( vkGetDeviceProcAddr( device, "vkCreateSampler" ) );
14787  vkDestroySampler = PFN_vkDestroySampler( vkGetDeviceProcAddr( device, "vkDestroySampler" ) );
14788  vkCreateDescriptorSetLayout = PFN_vkCreateDescriptorSetLayout( vkGetDeviceProcAddr( device, "vkCreateDescriptorSetLayout" ) );
14789  vkDestroyDescriptorSetLayout = PFN_vkDestroyDescriptorSetLayout( vkGetDeviceProcAddr( device, "vkDestroyDescriptorSetLayout" ) );
14790  vkCreateDescriptorPool = PFN_vkCreateDescriptorPool( vkGetDeviceProcAddr( device, "vkCreateDescriptorPool" ) );
14791  vkDestroyDescriptorPool = PFN_vkDestroyDescriptorPool( vkGetDeviceProcAddr( device, "vkDestroyDescriptorPool" ) );
14792  vkResetDescriptorPool = PFN_vkResetDescriptorPool( vkGetDeviceProcAddr( device, "vkResetDescriptorPool" ) );
14793  vkAllocateDescriptorSets = PFN_vkAllocateDescriptorSets( vkGetDeviceProcAddr( device, "vkAllocateDescriptorSets" ) );
14794  vkFreeDescriptorSets = PFN_vkFreeDescriptorSets( vkGetDeviceProcAddr( device, "vkFreeDescriptorSets" ) );
14795  vkUpdateDescriptorSets = PFN_vkUpdateDescriptorSets( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSets" ) );
14796  vkCreateFramebuffer = PFN_vkCreateFramebuffer( vkGetDeviceProcAddr( device, "vkCreateFramebuffer" ) );
14797  vkDestroyFramebuffer = PFN_vkDestroyFramebuffer( vkGetDeviceProcAddr( device, "vkDestroyFramebuffer" ) );
14798  vkCreateRenderPass = PFN_vkCreateRenderPass( vkGetDeviceProcAddr( device, "vkCreateRenderPass" ) );
14799  vkDestroyRenderPass = PFN_vkDestroyRenderPass( vkGetDeviceProcAddr( device, "vkDestroyRenderPass" ) );
14800  vkGetRenderAreaGranularity = PFN_vkGetRenderAreaGranularity( vkGetDeviceProcAddr( device, "vkGetRenderAreaGranularity" ) );
14801  vkCreateCommandPool = PFN_vkCreateCommandPool( vkGetDeviceProcAddr( device, "vkCreateCommandPool" ) );
14802  vkDestroyCommandPool = PFN_vkDestroyCommandPool( vkGetDeviceProcAddr( device, "vkDestroyCommandPool" ) );
14803  vkResetCommandPool = PFN_vkResetCommandPool( vkGetDeviceProcAddr( device, "vkResetCommandPool" ) );
14804  vkAllocateCommandBuffers = PFN_vkAllocateCommandBuffers( vkGetDeviceProcAddr( device, "vkAllocateCommandBuffers" ) );
14805  vkFreeCommandBuffers = PFN_vkFreeCommandBuffers( vkGetDeviceProcAddr( device, "vkFreeCommandBuffers" ) );
14806  vkBeginCommandBuffer = PFN_vkBeginCommandBuffer( vkGetDeviceProcAddr( device, "vkBeginCommandBuffer" ) );
14807  vkEndCommandBuffer = PFN_vkEndCommandBuffer( vkGetDeviceProcAddr( device, "vkEndCommandBuffer" ) );
14808  vkResetCommandBuffer = PFN_vkResetCommandBuffer( vkGetDeviceProcAddr( device, "vkResetCommandBuffer" ) );
14809  vkCmdBindPipeline = PFN_vkCmdBindPipeline( vkGetDeviceProcAddr( device, "vkCmdBindPipeline" ) );
14810  vkCmdSetViewport = PFN_vkCmdSetViewport( vkGetDeviceProcAddr( device, "vkCmdSetViewport" ) );
14811  vkCmdSetScissor = PFN_vkCmdSetScissor( vkGetDeviceProcAddr( device, "vkCmdSetScissor" ) );
14812  vkCmdSetLineWidth = PFN_vkCmdSetLineWidth( vkGetDeviceProcAddr( device, "vkCmdSetLineWidth" ) );
14813  vkCmdSetDepthBias = PFN_vkCmdSetDepthBias( vkGetDeviceProcAddr( device, "vkCmdSetDepthBias" ) );
14814  vkCmdSetBlendConstants = PFN_vkCmdSetBlendConstants( vkGetDeviceProcAddr( device, "vkCmdSetBlendConstants" ) );
14815  vkCmdSetDepthBounds = PFN_vkCmdSetDepthBounds( vkGetDeviceProcAddr( device, "vkCmdSetDepthBounds" ) );
14816  vkCmdSetStencilCompareMask = PFN_vkCmdSetStencilCompareMask( vkGetDeviceProcAddr( device, "vkCmdSetStencilCompareMask" ) );
14817  vkCmdSetStencilWriteMask = PFN_vkCmdSetStencilWriteMask( vkGetDeviceProcAddr( device, "vkCmdSetStencilWriteMask" ) );
14818  vkCmdSetStencilReference = PFN_vkCmdSetStencilReference( vkGetDeviceProcAddr( device, "vkCmdSetStencilReference" ) );
14819  vkCmdBindDescriptorSets = PFN_vkCmdBindDescriptorSets( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorSets" ) );
14820  vkCmdBindIndexBuffer = PFN_vkCmdBindIndexBuffer( vkGetDeviceProcAddr( device, "vkCmdBindIndexBuffer" ) );
14821  vkCmdBindVertexBuffers = PFN_vkCmdBindVertexBuffers( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers" ) );
14822  vkCmdDraw = PFN_vkCmdDraw( vkGetDeviceProcAddr( device, "vkCmdDraw" ) );
14823  vkCmdDrawIndexed = PFN_vkCmdDrawIndexed( vkGetDeviceProcAddr( device, "vkCmdDrawIndexed" ) );
14824  vkCmdDrawIndirect = PFN_vkCmdDrawIndirect( vkGetDeviceProcAddr( device, "vkCmdDrawIndirect" ) );
14825  vkCmdDrawIndexedIndirect = PFN_vkCmdDrawIndexedIndirect( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirect" ) );
14826  vkCmdDispatch = PFN_vkCmdDispatch( vkGetDeviceProcAddr( device, "vkCmdDispatch" ) );
14827  vkCmdDispatchIndirect = PFN_vkCmdDispatchIndirect( vkGetDeviceProcAddr( device, "vkCmdDispatchIndirect" ) );
14828  vkCmdCopyBuffer = PFN_vkCmdCopyBuffer( vkGetDeviceProcAddr( device, "vkCmdCopyBuffer" ) );
14829  vkCmdCopyImage = PFN_vkCmdCopyImage( vkGetDeviceProcAddr( device, "vkCmdCopyImage" ) );
14830  vkCmdBlitImage = PFN_vkCmdBlitImage( vkGetDeviceProcAddr( device, "vkCmdBlitImage" ) );
14831  vkCmdCopyBufferToImage = PFN_vkCmdCopyBufferToImage( vkGetDeviceProcAddr( device, "vkCmdCopyBufferToImage" ) );
14832  vkCmdCopyImageToBuffer = PFN_vkCmdCopyImageToBuffer( vkGetDeviceProcAddr( device, "vkCmdCopyImageToBuffer" ) );
14833  vkCmdUpdateBuffer = PFN_vkCmdUpdateBuffer( vkGetDeviceProcAddr( device, "vkCmdUpdateBuffer" ) );
14834  vkCmdFillBuffer = PFN_vkCmdFillBuffer( vkGetDeviceProcAddr( device, "vkCmdFillBuffer" ) );
14835  vkCmdClearColorImage = PFN_vkCmdClearColorImage( vkGetDeviceProcAddr( device, "vkCmdClearColorImage" ) );
14836  vkCmdClearDepthStencilImage = PFN_vkCmdClearDepthStencilImage( vkGetDeviceProcAddr( device, "vkCmdClearDepthStencilImage" ) );
14837  vkCmdClearAttachments = PFN_vkCmdClearAttachments( vkGetDeviceProcAddr( device, "vkCmdClearAttachments" ) );
14838  vkCmdResolveImage = PFN_vkCmdResolveImage( vkGetDeviceProcAddr( device, "vkCmdResolveImage" ) );
14839  vkCmdSetEvent = PFN_vkCmdSetEvent( vkGetDeviceProcAddr( device, "vkCmdSetEvent" ) );
14840  vkCmdResetEvent = PFN_vkCmdResetEvent( vkGetDeviceProcAddr( device, "vkCmdResetEvent" ) );
14841  vkCmdWaitEvents = PFN_vkCmdWaitEvents( vkGetDeviceProcAddr( device, "vkCmdWaitEvents" ) );
14842  vkCmdPipelineBarrier = PFN_vkCmdPipelineBarrier( vkGetDeviceProcAddr( device, "vkCmdPipelineBarrier" ) );
14843  vkCmdBeginQuery = PFN_vkCmdBeginQuery( vkGetDeviceProcAddr( device, "vkCmdBeginQuery" ) );
14844  vkCmdEndQuery = PFN_vkCmdEndQuery( vkGetDeviceProcAddr( device, "vkCmdEndQuery" ) );
14845  vkCmdResetQueryPool = PFN_vkCmdResetQueryPool( vkGetDeviceProcAddr( device, "vkCmdResetQueryPool" ) );
14846  vkCmdWriteTimestamp = PFN_vkCmdWriteTimestamp( vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp" ) );
14847  vkCmdCopyQueryPoolResults = PFN_vkCmdCopyQueryPoolResults( vkGetDeviceProcAddr( device, "vkCmdCopyQueryPoolResults" ) );
14848  vkCmdPushConstants = PFN_vkCmdPushConstants( vkGetDeviceProcAddr( device, "vkCmdPushConstants" ) );
14849  vkCmdBeginRenderPass = PFN_vkCmdBeginRenderPass( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass" ) );
14850  vkCmdNextSubpass = PFN_vkCmdNextSubpass( vkGetDeviceProcAddr( device, "vkCmdNextSubpass" ) );
14851  vkCmdEndRenderPass = PFN_vkCmdEndRenderPass( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass" ) );
14852  vkCmdExecuteCommands = PFN_vkCmdExecuteCommands( vkGetDeviceProcAddr( device, "vkCmdExecuteCommands" ) );
14853 
14854  //=== VK_VERSION_1_1 ===
14855  vkBindBufferMemory2 = PFN_vkBindBufferMemory2( vkGetDeviceProcAddr( device, "vkBindBufferMemory2" ) );
14856  vkBindImageMemory2 = PFN_vkBindImageMemory2( vkGetDeviceProcAddr( device, "vkBindImageMemory2" ) );
14857  vkGetDeviceGroupPeerMemoryFeatures = PFN_vkGetDeviceGroupPeerMemoryFeatures( vkGetDeviceProcAddr( device, "vkGetDeviceGroupPeerMemoryFeatures" ) );
14858  vkCmdSetDeviceMask = PFN_vkCmdSetDeviceMask( vkGetDeviceProcAddr( device, "vkCmdSetDeviceMask" ) );
14859  vkCmdDispatchBase = PFN_vkCmdDispatchBase( vkGetDeviceProcAddr( device, "vkCmdDispatchBase" ) );
14860  vkGetImageMemoryRequirements2 = PFN_vkGetImageMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements2" ) );
14861  vkGetBufferMemoryRequirements2 = PFN_vkGetBufferMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements2" ) );
14862  vkGetImageSparseMemoryRequirements2 = PFN_vkGetImageSparseMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements2" ) );
14863  vkTrimCommandPool = PFN_vkTrimCommandPool( vkGetDeviceProcAddr( device, "vkTrimCommandPool" ) );
14864  vkGetDeviceQueue2 = PFN_vkGetDeviceQueue2( vkGetDeviceProcAddr( device, "vkGetDeviceQueue2" ) );
14865  vkCreateSamplerYcbcrConversion = PFN_vkCreateSamplerYcbcrConversion( vkGetDeviceProcAddr( device, "vkCreateSamplerYcbcrConversion" ) );
14866  vkDestroySamplerYcbcrConversion = PFN_vkDestroySamplerYcbcrConversion( vkGetDeviceProcAddr( device, "vkDestroySamplerYcbcrConversion" ) );
14867  vkCreateDescriptorUpdateTemplate = PFN_vkCreateDescriptorUpdateTemplate( vkGetDeviceProcAddr( device, "vkCreateDescriptorUpdateTemplate" ) );
14868  vkDestroyDescriptorUpdateTemplate = PFN_vkDestroyDescriptorUpdateTemplate( vkGetDeviceProcAddr( device, "vkDestroyDescriptorUpdateTemplate" ) );
14869  vkUpdateDescriptorSetWithTemplate = PFN_vkUpdateDescriptorSetWithTemplate( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSetWithTemplate" ) );
14870  vkGetDescriptorSetLayoutSupport = PFN_vkGetDescriptorSetLayoutSupport( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSupport" ) );
14871 
14872  //=== VK_VERSION_1_2 ===
14873  vkCmdDrawIndirectCount = PFN_vkCmdDrawIndirectCount( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCount" ) );
14874  vkCmdDrawIndexedIndirectCount = PFN_vkCmdDrawIndexedIndirectCount( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCount" ) );
14875  vkCreateRenderPass2 = PFN_vkCreateRenderPass2( vkGetDeviceProcAddr( device, "vkCreateRenderPass2" ) );
14876  vkCmdBeginRenderPass2 = PFN_vkCmdBeginRenderPass2( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass2" ) );
14877  vkCmdNextSubpass2 = PFN_vkCmdNextSubpass2( vkGetDeviceProcAddr( device, "vkCmdNextSubpass2" ) );
14878  vkCmdEndRenderPass2 = PFN_vkCmdEndRenderPass2( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass2" ) );
14879  vkResetQueryPool = PFN_vkResetQueryPool( vkGetDeviceProcAddr( device, "vkResetQueryPool" ) );
14880  vkGetSemaphoreCounterValue = PFN_vkGetSemaphoreCounterValue( vkGetDeviceProcAddr( device, "vkGetSemaphoreCounterValue" ) );
14881  vkWaitSemaphores = PFN_vkWaitSemaphores( vkGetDeviceProcAddr( device, "vkWaitSemaphores" ) );
14882  vkSignalSemaphore = PFN_vkSignalSemaphore( vkGetDeviceProcAddr( device, "vkSignalSemaphore" ) );
14883  vkGetBufferDeviceAddress = PFN_vkGetBufferDeviceAddress( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddress" ) );
14884  vkGetBufferOpaqueCaptureAddress = PFN_vkGetBufferOpaqueCaptureAddress( vkGetDeviceProcAddr( device, "vkGetBufferOpaqueCaptureAddress" ) );
14886  PFN_vkGetDeviceMemoryOpaqueCaptureAddress( vkGetDeviceProcAddr( device, "vkGetDeviceMemoryOpaqueCaptureAddress" ) );
14887 
14888  //=== VK_VERSION_1_3 ===
14889  vkCreatePrivateDataSlot = PFN_vkCreatePrivateDataSlot( vkGetDeviceProcAddr( device, "vkCreatePrivateDataSlot" ) );
14890  vkDestroyPrivateDataSlot = PFN_vkDestroyPrivateDataSlot( vkGetDeviceProcAddr( device, "vkDestroyPrivateDataSlot" ) );
14891  vkSetPrivateData = PFN_vkSetPrivateData( vkGetDeviceProcAddr( device, "vkSetPrivateData" ) );
14892  vkGetPrivateData = PFN_vkGetPrivateData( vkGetDeviceProcAddr( device, "vkGetPrivateData" ) );
14893  vkCmdSetEvent2 = PFN_vkCmdSetEvent2( vkGetDeviceProcAddr( device, "vkCmdSetEvent2" ) );
14894  vkCmdResetEvent2 = PFN_vkCmdResetEvent2( vkGetDeviceProcAddr( device, "vkCmdResetEvent2" ) );
14895  vkCmdWaitEvents2 = PFN_vkCmdWaitEvents2( vkGetDeviceProcAddr( device, "vkCmdWaitEvents2" ) );
14896  vkCmdPipelineBarrier2 = PFN_vkCmdPipelineBarrier2( vkGetDeviceProcAddr( device, "vkCmdPipelineBarrier2" ) );
14897  vkCmdWriteTimestamp2 = PFN_vkCmdWriteTimestamp2( vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp2" ) );
14898  vkQueueSubmit2 = PFN_vkQueueSubmit2( vkGetDeviceProcAddr( device, "vkQueueSubmit2" ) );
14899  vkCmdCopyBuffer2 = PFN_vkCmdCopyBuffer2( vkGetDeviceProcAddr( device, "vkCmdCopyBuffer2" ) );
14900  vkCmdCopyImage2 = PFN_vkCmdCopyImage2( vkGetDeviceProcAddr( device, "vkCmdCopyImage2" ) );
14901  vkCmdCopyBufferToImage2 = PFN_vkCmdCopyBufferToImage2( vkGetDeviceProcAddr( device, "vkCmdCopyBufferToImage2" ) );
14902  vkCmdCopyImageToBuffer2 = PFN_vkCmdCopyImageToBuffer2( vkGetDeviceProcAddr( device, "vkCmdCopyImageToBuffer2" ) );
14903  vkCmdBlitImage2 = PFN_vkCmdBlitImage2( vkGetDeviceProcAddr( device, "vkCmdBlitImage2" ) );
14904  vkCmdResolveImage2 = PFN_vkCmdResolveImage2( vkGetDeviceProcAddr( device, "vkCmdResolveImage2" ) );
14905  vkCmdBeginRendering = PFN_vkCmdBeginRendering( vkGetDeviceProcAddr( device, "vkCmdBeginRendering" ) );
14906  vkCmdEndRendering = PFN_vkCmdEndRendering( vkGetDeviceProcAddr( device, "vkCmdEndRendering" ) );
14907  vkCmdSetCullMode = PFN_vkCmdSetCullMode( vkGetDeviceProcAddr( device, "vkCmdSetCullMode" ) );
14908  vkCmdSetFrontFace = PFN_vkCmdSetFrontFace( vkGetDeviceProcAddr( device, "vkCmdSetFrontFace" ) );
14909  vkCmdSetPrimitiveTopology = PFN_vkCmdSetPrimitiveTopology( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveTopology" ) );
14910  vkCmdSetViewportWithCount = PFN_vkCmdSetViewportWithCount( vkGetDeviceProcAddr( device, "vkCmdSetViewportWithCount" ) );
14911  vkCmdSetScissorWithCount = PFN_vkCmdSetScissorWithCount( vkGetDeviceProcAddr( device, "vkCmdSetScissorWithCount" ) );
14912  vkCmdBindVertexBuffers2 = PFN_vkCmdBindVertexBuffers2( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers2" ) );
14913  vkCmdSetDepthTestEnable = PFN_vkCmdSetDepthTestEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthTestEnable" ) );
14914  vkCmdSetDepthWriteEnable = PFN_vkCmdSetDepthWriteEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthWriteEnable" ) );
14915  vkCmdSetDepthCompareOp = PFN_vkCmdSetDepthCompareOp( vkGetDeviceProcAddr( device, "vkCmdSetDepthCompareOp" ) );
14916  vkCmdSetDepthBoundsTestEnable = PFN_vkCmdSetDepthBoundsTestEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthBoundsTestEnable" ) );
14917  vkCmdSetStencilTestEnable = PFN_vkCmdSetStencilTestEnable( vkGetDeviceProcAddr( device, "vkCmdSetStencilTestEnable" ) );
14918  vkCmdSetStencilOp = PFN_vkCmdSetStencilOp( vkGetDeviceProcAddr( device, "vkCmdSetStencilOp" ) );
14919  vkCmdSetRasterizerDiscardEnable = PFN_vkCmdSetRasterizerDiscardEnable( vkGetDeviceProcAddr( device, "vkCmdSetRasterizerDiscardEnable" ) );
14920  vkCmdSetDepthBiasEnable = PFN_vkCmdSetDepthBiasEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthBiasEnable" ) );
14921  vkCmdSetPrimitiveRestartEnable = PFN_vkCmdSetPrimitiveRestartEnable( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveRestartEnable" ) );
14922  vkGetDeviceBufferMemoryRequirements = PFN_vkGetDeviceBufferMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetDeviceBufferMemoryRequirements" ) );
14923  vkGetDeviceImageMemoryRequirements = PFN_vkGetDeviceImageMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetDeviceImageMemoryRequirements" ) );
14925  PFN_vkGetDeviceImageSparseMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetDeviceImageSparseMemoryRequirements" ) );
14926 
14927  //=== VK_KHR_swapchain ===
14928  vkCreateSwapchainKHR = PFN_vkCreateSwapchainKHR( vkGetDeviceProcAddr( device, "vkCreateSwapchainKHR" ) );
14929  vkDestroySwapchainKHR = PFN_vkDestroySwapchainKHR( vkGetDeviceProcAddr( device, "vkDestroySwapchainKHR" ) );
14930  vkGetSwapchainImagesKHR = PFN_vkGetSwapchainImagesKHR( vkGetDeviceProcAddr( device, "vkGetSwapchainImagesKHR" ) );
14931  vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR( vkGetDeviceProcAddr( device, "vkAcquireNextImageKHR" ) );
14932  vkQueuePresentKHR = PFN_vkQueuePresentKHR( vkGetDeviceProcAddr( device, "vkQueuePresentKHR" ) );
14934  PFN_vkGetDeviceGroupPresentCapabilitiesKHR( vkGetDeviceProcAddr( device, "vkGetDeviceGroupPresentCapabilitiesKHR" ) );
14936  PFN_vkGetDeviceGroupSurfacePresentModesKHR( vkGetDeviceProcAddr( device, "vkGetDeviceGroupSurfacePresentModesKHR" ) );
14937  vkAcquireNextImage2KHR = PFN_vkAcquireNextImage2KHR( vkGetDeviceProcAddr( device, "vkAcquireNextImage2KHR" ) );
14938 
14939  //=== VK_KHR_display_swapchain ===
14940  vkCreateSharedSwapchainsKHR = PFN_vkCreateSharedSwapchainsKHR( vkGetDeviceProcAddr( device, "vkCreateSharedSwapchainsKHR" ) );
14941 
14942  //=== VK_EXT_debug_marker ===
14943  vkDebugMarkerSetObjectTagEXT = PFN_vkDebugMarkerSetObjectTagEXT( vkGetDeviceProcAddr( device, "vkDebugMarkerSetObjectTagEXT" ) );
14944  vkDebugMarkerSetObjectNameEXT = PFN_vkDebugMarkerSetObjectNameEXT( vkGetDeviceProcAddr( device, "vkDebugMarkerSetObjectNameEXT" ) );
14945  vkCmdDebugMarkerBeginEXT = PFN_vkCmdDebugMarkerBeginEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerBeginEXT" ) );
14946  vkCmdDebugMarkerEndEXT = PFN_vkCmdDebugMarkerEndEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerEndEXT" ) );
14947  vkCmdDebugMarkerInsertEXT = PFN_vkCmdDebugMarkerInsertEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerInsertEXT" ) );
14948 
14949 #if defined( VK_ENABLE_BETA_EXTENSIONS )
14950  //=== VK_KHR_video_queue ===
14951  vkCreateVideoSessionKHR = PFN_vkCreateVideoSessionKHR( vkGetDeviceProcAddr( device, "vkCreateVideoSessionKHR" ) );
14952  vkDestroyVideoSessionKHR = PFN_vkDestroyVideoSessionKHR( vkGetDeviceProcAddr( device, "vkDestroyVideoSessionKHR" ) );
14954  PFN_vkGetVideoSessionMemoryRequirementsKHR( vkGetDeviceProcAddr( device, "vkGetVideoSessionMemoryRequirementsKHR" ) );
14955  vkBindVideoSessionMemoryKHR = PFN_vkBindVideoSessionMemoryKHR( vkGetDeviceProcAddr( device, "vkBindVideoSessionMemoryKHR" ) );
14956  vkCreateVideoSessionParametersKHR = PFN_vkCreateVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkCreateVideoSessionParametersKHR" ) );
14957  vkUpdateVideoSessionParametersKHR = PFN_vkUpdateVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkUpdateVideoSessionParametersKHR" ) );
14958  vkDestroyVideoSessionParametersKHR = PFN_vkDestroyVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkDestroyVideoSessionParametersKHR" ) );
14959  vkCmdBeginVideoCodingKHR = PFN_vkCmdBeginVideoCodingKHR( vkGetDeviceProcAddr( device, "vkCmdBeginVideoCodingKHR" ) );
14960  vkCmdEndVideoCodingKHR = PFN_vkCmdEndVideoCodingKHR( vkGetDeviceProcAddr( device, "vkCmdEndVideoCodingKHR" ) );
14961  vkCmdControlVideoCodingKHR = PFN_vkCmdControlVideoCodingKHR( vkGetDeviceProcAddr( device, "vkCmdControlVideoCodingKHR" ) );
14962 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
14963 
14964 #if defined( VK_ENABLE_BETA_EXTENSIONS )
14965  //=== VK_KHR_video_decode_queue ===
14966  vkCmdDecodeVideoKHR = PFN_vkCmdDecodeVideoKHR( vkGetDeviceProcAddr( device, "vkCmdDecodeVideoKHR" ) );
14967 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
14968 
14969  //=== VK_EXT_transform_feedback ===
14970  vkCmdBindTransformFeedbackBuffersEXT = PFN_vkCmdBindTransformFeedbackBuffersEXT( vkGetDeviceProcAddr( device, "vkCmdBindTransformFeedbackBuffersEXT" ) );
14971  vkCmdBeginTransformFeedbackEXT = PFN_vkCmdBeginTransformFeedbackEXT( vkGetDeviceProcAddr( device, "vkCmdBeginTransformFeedbackEXT" ) );
14972  vkCmdEndTransformFeedbackEXT = PFN_vkCmdEndTransformFeedbackEXT( vkGetDeviceProcAddr( device, "vkCmdEndTransformFeedbackEXT" ) );
14973  vkCmdBeginQueryIndexedEXT = PFN_vkCmdBeginQueryIndexedEXT( vkGetDeviceProcAddr( device, "vkCmdBeginQueryIndexedEXT" ) );
14974  vkCmdEndQueryIndexedEXT = PFN_vkCmdEndQueryIndexedEXT( vkGetDeviceProcAddr( device, "vkCmdEndQueryIndexedEXT" ) );
14975  vkCmdDrawIndirectByteCountEXT = PFN_vkCmdDrawIndirectByteCountEXT( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectByteCountEXT" ) );
14976 
14977  //=== VK_NVX_binary_import ===
14978  vkCreateCuModuleNVX = PFN_vkCreateCuModuleNVX( vkGetDeviceProcAddr( device, "vkCreateCuModuleNVX" ) );
14979  vkCreateCuFunctionNVX = PFN_vkCreateCuFunctionNVX( vkGetDeviceProcAddr( device, "vkCreateCuFunctionNVX" ) );
14980  vkDestroyCuModuleNVX = PFN_vkDestroyCuModuleNVX( vkGetDeviceProcAddr( device, "vkDestroyCuModuleNVX" ) );
14981  vkDestroyCuFunctionNVX = PFN_vkDestroyCuFunctionNVX( vkGetDeviceProcAddr( device, "vkDestroyCuFunctionNVX" ) );
14982  vkCmdCuLaunchKernelNVX = PFN_vkCmdCuLaunchKernelNVX( vkGetDeviceProcAddr( device, "vkCmdCuLaunchKernelNVX" ) );
14983 
14984  //=== VK_NVX_image_view_handle ===
14985  vkGetImageViewHandleNVX = PFN_vkGetImageViewHandleNVX( vkGetDeviceProcAddr( device, "vkGetImageViewHandleNVX" ) );
14986  vkGetImageViewAddressNVX = PFN_vkGetImageViewAddressNVX( vkGetDeviceProcAddr( device, "vkGetImageViewAddressNVX" ) );
14987 
14988  //=== VK_AMD_draw_indirect_count ===
14989  vkCmdDrawIndirectCountAMD = PFN_vkCmdDrawIndirectCountAMD( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCountAMD" ) );
14990  if ( !vkCmdDrawIndirectCount )
14992  vkCmdDrawIndexedIndirectCountAMD = PFN_vkCmdDrawIndexedIndirectCountAMD( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCountAMD" ) );
14995 
14996  //=== VK_AMD_shader_info ===
14997  vkGetShaderInfoAMD = PFN_vkGetShaderInfoAMD( vkGetDeviceProcAddr( device, "vkGetShaderInfoAMD" ) );
14998 
14999  //=== VK_KHR_dynamic_rendering ===
15000  vkCmdBeginRenderingKHR = PFN_vkCmdBeginRenderingKHR( vkGetDeviceProcAddr( device, "vkCmdBeginRenderingKHR" ) );
15001  if ( !vkCmdBeginRendering )
15003  vkCmdEndRenderingKHR = PFN_vkCmdEndRenderingKHR( vkGetDeviceProcAddr( device, "vkCmdEndRenderingKHR" ) );
15004  if ( !vkCmdEndRendering )
15006 
15007 #if defined( VK_USE_PLATFORM_WIN32_KHR )
15008  //=== VK_NV_external_memory_win32 ===
15009  vkGetMemoryWin32HandleNV = PFN_vkGetMemoryWin32HandleNV( vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleNV" ) );
15010 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
15011 
15012  //=== VK_KHR_device_group ===
15014  PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR( vkGetDeviceProcAddr( device, "vkGetDeviceGroupPeerMemoryFeaturesKHR" ) );
15017  vkCmdSetDeviceMaskKHR = PFN_vkCmdSetDeviceMaskKHR( vkGetDeviceProcAddr( device, "vkCmdSetDeviceMaskKHR" ) );
15018  if ( !vkCmdSetDeviceMask )
15020  vkCmdDispatchBaseKHR = PFN_vkCmdDispatchBaseKHR( vkGetDeviceProcAddr( device, "vkCmdDispatchBaseKHR" ) );
15021  if ( !vkCmdDispatchBase )
15023 
15024  //=== VK_KHR_maintenance1 ===
15025  vkTrimCommandPoolKHR = PFN_vkTrimCommandPoolKHR( vkGetDeviceProcAddr( device, "vkTrimCommandPoolKHR" ) );
15026  if ( !vkTrimCommandPool )
15028 
15029 #if defined( VK_USE_PLATFORM_WIN32_KHR )
15030  //=== VK_KHR_external_memory_win32 ===
15031  vkGetMemoryWin32HandleKHR = PFN_vkGetMemoryWin32HandleKHR( vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleKHR" ) );
15032  vkGetMemoryWin32HandlePropertiesKHR = PFN_vkGetMemoryWin32HandlePropertiesKHR( vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandlePropertiesKHR" ) );
15033 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
15034 
15035  //=== VK_KHR_external_memory_fd ===
15036  vkGetMemoryFdKHR = PFN_vkGetMemoryFdKHR( vkGetDeviceProcAddr( device, "vkGetMemoryFdKHR" ) );
15037  vkGetMemoryFdPropertiesKHR = PFN_vkGetMemoryFdPropertiesKHR( vkGetDeviceProcAddr( device, "vkGetMemoryFdPropertiesKHR" ) );
15038 
15039 #if defined( VK_USE_PLATFORM_WIN32_KHR )
15040  //=== VK_KHR_external_semaphore_win32 ===
15041  vkImportSemaphoreWin32HandleKHR = PFN_vkImportSemaphoreWin32HandleKHR( vkGetDeviceProcAddr( device, "vkImportSemaphoreWin32HandleKHR" ) );
15042  vkGetSemaphoreWin32HandleKHR = PFN_vkGetSemaphoreWin32HandleKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreWin32HandleKHR" ) );
15043 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
15044 
15045  //=== VK_KHR_external_semaphore_fd ===
15046  vkImportSemaphoreFdKHR = PFN_vkImportSemaphoreFdKHR( vkGetDeviceProcAddr( device, "vkImportSemaphoreFdKHR" ) );
15047  vkGetSemaphoreFdKHR = PFN_vkGetSemaphoreFdKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreFdKHR" ) );
15048 
15049  //=== VK_KHR_push_descriptor ===
15050  vkCmdPushDescriptorSetKHR = PFN_vkCmdPushDescriptorSetKHR( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetKHR" ) );
15052  PFN_vkCmdPushDescriptorSetWithTemplateKHR( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetWithTemplateKHR" ) );
15053 
15054  //=== VK_EXT_conditional_rendering ===
15055  vkCmdBeginConditionalRenderingEXT = PFN_vkCmdBeginConditionalRenderingEXT( vkGetDeviceProcAddr( device, "vkCmdBeginConditionalRenderingEXT" ) );
15056  vkCmdEndConditionalRenderingEXT = PFN_vkCmdEndConditionalRenderingEXT( vkGetDeviceProcAddr( device, "vkCmdEndConditionalRenderingEXT" ) );
15057 
15058  //=== VK_KHR_descriptor_update_template ===
15059  vkCreateDescriptorUpdateTemplateKHR = PFN_vkCreateDescriptorUpdateTemplateKHR( vkGetDeviceProcAddr( device, "vkCreateDescriptorUpdateTemplateKHR" ) );
15062  vkDestroyDescriptorUpdateTemplateKHR = PFN_vkDestroyDescriptorUpdateTemplateKHR( vkGetDeviceProcAddr( device, "vkDestroyDescriptorUpdateTemplateKHR" ) );
15065  vkUpdateDescriptorSetWithTemplateKHR = PFN_vkUpdateDescriptorSetWithTemplateKHR( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSetWithTemplateKHR" ) );
15068 
15069  //=== VK_NV_clip_space_w_scaling ===
15070  vkCmdSetViewportWScalingNV = PFN_vkCmdSetViewportWScalingNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportWScalingNV" ) );
15071 
15072  //=== VK_EXT_display_control ===
15073  vkDisplayPowerControlEXT = PFN_vkDisplayPowerControlEXT( vkGetDeviceProcAddr( device, "vkDisplayPowerControlEXT" ) );
15074  vkRegisterDeviceEventEXT = PFN_vkRegisterDeviceEventEXT( vkGetDeviceProcAddr( device, "vkRegisterDeviceEventEXT" ) );
15075  vkRegisterDisplayEventEXT = PFN_vkRegisterDisplayEventEXT( vkGetDeviceProcAddr( device, "vkRegisterDisplayEventEXT" ) );
15076  vkGetSwapchainCounterEXT = PFN_vkGetSwapchainCounterEXT( vkGetDeviceProcAddr( device, "vkGetSwapchainCounterEXT" ) );
15077 
15078  //=== VK_GOOGLE_display_timing ===
15079  vkGetRefreshCycleDurationGOOGLE = PFN_vkGetRefreshCycleDurationGOOGLE( vkGetDeviceProcAddr( device, "vkGetRefreshCycleDurationGOOGLE" ) );
15080  vkGetPastPresentationTimingGOOGLE = PFN_vkGetPastPresentationTimingGOOGLE( vkGetDeviceProcAddr( device, "vkGetPastPresentationTimingGOOGLE" ) );
15081 
15082  //=== VK_EXT_discard_rectangles ===
15083  vkCmdSetDiscardRectangleEXT = PFN_vkCmdSetDiscardRectangleEXT( vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleEXT" ) );
15084 
15085  //=== VK_EXT_hdr_metadata ===
15086  vkSetHdrMetadataEXT = PFN_vkSetHdrMetadataEXT( vkGetDeviceProcAddr( device, "vkSetHdrMetadataEXT" ) );
15087 
15088  //=== VK_KHR_create_renderpass2 ===
15089  vkCreateRenderPass2KHR = PFN_vkCreateRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCreateRenderPass2KHR" ) );
15090  if ( !vkCreateRenderPass2 )
15092  vkCmdBeginRenderPass2KHR = PFN_vkCmdBeginRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass2KHR" ) );
15093  if ( !vkCmdBeginRenderPass2 )
15095  vkCmdNextSubpass2KHR = PFN_vkCmdNextSubpass2KHR( vkGetDeviceProcAddr( device, "vkCmdNextSubpass2KHR" ) );
15096  if ( !vkCmdNextSubpass2 )
15098  vkCmdEndRenderPass2KHR = PFN_vkCmdEndRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass2KHR" ) );
15099  if ( !vkCmdEndRenderPass2 )
15101 
15102  //=== VK_KHR_shared_presentable_image ===
15103  vkGetSwapchainStatusKHR = PFN_vkGetSwapchainStatusKHR( vkGetDeviceProcAddr( device, "vkGetSwapchainStatusKHR" ) );
15104 
15105 #if defined( VK_USE_PLATFORM_WIN32_KHR )
15106  //=== VK_KHR_external_fence_win32 ===
15107  vkImportFenceWin32HandleKHR = PFN_vkImportFenceWin32HandleKHR( vkGetDeviceProcAddr( device, "vkImportFenceWin32HandleKHR" ) );
15108  vkGetFenceWin32HandleKHR = PFN_vkGetFenceWin32HandleKHR( vkGetDeviceProcAddr( device, "vkGetFenceWin32HandleKHR" ) );
15109 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
15110 
15111  //=== VK_KHR_external_fence_fd ===
15112  vkImportFenceFdKHR = PFN_vkImportFenceFdKHR( vkGetDeviceProcAddr( device, "vkImportFenceFdKHR" ) );
15113  vkGetFenceFdKHR = PFN_vkGetFenceFdKHR( vkGetDeviceProcAddr( device, "vkGetFenceFdKHR" ) );
15114 
15115  //=== VK_KHR_performance_query ===
15116  vkAcquireProfilingLockKHR = PFN_vkAcquireProfilingLockKHR( vkGetDeviceProcAddr( device, "vkAcquireProfilingLockKHR" ) );
15117  vkReleaseProfilingLockKHR = PFN_vkReleaseProfilingLockKHR( vkGetDeviceProcAddr( device, "vkReleaseProfilingLockKHR" ) );
15118 
15119  //=== VK_EXT_debug_utils ===
15120  vkSetDebugUtilsObjectNameEXT = PFN_vkSetDebugUtilsObjectNameEXT( vkGetDeviceProcAddr( device, "vkSetDebugUtilsObjectNameEXT" ) );
15121  vkSetDebugUtilsObjectTagEXT = PFN_vkSetDebugUtilsObjectTagEXT( vkGetDeviceProcAddr( device, "vkSetDebugUtilsObjectTagEXT" ) );
15122  vkQueueBeginDebugUtilsLabelEXT = PFN_vkQueueBeginDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueBeginDebugUtilsLabelEXT" ) );
15123  vkQueueEndDebugUtilsLabelEXT = PFN_vkQueueEndDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueEndDebugUtilsLabelEXT" ) );
15124  vkQueueInsertDebugUtilsLabelEXT = PFN_vkQueueInsertDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueInsertDebugUtilsLabelEXT" ) );
15125  vkCmdBeginDebugUtilsLabelEXT = PFN_vkCmdBeginDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdBeginDebugUtilsLabelEXT" ) );
15126  vkCmdEndDebugUtilsLabelEXT = PFN_vkCmdEndDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdEndDebugUtilsLabelEXT" ) );
15127  vkCmdInsertDebugUtilsLabelEXT = PFN_vkCmdInsertDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdInsertDebugUtilsLabelEXT" ) );
15128 
15129 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
15130  //=== VK_ANDROID_external_memory_android_hardware_buffer ===
15132  PFN_vkGetAndroidHardwareBufferPropertiesANDROID( vkGetDeviceProcAddr( device, "vkGetAndroidHardwareBufferPropertiesANDROID" ) );
15134  PFN_vkGetMemoryAndroidHardwareBufferANDROID( vkGetDeviceProcAddr( device, "vkGetMemoryAndroidHardwareBufferANDROID" ) );
15135 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
15136 
15137  //=== VK_EXT_sample_locations ===
15138  vkCmdSetSampleLocationsEXT = PFN_vkCmdSetSampleLocationsEXT( vkGetDeviceProcAddr( device, "vkCmdSetSampleLocationsEXT" ) );
15139 
15140  //=== VK_KHR_get_memory_requirements2 ===
15141  vkGetImageMemoryRequirements2KHR = PFN_vkGetImageMemoryRequirements2KHR( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements2KHR" ) );
15144  vkGetBufferMemoryRequirements2KHR = PFN_vkGetBufferMemoryRequirements2KHR( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements2KHR" ) );
15148  PFN_vkGetImageSparseMemoryRequirements2KHR( vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements2KHR" ) );
15151 
15152  //=== VK_KHR_acceleration_structure ===
15153  vkCreateAccelerationStructureKHR = PFN_vkCreateAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCreateAccelerationStructureKHR" ) );
15154  vkDestroyAccelerationStructureKHR = PFN_vkDestroyAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkDestroyAccelerationStructureKHR" ) );
15155  vkCmdBuildAccelerationStructuresKHR = PFN_vkCmdBuildAccelerationStructuresKHR( vkGetDeviceProcAddr( device, "vkCmdBuildAccelerationStructuresKHR" ) );
15157  PFN_vkCmdBuildAccelerationStructuresIndirectKHR( vkGetDeviceProcAddr( device, "vkCmdBuildAccelerationStructuresIndirectKHR" ) );
15158  vkBuildAccelerationStructuresKHR = PFN_vkBuildAccelerationStructuresKHR( vkGetDeviceProcAddr( device, "vkBuildAccelerationStructuresKHR" ) );
15159  vkCopyAccelerationStructureKHR = PFN_vkCopyAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCopyAccelerationStructureKHR" ) );
15161  PFN_vkCopyAccelerationStructureToMemoryKHR( vkGetDeviceProcAddr( device, "vkCopyAccelerationStructureToMemoryKHR" ) );
15163  PFN_vkCopyMemoryToAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCopyMemoryToAccelerationStructureKHR" ) );
15165  PFN_vkWriteAccelerationStructuresPropertiesKHR( vkGetDeviceProcAddr( device, "vkWriteAccelerationStructuresPropertiesKHR" ) );
15166  vkCmdCopyAccelerationStructureKHR = PFN_vkCmdCopyAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCmdCopyAccelerationStructureKHR" ) );
15168  PFN_vkCmdCopyAccelerationStructureToMemoryKHR( vkGetDeviceProcAddr( device, "vkCmdCopyAccelerationStructureToMemoryKHR" ) );
15170  PFN_vkCmdCopyMemoryToAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToAccelerationStructureKHR" ) );
15172  PFN_vkGetAccelerationStructureDeviceAddressKHR( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureDeviceAddressKHR" ) );
15174  PFN_vkCmdWriteAccelerationStructuresPropertiesKHR( vkGetDeviceProcAddr( device, "vkCmdWriteAccelerationStructuresPropertiesKHR" ) );
15176  PFN_vkGetDeviceAccelerationStructureCompatibilityKHR( vkGetDeviceProcAddr( device, "vkGetDeviceAccelerationStructureCompatibilityKHR" ) );
15178  PFN_vkGetAccelerationStructureBuildSizesKHR( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureBuildSizesKHR" ) );
15179 
15180  //=== VK_KHR_sampler_ycbcr_conversion ===
15181  vkCreateSamplerYcbcrConversionKHR = PFN_vkCreateSamplerYcbcrConversionKHR( vkGetDeviceProcAddr( device, "vkCreateSamplerYcbcrConversionKHR" ) );
15184  vkDestroySamplerYcbcrConversionKHR = PFN_vkDestroySamplerYcbcrConversionKHR( vkGetDeviceProcAddr( device, "vkDestroySamplerYcbcrConversionKHR" ) );
15187 
15188  //=== VK_KHR_bind_memory2 ===
15189  vkBindBufferMemory2KHR = PFN_vkBindBufferMemory2KHR( vkGetDeviceProcAddr( device, "vkBindBufferMemory2KHR" ) );
15190  if ( !vkBindBufferMemory2 )
15192  vkBindImageMemory2KHR = PFN_vkBindImageMemory2KHR( vkGetDeviceProcAddr( device, "vkBindImageMemory2KHR" ) );
15193  if ( !vkBindImageMemory2 )
15195 
15196  //=== VK_EXT_image_drm_format_modifier ===
15198  PFN_vkGetImageDrmFormatModifierPropertiesEXT( vkGetDeviceProcAddr( device, "vkGetImageDrmFormatModifierPropertiesEXT" ) );
15199 
15200  //=== VK_EXT_validation_cache ===
15201  vkCreateValidationCacheEXT = PFN_vkCreateValidationCacheEXT( vkGetDeviceProcAddr( device, "vkCreateValidationCacheEXT" ) );
15202  vkDestroyValidationCacheEXT = PFN_vkDestroyValidationCacheEXT( vkGetDeviceProcAddr( device, "vkDestroyValidationCacheEXT" ) );
15203  vkMergeValidationCachesEXT = PFN_vkMergeValidationCachesEXT( vkGetDeviceProcAddr( device, "vkMergeValidationCachesEXT" ) );
15204  vkGetValidationCacheDataEXT = PFN_vkGetValidationCacheDataEXT( vkGetDeviceProcAddr( device, "vkGetValidationCacheDataEXT" ) );
15205 
15206  //=== VK_NV_shading_rate_image ===
15207  vkCmdBindShadingRateImageNV = PFN_vkCmdBindShadingRateImageNV( vkGetDeviceProcAddr( device, "vkCmdBindShadingRateImageNV" ) );
15208  vkCmdSetViewportShadingRatePaletteNV = PFN_vkCmdSetViewportShadingRatePaletteNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportShadingRatePaletteNV" ) );
15209  vkCmdSetCoarseSampleOrderNV = PFN_vkCmdSetCoarseSampleOrderNV( vkGetDeviceProcAddr( device, "vkCmdSetCoarseSampleOrderNV" ) );
15210 
15211  //=== VK_NV_ray_tracing ===
15212  vkCreateAccelerationStructureNV = PFN_vkCreateAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkCreateAccelerationStructureNV" ) );
15213  vkDestroyAccelerationStructureNV = PFN_vkDestroyAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkDestroyAccelerationStructureNV" ) );
15215  PFN_vkGetAccelerationStructureMemoryRequirementsNV( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureMemoryRequirementsNV" ) );
15216  vkBindAccelerationStructureMemoryNV = PFN_vkBindAccelerationStructureMemoryNV( vkGetDeviceProcAddr( device, "vkBindAccelerationStructureMemoryNV" ) );
15217  vkCmdBuildAccelerationStructureNV = PFN_vkCmdBuildAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkCmdBuildAccelerationStructureNV" ) );
15218  vkCmdCopyAccelerationStructureNV = PFN_vkCmdCopyAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkCmdCopyAccelerationStructureNV" ) );
15219  vkCmdTraceRaysNV = PFN_vkCmdTraceRaysNV( vkGetDeviceProcAddr( device, "vkCmdTraceRaysNV" ) );
15220  vkCreateRayTracingPipelinesNV = PFN_vkCreateRayTracingPipelinesNV( vkGetDeviceProcAddr( device, "vkCreateRayTracingPipelinesNV" ) );
15221  vkGetRayTracingShaderGroupHandlesNV = PFN_vkGetRayTracingShaderGroupHandlesNV( vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupHandlesNV" ) );
15224  vkGetAccelerationStructureHandleNV = PFN_vkGetAccelerationStructureHandleNV( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureHandleNV" ) );
15226  PFN_vkCmdWriteAccelerationStructuresPropertiesNV( vkGetDeviceProcAddr( device, "vkCmdWriteAccelerationStructuresPropertiesNV" ) );
15227  vkCompileDeferredNV = PFN_vkCompileDeferredNV( vkGetDeviceProcAddr( device, "vkCompileDeferredNV" ) );
15228 
15229  //=== VK_KHR_maintenance3 ===
15230  vkGetDescriptorSetLayoutSupportKHR = PFN_vkGetDescriptorSetLayoutSupportKHR( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSupportKHR" ) );
15233 
15234  //=== VK_KHR_draw_indirect_count ===
15235  vkCmdDrawIndirectCountKHR = PFN_vkCmdDrawIndirectCountKHR( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCountKHR" ) );
15236  if ( !vkCmdDrawIndirectCount )
15238  vkCmdDrawIndexedIndirectCountKHR = PFN_vkCmdDrawIndexedIndirectCountKHR( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCountKHR" ) );
15241 
15242  //=== VK_EXT_external_memory_host ===
15243  vkGetMemoryHostPointerPropertiesEXT = PFN_vkGetMemoryHostPointerPropertiesEXT( vkGetDeviceProcAddr( device, "vkGetMemoryHostPointerPropertiesEXT" ) );
15244 
15245  //=== VK_AMD_buffer_marker ===
15246  vkCmdWriteBufferMarkerAMD = PFN_vkCmdWriteBufferMarkerAMD( vkGetDeviceProcAddr( device, "vkCmdWriteBufferMarkerAMD" ) );
15247 
15248  //=== VK_EXT_calibrated_timestamps ===
15249  vkGetCalibratedTimestampsEXT = PFN_vkGetCalibratedTimestampsEXT( vkGetDeviceProcAddr( device, "vkGetCalibratedTimestampsEXT" ) );
15250 
15251  //=== VK_NV_mesh_shader ===
15252  vkCmdDrawMeshTasksNV = PFN_vkCmdDrawMeshTasksNV( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksNV" ) );
15253  vkCmdDrawMeshTasksIndirectNV = PFN_vkCmdDrawMeshTasksIndirectNV( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectNV" ) );
15254  vkCmdDrawMeshTasksIndirectCountNV = PFN_vkCmdDrawMeshTasksIndirectCountNV( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectCountNV" ) );
15255 
15256  //=== VK_NV_scissor_exclusive ===
15257  vkCmdSetExclusiveScissorNV = PFN_vkCmdSetExclusiveScissorNV( vkGetDeviceProcAddr( device, "vkCmdSetExclusiveScissorNV" ) );
15258 
15259  //=== VK_NV_device_diagnostic_checkpoints ===
15260  vkCmdSetCheckpointNV = PFN_vkCmdSetCheckpointNV( vkGetDeviceProcAddr( device, "vkCmdSetCheckpointNV" ) );
15261  vkGetQueueCheckpointDataNV = PFN_vkGetQueueCheckpointDataNV( vkGetDeviceProcAddr( device, "vkGetQueueCheckpointDataNV" ) );
15262 
15263  //=== VK_KHR_timeline_semaphore ===
15264  vkGetSemaphoreCounterValueKHR = PFN_vkGetSemaphoreCounterValueKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreCounterValueKHR" ) );
15267  vkWaitSemaphoresKHR = PFN_vkWaitSemaphoresKHR( vkGetDeviceProcAddr( device, "vkWaitSemaphoresKHR" ) );
15268  if ( !vkWaitSemaphores )
15270  vkSignalSemaphoreKHR = PFN_vkSignalSemaphoreKHR( vkGetDeviceProcAddr( device, "vkSignalSemaphoreKHR" ) );
15271  if ( !vkSignalSemaphore )
15273 
15274  //=== VK_INTEL_performance_query ===
15275  vkInitializePerformanceApiINTEL = PFN_vkInitializePerformanceApiINTEL( vkGetDeviceProcAddr( device, "vkInitializePerformanceApiINTEL" ) );
15276  vkUninitializePerformanceApiINTEL = PFN_vkUninitializePerformanceApiINTEL( vkGetDeviceProcAddr( device, "vkUninitializePerformanceApiINTEL" ) );
15277  vkCmdSetPerformanceMarkerINTEL = PFN_vkCmdSetPerformanceMarkerINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceMarkerINTEL" ) );
15278  vkCmdSetPerformanceStreamMarkerINTEL = PFN_vkCmdSetPerformanceStreamMarkerINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceStreamMarkerINTEL" ) );
15279  vkCmdSetPerformanceOverrideINTEL = PFN_vkCmdSetPerformanceOverrideINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceOverrideINTEL" ) );
15281  PFN_vkAcquirePerformanceConfigurationINTEL( vkGetDeviceProcAddr( device, "vkAcquirePerformanceConfigurationINTEL" ) );
15283  PFN_vkReleasePerformanceConfigurationINTEL( vkGetDeviceProcAddr( device, "vkReleasePerformanceConfigurationINTEL" ) );
15285  PFN_vkQueueSetPerformanceConfigurationINTEL( vkGetDeviceProcAddr( device, "vkQueueSetPerformanceConfigurationINTEL" ) );
15286  vkGetPerformanceParameterINTEL = PFN_vkGetPerformanceParameterINTEL( vkGetDeviceProcAddr( device, "vkGetPerformanceParameterINTEL" ) );
15287 
15288  //=== VK_AMD_display_native_hdr ===
15289  vkSetLocalDimmingAMD = PFN_vkSetLocalDimmingAMD( vkGetDeviceProcAddr( device, "vkSetLocalDimmingAMD" ) );
15290 
15291  //=== VK_KHR_fragment_shading_rate ===
15292  vkCmdSetFragmentShadingRateKHR = PFN_vkCmdSetFragmentShadingRateKHR( vkGetDeviceProcAddr( device, "vkCmdSetFragmentShadingRateKHR" ) );
15293 
15294  //=== VK_EXT_buffer_device_address ===
15295  vkGetBufferDeviceAddressEXT = PFN_vkGetBufferDeviceAddressEXT( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddressEXT" ) );
15296  if ( !vkGetBufferDeviceAddress )
15298 
15299  //=== VK_KHR_present_wait ===
15300  vkWaitForPresentKHR = PFN_vkWaitForPresentKHR( vkGetDeviceProcAddr( device, "vkWaitForPresentKHR" ) );
15301 
15302 #if defined( VK_USE_PLATFORM_WIN32_KHR )
15303  //=== VK_EXT_full_screen_exclusive ===
15304  vkAcquireFullScreenExclusiveModeEXT = PFN_vkAcquireFullScreenExclusiveModeEXT( vkGetDeviceProcAddr( device, "vkAcquireFullScreenExclusiveModeEXT" ) );
15305  vkReleaseFullScreenExclusiveModeEXT = PFN_vkReleaseFullScreenExclusiveModeEXT( vkGetDeviceProcAddr( device, "vkReleaseFullScreenExclusiveModeEXT" ) );
15307  PFN_vkGetDeviceGroupSurfacePresentModes2EXT( vkGetDeviceProcAddr( device, "vkGetDeviceGroupSurfacePresentModes2EXT" ) );
15308 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
15309 
15310  //=== VK_KHR_buffer_device_address ===
15311  vkGetBufferDeviceAddressKHR = PFN_vkGetBufferDeviceAddressKHR( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddressKHR" ) );
15312  if ( !vkGetBufferDeviceAddress )
15314  vkGetBufferOpaqueCaptureAddressKHR = PFN_vkGetBufferOpaqueCaptureAddressKHR( vkGetDeviceProcAddr( device, "vkGetBufferOpaqueCaptureAddressKHR" ) );
15318  PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR( vkGetDeviceProcAddr( device, "vkGetDeviceMemoryOpaqueCaptureAddressKHR" ) );
15321 
15322  //=== VK_EXT_line_rasterization ===
15323  vkCmdSetLineStippleEXT = PFN_vkCmdSetLineStippleEXT( vkGetDeviceProcAddr( device, "vkCmdSetLineStippleEXT" ) );
15324 
15325  //=== VK_EXT_host_query_reset ===
15326  vkResetQueryPoolEXT = PFN_vkResetQueryPoolEXT( vkGetDeviceProcAddr( device, "vkResetQueryPoolEXT" ) );
15327  if ( !vkResetQueryPool )
15329 
15330  //=== VK_EXT_extended_dynamic_state ===
15331  vkCmdSetCullModeEXT = PFN_vkCmdSetCullModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetCullModeEXT" ) );
15332  if ( !vkCmdSetCullMode )
15334  vkCmdSetFrontFaceEXT = PFN_vkCmdSetFrontFaceEXT( vkGetDeviceProcAddr( device, "vkCmdSetFrontFaceEXT" ) );
15335  if ( !vkCmdSetFrontFace )
15337  vkCmdSetPrimitiveTopologyEXT = PFN_vkCmdSetPrimitiveTopologyEXT( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveTopologyEXT" ) );
15340  vkCmdSetViewportWithCountEXT = PFN_vkCmdSetViewportWithCountEXT( vkGetDeviceProcAddr( device, "vkCmdSetViewportWithCountEXT" ) );
15343  vkCmdSetScissorWithCountEXT = PFN_vkCmdSetScissorWithCountEXT( vkGetDeviceProcAddr( device, "vkCmdSetScissorWithCountEXT" ) );
15344  if ( !vkCmdSetScissorWithCount )
15346  vkCmdBindVertexBuffers2EXT = PFN_vkCmdBindVertexBuffers2EXT( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers2EXT" ) );
15347  if ( !vkCmdBindVertexBuffers2 )
15349  vkCmdSetDepthTestEnableEXT = PFN_vkCmdSetDepthTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthTestEnableEXT" ) );
15350  if ( !vkCmdSetDepthTestEnable )
15352  vkCmdSetDepthWriteEnableEXT = PFN_vkCmdSetDepthWriteEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthWriteEnableEXT" ) );
15353  if ( !vkCmdSetDepthWriteEnable )
15355  vkCmdSetDepthCompareOpEXT = PFN_vkCmdSetDepthCompareOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthCompareOpEXT" ) );
15356  if ( !vkCmdSetDepthCompareOp )
15358  vkCmdSetDepthBoundsTestEnableEXT = PFN_vkCmdSetDepthBoundsTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthBoundsTestEnableEXT" ) );
15361  vkCmdSetStencilTestEnableEXT = PFN_vkCmdSetStencilTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetStencilTestEnableEXT" ) );
15364  vkCmdSetStencilOpEXT = PFN_vkCmdSetStencilOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetStencilOpEXT" ) );
15365  if ( !vkCmdSetStencilOp )
15367 
15368  //=== VK_KHR_deferred_host_operations ===
15369  vkCreateDeferredOperationKHR = PFN_vkCreateDeferredOperationKHR( vkGetDeviceProcAddr( device, "vkCreateDeferredOperationKHR" ) );
15370  vkDestroyDeferredOperationKHR = PFN_vkDestroyDeferredOperationKHR( vkGetDeviceProcAddr( device, "vkDestroyDeferredOperationKHR" ) );
15372  PFN_vkGetDeferredOperationMaxConcurrencyKHR( vkGetDeviceProcAddr( device, "vkGetDeferredOperationMaxConcurrencyKHR" ) );
15373  vkGetDeferredOperationResultKHR = PFN_vkGetDeferredOperationResultKHR( vkGetDeviceProcAddr( device, "vkGetDeferredOperationResultKHR" ) );
15374  vkDeferredOperationJoinKHR = PFN_vkDeferredOperationJoinKHR( vkGetDeviceProcAddr( device, "vkDeferredOperationJoinKHR" ) );
15375 
15376  //=== VK_KHR_pipeline_executable_properties ===
15377  vkGetPipelineExecutablePropertiesKHR = PFN_vkGetPipelineExecutablePropertiesKHR( vkGetDeviceProcAddr( device, "vkGetPipelineExecutablePropertiesKHR" ) );
15378  vkGetPipelineExecutableStatisticsKHR = PFN_vkGetPipelineExecutableStatisticsKHR( vkGetDeviceProcAddr( device, "vkGetPipelineExecutableStatisticsKHR" ) );
15380  PFN_vkGetPipelineExecutableInternalRepresentationsKHR( vkGetDeviceProcAddr( device, "vkGetPipelineExecutableInternalRepresentationsKHR" ) );
15381 
15382  //=== VK_NV_device_generated_commands ===
15384  PFN_vkGetGeneratedCommandsMemoryRequirementsNV( vkGetDeviceProcAddr( device, "vkGetGeneratedCommandsMemoryRequirementsNV" ) );
15385  vkCmdPreprocessGeneratedCommandsNV = PFN_vkCmdPreprocessGeneratedCommandsNV( vkGetDeviceProcAddr( device, "vkCmdPreprocessGeneratedCommandsNV" ) );
15386  vkCmdExecuteGeneratedCommandsNV = PFN_vkCmdExecuteGeneratedCommandsNV( vkGetDeviceProcAddr( device, "vkCmdExecuteGeneratedCommandsNV" ) );
15387  vkCmdBindPipelineShaderGroupNV = PFN_vkCmdBindPipelineShaderGroupNV( vkGetDeviceProcAddr( device, "vkCmdBindPipelineShaderGroupNV" ) );
15388  vkCreateIndirectCommandsLayoutNV = PFN_vkCreateIndirectCommandsLayoutNV( vkGetDeviceProcAddr( device, "vkCreateIndirectCommandsLayoutNV" ) );
15389  vkDestroyIndirectCommandsLayoutNV = PFN_vkDestroyIndirectCommandsLayoutNV( vkGetDeviceProcAddr( device, "vkDestroyIndirectCommandsLayoutNV" ) );
15390 
15391  //=== VK_EXT_private_data ===
15392  vkCreatePrivateDataSlotEXT = PFN_vkCreatePrivateDataSlotEXT( vkGetDeviceProcAddr( device, "vkCreatePrivateDataSlotEXT" ) );
15393  if ( !vkCreatePrivateDataSlot )
15395  vkDestroyPrivateDataSlotEXT = PFN_vkDestroyPrivateDataSlotEXT( vkGetDeviceProcAddr( device, "vkDestroyPrivateDataSlotEXT" ) );
15396  if ( !vkDestroyPrivateDataSlot )
15398  vkSetPrivateDataEXT = PFN_vkSetPrivateDataEXT( vkGetDeviceProcAddr( device, "vkSetPrivateDataEXT" ) );
15399  if ( !vkSetPrivateData )
15401  vkGetPrivateDataEXT = PFN_vkGetPrivateDataEXT( vkGetDeviceProcAddr( device, "vkGetPrivateDataEXT" ) );
15402  if ( !vkGetPrivateData )
15404 
15405 #if defined( VK_ENABLE_BETA_EXTENSIONS )
15406  //=== VK_KHR_video_encode_queue ===
15407  vkCmdEncodeVideoKHR = PFN_vkCmdEncodeVideoKHR( vkGetDeviceProcAddr( device, "vkCmdEncodeVideoKHR" ) );
15408 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
15409 
15410 #if defined( VK_USE_PLATFORM_METAL_EXT )
15411  //=== VK_EXT_metal_objects ===
15412  vkExportMetalObjectsEXT = PFN_vkExportMetalObjectsEXT( vkGetDeviceProcAddr( device, "vkExportMetalObjectsEXT" ) );
15413 #endif /*VK_USE_PLATFORM_METAL_EXT*/
15414 
15415  //=== VK_KHR_synchronization2 ===
15416  vkCmdSetEvent2KHR = PFN_vkCmdSetEvent2KHR( vkGetDeviceProcAddr( device, "vkCmdSetEvent2KHR" ) );
15417  if ( !vkCmdSetEvent2 )
15419  vkCmdResetEvent2KHR = PFN_vkCmdResetEvent2KHR( vkGetDeviceProcAddr( device, "vkCmdResetEvent2KHR" ) );
15420  if ( !vkCmdResetEvent2 )
15422  vkCmdWaitEvents2KHR = PFN_vkCmdWaitEvents2KHR( vkGetDeviceProcAddr( device, "vkCmdWaitEvents2KHR" ) );
15423  if ( !vkCmdWaitEvents2 )
15425  vkCmdPipelineBarrier2KHR = PFN_vkCmdPipelineBarrier2KHR( vkGetDeviceProcAddr( device, "vkCmdPipelineBarrier2KHR" ) );
15426  if ( !vkCmdPipelineBarrier2 )
15428  vkCmdWriteTimestamp2KHR = PFN_vkCmdWriteTimestamp2KHR( vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp2KHR" ) );
15429  if ( !vkCmdWriteTimestamp2 )
15431  vkQueueSubmit2KHR = PFN_vkQueueSubmit2KHR( vkGetDeviceProcAddr( device, "vkQueueSubmit2KHR" ) );
15432  if ( !vkQueueSubmit2 )
15434  vkCmdWriteBufferMarker2AMD = PFN_vkCmdWriteBufferMarker2AMD( vkGetDeviceProcAddr( device, "vkCmdWriteBufferMarker2AMD" ) );
15435  vkGetQueueCheckpointData2NV = PFN_vkGetQueueCheckpointData2NV( vkGetDeviceProcAddr( device, "vkGetQueueCheckpointData2NV" ) );
15436 
15437  //=== VK_EXT_descriptor_buffer ===
15438  vkGetDescriptorSetLayoutSizeEXT = PFN_vkGetDescriptorSetLayoutSizeEXT( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSizeEXT" ) );
15440  PFN_vkGetDescriptorSetLayoutBindingOffsetEXT( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutBindingOffsetEXT" ) );
15441  vkGetDescriptorEXT = PFN_vkGetDescriptorEXT( vkGetDeviceProcAddr( device, "vkGetDescriptorEXT" ) );
15442  vkCmdBindDescriptorBuffersEXT = PFN_vkCmdBindDescriptorBuffersEXT( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorBuffersEXT" ) );
15443  vkCmdSetDescriptorBufferOffsetsEXT = PFN_vkCmdSetDescriptorBufferOffsetsEXT( vkGetDeviceProcAddr( device, "vkCmdSetDescriptorBufferOffsetsEXT" ) );
15445  PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorBufferEmbeddedSamplersEXT" ) );
15447  PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetBufferOpaqueCaptureDescriptorDataEXT" ) );
15449  PFN_vkGetImageOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetImageOpaqueCaptureDescriptorDataEXT" ) );
15451  PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetImageViewOpaqueCaptureDescriptorDataEXT" ) );
15453  PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetSamplerOpaqueCaptureDescriptorDataEXT" ) );
15455  vkGetDeviceProcAddr( device, "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT" ) );
15456 
15457  //=== VK_NV_fragment_shading_rate_enums ===
15458  vkCmdSetFragmentShadingRateEnumNV = PFN_vkCmdSetFragmentShadingRateEnumNV( vkGetDeviceProcAddr( device, "vkCmdSetFragmentShadingRateEnumNV" ) );
15459 
15460  //=== VK_EXT_mesh_shader ===
15461  vkCmdDrawMeshTasksEXT = PFN_vkCmdDrawMeshTasksEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksEXT" ) );
15462  vkCmdDrawMeshTasksIndirectEXT = PFN_vkCmdDrawMeshTasksIndirectEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectEXT" ) );
15463  vkCmdDrawMeshTasksIndirectCountEXT = PFN_vkCmdDrawMeshTasksIndirectCountEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectCountEXT" ) );
15464 
15465  //=== VK_KHR_copy_commands2 ===
15466  vkCmdCopyBuffer2KHR = PFN_vkCmdCopyBuffer2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyBuffer2KHR" ) );
15467  if ( !vkCmdCopyBuffer2 )
15469  vkCmdCopyImage2KHR = PFN_vkCmdCopyImage2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyImage2KHR" ) );
15470  if ( !vkCmdCopyImage2 )
15472  vkCmdCopyBufferToImage2KHR = PFN_vkCmdCopyBufferToImage2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyBufferToImage2KHR" ) );
15473  if ( !vkCmdCopyBufferToImage2 )
15475  vkCmdCopyImageToBuffer2KHR = PFN_vkCmdCopyImageToBuffer2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyImageToBuffer2KHR" ) );
15476  if ( !vkCmdCopyImageToBuffer2 )
15478  vkCmdBlitImage2KHR = PFN_vkCmdBlitImage2KHR( vkGetDeviceProcAddr( device, "vkCmdBlitImage2KHR" ) );
15479  if ( !vkCmdBlitImage2 )
15481  vkCmdResolveImage2KHR = PFN_vkCmdResolveImage2KHR( vkGetDeviceProcAddr( device, "vkCmdResolveImage2KHR" ) );
15482  if ( !vkCmdResolveImage2 )
15484 
15485  //=== VK_EXT_image_compression_control ===
15486  vkGetImageSubresourceLayout2EXT = PFN_vkGetImageSubresourceLayout2EXT( vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout2EXT" ) );
15487 
15488  //=== VK_EXT_device_fault ===
15489  vkGetDeviceFaultInfoEXT = PFN_vkGetDeviceFaultInfoEXT( vkGetDeviceProcAddr( device, "vkGetDeviceFaultInfoEXT" ) );
15490 
15491  //=== VK_KHR_ray_tracing_pipeline ===
15492  vkCmdTraceRaysKHR = PFN_vkCmdTraceRaysKHR( vkGetDeviceProcAddr( device, "vkCmdTraceRaysKHR" ) );
15493  vkCreateRayTracingPipelinesKHR = PFN_vkCreateRayTracingPipelinesKHR( vkGetDeviceProcAddr( device, "vkCreateRayTracingPipelinesKHR" ) );
15494  vkGetRayTracingShaderGroupHandlesKHR = PFN_vkGetRayTracingShaderGroupHandlesKHR( vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupHandlesKHR" ) );
15496  PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( vkGetDeviceProcAddr( device, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR" ) );
15497  vkCmdTraceRaysIndirectKHR = PFN_vkCmdTraceRaysIndirectKHR( vkGetDeviceProcAddr( device, "vkCmdTraceRaysIndirectKHR" ) );
15499  PFN_vkGetRayTracingShaderGroupStackSizeKHR( vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupStackSizeKHR" ) );
15501  PFN_vkCmdSetRayTracingPipelineStackSizeKHR( vkGetDeviceProcAddr( device, "vkCmdSetRayTracingPipelineStackSizeKHR" ) );
15502 
15503  //=== VK_EXT_vertex_input_dynamic_state ===
15504  vkCmdSetVertexInputEXT = PFN_vkCmdSetVertexInputEXT( vkGetDeviceProcAddr( device, "vkCmdSetVertexInputEXT" ) );
15505 
15506 #if defined( VK_USE_PLATFORM_FUCHSIA )
15507  //=== VK_FUCHSIA_external_memory ===
15508  vkGetMemoryZirconHandleFUCHSIA = PFN_vkGetMemoryZirconHandleFUCHSIA( vkGetDeviceProcAddr( device, "vkGetMemoryZirconHandleFUCHSIA" ) );
15510  PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA( vkGetDeviceProcAddr( device, "vkGetMemoryZirconHandlePropertiesFUCHSIA" ) );
15511 #endif /*VK_USE_PLATFORM_FUCHSIA*/
15512 
15513 #if defined( VK_USE_PLATFORM_FUCHSIA )
15514  //=== VK_FUCHSIA_external_semaphore ===
15515  vkImportSemaphoreZirconHandleFUCHSIA = PFN_vkImportSemaphoreZirconHandleFUCHSIA( vkGetDeviceProcAddr( device, "vkImportSemaphoreZirconHandleFUCHSIA" ) );
15516  vkGetSemaphoreZirconHandleFUCHSIA = PFN_vkGetSemaphoreZirconHandleFUCHSIA( vkGetDeviceProcAddr( device, "vkGetSemaphoreZirconHandleFUCHSIA" ) );
15517 #endif /*VK_USE_PLATFORM_FUCHSIA*/
15518 
15519 #if defined( VK_USE_PLATFORM_FUCHSIA )
15520  //=== VK_FUCHSIA_buffer_collection ===
15521  vkCreateBufferCollectionFUCHSIA = PFN_vkCreateBufferCollectionFUCHSIA( vkGetDeviceProcAddr( device, "vkCreateBufferCollectionFUCHSIA" ) );
15523  PFN_vkSetBufferCollectionImageConstraintsFUCHSIA( vkGetDeviceProcAddr( device, "vkSetBufferCollectionImageConstraintsFUCHSIA" ) );
15525  PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA( vkGetDeviceProcAddr( device, "vkSetBufferCollectionBufferConstraintsFUCHSIA" ) );
15526  vkDestroyBufferCollectionFUCHSIA = PFN_vkDestroyBufferCollectionFUCHSIA( vkGetDeviceProcAddr( device, "vkDestroyBufferCollectionFUCHSIA" ) );
15528  PFN_vkGetBufferCollectionPropertiesFUCHSIA( vkGetDeviceProcAddr( device, "vkGetBufferCollectionPropertiesFUCHSIA" ) );
15529 #endif /*VK_USE_PLATFORM_FUCHSIA*/
15530 
15531  //=== VK_HUAWEI_subpass_shading ===
15533  PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( vkGetDeviceProcAddr( device, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI" ) );
15534  vkCmdSubpassShadingHUAWEI = PFN_vkCmdSubpassShadingHUAWEI( vkGetDeviceProcAddr( device, "vkCmdSubpassShadingHUAWEI" ) );
15535 
15536  //=== VK_HUAWEI_invocation_mask ===
15537  vkCmdBindInvocationMaskHUAWEI = PFN_vkCmdBindInvocationMaskHUAWEI( vkGetDeviceProcAddr( device, "vkCmdBindInvocationMaskHUAWEI" ) );
15538 
15539  //=== VK_NV_external_memory_rdma ===
15540  vkGetMemoryRemoteAddressNV = PFN_vkGetMemoryRemoteAddressNV( vkGetDeviceProcAddr( device, "vkGetMemoryRemoteAddressNV" ) );
15541 
15542  //=== VK_EXT_pipeline_properties ===
15543  vkGetPipelinePropertiesEXT = PFN_vkGetPipelinePropertiesEXT( vkGetDeviceProcAddr( device, "vkGetPipelinePropertiesEXT" ) );
15544 
15545  //=== VK_EXT_extended_dynamic_state2 ===
15546  vkCmdSetPatchControlPointsEXT = PFN_vkCmdSetPatchControlPointsEXT( vkGetDeviceProcAddr( device, "vkCmdSetPatchControlPointsEXT" ) );
15547  vkCmdSetRasterizerDiscardEnableEXT = PFN_vkCmdSetRasterizerDiscardEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetRasterizerDiscardEnableEXT" ) );
15550  vkCmdSetDepthBiasEnableEXT = PFN_vkCmdSetDepthBiasEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthBiasEnableEXT" ) );
15551  if ( !vkCmdSetDepthBiasEnable )
15553  vkCmdSetLogicOpEXT = PFN_vkCmdSetLogicOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetLogicOpEXT" ) );
15554  vkCmdSetPrimitiveRestartEnableEXT = PFN_vkCmdSetPrimitiveRestartEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveRestartEnableEXT" ) );
15557 
15558  //=== VK_EXT_color_write_enable ===
15559  vkCmdSetColorWriteEnableEXT = PFN_vkCmdSetColorWriteEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorWriteEnableEXT" ) );
15560 
15561  //=== VK_KHR_ray_tracing_maintenance1 ===
15562  vkCmdTraceRaysIndirect2KHR = PFN_vkCmdTraceRaysIndirect2KHR( vkGetDeviceProcAddr( device, "vkCmdTraceRaysIndirect2KHR" ) );
15563 
15564  //=== VK_EXT_multi_draw ===
15565  vkCmdDrawMultiEXT = PFN_vkCmdDrawMultiEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMultiEXT" ) );
15566  vkCmdDrawMultiIndexedEXT = PFN_vkCmdDrawMultiIndexedEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMultiIndexedEXT" ) );
15567 
15568  //=== VK_EXT_opacity_micromap ===
15569  vkCreateMicromapEXT = PFN_vkCreateMicromapEXT( vkGetDeviceProcAddr( device, "vkCreateMicromapEXT" ) );
15570  vkDestroyMicromapEXT = PFN_vkDestroyMicromapEXT( vkGetDeviceProcAddr( device, "vkDestroyMicromapEXT" ) );
15571  vkCmdBuildMicromapsEXT = PFN_vkCmdBuildMicromapsEXT( vkGetDeviceProcAddr( device, "vkCmdBuildMicromapsEXT" ) );
15572  vkBuildMicromapsEXT = PFN_vkBuildMicromapsEXT( vkGetDeviceProcAddr( device, "vkBuildMicromapsEXT" ) );
15573  vkCopyMicromapEXT = PFN_vkCopyMicromapEXT( vkGetDeviceProcAddr( device, "vkCopyMicromapEXT" ) );
15574  vkCopyMicromapToMemoryEXT = PFN_vkCopyMicromapToMemoryEXT( vkGetDeviceProcAddr( device, "vkCopyMicromapToMemoryEXT" ) );
15575  vkCopyMemoryToMicromapEXT = PFN_vkCopyMemoryToMicromapEXT( vkGetDeviceProcAddr( device, "vkCopyMemoryToMicromapEXT" ) );
15576  vkWriteMicromapsPropertiesEXT = PFN_vkWriteMicromapsPropertiesEXT( vkGetDeviceProcAddr( device, "vkWriteMicromapsPropertiesEXT" ) );
15577  vkCmdCopyMicromapEXT = PFN_vkCmdCopyMicromapEXT( vkGetDeviceProcAddr( device, "vkCmdCopyMicromapEXT" ) );
15578  vkCmdCopyMicromapToMemoryEXT = PFN_vkCmdCopyMicromapToMemoryEXT( vkGetDeviceProcAddr( device, "vkCmdCopyMicromapToMemoryEXT" ) );
15579  vkCmdCopyMemoryToMicromapEXT = PFN_vkCmdCopyMemoryToMicromapEXT( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToMicromapEXT" ) );
15580  vkCmdWriteMicromapsPropertiesEXT = PFN_vkCmdWriteMicromapsPropertiesEXT( vkGetDeviceProcAddr( device, "vkCmdWriteMicromapsPropertiesEXT" ) );
15581  vkGetDeviceMicromapCompatibilityEXT = PFN_vkGetDeviceMicromapCompatibilityEXT( vkGetDeviceProcAddr( device, "vkGetDeviceMicromapCompatibilityEXT" ) );
15582  vkGetMicromapBuildSizesEXT = PFN_vkGetMicromapBuildSizesEXT( vkGetDeviceProcAddr( device, "vkGetMicromapBuildSizesEXT" ) );
15583 
15584  //=== VK_EXT_pageable_device_local_memory ===
15585  vkSetDeviceMemoryPriorityEXT = PFN_vkSetDeviceMemoryPriorityEXT( vkGetDeviceProcAddr( device, "vkSetDeviceMemoryPriorityEXT" ) );
15586 
15587  //=== VK_KHR_maintenance4 ===
15589  PFN_vkGetDeviceBufferMemoryRequirementsKHR( vkGetDeviceProcAddr( device, "vkGetDeviceBufferMemoryRequirementsKHR" ) );
15593  PFN_vkGetDeviceImageMemoryRequirementsKHR( vkGetDeviceProcAddr( device, "vkGetDeviceImageMemoryRequirementsKHR" ) );
15597  PFN_vkGetDeviceImageSparseMemoryRequirementsKHR( vkGetDeviceProcAddr( device, "vkGetDeviceImageSparseMemoryRequirementsKHR" ) );
15600 
15601  //=== VK_VALVE_descriptor_set_host_mapping ===
15603  PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutHostMappingInfoVALVE" ) );
15604  vkGetDescriptorSetHostMappingVALVE = PFN_vkGetDescriptorSetHostMappingVALVE( vkGetDeviceProcAddr( device, "vkGetDescriptorSetHostMappingVALVE" ) );
15605 
15606  //=== VK_NV_copy_memory_indirect ===
15607  vkCmdCopyMemoryIndirectNV = PFN_vkCmdCopyMemoryIndirectNV( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryIndirectNV" ) );
15608  vkCmdCopyMemoryToImageIndirectNV = PFN_vkCmdCopyMemoryToImageIndirectNV( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToImageIndirectNV" ) );
15609 
15610  //=== VK_NV_memory_decompression ===
15611  vkCmdDecompressMemoryNV = PFN_vkCmdDecompressMemoryNV( vkGetDeviceProcAddr( device, "vkCmdDecompressMemoryNV" ) );
15612  vkCmdDecompressMemoryIndirectCountNV = PFN_vkCmdDecompressMemoryIndirectCountNV( vkGetDeviceProcAddr( device, "vkCmdDecompressMemoryIndirectCountNV" ) );
15613 
15614  //=== VK_EXT_extended_dynamic_state3 ===
15615  vkCmdSetTessellationDomainOriginEXT = PFN_vkCmdSetTessellationDomainOriginEXT( vkGetDeviceProcAddr( device, "vkCmdSetTessellationDomainOriginEXT" ) );
15616  vkCmdSetDepthClampEnableEXT = PFN_vkCmdSetDepthClampEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthClampEnableEXT" ) );
15617  vkCmdSetPolygonModeEXT = PFN_vkCmdSetPolygonModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetPolygonModeEXT" ) );
15618  vkCmdSetRasterizationSamplesEXT = PFN_vkCmdSetRasterizationSamplesEXT( vkGetDeviceProcAddr( device, "vkCmdSetRasterizationSamplesEXT" ) );
15619  vkCmdSetSampleMaskEXT = PFN_vkCmdSetSampleMaskEXT( vkGetDeviceProcAddr( device, "vkCmdSetSampleMaskEXT" ) );
15620  vkCmdSetAlphaToCoverageEnableEXT = PFN_vkCmdSetAlphaToCoverageEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetAlphaToCoverageEnableEXT" ) );
15621  vkCmdSetAlphaToOneEnableEXT = PFN_vkCmdSetAlphaToOneEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetAlphaToOneEnableEXT" ) );
15622  vkCmdSetLogicOpEnableEXT = PFN_vkCmdSetLogicOpEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetLogicOpEnableEXT" ) );
15623  vkCmdSetColorBlendEnableEXT = PFN_vkCmdSetColorBlendEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorBlendEnableEXT" ) );
15624  vkCmdSetColorBlendEquationEXT = PFN_vkCmdSetColorBlendEquationEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorBlendEquationEXT" ) );
15625  vkCmdSetColorWriteMaskEXT = PFN_vkCmdSetColorWriteMaskEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorWriteMaskEXT" ) );
15626  vkCmdSetRasterizationStreamEXT = PFN_vkCmdSetRasterizationStreamEXT( vkGetDeviceProcAddr( device, "vkCmdSetRasterizationStreamEXT" ) );
15628  PFN_vkCmdSetConservativeRasterizationModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetConservativeRasterizationModeEXT" ) );
15630  PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT( vkGetDeviceProcAddr( device, "vkCmdSetExtraPrimitiveOverestimationSizeEXT" ) );
15631  vkCmdSetDepthClipEnableEXT = PFN_vkCmdSetDepthClipEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthClipEnableEXT" ) );
15632  vkCmdSetSampleLocationsEnableEXT = PFN_vkCmdSetSampleLocationsEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetSampleLocationsEnableEXT" ) );
15633  vkCmdSetColorBlendAdvancedEXT = PFN_vkCmdSetColorBlendAdvancedEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorBlendAdvancedEXT" ) );
15634  vkCmdSetProvokingVertexModeEXT = PFN_vkCmdSetProvokingVertexModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetProvokingVertexModeEXT" ) );
15635  vkCmdSetLineRasterizationModeEXT = PFN_vkCmdSetLineRasterizationModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetLineRasterizationModeEXT" ) );
15636  vkCmdSetLineStippleEnableEXT = PFN_vkCmdSetLineStippleEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetLineStippleEnableEXT" ) );
15637  vkCmdSetDepthClipNegativeOneToOneEXT = PFN_vkCmdSetDepthClipNegativeOneToOneEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthClipNegativeOneToOneEXT" ) );
15638  vkCmdSetViewportWScalingEnableNV = PFN_vkCmdSetViewportWScalingEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportWScalingEnableNV" ) );
15639  vkCmdSetViewportSwizzleNV = PFN_vkCmdSetViewportSwizzleNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportSwizzleNV" ) );
15640  vkCmdSetCoverageToColorEnableNV = PFN_vkCmdSetCoverageToColorEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageToColorEnableNV" ) );
15641  vkCmdSetCoverageToColorLocationNV = PFN_vkCmdSetCoverageToColorLocationNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageToColorLocationNV" ) );
15642  vkCmdSetCoverageModulationModeNV = PFN_vkCmdSetCoverageModulationModeNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageModulationModeNV" ) );
15644  PFN_vkCmdSetCoverageModulationTableEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageModulationTableEnableNV" ) );
15645  vkCmdSetCoverageModulationTableNV = PFN_vkCmdSetCoverageModulationTableNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageModulationTableNV" ) );
15646  vkCmdSetShadingRateImageEnableNV = PFN_vkCmdSetShadingRateImageEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetShadingRateImageEnableNV" ) );
15648  PFN_vkCmdSetRepresentativeFragmentTestEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetRepresentativeFragmentTestEnableNV" ) );
15649  vkCmdSetCoverageReductionModeNV = PFN_vkCmdSetCoverageReductionModeNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageReductionModeNV" ) );
15650 
15651  //=== VK_EXT_shader_module_identifier ===
15652  vkGetShaderModuleIdentifierEXT = PFN_vkGetShaderModuleIdentifierEXT( vkGetDeviceProcAddr( device, "vkGetShaderModuleIdentifierEXT" ) );
15654  PFN_vkGetShaderModuleCreateInfoIdentifierEXT( vkGetDeviceProcAddr( device, "vkGetShaderModuleCreateInfoIdentifierEXT" ) );
15655 
15656  //=== VK_NV_optical_flow ===
15657  vkCreateOpticalFlowSessionNV = PFN_vkCreateOpticalFlowSessionNV( vkGetDeviceProcAddr( device, "vkCreateOpticalFlowSessionNV" ) );
15658  vkDestroyOpticalFlowSessionNV = PFN_vkDestroyOpticalFlowSessionNV( vkGetDeviceProcAddr( device, "vkDestroyOpticalFlowSessionNV" ) );
15659  vkBindOpticalFlowSessionImageNV = PFN_vkBindOpticalFlowSessionImageNV( vkGetDeviceProcAddr( device, "vkBindOpticalFlowSessionImageNV" ) );
15660  vkCmdOpticalFlowExecuteNV = PFN_vkCmdOpticalFlowExecuteNV( vkGetDeviceProcAddr( device, "vkCmdOpticalFlowExecuteNV" ) );
15661 
15662  //=== VK_QCOM_tile_properties ===
15663  vkGetFramebufferTilePropertiesQCOM = PFN_vkGetFramebufferTilePropertiesQCOM( vkGetDeviceProcAddr( device, "vkGetFramebufferTilePropertiesQCOM" ) );
15665  PFN_vkGetDynamicRenderingTilePropertiesQCOM( vkGetDeviceProcAddr( device, "vkGetDynamicRenderingTilePropertiesQCOM" ) );
15666  }
15667 
15668  template <typename DynamicLoader>
15670  {
15671  PFN_vkGetInstanceProcAddr getInstanceProcAddr = dl.template getProcAddress<PFN_vkGetInstanceProcAddr>( "vkGetInstanceProcAddr" );
15672  PFN_vkGetDeviceProcAddr getDeviceProcAddr = dl.template getProcAddress<PFN_vkGetDeviceProcAddr>( "vkGetDeviceProcAddr" );
15673  init( static_cast<VkInstance>( instance ), getInstanceProcAddr, static_cast<VkDevice>( device ), device ? getDeviceProcAddr : nullptr );
15674  }
15675 
15676  template <typename DynamicLoader
15677 #if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
15679 #endif
15680  >
15682  {
15683  static DynamicLoader dl;
15684  init( instance, device, dl );
15685  }
15686  };
15687 } // namespace VULKAN_HPP_NAMESPACE
15688 #endif
void(VKAPI_PTR * PFN_vkCmdEndRenderPass2)(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo)
Definition: vulkan_core.h:6380
VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorBufferEmbeddedSamplersEXT(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set)
void(VKAPI_PTR * PFN_vkCmdSetScissorWithCountEXT)(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D *pScissors)
GLsizei GLenum GLsizei GLsizei GLuint memory
Definition: RE_OGL.h:202
VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t *pPropertyCount, VkDisplayModePropertiesKHR *pProperties)
VkDeviceAddress(VKAPI_PTR * PFN_vkGetBufferDeviceAddress)(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
Definition: vulkan_core.h:6385
PFN_vkCmdBindShadingRateImageNV vkCmdBindShadingRateImageNV
Definition: vulkan.hpp:13038
VkResult vkGetImageViewOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT *pInfo, void *pData) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4987
PFN_vkGetImageDrmFormatModifierPropertiesEXT vkGetImageDrmFormatModifierPropertiesEXT
Definition: vulkan.hpp:13029
PFN_vkGetImageOpaqueCaptureDescriptorDataEXT vkGetImageOpaqueCaptureDescriptorDataEXT
Definition: vulkan.hpp:13240
PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceCapabilitiesKHR
Definition: vulkan.hpp:12645
void vkCmdCopyImage2(VkCommandBuffer commandBuffer, const VkCopyImageInfo2 *pCopyImageInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2597
VKAPI_ATTR VkResult VKAPI_CALL vkCreatePrivateDataSlotEXT(VkDevice device, const VkPrivateDataSlotCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPrivateDataSlot *pPrivateDataSlot)
PFN_vkBindOpticalFlowSessionImageNV vkBindOpticalFlowSessionImageNV
Definition: vulkan.hpp:13446
VKAPI_ATTR void VKAPI_CALL vkCmdDecompressMemoryNV(VkCommandBuffer commandBuffer, uint32_t decompressRegionCount, const VkDecompressMemoryRegionNV *pDecompressMemoryRegions)
VKAPI_ATTR void VKAPI_CALL vkCmdSetColorBlendAdvancedEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT *pColorBlendAdvanced)
ValidationFailedEXTError(std::string const &message)
Definition: vulkan.hpp:6324
PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties
Definition: vulkan.hpp:12433
VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator)
PFN_vkCmdCopyImageToBuffer2 vkCmdCopyImageToBuffer2
Definition: vulkan.hpp:12618
VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
std::tuple< Result, UniqueHandle< Type, Dispatch > > asTuple()
Definition: vulkan.hpp:6556
void vkQueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3870
void(VKAPI_PTR * PFN_vkCmdCopyAccelerationStructureNV)(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode)
PFN_vkCmdDispatchIndirect vkCmdDispatchIndirect
Definition: vulkan.hpp:12531
VkResult(VKAPI_PTR * PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
Definition: vulkan_core.h:3972
bool operator>=(ArrayWrapper1D< char, N > const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:309
void(VKAPI_PTR * PFN_vkDestroyAccelerationStructureKHR)(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks *pAllocator)
InvalidShaderNVError(char const *message)
Definition: vulkan.hpp:6332
VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes, const VkDeviceSize *pStrides)
PFN_vkCmdBeginRendering vkCmdBeginRendering
Definition: vulkan.hpp:12621
void vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy *pRegions) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2050
void vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1990
void(VKAPI_PTR * PFN_vkCmdCopyImageToBuffer2)(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 *pCopyImageToBufferInfo)
Definition: vulkan_core.h:7305
PFN_vkCmdSetCheckpointNV vkCmdSetCheckpointNV
Definition: vulkan.hpp:13082
VkResult(VKAPI_PTR * PFN_vkGetRandROutputDisplayEXT)(VkPhysicalDevice physicalDevice, Display *dpy, RROutput rrOutput, VkDisplayKHR *pDisplay)
void vkCmdSubpassShadingHUAWEI(VkCommandBuffer commandBuffer) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5279
void vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet *pDescriptorCopies) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1815
VkResult vkCreateValidationCacheEXT(VkDevice device, const VkValidationCacheCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkValidationCacheEXT *pValidationCache) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4135
VkResult(VKAPI_PTR * PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo, const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory)
Definition: vulkan_core.h:3927
PFN_vkGetPhysicalDeviceToolProperties vkGetPhysicalDeviceToolProperties
Definition: vulkan.hpp:12604
VKAPI_ATTR void VKAPI_CALL vkUninitializePerformanceApiINTEL(VkDevice device)
PFN_vkCmdBindVertexBuffers2 vkCmdBindVertexBuffers2
Definition: vulkan.hpp:12628
VkResult vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBufferView *pView) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1632
PFN_vkCmdBeginRenderPass2KHR vkCmdBeginRenderPass2KHR
Definition: vulkan.hpp:12918
VkResult(VKAPI_PTR * PFN_vkAcquireXlibDisplayEXT)(VkPhysicalDevice physicalDevice, Display *dpy, VkDisplayKHR display)
VkResult(VKAPI_PTR * PFN_vkGetPastPresentationTimingGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pPresentationTimingCount, VkPastPresentationTimingGOOGLE *pPresentationTimings)
void vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit *pRegions, VkFilter filter) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2038
PFN_vkCreateCuModuleNVX vkCreateCuModuleNVX
Definition: vulkan.hpp:12772
VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable)
GLenum query
Definition: glad.h:2772
PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR
Definition: vulkan.hpp:12652
VKAPI_ATTR VkResult VKAPI_CALL vkCreatePrivateDataSlot(VkDevice device, const VkPrivateDataSlotCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPrivateDataSlot *pPrivateDataSlot)
PFN_vkBindImageMemory2 vkBindImageMemory2
Definition: vulkan.hpp:12561
void(VKAPI_PTR * PFN_vkCmdBlitImage2KHR)(VkCommandBuffer commandBuffer, const VkBlitImageInfo2 *pBlitImageInfo)
Definition: vulkan_core.h:9696
VKAPI_ATTR VkResult VKAPI_CALL vkCreateCuModuleNVX(VkDevice device, const VkCuModuleCreateInfoNVX *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCuModuleNVX *pModule)
PFN_vkCmdSetCoverageModulationModeNV vkCmdSetCoverageModulationModeNV
Definition: vulkan.hpp:13431
~UniqueHandle() VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1190
VkResult vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1888
VkResult(VKAPI_PTR * PFN_vkBindBufferMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos)
Definition: vulkan_core.h:8956
PFN_vkGetSemaphoreCounterValueKHR vkGetSemaphoreCounterValueKHR
Definition: vulkan.hpp:13086
VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query)
void(VKAPI_PTR * PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4])
Definition: vulkan_core.h:4004
VkResult vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, uint64_t timeout) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1548
VkResult(VKAPI_PTR * PFN_vkWaitSemaphoresKHR)(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout)
Definition: vulkan_core.h:9150
PFN_vkCmdClearColorImage vkCmdClearColorImage
Definition: vulkan.hpp:12539
VKAPI_ATTR void VKAPI_CALL vkExportMetalObjectsEXT(VkDevice device, VkExportMetalObjectsInfoEXT *pMetalObjectsInfo)
PFN_vkBindImageMemory2KHR vkBindImageMemory2KHR
Definition: vulkan.hpp:13026
Type release() VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1254
VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR *pInfo)
GLuint GLsizei const GLchar * message
Definition: glcorearb.h:2543
VKAPI_ATTR void VKAPI_CALL vkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin)
VkDeviceAddress(VKAPI_PTR * PFN_vkGetBufferDeviceAddressEXT)(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D *pScissors)
void(VKAPI_PTR * PFN_vkCmdSetCheckpointNV)(VkCommandBuffer commandBuffer, const void *pCheckpointMarker)
PFN_vkWaitForPresentKHR vkWaitForPresentKHR
Definition: vulkan.hpp:13129
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR
Definition: vulkan.hpp:12644
void vkCmdSetRasterizationStreamEXT(VkCommandBuffer commandBuffer, uint32_t rasterizationStream) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5638
typedef int(APIENTRYP RE_PFNGLXSWAPINTERVALSGIPROC)(int)
PFN_vkGetPhysicalDeviceImageFormatProperties2 vkGetPhysicalDeviceImageFormatProperties2
Definition: vulkan.hpp:12572
VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display *display)
void vkCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4355
void vkGetDeviceImageSparseMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2732
void(VKAPI_PTR * PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer)
Definition: vulkan_core.h:4041
PFN_vkCmdSetAlphaToOneEnableEXT vkCmdSetAlphaToOneEnableEXT
Definition: vulkan.hpp:13412
VkResult(VKAPI_PTR * PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDevice *pDevice)
Definition: vulkan_core.h:3917
InitializationFailedError(std::string const &message)
Definition: vulkan.hpp:6191
VkResult vkGetImageViewAddressNVX(VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX *pProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3235
void vkCmdSetFragmentShadingRateEnumNV(VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5009
void(VKAPI_PTR * PFN_vkGetDeviceBufferMemoryRequirementsKHR)(VkDevice device, const VkDeviceBufferMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
Definition: vulkan_core.h:9789
void vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_t patchControlPoints) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5310
void vkDestroyCuModuleNVX(VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3213
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable)
VkBool32(VKAPI_PTR * PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t *connection, xcb_visualid_t visual_id)
Definition: vulkan_xcb.h:35
LogicError(char const *what)
Definition: vulkan.hpp:6132
VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer)
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE *pHandle)
VkResult vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache *pSrcCaches) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1711
void(VKAPI_PTR * PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3987
VkResult(VKAPI_PTR * PFN_vkGetPipelineExecutablePropertiesKHR)(VkDevice device, const VkPipelineInfoKHR *pPipelineInfo, uint32_t *pExecutableCount, VkPipelineExecutablePropertiesKHR *pProperties)
Definition: vulkan_core.h:9449
VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D *pDiscardRectangles)
bool operator==(ArrayWrapper1D< char, N > const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:316
void vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1942
VKAPI_ATTR void VKAPI_CALL vkCmdSetLineRasterizationModeEXT(VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode)
PFN_vkCmdSetDepthClipEnableEXT vkCmdSetDepthClipEnableEXT
Definition: vulkan.hpp:13420
VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
VkResult(VKAPI_PTR * PFN_vkCmdSetPerformanceStreamMarkerINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL *pMarkerInfo)
GLbitfield flags
Definition: glcorearb.h:1596
VkPrimitiveTopology
Definition: vulkan_core.h:1957
PFN_vkCmdSetScissorWithCountEXT vkCmdSetScissorWithCountEXT
Definition: vulkan.hpp:13169
VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, const VkDependencyInfo *pDependencyInfos)
void(VKAPI_PTR * PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
Definition: vulkan_core.h:4003
void(VKAPI_PTR * PFN_vkGetShaderModuleIdentifierEXT)(VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT *pIdentifier)
VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSizeEXT(VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize *pLayoutSizeInBytes)
VKAPI_ATTR void VKAPI_CALL vkGetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t *pData)
VkResult vkEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2289
VKAPI_ATTR void VKAPI_CALL vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
PFN_vkCmdWaitEvents2KHR vkCmdWaitEvents2KHR
Definition: vulkan.hpp:13225
void vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3145
void vkUnmapMemory(VkDevice device, VkDeviceMemory memory) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1460
VkResult(VKAPI_PTR * PFN_vkSetPrivateData)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data)
Definition: vulkan_core.h:7294
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
Definition: vulkan.hpp:3390
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, uint32_t *pSurfaceFormatCount, VkSurfaceFormat2KHR *pSurfaceFormats)
Definition: vulkan_core.h:8759
PFN_vkCmdSetColorBlendEnableEXT vkCmdSetColorBlendEnableEXT
Definition: vulkan.hpp:13414
VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageToColorLocationNV(VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion)
VkResult(VKAPI_PTR * PFN_vkEnumerateInstanceLayerProperties)(uint32_t *pPropertyCount, VkLayerProperties *pProperties)
Definition: vulkan_core.h:3921
void(VKAPI_PTR * PFN_vkCmdSetCoverageModulationTableNV)(VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float *pCoverageModulationTable)
void(VKAPI_PTR * PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
Definition: vulkan_core.h:4006
VkResult(VKAPI_PTR * PFN_vkGetFenceWin32HandleKHR)(VkDevice device, const VkFenceGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle)
Definition: vulkan_win32.h:197
VULKAN_HPP_CONSTEXPR Flags< BitType > operator^(BitType bit, Flags< BitType > const &flags) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:553
bool operator>=(std::string const &lhs, ArrayWrapper1D< char, N > const &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:348
PFN_vkCmdWriteMicromapsPropertiesEXT vkCmdWriteMicromapsPropertiesEXT
Definition: vulkan.hpp:13381
VkResult(VKAPI_PTR * PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence *pFences)
Definition: vulkan_core.h:3943
VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructuresIndirectKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkDeviceAddress *pIndirectDeviceAddresses, const uint32_t *pIndirectStrides, const uint32_t *const *ppMaxPrimitiveCounts)
PFN_vkGetMemoryRemoteAddressNV vkGetMemoryRemoteAddressNV
Definition: vulkan.hpp:13338
PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements
Definition: vulkan.hpp:12450
VkResult(VKAPI_PTR * PFN_vkCreateDeferredOperationKHR)(VkDevice device, const VkAllocationCallbacks *pAllocator, VkDeferredOperationKHR *pDeferredOperation)
Definition: vulkan_core.h:9353
VkResult(VKAPI_PTR * PFN_vkWaitForPresentKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout)
Definition: vulkan_core.h:9299
void(VKAPI_PTR * PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3989
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, VkSurfaceCapabilities2KHR *pSurfaceCapabilities)
VkProvokingVertexModeEXT
VkResult(VKAPI_PTR * PFN_vkGetSemaphoreWin32HandleKHR)(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle)
Definition: vulkan_win32.h:154
VkResult(VKAPI_PTR * PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, const VkXlibSurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
Definition: vulkan_xlib.h:34
VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkEvent *pEvent)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkInstance *pInstance)
PFN_vkCmdCopyMemoryToImageIndirectNV vkCmdCopyMemoryToImageIndirectNV
Definition: vulkan.hpp:13399
StructureChain(StructureChain const &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:984
PFN_vkEnumerateInstanceVersion vkEnumerateInstanceVersion
Definition: vulkan.hpp:12559
VKAPI_ATTR void VKAPI_CALL vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
VkDeviceAddress vkGetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo *pInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2510
VKAPI_ATTR void VKAPI_CALL vkDestroyDeferredOperationKHR(VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks *pAllocator)
void vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1390
PFN_vkCmdCopyMicromapEXT vkCmdCopyMicromapEXT
Definition: vulkan.hpp:13378
PFN_vkCmdPushDescriptorSetWithTemplateKHR vkCmdPushDescriptorSetWithTemplateKHR
Definition: vulkan.hpp:12871
void(VKAPI_PTR * PFN_vkCmdSetFrontFaceEXT)(VkCommandBuffer commandBuffer, VkFrontFace frontFace)
void(VKAPI_PTR * PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements)
Definition: vulkan_core.h:3937
void vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1674
VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties)
PFN_vkDestroyQueryPool vkDestroyQueryPool
Definition: vulkan.hpp:12468
VkResult vkGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void *pHostPointer, VkMemoryHostPointerPropertiesEXT *pMemoryHostPointerProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4345
LogicError(const std::string &what)
Definition: vulkan.hpp:6131
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceExternalImageFormatPropertiesNV(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV *pExternalImageFormatProperties)
VkResult(VKAPI_PTR * PFN_vkSetDebugUtilsObjectNameEXT)(VkDevice device, const VkDebugUtilsObjectNameInfoEXT *pNameInfo)
void vkQueueEndDebugUtilsLabelEXT(VkQueue queue) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3865
auto to_string(const T &value) -> std::string
Definition: format.h:2597
VkResult(VKAPI_PTR * PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI)(VkDevice device, VkRenderPass renderpass, VkExtent2D *pMaxWorkgroupSize)
void vkCmdSetDepthClampEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5579
void(VKAPI_PTR * PFN_vkGetDescriptorEXT)(VkDevice device, const VkDescriptorGetInfoEXT *pDescriptorInfo, size_t dataSize, void *pDescriptor)
PFN_vkGetPrivateDataEXT vkGetPrivateDataEXT
Definition: vulkan.hpp:13206
VkResult(VKAPI_PTR * PFN_vkReleaseFullScreenExclusiveModeEXT)(VkDevice device, VkSwapchainKHR swapchain)
Definition: vulkan_win32.h:287
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats)
void(VKAPI_PTR * PFN_vkUninitializePerformanceApiINTEL)(VkDevice device)
PFN_vkDestroyDescriptorUpdateTemplateKHR vkDestroyDescriptorUpdateTemplateKHR
Definition: vulkan.hpp:12879
VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR *pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR *pCapabilities)
void(VKAPI_PTR * PFN_vkCmdCopyMemoryToImageIndirectNV)(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VkImage dstImage, VkImageLayout dstImageLayout, const VkImageSubresourceLayers *pImageSubresources)
PFN_vkCmdSetScissorWithCount vkCmdSetScissorWithCount
Definition: vulkan.hpp:12627
void(VKAPI_PTR * PFN_vkCmdBindTransformFeedbackBuffersEXT)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes)
void vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2490
VkResult vkCreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchains) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2896
uint32_t VkBool32
Definition: vulkan_core.h:93
void vkCmdCuLaunchKernelNVX(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX *pLaunchInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3223
VkResult(VKAPI_PTR * PFN_vkGetRefreshCycleDurationGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE *pDisplayTimingProperties)
VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos)
VkResult vkGetMemoryRemoteAddressNV(VkDevice device, const VkMemoryGetRemoteAddressInfoNV *pMemoryGetRemoteAddressInfo, VkRemoteAddressNV *pAddress) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5293
void(VKAPI_PTR * PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:7589
void vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1355
VkResult vkGetImageOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkImageCaptureDescriptorDataInfoEXT *pInfo, void *pData) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4982
VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
void(VKAPI_PTR * PFN_vkGetImageSubresourceLayout2EXT)(VkDevice device, VkImage image, const VkImageSubresource2EXT *pSubresource, VkSubresourceLayout2EXT *pLayout)
VkResult vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1726
void vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2441
PFN_vkCmdBeginDebugUtilsLabelEXT vkCmdBeginDebugUtilsLabelEXT
Definition: vulkan.hpp:12977
VkResult(VKAPI_PTR * PFN_vkGetDeviceGroupSurfacePresentModes2EXT)(VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR *pModes)
Definition: vulkan_win32.h:288
VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR *pModes)
void(VKAPI_PTR * PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment *pAttachments, uint32_t rectCount, const VkClearRect *pRects)
Definition: vulkan_core.h:4027
void vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3155
LayerNotPresentError(std::string const &message)
Definition: vulkan.hpp:6212
void(VKAPI_PTR * PFN_vkDestroyIndirectCommandsLayoutNV)(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks *pAllocator)
PFN_vkCmdDrawMeshTasksIndirectEXT vkCmdDrawMeshTasksIndirectEXT
Definition: vulkan.hpp:13250
VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV *pShadingRatePalettes)
void(VKAPI_PTR * PFN_vkCmdSetDepthTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable)
PFN_vkCmdSetFragmentShadingRateKHR vkCmdSetFragmentShadingRateKHR
Definition: vulkan.hpp:13120
PFN_vkBindBufferMemory vkBindBufferMemory
Definition: vulkan.hpp:12448
VkResult vkCreateCuFunctionNVX(VkDevice device, const VkCuFunctionCreateInfoNVX *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCuFunctionNVX *pFunction) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3205
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPropertiesKHR *pProperties)
VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutHostMappingInfoVALVE(VkDevice device, const VkDescriptorSetBindingReferenceVALVE *pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE *pHostMapping)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBufferView *pView)
VkResult(VKAPI_PTR * PFN_vkResetEvent)(VkDevice device, VkEvent event)
Definition: vulkan_core.h:3952
VkResult vkWriteMicromapsPropertiesEXT(VkDevice device, uint32_t micromapCount, const VkMicromapEXT *pMicromaps, VkQueryType queryType, size_t dataSize, void *pData, size_t stride) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5438
VkResult vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t *pValue) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2495
VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer, const VkDependencyInfo *pDependencyInfo)
VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks *pAllocator)
PFN_vkCmdSetDepthCompareOpEXT vkCmdSetDepthCompareOpEXT
Definition: vulkan.hpp:13173
PFN_vkGetBufferDeviceAddressEXT vkGetBufferDeviceAddressEXT
Definition: vulkan.hpp:13123
static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask
Definition: vulkan.hpp:380
VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks *pAllocator)
VKAPI_ATTR void VKAPI_CALL vkCmdBindInvocationMaskHUAWEI(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
PFN_vkGetPhysicalDeviceMemoryProperties2KHR vkGetPhysicalDeviceMemoryProperties2KHR
Definition: vulkan.hpp:12816
void vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3329
VULKAN_HPP_CONSTEXPR_14 Flags< BitType > & operator|=(Flags< BitType > const &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:463
#define VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:200
FragmentationError(std::string const &message)
Definition: vulkan.hpp:6282
VKAPI_ATTR VkResult VKAPI_CALL vkCreateOpticalFlowSessionNV(VkDevice device, const VkOpticalFlowSessionCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkOpticalFlowSessionNV *pSession)
VkResult(VKAPI_PTR * PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void *pData, VkDeviceSize stride, VkQueryResultFlags flags)
Definition: vulkan_core.h:3955
void(VKAPI_PTR * PFN_vkCmdSetDepthBiasEnable)(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable)
Definition: vulkan_core.h:7323
void(VKAPI_PTR * PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3959
PFN_vkCmdSetRasterizationSamplesEXT vkCmdSetRasterizationSamplesEXT
Definition: vulkan.hpp:13409
void(VKAPI_PTR * PFN_vkCmdSetProvokingVertexModeEXT)(VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode)
void(VKAPI_PTR * PFN_vkCmdSetTessellationDomainOriginEXT)(VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin)
VkResult vkWaitForPresentKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4561
void vkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3530
UnknownError(std::string const &message)
Definition: vulkan.hpp:6261
PFN_vkCreateDescriptorUpdateTemplate vkCreateDescriptorUpdateTemplate
Definition: vulkan.hpp:12580
PFN_vkCmdBindIndexBuffer vkCmdBindIndexBuffer
Definition: vulkan.hpp:12524
void vkGetAccelerationStructureMemoryRequirementsNV(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2KHR *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4202
void vkCmdSetCoverageToColorEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5705
VkResult(VKAPI_PTR * PFN_vkGetSemaphoreFdKHR)(VkDevice device, const VkSemaphoreGetFdInfoKHR *pGetFdInfo, int *pFd)
Definition: vulkan_core.h:8310
ArrayProxy(uint32_t count, T const *ptr) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:606
void(VKAPI_PTR * PFN_vkCmdSetRasterizerDiscardEnable)(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable)
Definition: vulkan_core.h:7322
VkResult
Definition: vulkan_core.h:139
void vkCmdSetColorBlendEquationEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT *pColorBlendEquations) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5622
VKAPI_ATTR void VKAPI_CALL vkCmdSetAlphaToOneEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable)
VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology)
void(VKAPI_PTR * PFN_vkCmdBeginRendering)(VkCommandBuffer commandBuffer, const VkRenderingInfo *pRenderingInfo)
Definition: vulkan_core.h:7308
VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
VKAPI_ATTR void VKAPI_CALL vkCmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo)
void vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2323
void(VKAPI_PTR * PFN_vkCmdSetCullMode)(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode)
Definition: vulkan_core.h:7310
VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void *pData)
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties *pQueueFamilyProperties)
VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToImageIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VkImage dstImage, VkImageLayout dstImageLayout, const VkImageSubresourceLayers *pImageSubresources)
OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:6014
void vkCmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4890
uint32_t size() const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:835
PFN_vkCmdSetDepthBiasEnableEXT vkCmdSetDepthBiasEnableEXT
Definition: vulkan.hpp:13346
void vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1924
VkResult vkCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4305
VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit2KHR(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 *pSubmits, VkFence fence)
void(VKAPI_PTR * PFN_vkCmdSetRepresentativeFragmentTestEnableNV)(VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable)
PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT vkGetPhysicalDeviceSurfaceCapabilities2EXT
Definition: vulkan.hpp:12898
void(VKAPI_PTR * PFN_vkCmdSetStencilTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable)
PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines
Definition: vulkan.hpp:12485
void(VKAPI_PTR * PFN_vkCmdSetSampleLocationsEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable)
VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks *pAllocator)
PFN_vkCmdSetAlphaToCoverageEnableEXT vkCmdSetAlphaToCoverageEnableEXT
Definition: vulkan.hpp:13411
PFN_vkDestroyCuModuleNVX vkDestroyCuModuleNVX
Definition: vulkan.hpp:12774
VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceScreenPresentationSupportQNX(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct _screen_window *window)
PFN_vkGetShaderModuleCreateInfoIdentifierEXT vkGetShaderModuleCreateInfoIdentifierEXT
Definition: vulkan.hpp:13440
PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR
Definition: vulkan.hpp:12653
PFN_vkGetImageViewAddressNVX vkGetImageViewAddressNVX
Definition: vulkan.hpp:12780
VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
void vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3164
void(VKAPI_PTR * PFN_vkDestroySamplerYcbcrConversion)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:5552
PFN_vkCmdSetColorBlendEquationEXT vkCmdSetColorBlendEquationEXT
Definition: vulkan.hpp:13415
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
Definition: vulkan.hpp:2278
void vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void *pData) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2070
PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV vkGetPhysicalDeviceExternalImageFormatPropertiesNV
Definition: vulkan.hpp:12801
void vkGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2303
void(VKAPI_PTR * PFN_vkCmdBuildAccelerationStructuresIndirectKHR)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkDeviceAddress *pIndirectDeviceAddresses, const uint32_t *pIndirectStrides, const uint32_t *const *ppMaxPrimitiveCounts)
void vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1323
VKAPI_ATTR void VKAPI_CALL vkCmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer, const VkExtent2D *pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR
Definition: vulkan.hpp:12942
void vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2195
PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT vkGetBufferOpaqueCaptureDescriptorDataEXT
Definition: vulkan.hpp:13239
VKAPI_ATTR VkResult VKAPI_CALL vkGetRefreshCycleDurationGOOGLE(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE *pDisplayTimingProperties)
VULKAN_HPP_CONSTEXPR bool operator!=(Flags< BitType > const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:427
PFN_vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2
Definition: vulkan.hpp:12567
VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties)
void vkCmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2713
VkFlags VkDescriptorPoolResetFlags
Definition: vulkan_core.h:2681
PFN_vkCmdDrawMultiIndexedEXT vkCmdDrawMultiIndexedEXT
Definition: vulkan.hpp:13367
void(VKAPI_PTR * PFN_vkCmdDrawIndexedIndirectCount)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
Definition: vulkan_core.h:6376
PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR
Definition: vulkan.hpp:12943
PFN_vkGetPhysicalDeviceToolPropertiesEXT vkGetPhysicalDeviceToolPropertiesEXT
Definition: vulkan.hpp:13126
void(VKAPI_PTR * PFN_vkCmdSetPatchControlPointsEXT)(VkCommandBuffer commandBuffer, uint32_t patchControlPoints)
PFN_vkCmdDecompressMemoryIndirectCountNV vkCmdDecompressMemoryIndirectCountNV
Definition: vulkan.hpp:13403
VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL *pOverrideInfo)
VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV *pViewportWScalings)
void(VKAPI_PTR * PFN_vkCmdPreprocessGeneratedCommandsNV)(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo)
VkResult vkGetMemoryFdKHR(VkDevice device, const VkMemoryGetFdInfoKHR *pGetFdInfo, int *pFd) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3457
void(VKAPI_PTR * PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
Definition: vulkan_core.h:4015
VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageToColorEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable)
VKAPI_ATTR VkResult VKAPI_CALL vkCopyMicromapToMemoryEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT *pInfo)
VKAPI_ATTR VkResult VKAPI_CALL vkMergeValidationCachesEXT(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT *pSrcCaches)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties)
Definition: vulkan_core.h:8036
VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites)
VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
PFN_vkGetDeviceMemoryOpaqueCaptureAddress vkGetDeviceMemoryOpaqueCaptureAddress
Definition: vulkan.hpp:12601
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pRectCount, VkRect2D *pRects)
VKAPI_ATTR VkResult VKAPI_CALL vkGetImageViewAddressNVX(VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX *pProperties)
VkResult vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo, VkDescriptorSet *pDescriptorSets) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1800
VkTessellationDomainOrigin
Definition: vulkan_core.h:4862
void vkGetDeviceMicromapCompatibilityEXT(VkDevice device, const VkMicromapVersionInfoEXT *pVersionInfo, VkAccelerationStructureCompatibilityKHR *pCompatibility) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5474
VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilOpEXT(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp)
VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable)
VKAPI_ATTR void VKAPI_CALL vkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo)
VkResult vkBuildAccelerationStructuresKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkAccelerationStructureBuildRangeInfoKHR *const *ppBuildRangeInfos) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4005
void
Definition: png.h:1083
PFN_vkCmdEndRenderPass2KHR vkCmdEndRenderPass2KHR
Definition: vulkan.hpp:12920
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT *pSurfaceCapabilities)
VKAPI_ATTR void VKAPI_CALL vkResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
void(VKAPI_PTR * PFN_vkCmdDrawMultiEXT)(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT *pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride)
PFN_vkCreatePipelineCache vkCreatePipelineCache
Definition: vulkan.hpp:12481
VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus(VkDevice device, VkFence fence)
VkResult vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1470
PFN_vkCreateDeferredOperationKHR vkCreateDeferredOperationKHR
Definition: vulkan.hpp:13179
void(VKAPI_PTR * PFN_vkCmdSetCoverageReductionModeNV)(VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode)
VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderingKHR(VkCommandBuffer commandBuffer)
VkResult vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1824
VkResult(VKAPI_PTR * PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, uint64_t timeout)
Definition: vulkan_core.h:3945
VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers)
void(VKAPI_PTR * PFN_vkCmdDrawMultiIndexedEXT)(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT *pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t *pVertexOffset)
void vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1952
PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices
Definition: vulkan.hpp:12422
void vkGetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3954
VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointDataNV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointDataNV *pCheckpointData)
void vkGetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t *pData) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4859
GLboolean * data
Definition: glcorearb.h:131
void swap(UT::ArraySet< Key, MULTI, MAX_LOAD_FACTOR_256, Clearer, Hash, KeyEqual > &a, UT::ArraySet< Key, MULTI, MAX_LOAD_FACTOR_256, Clearer, Hash, KeyEqual > &b)
Definition: UT_ArraySet.h:1639
void vkDestroyAccelerationStructureKHR(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3979
VkResult(VKAPI_PTR * PFN_vkDisplayPowerControlEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT *pDisplayPowerInfo)
VKAPI_ATTR void VKAPI_CALL vkGetDescriptorEXT(VkDevice device, const VkDescriptorGetInfoEXT *pDescriptorInfo, size_t dataSize, void *pDescriptor)
OutOfPoolMemoryError(std::string const &message)
Definition: vulkan.hpp:6268
VkResult(VKAPI_PTR * PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t *pPropertyCount, VkDisplayModePropertiesKHR *pProperties)
Definition: vulkan_core.h:7861
VkResult(VKAPI_PTR * PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
Definition: vulkan_core.h:3941
void(VKAPI_PTR * PFN_vkCmdBeginTransformFeedbackEXT)(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
PFN_vkGetDescriptorSetLayoutSupportKHR vkGetDescriptorSetLayoutSupportKHR
Definition: vulkan.hpp:13057
VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource *pSubresource, VkSubresourceLayout *pLayout)
void(VKAPI_PTR * PFN_vkCmdDispatchBaseKHR)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
Definition: vulkan_core.h:8103
VKAPI_ATTR uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
void(VKAPI_PTR * PFN_vkCmdEndConditionalRenderingEXT)(VkCommandBuffer commandBuffer)
void vkCmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2632
PFN_vkCopyMemoryToMicromapEXT vkCopyMemoryToMicromapEXT
Definition: vulkan.hpp:13376
VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo)
VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
void vkDestroyMicromapEXT(VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5401
const GLdouble * v
Definition: glcorearb.h:837
PFN_vkCmdBeginRenderPass2 vkCmdBeginRenderPass2
Definition: vulkan.hpp:12592
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures)
void(VKAPI_PTR * PFN_vkCmdSetRasterizationSamplesEXT)(VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples)
VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
void(VKAPI_PTR * PFN_vkDestroyBufferCollectionFUCHSIA)(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkAllocationCallbacks *pAllocator)
VkResult(VKAPI_PTR * PFN_vkGetMemoryWin32HandleNV)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE *pHandle)
Definition: vulkan_win32.h:228
VkResult(VKAPI_PTR * PFN_vkCmdSetPerformanceMarkerINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL *pMarkerInfo)
VkDeviceAddress(VKAPI_PTR * PFN_vkGetBufferDeviceAddressKHR)(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
Definition: vulkan_core.h:9330
VKAPI_ATTR void VKAPI_CALL vkCmdSetAlphaToCoverageEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable)
VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent(VkDevice device, VkEvent event)
void(VKAPI_PTR * PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth)
Definition: vulkan_core.h:4002
PFN_vkCmdSetRasterizerDiscardEnableEXT vkCmdSetRasterizerDiscardEnableEXT
Definition: vulkan.hpp:13345
VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo)
PFN_vkCmdSetViewportWithCountEXT vkCmdSetViewportWithCountEXT
Definition: vulkan.hpp:13168
VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreFdKHR(VkDevice device, const VkImportSemaphoreFdInfoKHR *pImportSemaphoreFdInfo)
void vkSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3905
void vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1653
VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve *pRegions)
const T & back() const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:824
void vkCmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4791
void(VKAPI_PTR * PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource *pSubresource, VkSubresourceLayout *pLayout)
Definition: vulkan_core.h:3962
VkResult(VKAPI_PTR * PFN_vkGetRayTracingShaderGroupHandlesNV)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer, const VkCopyImageInfo2 *pCopyImageInfo)
VkResult(VKAPI_PTR * PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineCache *pPipelineCache)
Definition: vulkan_core.h:3967
VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
void(VKAPI_PTR * PFN_vkCmdSetDepthBoundsTestEnable)(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable)
Definition: vulkan_core.h:7319
VKAPI_ATTR VkResult VKAPI_CALL vkAcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display *dpy, VkDisplayKHR display)
PFN_vkCopyMicromapToMemoryEXT vkCopyMicromapToMemoryEXT
Definition: vulkan.hpp:13375
void(VKAPI_PTR * PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE)(VkDevice device, const VkDescriptorSetBindingReferenceVALVE *pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE *pHostMapping)
VkResult(VKAPI_PTR * PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDisplayModeKHR *pMode)
Definition: vulkan_core.h:7862
VkResult(VKAPI_PTR * PFN_vkGetImageDrmFormatModifierPropertiesEXT)(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT *pProperties)
void vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer, const VkDependencyInfo *pDependencyInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4903
VKAPI_ATTR void VKAPI_CALL vkCmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode)
VKAPI_ATTR VkResult VKAPI_CALL vkSignalSemaphoreKHR(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo)
VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages)
VkResult vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2259
VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t *pPropertyCount, VkDisplayModeProperties2KHR *pProperties)
void(VKAPI_PTR * PFN_vkUpdateDescriptorSetWithTemplateKHR)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData)
Definition: vulkan_core.h:8408
void(VKAPI_PTR * PFN_vkCmdDebugMarkerBeginEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo)
Definition: vulkan_core.h:9991
VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImage *pImage)
PFN_vkGetDeviceImageMemoryRequirements vkGetDeviceImageMemoryRequirements
Definition: vulkan.hpp:12639
GLsizei const GLchar *const * string
Definition: glcorearb.h:814
GLsizei const GLfloat * value
Definition: glcorearb.h:824
void(VKAPI_PTR * PFN_vkCmdDecodeVideoKHR)(VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR *pDecodeInfo)
Definition: vulkan_beta.h:363
void(VKAPI_PTR * PFN_vkCmdResetEvent2KHR)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask)
Definition: vulkan_core.h:9563
VKAPI_ATTR VkResult VKAPI_CALL vkGetBufferCollectionPropertiesFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, VkBufferCollectionPropertiesFUCHSIA *pProperties)
void vkCmdBuildAccelerationStructuresKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkAccelerationStructureBuildRangeInfoKHR *const *ppBuildRangeInfos) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3986
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties)
PFN_vkCmdBeginQueryIndexedEXT vkCmdBeginQueryIndexedEXT
Definition: vulkan.hpp:12767
RefType const * operator->() const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:912
auto system_error(int error_code, format_string< T...> fmt, T &&...args) -> std::system_error
Definition: format.h:2240
PFN_vkCmdBindVertexBuffers2EXT vkCmdBindVertexBuffers2EXT
Definition: vulkan.hpp:13170
PFN_vkUninitializePerformanceApiINTEL vkUninitializePerformanceApiINTEL
Definition: vulkan.hpp:13092
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
FragmentedPoolError(std::string const &message)
Definition: vulkan.hpp:6254
PFN_vkVoidFunction vkGetInstanceProcAddr(VkInstance instance, const char *pName) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1372
void vkSetHdrMetadataEXT(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR *pSwapchains, const VkHdrMetadataEXT *pMetadata) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3667
void(VKAPI_PTR * PFN_vkCmdResolveImage2)(VkCommandBuffer commandBuffer, const VkResolveImageInfo2 *pResolveImageInfo)
Definition: vulkan_core.h:7307
VkOpticalFlowSessionBindingPointNV
void vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment *pAttachments, uint32_t rectCount, const VkClearRect *pRects) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2102
VkResult(VKAPI_PTR * PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache *pSrcCaches)
Definition: vulkan_core.h:3970
void(VKAPI_PTR * PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport *pViewports)
Definition: vulkan_core.h:4000
VkResult(VKAPI_PTR * PFN_vkGetSwapchainCounterEXT)(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t *pCounterValue)
void(VKAPI_PTR * PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements *pSparseMemoryRequirements)
Definition: vulkan_core.h:3938
PFN_dummy vkGetPhysicalDeviceWaylandPresentationSupportKHR_placeholder
Definition: vulkan.hpp:12696
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures)
Definition: vulkan_core.h:3909
VkResult vkCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4270
VKAPI_ATTR void VKAPI_CALL vkCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV *pCustomSampleOrders)
void(VKAPI_PTR * PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3957
VkDebugReportObjectTypeEXT
Definition: vulkan_core.h:9817
void vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2203
void(VKAPI_PTR * PFN_vkCmdDecompressMemoryIndirectCountNV)(VkCommandBuffer commandBuffer, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t stride)
VkResult vkEnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1395
void vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, const VkSubpassBeginInfo *pSubpassBeginInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2471
T const * data() const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:684
uint32_t vkGetImageViewHandleNVX(VkDevice device, const VkImageViewHandleInfoNVX *pInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3230
PFN_vkSetDebugUtilsObjectNameEXT vkSetDebugUtilsObjectNameEXT
Definition: vulkan.hpp:12972
void vkCmdSetProvokingVertexModeEXT(VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5672
VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCommandPool *pCommandPool)
SystemError(int ev, std::error_category const &ecat, char const *what)
Definition: vulkan.hpp:6150
VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT *pInfo)
void(VKAPI_PTR * PFN_vkCmdSetAlphaToOneEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable)
PFN_vkCmdWriteBufferMarker2AMD vkCmdWriteBufferMarker2AMD
Definition: vulkan.hpp:13229
void vkCmdCopyMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT *pInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5449
PFN_vkDestroyIndirectCommandsLayoutNV vkDestroyIndirectCommandsLayoutNV
Definition: vulkan.hpp:13196
VKAPI_ATTR void VKAPI_CALL vkCmdExecuteGeneratedCommandsNV(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo)
void vkCmdSetSampleLocationsEnableEXT(VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5659
void vkDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3898
VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
PFN_vkCmdSetPerformanceOverrideINTEL vkCmdSetPerformanceOverrideINTEL
Definition: vulkan.hpp:13095
VkResult vkInitializePerformanceApiINTEL(VkDevice device, const VkInitializePerformanceApiInfoINTEL *pInitializeInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4447
VKAPI_ATTR VkResult VKAPI_CALL vkDisplayPowerControlEXT(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT *pDisplayPowerInfo)
GLuint64 GLenum handleType
Definition: RE_OGL.h:262
VKAPI_ATTR void VKAPI_CALL vkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo)
void(VKAPI_PTR * PFN_vkCmdWriteAccelerationStructuresPropertiesKHR)(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR *pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
PFN_vkCmdEndRenderPass vkCmdEndRenderPass
Definition: vulkan.hpp:12555
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp)
PFN_vkCmdSetDepthWriteEnable vkCmdSetDepthWriteEnable
Definition: vulkan.hpp:12630
VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode)
VKAPI_ATTR void VKAPI_CALL vkCmdCopyMicromapToMemoryEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT *pInfo)
void(VKAPI_PTR * PFN_vkCmdCopyImage2KHR)(VkCommandBuffer commandBuffer, const VkCopyImageInfo2 *pCopyImageInfo)
Definition: vulkan_core.h:9693
VkResult vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1837
ArrayProxy(V const &v) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:646
void vkCmdSetRepresentativeFragmentTestEnableNV(VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5737
void(VKAPI_PTR * PFN_vkGetDeviceMicromapCompatibilityEXT)(VkDevice device, const VkMicromapVersionInfoEXT *pVersionInfo, VkAccelerationStructureCompatibilityKHR *pCompatibility)
ArrayProxy(std::initializer_list< T > const &list) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:624
PFN_vkCmdDrawIndirectCountAMD vkCmdDrawIndirectCountAMD
Definition: vulkan.hpp:12783
DynamicLoader(DynamicLoader &&other) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:12359
PFN_vkGetPhysicalDeviceImageFormatProperties2KHR vkGetPhysicalDeviceImageFormatProperties2KHR
Definition: vulkan.hpp:12814
PFN_vkCmdBuildMicromapsEXT vkCmdBuildMicromapsEXT
Definition: vulkan.hpp:13372
void vkCmdCopyMemoryIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5536
virtual std::string message(int ev) const override
Definition: vulkan.hpp:6106
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixPropertiesNV *pProperties)
void(VKAPI_PTR * PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3979
void vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2190
void vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1749
PFN_vkCmdSetLogicOpEXT vkCmdSetLogicOpEXT
Definition: vulkan.hpp:13347
VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleLocationsEnableEXT(VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable)
void vkCmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4655
void vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2396
PFN_vkCmdDrawIndirectCount vkCmdDrawIndirectCount
Definition: vulkan.hpp:12589
VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSparseMemoryRequirementsKHR(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
void vkDestroyPrivateDataSlotEXT(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4848
DynamicLoader(std::string const &vulkanLibraryName={})
Definition: vulkan.hpp:12318
void(VKAPI_PTR * PFN_vkCmdDrawIndexedIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
PFN_vkCmdSetCoverageModulationTableNV vkCmdSetCoverageModulationTableNV
Definition: vulkan.hpp:13433
VKAPI_ATTR void VKAPI_CALL vkCmdSetDescriptorBufferOffsetsEXT(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t *pBufferIndices, const VkDeviceSize *pOffsets)
VKAPI_ATTR void VKAPI_CALL vkDestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks *pAllocator)
PFN_vkCmdDebugMarkerInsertEXT vkCmdDebugMarkerInsertEXT
Definition: vulkan.hpp:12725
PFN_vkGetRayTracingShaderGroupHandlesKHR vkGetRayTracingShaderGroupHandlesKHR
Definition: vulkan.hpp:13288
VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
void(VKAPI_PTR * PFN_vkCmdDrawIndirectCountKHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
Definition: vulkan_core.h:8994
VkFlags VkDebugUtilsMessageTypeFlagsEXT
VKAPI_ATTR void VKAPI_CALL vkDestroyPrivateDataSlotEXT(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks *pAllocator)
PFN_vkGetDisplayPlaneCapabilitiesKHR vkGetDisplayPlaneCapabilitiesKHR
Definition: vulkan.hpp:12666
void vkCmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2708
PFN_vkCmdSetLineRasterizationModeEXT vkCmdSetLineRasterizationModeEXT
Definition: vulkan.hpp:13424
void vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1736
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties)
Definition: vulkan_core.h:5543
PFN_vkGetMemoryHostPointerPropertiesEXT vkGetMemoryHostPointerPropertiesEXT
Definition: vulkan.hpp:13064
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties)
VkResult vkGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t *pPropertyCount, VkDisplayModePropertiesKHR *pProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2861
VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport *pViewports)
void vkCmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4918
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
Definition: vulkan.hpp:4237
void(VKAPI_PTR * PFN_vkCmdCopyBuffer2)(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 *pCopyBufferInfo)
Definition: vulkan_core.h:7302
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties *pMemoryProperties)
Definition: vulkan_core.h:3914
VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizationStreamEXT(VkCommandBuffer commandBuffer, uint32_t rasterizationStream)
VkResult(VKAPI_PTR * PFN_vkCreateImagePipeSurfaceFUCHSIA)(VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
void vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, const VkSubpassBeginInfo *pSubpassBeginInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3685
VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportSwizzleNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV *pViewportSwizzles)
void vkCmdDecompressMemoryNV(VkCommandBuffer commandBuffer, uint32_t decompressRegionCount, const VkDecompressMemoryRegionNV *pDecompressMemoryRegions) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5557
void vkCmdEndRenderingKHR(VkCommandBuffer commandBuffer) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3283
VkResult vkGetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayProperties2KHR *pProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3795
StridedArrayProxy(uint32_t count, T const *ptr, uint32_t stride) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:856
uint64_t DeviceAddress
Definition: vulkan.hpp:6074
void(VKAPI_PTR * PFN_vkCmdResetEvent2)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask)
Definition: vulkan_core.h:7297
VKAPI_ATTR void VKAPI_CALL vkGetShaderModuleCreateInfoIdentifierEXT(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, VkShaderModuleIdentifierEXT *pIdentifier)
void(VKAPI_PTR * PFN_vkResetQueryPoolEXT)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
PFN_vkVoidFunction(VKAPI_PTR * PFN_vkGetDeviceProcAddr)(VkDevice device, const char *pName)
Definition: vulkan_core.h:3916
PFN_vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties
Definition: vulkan.hpp:12424
VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator)
PFN_vkCmdBindInvocationMaskHUAWEI vkCmdBindInvocationMaskHUAWEI
Definition: vulkan.hpp:13335
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceExternalFenceProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties)
Definition: vulkan_core.h:5557
PFN_vkCmdDrawIndexedIndirect vkCmdDrawIndexedIndirect
Definition: vulkan.hpp:12529
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryZirconHandleFUCHSIA(VkDevice device, const VkMemoryGetZirconHandleInfoFUCHSIA *pGetZirconHandleInfo, zx_handle_t *pZirconHandle)
VkResult vkGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR *pDeviceGroupPresentCapabilities) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2812
void(VKAPI_PTR * PFN_vkCmdBeginRenderingKHR)(VkCommandBuffer commandBuffer, const VkRenderingInfo *pRenderingInfo)
Definition: vulkan_core.h:7987
void vkCmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2683
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
Definition: vulkan.hpp:2657
VKAPI_ATTR void VKAPI_CALL vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator)
VkFlags VkCullModeFlags
Definition: vulkan_core.h:2630
FragmentationError(char const *message)
Definition: vulkan.hpp:6283
VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureMemoryRequirementsNV(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2KHR *pMemoryRequirements)
VkFlags VkColorComponentFlags
Definition: vulkan_core.h:2541
VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressEXT(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
PFN_vkCmdTraceRaysIndirect2KHR vkCmdTraceRaysIndirect2KHR
Definition: vulkan.hpp:13363
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
Definition: vulkan.hpp:2157
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties)
Definition: vulkan_core.h:8035
PFN_vkGetDeviceImageMemoryRequirementsKHR vkGetDeviceImageMemoryRequirementsKHR
Definition: vulkan.hpp:13390
PFN_vkGetBufferDeviceAddress vkGetBufferDeviceAddress
Definition: vulkan.hpp:12599
PFN_vkGetDeviceMicromapCompatibilityEXT vkGetDeviceMicromapCompatibilityEXT
Definition: vulkan.hpp:13382
void vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4706
VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void **ppData)
VkResult(VKAPI_PTR * PFN_vkGetDeviceGroupSurfacePresentModesKHR)(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR *pModes)
Definition: vulkan_core.h:7729
VkResult(VKAPI_PTR * PFN_vkGetAccelerationStructureHandleNV)(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void *pData)
void(VKAPI_PTR * PFN_vkCmdOpticalFlowExecuteNV)(VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV *pExecuteInfo)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT)(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT *pMultisampleProperties)
void vkCmdSetAlphaToOneEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5604
VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache *pSrcCaches)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties)
Definition: vulkan_core.h:8269
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities)
Definition: vulkan_core.h:7591
VkResult(VKAPI_PTR * PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t *pDataSize, void *pData)
Definition: vulkan_core.h:3969
void(VKAPI_PTR * PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT)(VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize)
void(VKAPI_PTR * PFN_vkCmdTraceRaysKHR)(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth)
VkResult(VKAPI_PTR * PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT *pInfo, void *pData)
const T * begin() const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:652
PFN_vkCmdSetSampleMaskEXT vkCmdSetSampleMaskEXT
Definition: vulkan.hpp:13410
void(VKAPI_PTR * PFN_vkSubmitDebugUtilsMessageEXT)(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData)
VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable)
void(VKAPI_PTR * PFN_vkCmdDecompressMemoryNV)(VkCommandBuffer commandBuffer, uint32_t decompressRegionCount, const VkDecompressMemoryRegionNV *pDecompressMemoryRegions)
void(VKAPI_PTR * PFN_vkReleaseProfilingLockKHR)(VkDevice device)
Definition: vulkan_core.h:8692
void(VKAPI_PTR * PFN_vkCmdSetCoverageModulationTableEnableNV)(VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable)
void(VKAPI_PTR * PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set)
Type & operator*() VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1227
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
Definition: vulkan.hpp:4680
VkResult vkAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR *pAcquireInfo, uint32_t *pImageIndex) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2832
PFN_vkEnumeratePhysicalDeviceGroupsKHR vkEnumeratePhysicalDeviceGroupsKHR
Definition: vulkan.hpp:12835
void vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3880
VkResult(VKAPI_PTR * PFN_vkGetCalibratedTimestampsEXT)(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT *pTimestampInfos, uint64_t *pTimestamps, uint64_t *pMaxDeviation)
VkResult(VKAPI_PTR * PFN_vkAcquireProfilingLockKHR)(VkDevice device, const VkAcquireProfilingLockInfoKHR *pInfo)
Definition: vulkan_core.h:8691
void(VKAPI_PTR * PFN_vkCmdDrawIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
void vkCmdSetStencilTestEnable(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2688
VkFlags VkCommandPoolTrimFlags
Definition: vulkan_core.h:4944
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceExternalBufferProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties)
Definition: vulkan_core.h:5556
VKAPI_ATTR VkResult VKAPI_CALL vkGetFramebufferTilePropertiesQCOM(VkDevice device, VkFramebuffer framebuffer, uint32_t *pPropertiesCount, VkTilePropertiesQCOM *pProperties)
void vkQueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3860
PFN_vkCreateDescriptorPool vkCreateDescriptorPool
Definition: vulkan.hpp:12494
const T & front() const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:818
VkFilter
Definition: vulkan_core.h:2024
void(VKAPI_PTR * PFN_vkDestroyDebugUtilsMessengerEXT)(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks *pAllocator)
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR)(VkPhysicalDevice physicalDevice, const VkVideoProfileInfoKHR *pVideoProfile, VkVideoCapabilitiesKHR *pCapabilities)
Definition: vulkan_beta.h:240
PFN_vkCmdCopyBufferToImage2 vkCmdCopyBufferToImage2
Definition: vulkan.hpp:12617
void(VKAPI_PTR * PFN_vkDestroyDebugReportCallbackEXT)(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:9892
PFN_vkCreateRenderPass vkCreateRenderPass
Definition: vulkan.hpp:12502
VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkShaderModule *pShaderModule)
VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures)
void(VKAPI_PTR * PFN_vkResetQueryPool)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
Definition: vulkan_core.h:6381
void vkGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3360
VkResult vkSetEvent(VkDevice device, VkEvent event) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1584
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats)
Definition: vulkan_core.h:7592
PFN_vkCreatePipelineLayout vkCreatePipelineLayout
Definition: vulkan.hpp:12488
VkResult(VKAPI_PTR * PFN_vkCreateViSurfaceNN)(VkInstance instance, const VkViSurfaceCreateInfoNN *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
Definition: vulkan_vi.h:33
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable)
PFN_vkCmdSetViewportSwizzleNV vkCmdSetViewportSwizzleNV
Definition: vulkan.hpp:13428
VkResult(VKAPI_PTR * PFN_vkAcquireNextImage2KHR)(VkDevice device, const VkAcquireNextImageInfoKHR *pAcquireInfo, uint32_t *pImageIndex)
Definition: vulkan_core.h:7731
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties)
PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR vkGetPhysicalDeviceExternalBufferPropertiesKHR
Definition: vulkan.hpp:12838
VKAPI_ATTR void VKAPI_CALL vkGetDeviceBufferMemoryRequirements(VkDevice device, const VkDeviceBufferMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
PFN_vkDestroySemaphore vkDestroySemaphore
Definition: vulkan.hpp:12461
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPlaneProperties2KHR *pProperties)
Definition: vulkan_core.h:8819
VKAPI_ATTR void VKAPI_CALL vkDestroyAccelerationStructureNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks *pAllocator)
void(VKAPI_PTR * PFN_vkCmdBuildAccelerationStructuresKHR)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkAccelerationStructureBuildRangeInfoKHR *const *ppBuildRangeInfos)
PFN_vkCmdEndConditionalRenderingEXT vkCmdEndConditionalRenderingEXT
Definition: vulkan.hpp:12875
VKAPI_ATTR void VKAPI_CALL vkQueueEndDebugUtilsLabelEXT(VkQueue queue)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceFeatures2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures)
Definition: vulkan_core.h:5542
VKAPI_ATTR VkResult VKAPI_CALL vkCreateVideoSessionParametersKHR(VkDevice device, const VkVideoSessionParametersCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkVideoSessionParametersKHR *pVideoSessionParameters)
PFN_vkDestroyBufferView vkDestroyBufferView
Definition: vulkan.hpp:12473
VkResult(VKAPI_PTR * PFN_vkGetImageViewAddressNVX)(VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX *pProperties)
void vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, VkSubpassContents contents) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2225
void(VKAPI_PTR * PFN_vkSetDeviceMemoryPriorityEXT)(VkDevice device, VkDeviceMemory memory, float priority)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDevice *pDevice)
void vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1421
PFN_vkCopyAccelerationStructureToMemoryKHR vkCopyAccelerationStructureToMemoryKHR
Definition: vulkan.hpp:13009
void vkCmdSetCoverageToColorLocationNV(VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5710
void(VKAPI_PTR * PFN_vkGetAccelerationStructureMemoryRequirementsNV)(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2KHR *pMemoryRequirements)
VULKAN_HPP_CONSTEXPR ArrayProxyNoTemporaries() VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:698
PFN_vkGetShaderInfoAMD vkGetShaderInfoAMD
Definition: vulkan.hpp:12787
void vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2425
PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR vkGetPhysicalDeviceExternalFencePropertiesKHR
Definition: vulkan.hpp:12926
void(VKAPI_PTR * PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, VkSubpassContents contents)
Definition: vulkan_core.h:4039
void(VKAPI_PTR * PFN_vkCmdSetColorBlendEquationEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT *pColorBlendEquations)
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceToolProperties)(VkPhysicalDevice physicalDevice, uint32_t *pToolCount, VkPhysicalDeviceToolProperties *pToolProperties)
Definition: vulkan_core.h:7291
VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImageView *pView)
PFN_vkGetImageSparseMemoryRequirements2KHR vkGetImageSparseMemoryRequirements2KHR
Definition: vulkan.hpp:13000
OutOfHostMemoryError(char const *message)
Definition: vulkan.hpp:6178
VkResult vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineCache *pPipelineCache) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1692
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryAndroidHardwareBufferANDROID(VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID *pInfo, struct AHardwareBuffer **pBuffer)
VkSurfaceCounterFlagBitsEXT
VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent(VkDevice device, VkEvent event)
void vkCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4321
void vkSetLocalDimmingAMD(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4498
**But if you need a or simply need to know when the task has note that the like this
Definition: thread.h:617
void vkCmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D *pScissors) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2652
void vkCmdSetVertexInputEXT(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT *pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT *pVertexAttributeDescriptions) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5185
VKAPI_ATTR VkResult VKAPI_CALL vkSetBufferCollectionBufferConstraintsFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkBufferConstraintsInfoFUCHSIA *pBufferConstraintsInfo)
VkResult vkCmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL *pOverrideInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4468
void(VKAPI_PTR * PFN_vkGetDeviceAccelerationStructureCompatibilityKHR)(VkDevice device, const VkAccelerationStructureVersionInfoKHR *pVersionInfo, VkAccelerationStructureCompatibilityKHR *pCompatibility)
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
Definition: vulkan.hpp:4216
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPlanePropertiesKHR *pProperties)
Definition: vulkan_core.h:7859
void vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3509
void(VKAPI_PTR * PFN_vkCmdSetRayTracingPipelineStackSizeKHR)(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize)
GLenum GLenum GLsizei void * image
Definition: glad.h:5132
VKAPI_ATTR void VKAPI_CALL vkCmdDrawMultiIndexedEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT *pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t *pVertexOffset)
PFN_vkSetDeviceMemoryPriorityEXT vkSetDeviceMemoryPriorityEXT
Definition: vulkan.hpp:13386
PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR
Definition: vulkan.hpp:12643
VkResult vkEnumerateInstanceVersion(uint32_t *pApiVersion) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2249
void(VKAPI_PTR * PFN_vkGetDescriptorSetHostMappingVALVE)(VkDevice device, VkDescriptorSet descriptorSet, void **ppData)
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties)
void vkGetShaderModuleIdentifierEXT(VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT *pIdentifier) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5749
void vkCmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2668
VKAPI_ATTR void VKAPI_CALL vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer)
void(VKAPI_PTR * PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
Definition: vulkan_core.h:4013
VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator)
VULKAN_HPP_CONSTEXPR ArrayWrapper1D(std::array< T, N > const &data) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:244
T getProcAddress(const char *function) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:12387
VkResult vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1538
PFN_vkCmdResolveImage2KHR vkCmdResolveImage2KHR
Definition: vulkan.hpp:13259
void(VKAPI_PTR * PFN_vkCmdSetColorBlendAdvancedEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT *pColorBlendAdvanced)
PFN_vkCmdSetFragmentShadingRateEnumNV vkCmdSetFragmentShadingRateEnumNV
Definition: vulkan.hpp:13246
VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo, VkDescriptorSet *pDescriptorSets)
VKAPI_ATTR void VKAPI_CALL vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_t patchControlPoints)
void vkCmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5320
VkResult vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t *pDataSize, void *pData) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1705
VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp)
VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks *pAllocator)
void vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1640
VkResult vkGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT *pTimestampInfos, uint64_t *pTimestamps, uint64_t *pMaxDeviation) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4373
void vkDestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4144
VkResult(VKAPI_PTR * PFN_vkCopyMicromapToMemoryEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT *pInfo)
void(VKAPI_PTR * PFN_vkCmdDrawMeshTasksIndirectEXT)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
VkResult vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2388
VkFlags VkPipelineStageFlags
Definition: vulkan_core.h:2401
void vkGetDeviceImageMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2725
Type const * operator->() const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1212
bool empty() const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:830
VkResult vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo, VkCommandBuffer *pCommandBuffers) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1873
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable)
PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges
Definition: vulkan.hpp:12446
VkResult vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1716
const T & back() const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:668
VkResult vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1382
PFN_vkCmdOpticalFlowExecuteNV vkCmdOpticalFlowExecuteNV
Definition: vulkan.hpp:13447
**But if you need a result
Definition: thread.h:613
void(VKAPI_PTR * PFN_vkCmdEndTransformFeedbackEXT)(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
VkResult(VKAPI_PTR * PFN_vkCopyMemoryToAccelerationStructureKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo)
void(VKAPI_PTR * PFN_vkCmdTraceRaysIndirectKHR)(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress)
VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveTopology(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology)
VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage2(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 *pCopyBufferToImageInfo)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool)
void vkCmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void *pCheckpointMarker) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4418
VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchains)
void vkCmdCopyBuffer2(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 *pCopyBufferInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2592
VkResult(VKAPI_PTR * PFN_vkCreateAccelerationStructureKHR)(VkDevice device, const VkAccelerationStructureCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureKHR *pAccelerationStructure)
VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversionKHR(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator)
VkFlags VkExternalMemoryHandleTypeFlagsNV
VULKAN_HPP_CONSTEXPR_14 Flags< BitType > & operator^=(Flags< BitType > const &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:475
void(VKAPI_PTR * PFN_vkCmdEndDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer)
void vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties *pFormatProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1339
VkResult(VKAPI_PTR * PFN_vkCreateDebugReportCallbackEXT)(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pCallback)
Definition: vulkan_core.h:9891
VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures)
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceFormatProperties2KHR)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties)
Definition: vulkan_core.h:8034
void init(VULKAN_HPP_NAMESPACE::Instance const &instance, VULKAN_HPP_NAMESPACE::Device const &device) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:15681
VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainCounterEXT(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t *pCounterValue)
VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceFdKHR(VkDevice device, const VkImportFenceFdInfoKHR *pImportFenceFdInfo)
void vkGetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3947
void vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1533
TooManyObjectsError(std::string const &message)
Definition: vulkan.hpp:6240
void vkGetDescriptorSetLayoutBindingOffsetEXT(VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize *pOffset) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4936
VkResult(VKAPI_PTR * PFN_vkGetPipelineExecutableInternalRepresentationsKHR)(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR *pInternalRepresentations)
Definition: vulkan_core.h:9451
void(VKAPI_PTR * PFN_vkCmdSetDiscardRectangleEXT)(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D *pDiscardRectangles)
PFN_vkCmdClearAttachments vkCmdClearAttachments
Definition: vulkan.hpp:12541
void(VKAPI_PTR * PFN_vkExportMetalObjectsEXT)(VkDevice device, VkExportMetalObjectsInfoEXT *pMetalObjectsInfo)
Definition: vulkan_metal.h:181
VkPresentModeKHR
Definition: vulkan_core.h:7517
VkResult(VKAPI_PTR * PFN_vkGetMemoryHostPointerPropertiesEXT)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void *pHostPointer, VkMemoryHostPointerPropertiesEXT *pMemoryHostPointerProperties)
VKAPI_ATTR void VKAPI_CALL vkCmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV *pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
PFN_vkCreateSamplerYcbcrConversionKHR vkCreateSamplerYcbcrConversionKHR
Definition: vulkan.hpp:13021
VKAPI_ATTR void VKAPI_CALL vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes)
void(VKAPI_PTR * PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
Definition: vulkan_core.h:4024
GLuint sampler
Definition: glcorearb.h:1656
PFN_vkCmdEndQueryIndexedEXT vkCmdEndQueryIndexedEXT
Definition: vulkan.hpp:12768
VkResult(VKAPI_PTR * PFN_vkGetImageOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkImageCaptureDescriptorDataInfoEXT *pInfo, void *pData)
PFN_vkInitializePerformanceApiINTEL vkInitializePerformanceApiINTEL
Definition: vulkan.hpp:13091
PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT vkGetImageViewOpaqueCaptureDescriptorDataEXT
Definition: vulkan.hpp:13241
const T * begin() const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:808
void(VKAPI_PTR * PFN_vkCmdSetDeviceMask)(VkCommandBuffer commandBuffer, uint32_t deviceMask)
Definition: vulkan_core.h:5536
PFN_vkGetDeviceBufferMemoryRequirements vkGetDeviceBufferMemoryRequirements
Definition: vulkan.hpp:12638
ExtensionNotPresentError(std::string const &message)
Definition: vulkan.hpp:6219
VkResult(VKAPI_PTR * PFN_vkCreateCuFunctionNVX)(VkDevice device, const VkCuFunctionCreateInfoNVX *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCuFunctionNVX *pFunction)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
PFN_vkCmdPreprocessGeneratedCommandsNV vkCmdPreprocessGeneratedCommandsNV
Definition: vulkan.hpp:13192
VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier2(VkCommandBuffer commandBuffer, const VkDependencyInfo *pDependencyInfo)
void vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t *pPropertyCount, VkSparseImageFormatProperties *pProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1508
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties)
void(VKAPI_PTR * PFN_vkDestroyPrivateDataSlotEXT)(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks *pAllocator)
PFN_vkCmdWriteTimestamp vkCmdWriteTimestamp
Definition: vulkan.hpp:12550
VkResult vkBuildMicromapsEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT *pInfos) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5411
void(VKAPI_PTR * PFN_vkCmdWaitEvents2)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, const VkDependencyInfo *pDependencyInfos)
Definition: vulkan_core.h:7298
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceFragmentShadingRatesKHR(VkPhysicalDevice physicalDevice, uint32_t *pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR *pFragmentShadingRates)
void(VKAPI_PTR * PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
Definition: vulkan_core.h:4029
void vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1574
VKAPI_ATTR VkResult VKAPI_CALL vkCreateVideoSessionKHR(VkDevice device, const VkVideoSessionCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkVideoSessionKHR *pVideoSession)
VKAPI_ATTR void VKAPI_CALL vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator)
VkResult(VKAPI_PTR * PFN_vkImportSemaphoreFdKHR)(VkDevice device, const VkImportSemaphoreFdInfoKHR *pImportSemaphoreFdInfo)
Definition: vulkan_core.h:8309
VkBool32(VKAPI_PTR * PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display *dpy, VisualID visualID)
Definition: vulkan_xlib.h:35
PFN_vkCmdSetPrimitiveTopology vkCmdSetPrimitiveTopology
Definition: vulkan.hpp:12625
void(VKAPI_PTR * PFN_vkCmdCopyImage2)(VkCommandBuffer commandBuffer, const VkCopyImageInfo2 *pCopyImageInfo)
Definition: vulkan_core.h:7303
PFN_vkGetPhysicalDeviceDisplayPropertiesKHR vkGetPhysicalDeviceDisplayPropertiesKHR
Definition: vulkan.hpp:12661
VKAPI_ATTR void VKAPI_CALL vkCmdDrawMultiEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT *pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride)
void vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2077
PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV
Definition: vulkan.hpp:13135
OutOfDeviceMemoryError(std::string const &message)
Definition: vulkan.hpp:6184
VkResult vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t *pCounterCount, VkPerformanceCounterKHR *pCounters, VkPerformanceCounterDescriptionKHR *pCounterDescriptions) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3749
void vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2342
VkResult vkRegisterDisplayEventEXT(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT *pDisplayEventInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3621
PFN_vkCopyMemoryToAccelerationStructureKHR vkCopyMemoryToAccelerationStructureKHR
Definition: vulkan.hpp:13010
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
Definition: vulkan.hpp:1957
void(VKAPI_PTR * PFN_vkCmdCopyMemoryToAccelerationStructureKHR)(VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo)
PFN_vkCreateRayTracingPipelinesKHR vkCreateRayTracingPipelinesKHR
Definition: vulkan.hpp:13287
VkResult vkGetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo *pRenderingInfo, VkTilePropertiesQCOM *pProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5810
VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout2EXT(VkDevice device, VkImage image, const VkImageSubresource2EXT *pSubresource, VkSubresourceLayout2EXT *pLayout)
void(VKAPI_PTR * PFN_vkGetImageSparseMemoryRequirements2KHR)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
Definition: vulkan_core.h:8881
VkResult(VKAPI_PTR * PFN_vkCopyMicromapEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT *pInfo)
VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, const VkDependencyInfo *pDependencyInfos)
void(VKAPI_PTR * PFN_vkCmdCopyMemoryIndirectNV)(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride)
void(VKAPI_PTR * PFN_vkDestroyVideoSessionParametersKHR)(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_beta.h:248
void(VKAPI_PTR * PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3961
VkResult(VKAPI_PTR * PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBufferView *pView)
Definition: vulkan_core.h:3958
VKAPI_ATTR void VKAPI_CALL vkCmdEncodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR *pEncodeInfo)
VkResult(VKAPI_PTR * PFN_vkSetPrivateDataEXT)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data)
void vkCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4229
FragmentedPoolError(char const *message)
Definition: vulkan.hpp:6255
VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
VkResult(VKAPI_PTR * PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
Definition: vulkan_core.h:3971
VkExternalMemoryHandleTypeFlagBits
Definition: vulkan_core.h:4947
ArrayProxyNoTemporaries(std::initializer_list< typename std::remove_const< T >::type > const &list) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:771
VkResult vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5153
void(VKAPI_PTR * PFN_vkCmdSetDepthTestEnable)(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable)
Definition: vulkan_core.h:7316
void vkGetDeviceAccelerationStructureCompatibilityKHR(VkDevice device, const VkAccelerationStructureVersionInfoKHR *pVersionInfo, VkAccelerationStructureCompatibilityKHR *pCompatibility) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4080
VkResult vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1402
VkResult(VKAPI_PTR * PFN_vkCreateValidationCacheEXT)(VkDevice device, const VkValidationCacheCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkValidationCacheEXT *pValidationCache)
VKAPI_ATTR void VKAPI_CALL vkGetMicromapBuildSizesEXT(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT *pBuildInfo, VkMicromapBuildSizesInfoEXT *pSizeInfo)
PFN_vkGetPhysicalDeviceFeatures2 vkGetPhysicalDeviceFeatures2
Definition: vulkan.hpp:12569
void vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1762
VKAPI_ATTR VkResult VKAPI_CALL vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout)
void vkCmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV *pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4294
PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties
Definition: vulkan.hpp:12426
ArrayProxyNoTemporaries(std::initializer_list< T > const &list) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:762
void(VKAPI_PTR * PFN_vkCmdSetEvent2)(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo *pDependencyInfo)
Definition: vulkan_core.h:7296
VKAPI_ATTR VkResult VKAPI_CALL vkReleaseFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain)
VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo *pDependencyInfo)
VkShaderGroupShaderKHR
VKAPI_ATTR void VKAPI_CALL vkReleaseProfilingLockKHR(VkDevice device)
VkResult(VKAPI_PTR * PFN_vkAcquireWinrtDisplayNV)(VkPhysicalDevice physicalDevice, VkDisplayKHR display)
Definition: vulkan_win32.h:315
VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t *pDynamicOffsets)
VkResult vkDeferredOperationJoinKHR(VkDevice device, VkDeferredOperationKHR operation) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4750
VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreZirconHandleFUCHSIA(VkDevice device, const VkImportSemaphoreZirconHandleInfoFUCHSIA *pImportSemaphoreZirconHandleInfo)
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pPresentModeCount, VkPresentModeKHR *pPresentModes)
Definition: vulkan_core.h:7593
VkResult(VKAPI_PTR * PFN_vkBindBufferMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos)
Definition: vulkan_core.h:5533
VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingEnableNV(VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable)
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, uint32_t *pSurfaceFormatCount, VkSurfaceFormat2KHR *pSurfaceFormats)
std::enable_if<!std::is_same< ClassType, typename std::tuple_element< 0, std::tuple< ChainElements...> >::type >::value||(Which!=0), void >::type relink() VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1061
void(VKAPI_PTR * PFN_vkCmdSetFragmentShadingRateEnumNV)(VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue *pColor, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
void(VKAPI_PTR * PFN_vkCmdDrawIndirectCount)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
Definition: vulkan_core.h:6375
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPropertiesKHR *pProperties)
Definition: vulkan_core.h:7858
void(VKAPI_PTR * PFN_vkUpdateDescriptorSetWithTemplate)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData)
Definition: vulkan_core.h:5555
PFN_vkCreateRenderPass2 vkCreateRenderPass2
Definition: vulkan.hpp:12591
PFN_vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceImageFormatProperties
Definition: vulkan.hpp:12425
void vkCmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport *pViewports) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2647
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceFeatures2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures)
Definition: vulkan_core.h:8032
VKAPI_ATTR void VKAPI_CALL vkDestroyMicromapEXT(VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks *pAllocator)
VKAPI_ATTR void VKAPI_CALL vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
PFN_vkDestroyRenderPass vkDestroyRenderPass
Definition: vulkan.hpp:12503
VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy *pRegions)
VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer2(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 *pCopyBufferInfo)
PFN_vkDestroySamplerYcbcrConversionKHR vkDestroySamplerYcbcrConversionKHR
Definition: vulkan.hpp:13022
VkResult(VKAPI_PTR * PFN_vkQueueSetPerformanceConfigurationINTEL)(VkQueue queue, VkPerformanceConfigurationINTEL configuration)
VkResult vkGetPipelinePropertiesEXT(VkDevice device, const VkPipelineInfoEXT *pPipelineInfo, VkBaseOutStructure *pPipelineProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5303
void(VKAPI_PTR * PFN_vkCmdDebugMarkerEndEXT)(VkCommandBuffer commandBuffer)
Definition: vulkan_core.h:9992
VKAPI_ATTR VkResult VKAPI_CALL vkGetAndroidHardwareBufferPropertiesANDROID(VkDevice device, const struct AHardwareBuffer *buffer, VkAndroidHardwareBufferPropertiesANDROID *pProperties)
VKAPI_ATTR VkResult VKAPI_CALL vkGetImageOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkImageCaptureDescriptorDataInfoEXT *pInfo, void *pData)
VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth)
VkResult vkGetDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR *display) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4833
VkResult(VKAPI_PTR * PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, VkMemoryZirconHandlePropertiesFUCHSIA *pMemoryZirconHandleProperties)
PFN_vkCmdSetViewportShadingRatePaletteNV vkCmdSetViewportShadingRatePaletteNV
Definition: vulkan.hpp:13039
PFN_vkDestroyCommandPool vkDestroyCommandPool
Definition: vulkan.hpp:12506
VkResult vkGetSemaphoreCounterValueKHR(VkDevice device, VkSemaphore semaphore, uint64_t *pValue) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4430
IncompatibleDriverError(std::string const &message)
Definition: vulkan.hpp:6233
PFN_vkCmdSetDepthBiasEnable vkCmdSetDepthBiasEnable
Definition: vulkan.hpp:12636
VkResult(VKAPI_PTR * PFN_vkWriteAccelerationStructuresPropertiesKHR)(VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR *pAccelerationStructures, VkQueryType queryType, size_t dataSize, void *pData, size_t stride)
PFN_vkCompileDeferredNV vkCompileDeferredNV
Definition: vulkan.hpp:13054
void(VKAPI_PTR * PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
Definition: vulkan_core.h:4008
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties *pFormatProperties)
VkFlags VkStencilFaceFlags
Definition: vulkan_core.h:2782
VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy *pRegions)
void vkCmdSetViewportSwizzleNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV *pViewportSwizzles) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5697
VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceWin32HandleKHR(VkDevice device, const VkImportFenceWin32HandleInfoKHR *pImportFenceWin32HandleInfo)
VkResult vkGetPhysicalDeviceFragmentShadingRatesKHR(VkPhysicalDevice physicalDevice, uint32_t *pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR *pFragmentShadingRates) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4529
VkResult vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, VkPhysicalDevice *pPhysicalDevices) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1328
PFN_vkMergeValidationCachesEXT vkMergeValidationCachesEXT
Definition: vulkan.hpp:13034
void vkCmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer, const VkExtent2D *pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4536
OutOfDateKHRError(char const *message)
Definition: vulkan.hpp:6311
VkBool32(VKAPI_PTR * PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, IDirectFB *dfb)
virtual const char * name() const VULKAN_HPP_NOEXCEPT override
Definition: vulkan.hpp:6102
PFN_vkCmdEndTransformFeedbackEXT vkCmdEndTransformFeedbackEXT
Definition: vulkan.hpp:12766
VkResult vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkInstance *pInstance) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1318
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayProperties2KHR *pProperties)
VKAPI_ATTR void VKAPI_CALL vkCmdSetFragmentShadingRateEnumNV(VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
void vkCmdDecompressMemoryIndirectCountNV(VkCommandBuffer commandBuffer, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t stride) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5564
VkResult vkGetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR *pGetFdInfo, int *pFd) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3502
VKAPI_ATTR VkResult VKAPI_CALL vkCreateMetalSurfaceEXT(VkInstance instance, const VkMetalSurfaceCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
PFN_vkResetCommandBuffer vkResetCommandBuffer
Definition: vulkan.hpp:12512
PFN_vkReleaseProfilingLockKHR vkReleaseProfilingLockKHR
Definition: vulkan.hpp:12945
void vkCmdBindInvocationMaskHUAWEI(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5286
void(VKAPI_PTR * PFN_vkCmdSetPrimitiveRestartEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable)
void(VKAPI_PTR * PFN_vkCmdBeginConditionalRenderingEXT)(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin)
PFN_vkGetDrmDisplayEXT vkGetDrmDisplayEXT
Definition: vulkan.hpp:13200
VkResult(VKAPI_PTR * PFN_vkGetDrmDisplayEXT)(VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR *display)
VkQueryType
Definition: vulkan_core.h:1715
VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator)
VKAPI_ATTR void VKAPI_CALL vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks *pAllocator)
PFN_vkGetPhysicalDevicePresentRectanglesKHR vkGetPhysicalDevicePresentRectanglesKHR
Definition: vulkan.hpp:12657
VkFlags VkImageUsageFlags
Definition: vulkan_core.h:2311
VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet *pDescriptorCopies)
VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
PFN_dummy vkGetPhysicalDeviceDirectFBPresentationSupportEXT_placeholder
Definition: vulkan.hpp:13282
VkFragmentShadingRateCombinerOpKHR
Definition: vulkan_core.h:9188
PFN_vkCmdSetDepthBoundsTestEnableEXT vkCmdSetDepthBoundsTestEnableEXT
Definition: vulkan.hpp:13174
Error() VULKAN_HPP_NOEXCEPT=default
void(VKAPI_PTR * PFN_vkGetDeviceBufferMemoryRequirements)(VkDevice device, const VkDeviceBufferMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
Definition: vulkan_core.h:7325
void(VKAPI_PTR * PFN_vkCmdBindDescriptorSets)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t *pDynamicOffsets)
Definition: vulkan_core.h:4009
PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR vkGetPhysicalDeviceSparseImageFormatProperties2KHR
Definition: vulkan.hpp:12817
void vkCmdSetDepthClipNegativeOneToOneEXT(VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5687
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties)
VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask)
PFN_vkCmdSetRayTracingPipelineStackSizeKHR vkCmdSetRayTracingPipelineStackSizeKHR
Definition: vulkan.hpp:13292
VkPolygonMode
Definition: vulkan_core.h:1972
VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query)
VKAPI_ATTR void VKAPI_CALL vkGetDeviceAccelerationStructureCompatibilityKHR(VkDevice device, const VkAccelerationStructureVersionInfoKHR *pVersionInfo, VkAccelerationStructureCompatibilityKHR *pCompatibility)
VKAPI_ATTR VkResult VKAPI_CALL vkUpdateVideoSessionParametersKHR(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR *pUpdateInfo)
void vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4665
VkFrontFace
Definition: vulkan_core.h:1945
PFN_vkGetPhysicalDeviceSparseImageFormatProperties vkGetPhysicalDeviceSparseImageFormatProperties
Definition: vulkan.hpp:12453
FeatureNotPresentError(std::string const &message)
Definition: vulkan.hpp:6226
void(VKAPI_PTR * PFN_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)
Definition: vulkan_core.h:4032
VKAPI_ATTR VkResult VKAPI_CALL vkCreateMacOSSurfaceMVK(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
VkResult vkGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, size_t *pDataSize, void *pData) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4157
VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilTestEnable(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable)
ObjectDestroy(OwnerType owner, Optional< const AllocationCallbacks > allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5898
void(VKAPI_PTR * PFN_vkGetImageMemoryRequirements2)(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
Definition: vulkan_core.h:5539
VKAPI_ATTR VkResult VKAPI_CALL vkCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader)
void(VKAPI_PTR * PFN_vkCmdBindVertexBuffers2EXT)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes, const VkDeviceSize *pStrides)
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV)(VkPhysicalDevice physicalDevice, uint32_t *pCombinationCount, VkFramebufferMixedSamplesCombinationNV *pCombinations)
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties)
PFN_vkBuildMicromapsEXT vkBuildMicromapsEXT
Definition: vulkan.hpp:13373
void(VKAPI_PTR * PFN_vkCmdCopyBufferToImage2KHR)(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 *pCopyBufferToImageInfo)
Definition: vulkan_core.h:9694
VkResult vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorSetLayout *pSetLayout) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1767
InvalidExternalHandleError(std::string const &message)
Definition: vulkan.hpp:6275
basic_string_view< char > string_view
Definition: core.h:522
PFN_vkCmdInsertDebugUtilsLabelEXT vkCmdInsertDebugUtilsLabelEXT
Definition: vulkan.hpp:12979
void vkCmdSetCoverageModulationModeNV(VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5715
void vkCmdSetDepthClipEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5654
void vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1790
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV)(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixPropertiesNV *pProperties)
VkResult vkCreateDescriptorUpdateTemplateKHR(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3543
PFN_vkCreateAccelerationStructureKHR vkCreateAccelerationStructureKHR
Definition: vulkan.hpp:13003
VkResult(VKAPI_PTR * PFN_vkCreateVideoSessionParametersKHR)(VkDevice device, const VkVideoSessionParametersCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkVideoSessionParametersKHR *pVideoSessionParameters)
Definition: vulkan_beta.h:246
void vkCmdSetSampleMaskEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask *pSampleMask) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5594
VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferCollectionFUCHSIA(VkDevice device, const VkBufferCollectionCreateInfoFUCHSIA *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBufferCollectionFUCHSIA *pCollection)
void vkGetDeviceBufferMemoryRequirements(VkDevice device, const VkDeviceBufferMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2718
VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingShaderGroupHandlesNV(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
void(VKAPI_PTR * PFN_vkCmdSetPrimitiveTopology)(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology)
Definition: vulkan_core.h:7312
void(VKAPI_PTR * PFN_vkCmdWriteMicromapsPropertiesEXT)(VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT *pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo)
struct _cl_event * event
Definition: glcorearb.h:2961
PFN_vkCmdSetShadingRateImageEnableNV vkCmdSetShadingRateImageEnableNV
Definition: vulkan.hpp:13434
void vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1700
VkResult(VKAPI_PTR * PFN_vkRegisterDisplayEventEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT *pDisplayEventInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateDeferredOperationKHR(VkDevice device, const VkAllocationCallbacks *pAllocator, VkDeferredOperationKHR *pDeferredOperation)
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceToolPropertiesEXT)(VkPhysicalDevice physicalDevice, uint32_t *pToolCount, VkPhysicalDeviceToolProperties *pToolProperties)
VkResult(VKAPI_PTR * PFN_vkSetEvent)(VkDevice device, VkEvent event)
Definition: vulkan_core.h:3951
void(VKAPI_PTR * PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3981
VKAPI_ATTR VkResult VKAPI_CALL vkCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureKHR *pAccelerationStructure)
VKAPI_ATTR VkResult VKAPI_CALL vkAcquireProfilingLockKHR(VkDevice device, const VkAcquireProfilingLockInfoKHR *pInfo)
VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers
Definition: vulkan.hpp:12525
VkResult(VKAPI_PTR * PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo *pBindInfo, VkFence fence)
Definition: vulkan_core.h:3940
PFN_vkCmdSetStencilCompareMask vkCmdSetStencilCompareMask
Definition: vulkan.hpp:12520
void vkCmdBlitImage2(VkCommandBuffer commandBuffer, const VkBlitImageInfo2 *pBlitImageInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2612
void vkCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3385
VkResult vkGetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3706
VkResult(VKAPI_PTR * PFN_vkCreateVideoSessionKHR)(VkDevice device, const VkVideoSessionCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkVideoSessionKHR *pVideoSession)
Definition: vulkan_beta.h:242
void vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2418
VkResult(VKAPI_PTR * PFN_vkCreateInstance)(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkInstance *pInstance)
Definition: vulkan_core.h:3906
VkResult vkSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT *pTagInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3855
VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
#define VULKAN_HPP_ASSERT_ON_RESULT
Definition: vulkan.hpp:74
VkResult vkGetMemoryFdPropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR *pMemoryFdProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3462
VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pPresentModeCount, VkPresentModeKHR *pPresentModes) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2770
VkResult(VKAPI_PTR * PFN_vkGetRayTracingShaderGroupHandlesKHR)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
void(VKAPI_PTR * PFN_vkCmdSubpassShadingHUAWEI)(VkCommandBuffer commandBuffer)
VkResult(VKAPI_PTR * PFN_vkGetValidationCacheDataEXT)(VkDevice device, VkValidationCacheEXT validationCache, size_t *pDataSize, void *pData)
VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutablePropertiesKHR(VkDevice device, const VkPipelineInfoKHR *pPipelineInfo, uint32_t *pExecutableCount, VkPipelineExecutablePropertiesKHR *pProperties)
uint64_t vkGetDeviceMemoryOpaqueCaptureAddress(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2520
VkResult vkResetEvent(VkDevice device, VkEvent event) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1589
VkResult(VKAPI_PTR * PFN_vkGetSemaphoreCounterValueKHR)(VkDevice device, VkSemaphore semaphore, uint64_t *pValue)
Definition: vulkan_core.h:9149
VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties)
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties)
VkResult(VKAPI_PTR * PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets)
Definition: vulkan_core.h:3984
PFN_vkCmdBindTransformFeedbackBuffersEXT vkCmdBindTransformFeedbackBuffersEXT
Definition: vulkan.hpp:12764
VKAPI_ATTR void VKAPI_CALL vkDestroyAccelerationStructureKHR(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks *pAllocator)
VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPlanePropertiesKHR *pProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2846
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainEXT *pTimeDomains)
VkResult vkCreateRayTracingPipelinesKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5136
void(VKAPI_PTR * PFN_vkCmdSetDepthClipNegativeOneToOneEXT)(VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne)
void vkCmdSetTessellationDomainOriginEXT(VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5574
VkResult(VKAPI_PTR * PFN_vkAcquirePerformanceConfigurationINTEL)(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL *pAcquireInfo, VkPerformanceConfigurationINTEL *pConfiguration)
VKAPI_ATTR void VKAPI_CALL vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp)
PFN_vkSubmitDebugUtilsMessageEXT vkSubmitDebugUtilsMessageEXT
Definition: vulkan.hpp:12982
VKAPI_ATTR VkResult VKAPI_CALL vkCreateMicromapEXT(VkDevice device, const VkMicromapCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkMicromapEXT *pMicromap)
void vkCmdTraceRaysIndirectKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5159
VkResult vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1807
PFN_vkCreateBufferView vkCreateBufferView
Definition: vulkan.hpp:12472
VkResult vkCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pCallback) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2995
VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo)
VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator)
VKAPI_ATTR VkResult VKAPI_CALL vkCopyAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR *pInfo)
VULKAN_HPP_CONSTEXPR Flags(BitType bit) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:392
PFN_vkCmdSetStencilReference vkCmdSetStencilReference
Definition: vulkan.hpp:12522
VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksEXT(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
VkResult(VKAPI_PTR * PFN_vkGetVideoSessionMemoryRequirementsKHR)(VkDevice device, VkVideoSessionKHR videoSession, uint32_t *pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR *pMemoryRequirements)
Definition: vulkan_beta.h:244
PFN_vkCmdDebugMarkerBeginEXT vkCmdDebugMarkerBeginEXT
Definition: vulkan.hpp:12723
VKAPI_ATTR void VKAPI_CALL 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)
void vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize *pCommittedMemoryInBytes) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1475
VkResult(VKAPI_PTR * PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
Definition: vulkan_core.h:3935
PFN_vkFreeDescriptorSets vkFreeDescriptorSets
Definition: vulkan.hpp:12498
PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR vkGetDeviceGroupPeerMemoryFeaturesKHR
Definition: vulkan.hpp:12820
PFN_vkGetDynamicRenderingTilePropertiesQCOM vkGetDynamicRenderingTilePropertiesQCOM
Definition: vulkan.hpp:13451
PFN_vkCreatePrivateDataSlotEXT vkCreatePrivateDataSlotEXT
Definition: vulkan.hpp:13203
void vkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3885
void(VKAPI_PTR * PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3992
VkResult(VKAPI_PTR * PFN_vkQueueWaitIdle)(VkQueue queue)
Definition: vulkan_core.h:3925
PoolType getPool() const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:6049
void vkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3875
VkResult(VKAPI_PTR * PFN_vkCreateDescriptorUpdateTemplateKHR)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
Definition: vulkan_core.h:8406
void(VKAPI_PTR * PFN_vkGetImageMemoryRequirements2KHR)(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
Definition: vulkan_core.h:8879
PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool
Definition: vulkan.hpp:12495
VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorSetLayout *pSetLayout)
VkResult(VKAPI_PTR * PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkEvent *pEvent)
Definition: vulkan_core.h:3948
PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers
Definition: vulkan.hpp:12508
VKAPI_ATTR void VKAPI_CALL vkCmdDecompressMemoryIndirectCountNV(VkCommandBuffer commandBuffer, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t stride)
PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR vkGetPhysicalDeviceSurfaceCapabilities2KHR
Definition: vulkan.hpp:12948
VkResult vkSignalSemaphoreKHR(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4440
VKAPI_ATTR VkResult VKAPI_CALL vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences)
VkResult vkAcquireDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4828
void(VKAPI_PTR * PFN_vkQueueBeginDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo)
VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
VKAPI_ATTR void VKAPI_CALL vkGetShaderModuleIdentifierEXT(VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT *pIdentifier)
void vkCmdCopyMemoryToAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4057
PFN_vkMergePipelineCaches vkMergePipelineCaches
Definition: vulkan.hpp:12484
VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutNV(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkIndirectCommandsLayoutNV *pIndirectCommandsLayout)
void(VKAPI_PTR * PFN_vkCmdSetSampleLocationsEXT)(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT *pSampleLocationsInfo)
VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo *pDependencyInfo)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t *pPropertyCount, VkSparseImageFormatProperties *pProperties)
Definition: vulkan_core.h:3939
VkResult(VKAPI_PTR * PFN_vkGetFenceFdKHR)(VkDevice device, const VkFenceGetFdInfoKHR *pGetFdInfo, int *pFd)
Definition: vulkan_core.h:8562
PFN_vkCmdBindDescriptorBuffersEXT vkCmdBindDescriptorBuffersEXT
Definition: vulkan.hpp:13236
VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize *pCommittedMemoryInBytes)
VkResult vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pRectCount, VkRect2D *pRects) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2824
void vkCmdBindDescriptorBufferEmbeddedSamplersEXT(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4967
void vkCmdCopyAccelerationStructureToMemoryKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4051
void(VKAPI_PTR * PFN_vkDestroyCuModuleNVX)(VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks *pAllocator)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties)
Definition: vulkan_core.h:8033
VkResult(VKAPI_PTR * PFN_vkBindImageMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
Definition: vulkan_core.h:5534
PFN_vkCmdSetDepthBounds vkCmdSetDepthBounds
Definition: vulkan.hpp:12519
VkDebugUtilsMessageSeverityFlagBitsEXT
void(VKAPI_PTR * PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:7724
PFN_vkCreatePrivateDataSlot vkCreatePrivateDataSlot
Definition: vulkan.hpp:12605
PFN_vkCmdCopyImage2KHR vkCmdCopyImage2KHR
Definition: vulkan.hpp:13255
GLint GLsizei GLsizei height
Definition: glcorearb.h:103
VkResult vkGetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT *pProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4128
VkResult vkGetDeviceFaultInfoEXT(VkDevice device, VkDeviceFaultCountsEXT *pFaultCounts, VkDeviceFaultInfoEXT *pFaultInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5084
void vkCmdWriteAccelerationStructuresPropertiesKHR(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR *pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4069
VkResult(VKAPI_PTR * PFN_vkGetMemoryWin32HandleKHR)(VkDevice device, const VkMemoryGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle)
Definition: vulkan_win32.h:82
void(VKAPI_PTR * PFN_vkCmdBindVertexBuffers2)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes, const VkDeviceSize *pStrides)
Definition: vulkan_core.h:7315
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties)
VKAPI_ATTR void VKAPI_CALL vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator)
VkResult vkGetPastPresentationTimingGOOGLE(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pPresentationTimingCount, VkPastPresentationTimingGOOGLE *pPresentationTimings) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3647
VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2 *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
PFN_vkCmdSetCullModeEXT vkCmdSetCullModeEXT
Definition: vulkan.hpp:13165
VkFlags VkCommandBufferResetFlags
Definition: vulkan_core.h:2773
void(VKAPI_PTR * PFN_vkCmdDrawMeshTasksNV)(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask)
virtual const char * what() const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:6134
VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2KHR(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
void vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2363
void(VKAPI_PTR * PFN_vkGetDeviceGroupPeerMemoryFeatures)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures)
Definition: vulkan_core.h:5535
void(VKAPI_PTR * PFN_vkDestroyDescriptorUpdateTemplate)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:5554
void vkCmdOpticalFlowExecuteNV(VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV *pExecuteInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5793
VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties)
PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT vkCmdSetExtraPrimitiveOverestimationSizeEXT
Definition: vulkan.hpp:13419
VULKAN_HPP_CONSTEXPR ArrayProxyNoTemporaries(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:704
void vkCmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, const VkDependencyInfo *pDependencyInfos) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2569
PFN_vkGetMemoryFdPropertiesKHR vkGetMemoryFdPropertiesKHR
Definition: vulkan.hpp:12851
VKAPI_ATTR void VKAPI_CALL 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)
VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 *pCopyImageToBufferInfo)
VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupportKHR(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport)
void(VKAPI_PTR * PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
Definition: vulkan_core.h:4007
VkFlags VkMemoryMapFlags
Definition: vulkan_core.h:2402
void vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2005
#define VULKAN_HPP_CONST_OR_CONSTEXPR
Definition: vulkan.hpp:193
void vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy *pRegions) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2027
uint64_t(VKAPI_PTR * PFN_vkGetBufferOpaqueCaptureAddressKHR)(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
Definition: vulkan_core.h:9331
VkResult vkMergeValidationCachesEXT(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT *pSrcCaches) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4149
VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos)
VKAPI_ATTR void VKAPI_CALL vkCmdSetColorWriteMaskEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags *pColorWriteMasks)
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdPropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR *pMemoryFdProperties)
void(VKAPI_PTR * PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
Definition: vulkan_core.h:4012
VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
VkResult vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void **ppData) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1454
GLuint framebuffer
Definition: glcorearb.h:1287
PFN_vkCmdSetLineStippleEnableEXT vkCmdSetLineStippleEnableEXT
Definition: vulkan.hpp:13425
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT *pSurfaceCapabilities)
VkResult vkGetRayTracingShaderGroupHandlesNV(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4280
void(VKAPI_PTR * PFN_vkCmdPipelineBarrier2KHR)(VkCommandBuffer commandBuffer, const VkDependencyInfo *pDependencyInfo)
Definition: vulkan_core.h:9565
VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplateKHR(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator)
PFN_vkCreateRenderPass2KHR vkCreateRenderPass2KHR
Definition: vulkan.hpp:12917
VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceMemoryOpaqueCaptureAddressKHR(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo)
PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements
Definition: vulkan.hpp:12451
PFN_vkCmdDrawMeshTasksIndirectCountEXT vkCmdDrawMeshTasksIndirectCountEXT
Definition: vulkan.hpp:13251
void(VKAPI_PTR * PFN_vkCmdControlVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR *pCodingControlInfo)
Definition: vulkan_beta.h:251
#define VULKAN_HPP_CONSTEXPR
Definition: vulkan.hpp:191
PFN_vkCmdWriteAccelerationStructuresPropertiesNV vkCmdWriteAccelerationStructuresPropertiesNV
Definition: vulkan.hpp:13053
VkResult(VKAPI_PTR * PFN_vkSetDebugUtilsObjectTagEXT)(VkDevice device, const VkDebugUtilsObjectTagInfoEXT *pTagInfo)
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32 *pSupported)
Definition: vulkan_core.h:7590
VkResult vkCopyMicromapToMemoryEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT *pInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5424
PFN_vkGetPhysicalDeviceProperties2KHR vkGetPhysicalDeviceProperties2KHR
Definition: vulkan.hpp:12812
VkResult(VKAPI_PTR * PFN_vkBindImageMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
Definition: vulkan_core.h:8957
VkResult(VKAPI_PTR * PFN_vkCreateStreamDescriptorSurfaceGGP)(VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
Definition: vulkan_ggp.h:33
VKAPI_ATTR VkResult VKAPI_CALL vkGetDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR *display)
void(VKAPI_PTR * PFN_vkCmdCopyImageToBuffer2KHR)(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 *pCopyImageToBufferInfo)
Definition: vulkan_core.h:9695
VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT *pTagInfo)
GLintptr offset
Definition: glcorearb.h:665
void(VKAPI_PTR * PFN_vkCmdSetStencilOp)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp)
Definition: vulkan_core.h:7321
bool operator>(std::string const &lhs, ArrayWrapper1D< char, N > const &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:342
VKAPI_ATTR VkResult VKAPI_CALL vkBindVideoSessionMemoryKHR(VkDevice device, VkVideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VkBindVideoSessionMemoryInfoKHR *pBindSessionMemoryInfos)
void vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT *pSampleLocationsInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3933
void vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2742
VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags)
PFN_vkSignalSemaphoreKHR vkSignalSemaphoreKHR
Definition: vulkan.hpp:13088
VkResult(VKAPI_PTR * PFN_vkCreateXcbSurfaceKHR)(VkInstance instance, const VkXcbSurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
Definition: vulkan_xcb.h:34
VkResult(VKAPI_PTR * PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void **ppData)
Definition: vulkan_core.h:3929
PFN_vkCmdSetDepthWriteEnableEXT vkCmdSetDepthWriteEnableEXT
Definition: vulkan.hpp:13172
VkResult(VKAPI_PTR * PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer)
Definition: vulkan_core.h:3956
Definition: core.h:760
void vkResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4648
void vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties *pQueueFamilyProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1360
PFN_vkDestroyOpticalFlowSessionNV vkDestroyOpticalFlowSessionNV
Definition: vulkan.hpp:13445
VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth)
void(VKAPI_PTR * PFN_vkCmdDrawIndexedIndirectCountKHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
Definition: vulkan_core.h:8995
PFN_dummy vkSetBufferCollectionBufferConstraintsFUCHSIA_placeholder
Definition: vulkan.hpp:13325
std::enable_if<!std::is_same< ClassType, typename std::tuple_element< 0, std::tuple< ChainElements...> >::type >::value||(Which!=0), void >::type unlink() VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1073
PFN_vkDestroyPrivateDataSlot vkDestroyPrivateDataSlot
Definition: vulkan.hpp:12606
VkResult(VKAPI_PTR * PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo)
Definition: vulkan_core.h:3996
PFN_vkGetDeviceGroupSurfacePresentModesKHR vkGetDeviceGroupSurfacePresentModesKHR
Definition: vulkan.hpp:12656
void vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2122
VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask)
void vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue *pColor, uint32_t rangeCount, const VkImageSubresourceRange *pRanges) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2082
VkResult(VKAPI_PTR * PFN_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR *pMemoryWin32HandleProperties)
Definition: vulkan_win32.h:83
ArrayProxyNoTemporaries(typename std::remove_const< T >::type(&ptr)[C]) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:753
PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets
Definition: vulkan.hpp:12499
PFN_vkCmdCopyMemoryToMicromapEXT vkCmdCopyMemoryToMicromapEXT
Definition: vulkan.hpp:13380
VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator)
void(VKAPI_PTR * PFN_vkCmdSetViewportWithCount)(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport *pViewports)
Definition: vulkan_core.h:7313
VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableStatisticsKHR(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pStatisticCount, VkPipelineExecutableStatisticKHR *pStatistics)
VkResult(VKAPI_PTR * PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t *pCounterCount, VkPerformanceCounterKHR *pCounters, VkPerformanceCounterDescriptionKHR *pCounterDescriptions)
Definition: vulkan_core.h:8689
typename std::underlying_type< ExternalMemoryFeatureFlagBitsNV >::type MaskType
Definition: vulkan.hpp:387
void(VKAPI_PTR * PFN_vkCmdSetDepthBiasEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable)
VkResult(VKAPI_PTR * PFN_vkCreateDirectFBSurfaceEXT)(VkInstance instance, const VkDirectFBSurfaceCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
VKAPI_ATTR VkResult VKAPI_CALL vkBindOpticalFlowSessionImageNV(VkDevice device, VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout)
VkResult vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1741
void vkDestroyIndirectCommandsLayoutNV(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4819
VKAPI_ATTR void VKAPI_CALL vkCmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfo *pRenderingInfo)
PFN_vkSetLocalDimmingAMD vkSetLocalDimmingAMD
Definition: vulkan.hpp:13102
PFN_vkCmdSetPerformanceStreamMarkerINTEL vkCmdSetPerformanceStreamMarkerINTEL
Definition: vulkan.hpp:13094
bool empty() const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:674
VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks *pAllocator)
VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes, const VkDeviceSize *pStrides)
VkResult vkEnumeratePhysicalDeviceGroupsKHR(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3422
VkResult vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(VkDevice device, VkRenderPass renderpass, VkExtent2D *pMaxWorkgroupSize) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5274
VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer, const VkResolveImageInfo2 *pResolveImageInfo)
void vkCmdSetShadingRateImageEnableNV(VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5732
PFN_vkCmdSetCoverageReductionModeNV vkCmdSetCoverageReductionModeNV
Definition: vulkan.hpp:13436
VkResult(VKAPI_PTR * PFN_vkCreateMicromapEXT)(VkDevice device, const VkMicromapCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkMicromapEXT *pMicromap)
VkResult vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(VkPhysicalDevice physicalDevice, uint32_t *pCombinationCount, VkFramebufferMixedSamplesCombinationNV *pCombinations) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4577
void vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3699
VkResult vkImportFenceFdKHR(VkDevice device, const VkImportFenceFdInfoKHR *pImportFenceFdInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3736
void(VKAPI_PTR * PFN_vkCmdSetViewportWithCountEXT)(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport *pViewports)
void(VKAPI_PTR * PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
Definition: vulkan_core.h:4010
VkResult vkGetPipelineExecutableStatisticsKHR(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pStatisticCount, VkPipelineExecutableStatisticKHR *pStatistics) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4765
void vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3184
VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
VkResult vkGetAccelerationStructureHandleNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void *pData) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4286
VKAPI_ATTR VkResult VKAPI_CALL vkBindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV *pBindInfos)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties *pQueueFamilyProperties)
Definition: vulkan_core.h:3913
VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainEXT *pTimeDomains) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4366
PFN_vkCreateDescriptorUpdateTemplateKHR vkCreateDescriptorUpdateTemplateKHR
Definition: vulkan.hpp:12878
VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
VkResult vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4853
PFN_vkCmdSetDepthClampEnableEXT vkCmdSetDepthClampEnableEXT
Definition: vulkan.hpp:13407
PFN_vkGetImageSubresourceLayout vkGetImageSubresourceLayout
Definition: vulkan.hpp:12476
std::enable_if<!std::is_same< ClassType, typename std::tuple_element< 0, std::tuple< ChainElements...> >::type >::value||(Which!=0), bool >::type isLinked() const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1053
VkResult vkGetEventStatus(VkDevice device, VkEvent event) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1579
OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5907
void vkGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3353
VkResult(VKAPI_PTR * PFN_vkCreatePrivateDataSlotEXT)(VkDevice device, const VkPrivateDataSlotCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPrivateDataSlot *pPrivateDataSlot)
PFN_vkDestroyFramebuffer vkDestroyFramebuffer
Definition: vulkan.hpp:12501
void vkCmdSetCoverageReductionModeNV(VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5742
VkDeviceAddress vkGetBufferDeviceAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo *pInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4624
PFN_dummy vkSetBufferCollectionImageConstraintsFUCHSIA_placeholder
Definition: vulkan.hpp:13324
void(VKAPI_PTR * PFN_vkCmdSetColorWriteEnableEXT)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32 *pColorWriteEnables)
#define VULKAN_HPP_NAMESPACE
Definition: vulkan.hpp:229
VkResult(VKAPI_PTR * PFN_vkDeviceWaitIdle)(VkDevice device)
Definition: vulkan_core.h:3926
VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets)
ObjectDestroy(Optional< const AllocationCallbacks > allocationCallbacks, Dispatch const &dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5938
VkResult(VKAPI_PTR * PFN_vkCopyMemoryToMicromapEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT *pInfo)
VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue)
void vkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2403
VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelinePropertiesEXT(VkDevice device, const VkPipelineInfoEXT *pPipelineInfo, VkBaseOutStructure *pPipelineProperties)
VKAPI_ATTR VkResult VKAPI_CALL vkGetBufferOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT *pInfo, void *pData)
#define VULKAN_HPP_CONSTEXPR_14
Definition: vulkan.hpp:192
void ignore(T const &) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:6508
VkResult vkReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3578
PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties
Definition: vulkan.hpp:12428
VULKAN_HPP_CONSTEXPR bool operator>(Flags< BitType > const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:412
VkResult(VKAPI_PTR * PFN_vkWaitSemaphores)(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout)
Definition: vulkan_core.h:6383
void vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange *pRanges) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2092
void vkCmdDrawMeshTasksIndirectEXT(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5023
PFN_vkCmdDecompressMemoryNV vkCmdDecompressMemoryNV
Definition: vulkan.hpp:13402
PFN_vkResetQueryPoolEXT vkResetQueryPoolEXT
Definition: vulkan.hpp:13162
VKAPI_ATTR VkResult VKAPI_CALL vkGetDeferredOperationResultKHR(VkDevice device, VkDeferredOperationKHR operation)
void(VKAPI_PTR * PFN_vkVoidFunction)(void)
Definition: vulkan_core.h:2918
PFN_vkBeginCommandBuffer vkBeginCommandBuffer
Definition: vulkan.hpp:12510
VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence)
void vkCmdSetCoverageModulationTableNV(VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float *pCoverageModulationTable) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5725
VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, VkPhysicalDevice *pPhysicalDevices)
UnknownError(char const *message)
Definition: vulkan.hpp:6262
PFN_vkCmdCopyBuffer2KHR vkCmdCopyBuffer2KHR
Definition: vulkan.hpp:13254
VkCompareOp
Definition: vulkan_core.h:1846
VkResult(VKAPI_PTR * PFN_vkCreateRenderPass2)(VkDevice device, const VkRenderPassCreateInfo2 *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
Definition: vulkan_core.h:6377
VkResult vkGetPipelineExecutablePropertiesKHR(VkDevice device, const VkPipelineInfoKHR *pPipelineInfo, uint32_t *pExecutableCount, VkPipelineExecutablePropertiesKHR *pProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4757
VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR *pDeviceGroupPresentCapabilities)
PFN_vkGetBufferOpaqueCaptureAddressKHR vkGetBufferOpaqueCaptureAddressKHR
Definition: vulkan.hpp:13155
void vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1845
void(VKAPI_PTR * PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures)
Definition: vulkan_core.h:8101
void vkCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3039
void(VKAPI_PTR * PFN_vkGetDeviceImageSparseMemoryRequirements)(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
Definition: vulkan_core.h:7327
GLbitfield GLuint64 timeout
Definition: glcorearb.h:1599
VkDeviceAddress vkGetAccelerationStructureDeviceAddressKHR(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR *pInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4063
void vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2232
void vkCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport *pViewports) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4670
virtual const char * what() const VULKAN_HPP_NOEXCEPT=0
PFN_vkCmdSetExclusiveScissorNV vkCmdSetExclusiveScissorNV
Definition: vulkan.hpp:13079
void(VKAPI_PTR * PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3928
VkResult(VKAPI_PTR * PFN_vkMergeValidationCachesEXT)(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT *pSrcCaches)
VKAPI_ATTR uint32_t VKAPI_CALL vkGetDeferredOperationMaxConcurrencyKHR(VkDevice device, VkDeferredOperationKHR operation)
PFN_vkGetDisplayModeProperties2KHR vkGetDisplayModeProperties2KHR
Definition: vulkan.hpp:12954
bool operator!=(ArrayWrapper1D< char, N > const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:322
VkResult vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32 *pSupported) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2747
VkResult vkBindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV *pBindInfos) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4209
void init(PFN_vkGetInstanceProcAddr getInstanceProcAddr) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:13462
void vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1947
VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, uint64_t timeout)
VkResult(VKAPI_PTR * PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA)(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkBufferConstraintsInfoFUCHSIA *pBufferConstraintsInfo)
PFN_vkAcquireDrmDisplayEXT vkAcquireDrmDisplayEXT
Definition: vulkan.hpp:13199
void vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2328
PFN_vkDestroyDebugReportCallbackEXT vkDestroyDebugReportCallbackEXT
Definition: vulkan.hpp:12717
void(VKAPI_PTR * PFN_vkGetImageSparseMemoryRequirements2)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
Definition: vulkan_core.h:5541
void vkGetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3376
PFN_vkCreateIndirectCommandsLayoutNV vkCreateIndirectCommandsLayoutNV
Definition: vulkan.hpp:13195
VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, VkSurfaceCapabilities2KHR *pSurfaceCapabilities) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3778
void vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2060
VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHR(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR *pImportSemaphoreWin32HandleInfo)
void vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1984
VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 *pSubmits, VkFence fence)
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
Definition: vulkan.hpp:4956
void(VKAPI_PTR * PFN_vkCmdSetViewportShadingRatePaletteNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV *pShadingRatePalettes)
void(VKAPI_PTR * PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
Definition: vulkan_core.h:4026
PFN_vkCmdEndDebugUtilsLabelEXT vkCmdEndDebugUtilsLabelEXT
Definition: vulkan.hpp:12978
PFN_vkDebugMarkerSetObjectNameEXT vkDebugMarkerSetObjectNameEXT
Definition: vulkan.hpp:12722
PFN_vkCmdSetViewportWScalingEnableNV vkCmdSetViewportWScalingEnableNV
Definition: vulkan.hpp:13427
void(VKAPI_PTR * PFN_vkDestroyCuFunctionNVX)(VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks *pAllocator)
VKAPI_ATTR VkResult VKAPI_CALL vkQueueSetPerformanceConfigurationINTEL(VkQueue queue, VkPerformanceConfigurationINTEL configuration)
PFN_vkCopyAccelerationStructureKHR vkCopyAccelerationStructureKHR
Definition: vulkan.hpp:13008
VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage2(VkCommandBuffer commandBuffer, const VkCopyImageInfo2 *pCopyImageInfo)
void(VKAPI_PTR * PFN_vkCmdDispatchBase)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
Definition: vulkan_core.h:5537
#define VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT
Definition: vulkan.hpp:5885
void vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy *pRegions) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2021
uint64_t(VKAPI_PTR * PFN_vkGetBufferOpaqueCaptureAddress)(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
Definition: vulkan_core.h:6386
VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
VkResult(VKAPI_PTR * PFN_vkGetDeferredOperationResultKHR)(VkDevice device, VkDeferredOperationKHR operation)
Definition: vulkan_core.h:9356
PFN_vkCmdPushConstants vkCmdPushConstants
Definition: vulkan.hpp:12552
void vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3179
VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModes2EXT(VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR *pModes)
VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, const VkSubpassBeginInfo *pSubpassBeginInfo)
VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask)
ResultValue(Result r, T &&v) VULKAN_HPP_NOEXCEPT(VULKAN_HPP_NOEXCEPT(T(std
Definition: vulkan.hpp:6525
VkResult(VKAPI_PTR * PFN_vkGetPerformanceParameterINTEL)(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL *pValue)
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures)
uint32_t size() const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:679
void(VKAPI_PTR * PFN_vkCmdWriteTimestamp2KHR)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query)
Definition: vulkan_core.h:9566
PFN_vkCmdSetLineStippleEXT vkCmdSetLineStippleEXT
Definition: vulkan.hpp:13159
PFN_vkCmdSetPrimitiveTopologyEXT vkCmdSetPrimitiveTopologyEXT
Definition: vulkan.hpp:13167
VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment *pAttachments, uint32_t rectCount, const VkClearRect *pRects)
void vkCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32 *pColorWriteEnables) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5356
PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage
Definition: vulkan.hpp:12535
void(VKAPI_PTR * PFN_vkCmdWriteBufferMarker2AMD)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
Definition: vulkan_core.h:9568
PFN_vkRegisterDisplayEventEXT vkRegisterDisplayEventEXT
Definition: vulkan.hpp:12903
VkResult(VKAPI_PTR * PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
Definition: vulkan_core.h:7864
void * VkRemoteAddressNV
void vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2242
PFN_vkCmdCopyAccelerationStructureToMemoryKHR vkCmdCopyAccelerationStructureToMemoryKHR
Definition: vulkan.hpp:13013
VkDeviceAddress(VKAPI_PTR * PFN_vkGetAccelerationStructureDeviceAddressKHR)(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR *pInfo)
PFN_vkDestroyPipelineLayout vkDestroyPipelineLayout
Definition: vulkan.hpp:12489
PFN_vkVoidFunction(VKAPI_PTR * PFN_vkGetInstanceProcAddr)(VkInstance instance, const char *pName)
Definition: vulkan_core.h:3915
void vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4691
PFN_vkCmdDispatchBaseKHR vkCmdDispatchBaseKHR
Definition: vulkan.hpp:12822
VkResult(VKAPI_PTR * PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char *pLayerPrefix, const char *pMessage)
PFN_vkGetDescriptorSetLayoutSizeEXT vkGetDescriptorSetLayoutSizeEXT
Definition: vulkan.hpp:13233
VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR *pCapabilities)
PFN_vkCreateFramebuffer vkCreateFramebuffer
Definition: vulkan.hpp:12500
void init(VULKAN_HPP_NAMESPACE::Instance instanceCpp) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:13502
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModes2EXT(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, uint32_t *pPresentModeCount, VkPresentModeKHR *pPresentModes)
VKAPI_ATTR void VKAPI_CALL vkCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32 *pColorWriteEnables)
void vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4641
void vkCmdCopyMemoryToMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT *pInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5459
VKAPI_ATTR void VKAPI_CALL vkCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
PFN_vkBuildAccelerationStructuresKHR vkBuildAccelerationStructuresKHR
Definition: vulkan.hpp:13007
VULKAN_HPP_INLINE std::error_condition make_error_condition(Result e) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:6169
void(VKAPI_PTR * PFN_vkCmdBuildMicromapsEXT)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT *pInfos)
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClipEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable)
void(VKAPI_PTR * PFN_vkCmdEndVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR *pEndCodingInfo)
Definition: vulkan_beta.h:250
VkFlags VkQueryControlFlags
Definition: vulkan_core.h:2767
PFN_vkCmdSetPerformanceMarkerINTEL vkCmdSetPerformanceMarkerINTEL
Definition: vulkan.hpp:13093
PFN_vkCmdCopyMemoryIndirectNV vkCmdCopyMemoryIndirectNV
Definition: vulkan.hpp:13398
VKAPI_ATTR void VKAPI_CALL vkSetLocalDimmingAMD(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable)
void(VKAPI_PTR * PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers)
Definition: vulkan_core.h:4042
VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR *pGetFdInfo, int *pFd)
void vkGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3431
void vkCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3242
PFN_vkGetPhysicalDeviceFormatProperties2KHR vkGetPhysicalDeviceFormatProperties2KHR
Definition: vulkan.hpp:12813
VKAPI_ATTR void VKAPI_CALL vkQueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo)
void vkCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5315
PFN_vkCmdDrawIndexedIndirectCountKHR vkCmdDrawIndexedIndirectCountKHR
Definition: vulkan.hpp:13061
void(VKAPI_PTR * PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3907
VkResult(VKAPI_PTR * PFN_vkEnumerateInstanceVersion)(uint32_t *pApiVersion)
Definition: vulkan_core.h:5532
PFN_vkDeferredOperationJoinKHR vkDeferredOperationJoinKHR
Definition: vulkan.hpp:13183
void(VKAPI_PTR * PFN_vkCmdCuLaunchKernelNVX)(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX *pLaunchInfo)
PFN_vkCmdWriteAccelerationStructuresPropertiesKHR vkCmdWriteAccelerationStructuresPropertiesKHR
Definition: vulkan.hpp:13016
std::enable_if< std::is_same< ClassType, typename std::tuple_element< 0, std::tuple< ChainElements...> >::type >::value &&(Which==0), bool >::type isLinked() const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1046
VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain)
GLint GLint GLsizei GLint GLenum format
Definition: glcorearb.h:108
void(VKAPI_PTR * PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D *pScissors)
Definition: vulkan_core.h:4001
VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer)
void vkCmdCopyMicromapToMemoryEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT *pInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5454
uint32_t(VKAPI_PTR * PFN_vkGetDeferredOperationMaxConcurrencyKHR)(VkDevice device, VkDeferredOperationKHR operation)
Definition: vulkan_core.h:9355
VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(VkDevice device, VkRenderPass renderpass, VkExtent2D *pMaxWorkgroupSize)
VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport)
void vkCmdCopyBufferToImage2(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 *pCopyBufferToImageInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2602
void(VKAPI_PTR * PFN_vkCmdSetSampleMaskEXT)(VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask *pSampleMask)
VkResult(VKAPI_PTR * PFN_vkEnumeratePhysicalDeviceGroups)(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties)
Definition: vulkan_core.h:5538
VkResult vkCreateMicromapEXT(VkDevice device, const VkMicromapCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkMicromapEXT *pMicromap) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5393
VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceWin32HandleKHR(VkDevice device, const VkFenceGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle)
IncompatibleDisplayKHRError(std::string const &message)
Definition: vulkan.hpp:6317
PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier
Definition: vulkan.hpp:12546
VkResult(VKAPI_PTR * PFN_vkAcquireFullScreenExclusiveModeEXT)(VkDevice device, VkSwapchainKHR swapchain)
Definition: vulkan_win32.h:286
VKAPI_ATTR void VKAPI_CALL vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator)
VkResult(VKAPI_PTR * PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
Definition: vulkan_core.h:3988
PFN_vkCmdSetPrimitiveRestartEnableEXT vkCmdSetPrimitiveRestartEnableEXT
Definition: vulkan.hpp:13348
VkResult vkGetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice, uint32_t *pToolCount, VkPhysicalDeviceToolProperties *pToolProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2527
VkResult(VKAPI_PTR * PFN_vkBuildMicromapsEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT *pInfos)
PFN_vkGetPipelineExecutablePropertiesKHR vkGetPipelineExecutablePropertiesKHR
Definition: vulkan.hpp:13186
VkResult vkGetSamplerOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT *pInfo, void *pData) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4995
VkResult(VKAPI_PTR * PFN_vkCreateCuModuleNVX)(VkDevice device, const VkCuModuleCreateInfoNVX *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCuModuleNVX *pModule)
PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges
Definition: vulkan.hpp:12445
PFN_vkWriteAccelerationStructuresPropertiesKHR vkWriteAccelerationStructuresPropertiesKHR
Definition: vulkan.hpp:13011
void vkCmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo *pDependencyInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2559
GLint GLenum GLboolean GLsizei stride
Definition: glcorearb.h:872
PFN_vkCmdSetSampleLocationsEnableEXT vkCmdSetSampleLocationsEnableEXT
Definition: vulkan.hpp:13421
PFN_vkCmdBlitImage2KHR vkCmdBlitImage2KHR
Definition: vulkan.hpp:13258
PFN_vkCmdCuLaunchKernelNVX vkCmdCuLaunchKernelNVX
Definition: vulkan.hpp:12776
PFN_vkDebugMarkerSetObjectTagEXT vkDebugMarkerSetObjectTagEXT
Definition: vulkan.hpp:12721
VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplateKHR(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
VKAPI_ATTR void VKAPI_CALL vkCmdSetExtraPrimitiveOverestimationSizeEXT(VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize)
VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer)
VkResult(VKAPI_PTR * PFN_vkInitializePerformanceApiINTEL)(VkDevice device, const VkInitializePerformanceApiInfoINTEL *pInitializeInfo)
PFN_vkVoidFunction vkGetDeviceProcAddr(VkDevice device, const char *pName) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1377
PFN_vkWaitSemaphoresKHR vkWaitSemaphoresKHR
Definition: vulkan.hpp:13087
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable)
PFN_vkGetDeviceGroupPeerMemoryFeatures vkGetDeviceGroupPeerMemoryFeatures
Definition: vulkan.hpp:12562
void vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2355
void vkCmdSetConservativeRasterizationModeEXT(VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5643
void(VKAPI_PTR * PFN_vkGetDeviceImageMemoryRequirementsKHR)(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
Definition: vulkan_core.h:9790
DynamicLoader & operator=(DynamicLoader &&other) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:12366
VkResult vkGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, uint32_t *pSurfaceFormatCount, VkSurfaceFormat2KHR *pSurfaceFormats) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3785
VkResult vkDisplayPowerControlEXT(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT *pDisplayPowerInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3608
Optional(RefType &reference) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:895
void(VKAPI_PTR * PFN_vkGetBufferMemoryRequirements2)(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
Definition: vulkan_core.h:5540
void(VKAPI_PTR * PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3947
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pPresentModeCount, VkPresentModeKHR *pPresentModes)
VkResult(VKAPI_PTR * PFN_vkCreateSharedSwapchainsKHR)(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchains)
Definition: vulkan_core.h:7921
NativeWindowInUseKHRError(std::string const &message)
Definition: vulkan.hpp:6303
VkResult(VKAPI_PTR * PFN_vkWriteMicromapsPropertiesEXT)(VkDevice device, uint32_t micromapCount, const VkMicromapEXT *pMicromaps, VkQueryType queryType, size_t dataSize, void *pData, size_t stride)
VkResult(VKAPI_PTR * PFN_vkGetSemaphoreZirconHandleFUCHSIA)(VkDevice device, const VkSemaphoreGetZirconHandleInfoFUCHSIA *pGetZirconHandleInfo, zx_handle_t *pZirconHandle)
void(VKAPI_PTR * PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize *pCommittedMemoryInBytes)
Definition: vulkan_core.h:3933
VkResult vkCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkEvent *pEvent) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1566
VkResult vkCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1619
PFN_vkCmdSetStencilTestEnableEXT vkCmdSetStencilTestEnableEXT
Definition: vulkan.hpp:13175
VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT *pTagInfo)
void(VKAPI_PTR * PFN_vkGetAccelerationStructureBuildSizesKHR)(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR *pBuildInfo, const uint32_t *pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR *pSizeInfo)
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdKHR(VkDevice device, const VkMemoryGetFdInfoKHR *pGetFdInfo, int *pFd)
VULKAN_HPP_INLINE void resultCheck(Result result, char const *message)
Definition: vulkan.hpp:6639
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
VkCopyAccelerationStructureModeKHR
void(VKAPI_PTR * PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue *pColor, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
Definition: vulkan_core.h:4025
ArrayProxy(std::initializer_list< typename std::remove_const< T >::type > const &list) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:631
void(VKAPI_PTR * PFN_vkGetQueueCheckpointData2NV)(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointData2NV *pCheckpointData)
Definition: vulkan_core.h:9569
VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkLayerProperties *pProperties)
VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPlaneProperties2KHR *pProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3802
void vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2011
VkResult(VKAPI_PTR * PFN_vkReleasePerformanceConfigurationINTEL)(VkDevice device, VkPerformanceConfigurationINTEL configuration)
void vkCmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2673
void(VKAPI_PTR * PFN_vkCmdBeginQueryIndexedEXT)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index)
VKAPI_ATTR VkResult VKAPI_CALL vkAcquireFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain)
VKAPI_ATTR VkResult VKAPI_CALL vkGetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT *pProperties)
VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage2(VkCommandBuffer commandBuffer, const VkBlitImageInfo2 *pBlitImageInfo)
VkResult(VKAPI_PTR * PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
Definition: vulkan_core.h:3932
void vkCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo *pDependencyInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4885
PFN_vkCmdBindPipelineShaderGroupNV vkCmdBindPipelineShaderGroupNV
Definition: vulkan.hpp:13194
void(VKAPI_PTR * PFN_vkCmdTraceRaysIndirect2KHR)(VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress)
Definition: vulkan_core.h:9764
PFN_vkGetPipelineExecutableStatisticsKHR vkGetPipelineExecutableStatisticsKHR
Definition: vulkan.hpp:13187
VKAPI_ATTR void VKAPI_CALL vkCmdOpticalFlowExecuteNV(VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV *pExecuteInfo)
void(VKAPI_PTR * PFN_vkCmdNextSubpass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo, const VkSubpassEndInfo *pSubpassEndInfo)
Definition: vulkan_core.h:8462
VKAPI_ATTR VkDeviceSize VKAPI_CALL vkGetRayTracingShaderGroupStackSizeKHR(VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader)
void vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2452
PFN_vkGetQueueCheckpointDataNV vkGetQueueCheckpointDataNV
Definition: vulkan.hpp:13083
PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV vkGetPhysicalDeviceCooperativeMatrixPropertiesNV
Definition: vulkan.hpp:13132
VKAPI_ATTR void VKAPI_CALL vkCmdSetConservativeRasterizationModeEXT(VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode)
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t *pPropertyCount, VkSparseImageFormatProperties *pProperties)
PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr
Definition: vulkan.hpp:12430
VkResult(VKAPI_PTR * PFN_vkCreateSamplerYcbcrConversionKHR)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion)
Definition: vulkan_core.h:8932
VKAPI_ATTR void VKAPI_CALL vkCmdBuildMicromapsEXT(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT *pInfos)
SystemError(std::error_code ec, char const *what)
Definition: vulkan.hpp:6147
void vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer, const VkResolveImageInfo2 *pResolveImageInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5067
void(VKAPI_PTR * PFN_vkCmdSetPrimitiveTopologyEXT)(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology)
void vkCmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2637
ArrayProxyNoTemporaries(typename std::remove_const< T >::type &value) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:720
PFN_vkGetImageMemoryRequirements2 vkGetImageMemoryRequirements2
Definition: vulkan.hpp:12566
PFN_vkCmdExecuteGeneratedCommandsNV vkCmdExecuteGeneratedCommandsNV
Definition: vulkan.hpp:13193
VKAPI_ATTR void VKAPI_CALL vkCmdSetColorBlendEquationEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT *pColorBlendEquations)
ResultValue(Result r, T &v) VULKAN_HPP_NOEXCEPT(VULKAN_HPP_NOEXCEPT(T(v)))
Definition: vulkan.hpp:6516
void vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1932
void vkDestroyDeferredOperationKHR(VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4735
std::tuple< Result, std::vector< UniqueHandle< Type, Dispatch > > > asTuple()
Definition: vulkan.hpp:6578
void(VKAPI_PTR * PFN_vkTrimCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
Definition: vulkan_core.h:5549
VkImageTiling
Definition: vulkan_core.h:1692
PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR
Definition: vulkan.hpp:12999
VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask)
void(VKAPI_PTR * PFN_vkCmdWriteBufferMarkerAMD)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
void(VKAPI_PTR * PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3954
VkAccelerationStructureCompatibilityKHR
void init(VULKAN_HPP_NAMESPACE::Device deviceCpp) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:14727
uint64_t vkGetDeviceMemoryOpaqueCaptureAddressKHR(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4634
void(VKAPI_PTR * PFN_vkCmdSetDepthClampEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable)
VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDeviceEventEXT(VkDevice device, const VkDeviceEventInfoEXT *pDeviceEventInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
void vkGetDescriptorSetLayoutSupportKHR(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4312
VKAPI_ATTR void VKAPI_CALL vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
*get result *(waiting if necessary)*A common idiom is to fire a bunch of sub tasks at the queue
Definition: thread.h:623
VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDisplayEventEXT(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT *pDisplayEventInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
VkResult vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1795
GLint location
Definition: glcorearb.h:805
VkAccelerationStructureBuildTypeKHR
auto get(const UT_ARTIterator< T > &it) -> decltype(it.key())
Definition: UT_ARTMap.h:1073
VkResult(VKAPI_PTR * PFN_vkImportFenceWin32HandleKHR)(VkDevice device, const VkImportFenceWin32HandleInfoKHR *pImportFenceWin32HandleInfo)
Definition: vulkan_win32.h:196
#define VULKAN_HPP_ASSERT
Definition: vulkan.hpp:70
VkResult vkGetPhysicalDeviceToolPropertiesEXT(VkPhysicalDevice physicalDevice, uint32_t *pToolCount, VkPhysicalDeviceToolProperties *pToolProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4552
void init(VULKAN_HPP_NAMESPACE::Instance const &instance, VULKAN_HPP_NAMESPACE::Device const &device, DynamicLoader const &dl) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:15669
void vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4660
VkResult(VKAPI_PTR * PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT *pInfo, void *pData)
VkResult vkAcquireProfilingLockKHR(VkDevice device, const VkAcquireProfilingLockInfoKHR *pInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3766
PFN_vkCmdSetProvokingVertexModeEXT vkCmdSetProvokingVertexModeEXT
Definition: vulkan.hpp:13423
VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents)
VKAPI_ATTR void VKAPI_CALL vkCmdCuLaunchKernelNVX(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX *pLaunchInfo)
ArrayProxyNoTemporaries(std::initializer_list< T > &list) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:780
void vkGetImageSubresourceLayout2EXT(VkDevice device, VkImage image, const VkImageSubresource2EXT *pSubresource, VkSubresourceLayout2EXT *pLayout) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5074
void(VKAPI_PTR * PFN_vkCmdSetDepthCompareOpEXT)(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp)
PFN_vkCmdSetStencilOpEXT vkCmdSetStencilOpEXT
Definition: vulkan.hpp:13176
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoCapabilitiesKHR(VkPhysicalDevice physicalDevice, const VkVideoProfileInfoKHR *pVideoProfile, VkVideoCapabilitiesKHR *pCapabilities)
void vkCmdEndRenderPass(VkCommandBuffer commandBuffer) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2237
VkDeviceSize vkGetRayTracingShaderGroupStackSizeKHR(VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5170
PFN_vkCreateDebugUtilsMessengerEXT vkCreateDebugUtilsMessengerEXT
Definition: vulkan.hpp:12980
void(VKAPI_PTR * PFN_vkCmdSetCoarseSampleOrderNV)(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV *pCustomSampleOrders)
void(VKAPI_PTR * PFN_vkCmdSetEvent2KHR)(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo *pDependencyInfo)
Definition: vulkan_core.h:9562
VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL *pMarkerInfo)
void vkDestroyCuFunctionNVX(VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3218
VkResult vkImportSemaphoreFdKHR(VkDevice device, const VkImportSemaphoreFdInfoKHR *pImportSemaphoreFdInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3497
PFN_vkImportSemaphoreFdKHR vkImportSemaphoreFdKHR
Definition: vulkan.hpp:12866
void(VKAPI_PTR * PFN_vkDestroyPrivateDataSlot)(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:7293
VKAPI_ATTR void VKAPI_CALL vkCmdSetPolygonModeEXT(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode)
PFN_vkCmdSetFrontFaceEXT vkCmdSetFrontFaceEXT
Definition: vulkan.hpp:13166
PFN_vkCmdSetStencilWriteMask vkCmdSetStencilWriteMask
Definition: vulkan.hpp:12521
VkResult vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImage *pImage) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1645
PFN_vkDestroyValidationCacheEXT vkDestroyValidationCacheEXT
Definition: vulkan.hpp:13033
PFN_vkCreateHeadlessSurfaceEXT vkCreateHeadlessSurfaceEXT
Definition: vulkan.hpp:13151
VKAPI_ATTR void VKAPI_CALL vkCmdSetColorBlendEnableEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32 *pColorBlendEnables)
void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR *pPerformanceQueryCreateInfo, uint32_t *pNumPasses) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3759
VkTimeDomainEXT
PFN_vkGetAccelerationStructureBuildSizesKHR vkGetAccelerationStructureBuildSizesKHR
Definition: vulkan.hpp:13018
void vkCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4384
void vkCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4332
NotPermittedKHRError(std::string const &message)
Definition: vulkan.hpp:6426
void(VKAPI_PTR * PFN_vkCmdBeginDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo)
VkResult vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixPropertiesNV *pProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4568
VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable)
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryRemoteAddressNV(VkDevice device, const VkMemoryGetRemoteAddressInfoNV *pMemoryGetRemoteAddressInfo, VkRemoteAddressNV *pAddress)
PFN_vkBindBufferMemory2 vkBindBufferMemory2
Definition: vulkan.hpp:12560
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void *pHostPointer, VkMemoryHostPointerPropertiesEXT *pMemoryHostPointerProperties)
VkResult(VKAPI_PTR * PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo, VkDescriptorSet *pDescriptorSets)
Definition: vulkan_core.h:3983
VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo)
VkResult(VKAPI_PTR * PFN_vkCreateWaylandSurfaceKHR)(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
VkBool32(VKAPI_PTR * PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display *display)
PFN_vkGetRenderAreaGranularity vkGetRenderAreaGranularity
Definition: vulkan.hpp:12504
VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance, const char *pName)
void vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1627
PFN_vkCmdDrawMeshTasksNV vkCmdDrawMeshTasksNV
Definition: vulkan.hpp:13074
VkShaderStageFlagBits
Definition: vulkan_core.h:2594
VKAPI_ATTR void VKAPI_CALL vkCmdBeginVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR *pBeginInfo)
VkResult(VKAPI_PTR * PFN_vkGetFramebufferTilePropertiesQCOM)(VkDevice device, VkFramebuffer framebuffer, uint32_t *pPropertiesCount, VkTilePropertiesQCOM *pProperties)
void vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2016
PFN_vkDebugReportMessageEXT vkDebugReportMessageEXT
Definition: vulkan.hpp:12718
void(VKAPI_PTR * PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D *pGranularity)
Definition: vulkan_core.h:3990
void(VKAPI_PTR * PFN_vkCmdSetLineStippleEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable)
VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData)
void vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1903
VKAPI_ATTR VkResult VKAPI_CALL vkSetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data)
void(VKAPI_PTR * PFN_vkCmdBeginRenderPass2KHR)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, const VkSubpassBeginInfo *pSubpassBeginInfo)
Definition: vulkan_core.h:8461
void vkCmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2703
void destroy(T t) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:6056
VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements *pSparseMemoryRequirements)
VkResult(VKAPI_PTR * PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT *pInfo, void *pData)
VULKAN_HPP_CONSTEXPR Flags(MaskType flags) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:396
ArrayProxyNoTemporaries(T(&ptr)[C]) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:743
VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks *pAllocator)
VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
VkResult(VKAPI_PTR * PFN_vkGetDeviceFaultInfoEXT)(VkDevice device, VkDeviceFaultCountsEXT *pFaultCounts, VkDeviceFaultInfoEXT *pFaultInfo)
PFN_vkCreateOpticalFlowSessionNV vkCreateOpticalFlowSessionNV
Definition: vulkan.hpp:13444
void(VKAPI_PTR * PFN_vkCmdCopyMicromapToMemoryEXT)(VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT *pInfo)
PFN_vkCmdSetCoverageToColorEnableNV vkCmdSetCoverageToColorEnableNV
Definition: vulkan.hpp:13429
const T * end() const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:813
VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo)
VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void *pData)
VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT *pSurfaceCapabilities) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3599
ResultValue(Result r, std::vector< UniqueHandle< Type, Dispatch >> &&v) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:6569
PFN_vkCreateCommandPool vkCreateCommandPool
Definition: vulkan.hpp:12505
VKAPI_ATTR void VKAPI_CALL vkSetHdrMetadataEXT(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR *pSwapchains, const VkHdrMetadataEXT *pMetadata)
VkResult vkCreatePrivateDataSlotEXT(VkDevice device, const VkPrivateDataSlotCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPrivateDataSlot *pPrivateDataSlot) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4840
void(VKAPI_PTR * PFN_vkCmdCopyBuffer2KHR)(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 *pCopyBufferInfo)
Definition: vulkan_core.h:9692
void(VKAPI_PTR * PFN_vkCmdSetLineRasterizationModeEXT)(VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode)
void(VKAPI_PTR * PFN_vkCmdPushDescriptorSetWithTemplateKHR)(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void *pData)
Definition: vulkan_core.h:8334
VkResult vkGetRayTracingShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5147
VkResult vkQueueSetPerformanceConfigurationINTEL(VkQueue queue, VkPerformanceConfigurationINTEL configuration) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4485
PFN_vkCmdDrawIndirectCountKHR vkCmdDrawIndirectCountKHR
Definition: vulkan.hpp:13060
VkResult(VKAPI_PTR * PFN_vkCreateMetalSurfaceEXT)(VkInstance instance, const VkMetalSurfaceCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
Definition: vulkan_metal.h:39
VkResult(VKAPI_PTR * PFN_vkImportSemaphoreZirconHandleFUCHSIA)(VkDevice device, const VkImportSemaphoreZirconHandleInfoFUCHSIA *pImportSemaphoreZirconHandleInfo)
VKAPI_ATTR void VKAPI_CALL vkDestroyBufferCollectionFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkAllocationCallbacks *pAllocator)
VULKAN_HPP_CONSTEXPR Flags< BitType > operator&(Flags< BitType > const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:440
void vkCmdCopyMemoryToImageIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VkImage dstImage, VkImageLayout dstImageLayout, const VkImageSubresourceLayers *pImageSubresources) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5544
VKAPI_ATTR VkResult VKAPI_CALL vkCreateScreenSurfaceQNX(VkInstance instance, const VkScreenSurfaceCreateInfoQNX *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
VkFlags VkDebugReportFlagsEXT
Definition: vulkan_core.h:9872
VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2762
void vkCmdResolveImage2(VkCommandBuffer commandBuffer, const VkResolveImageInfo2 *pResolveImageInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2617
void reset(Type const &value=Type()) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1242
VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy *pRegions)
void vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1919
PFN_vkCmdSetDepthBoundsTestEnable vkCmdSetDepthBoundsTestEnable
Definition: vulkan.hpp:12632
PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT
Definition: vulkan.hpp:13243
void(VKAPI_PTR * PFN_vkDestroyVideoSessionKHR)(VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_beta.h:243
VkResult(VKAPI_PTR * PFN_vkQueueSubmit2)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 *pSubmits, VkFence fence)
Definition: vulkan_core.h:7301
VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableInternalRepresentationsKHR(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR *pInternalRepresentations)
VkCoverageReductionModeNV
VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
void vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3334
VkResult(VKAPI_PTR * PFN_vkSetBufferCollectionImageConstraintsFUCHSIA)(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkImageConstraintsInfoFUCHSIA *pImageConstraintsInfo)
const struct VkBaseInStructure * pNext
Definition: vulkan_core.h:2812
VkResult(VKAPI_PTR * PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t *pDisplayCount, VkDisplayKHR *pDisplays)
Definition: vulkan_core.h:7860
OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:6045
PFN_vkCmdBeginTransformFeedbackEXT vkCmdBeginTransformFeedbackEXT
Definition: vulkan.hpp:12765
VkResult(VKAPI_PTR * PFN_vkBindOpticalFlowSessionImageNV)(VkDevice device, VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout)
PFN_vkCmdSetTessellationDomainOriginEXT vkCmdSetTessellationDomainOriginEXT
Definition: vulkan.hpp:13406
VkResult vkCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1525
void(VKAPI_PTR * PFN_vkCmdSetPrimitiveRestartEnable)(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable)
Definition: vulkan_core.h:7324
ArrayProxy(T const &value) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:600
VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
VULKAN_HPP_CONSTEXPR bool operator>=(Flags< BitType > const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:417
void vkCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D *pScissors) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4675
void vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1495
VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride)
VkResult(VKAPI_PTR * PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
Definition: vulkan_core.h:3993
void vkCmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, const VkDependencyInfo *pDependencyInfos) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4895
VKAPI_ATTR void VKAPI_CALL vkCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D *pScissors)
void vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D *pScissors) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1914
ArrayProxy(T const (&ptr)[C]) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:613
void vkDestroyAccelerationStructureNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4195
void vkCmdSetExtraPrimitiveOverestimationSizeEXT(VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5649
void(VKAPI_PTR * PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve *pRegions)
Definition: vulkan_core.h:4028
PFN_vkGetDeviceBufferMemoryRequirementsKHR vkGetDeviceBufferMemoryRequirementsKHR
Definition: vulkan.hpp:13389
void(VKAPI_PTR * PFN_vkCmdSetStencilOpEXT)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp)
VkResult(VKAPI_PTR * PFN_vkCreatePrivateDataSlot)(VkDevice device, const VkPrivateDataSlotCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPrivateDataSlot *pPrivateDataSlot)
Definition: vulkan_core.h:7292
PFN_vkGetPhysicalDeviceMemoryProperties2 vkGetPhysicalDeviceMemoryProperties2
Definition: vulkan.hpp:12574
VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex)
VkResult vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1898
VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements *pMemoryRequirements)
void vkCmdWriteMicromapsPropertiesEXT(VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT *pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5464
VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
void vkCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4164
VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(uint32_t *pPropertyCount, VkLayerProperties *pProperties)
VkResult(VKAPI_PTR * PFN_vkBindAccelerationStructureMemoryNV)(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV *pBindInfos)
void(VKAPI_PTR * PFN_vkCmdBindInvocationMaskHUAWEI)(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
VkResult(VKAPI_PTR * PFN_vkCopyAccelerationStructureKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR *pInfo)
PFN_vkGetBufferOpaqueCaptureAddress vkGetBufferOpaqueCaptureAddress
Definition: vulkan.hpp:12600
void vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D *pDiscardRectangles) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3657
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceExternalSemaphoreProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties)
Definition: vulkan_core.h:5558
GA_API const UT_StringHolder transform
PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT vkGetPhysicalDeviceCalibrateableTimeDomainsEXT
Definition: vulkan.hpp:13070
VULKAN_HPP_CONSTEXPR bool operator==(Flags< BitType > const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:422
VKAPI_ATTR void VKAPI_CALL vkSetDeviceMemoryPriorityEXT(VkDevice device, VkDeviceMemory memory, float priority)
void(VKAPI_PTR * PFN_vkGetDescriptorSetLayoutBindingOffsetEXT)(VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize *pOffset)
VkResult vkGetFenceStatus(VkDevice device, VkFence fence) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1543
GLint GLenum GLint x
Definition: glcorearb.h:409
void vkGetShaderModuleCreateInfoIdentifierEXT(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, VkShaderModuleIdentifierEXT *pIdentifier) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5754
VkResult vkCreateIndirectCommandsLayoutNV(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkIndirectCommandsLayoutNV *pIndirectCommandsLayout) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4811
void(VKAPI_PTR * PFN_vkCmdSetDepthWriteEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable)
PFN_vkCmdSetDescriptorBufferOffsetsEXT vkCmdSetDescriptorBufferOffsetsEXT
Definition: vulkan.hpp:13237
void(VKAPI_PTR * PFN_vkCmdSetVertexInputEXT)(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT *pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT *pVertexAttributeDescriptions)
void(VKAPI_PTR * PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void *pValues)
Definition: vulkan_core.h:4038
VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex)
void vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2185
VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers)
void vkCmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 *pCopyImageToBufferInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5057
VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSampler *pSampler)
VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleMaskEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask *pSampleMask)
VKAPI_ATTR VkResult VKAPI_CALL vkGetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t *pInfoSize, void *pInfo)
VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructuresKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkAccelerationStructureBuildRangeInfoKHR *const *ppBuildRangeInfos)
void(VKAPI_PTR * PFN_vkCmdCopyAccelerationStructureKHR)(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR *pInfo)
VKAPI_ATTR VkResult VKAPI_CALL vkGetAccelerationStructureHandleNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void *pData)
void vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo, const VkSubpassEndInfo *pSubpassEndInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3692
VkResult(VKAPI_PTR * PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT *pInfo, void *pData)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain)
void(VKAPI_PTR * PFN_vkGetBufferMemoryRequirements2KHR)(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
Definition: vulkan_core.h:8880
VkResult(VKAPI_PTR * PFN_vkCreateRenderPass2KHR)(VkDevice device, const VkRenderPassCreateInfo2 *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
Definition: vulkan_core.h:8460
PFN_vkDestroyPipelineCache vkDestroyPipelineCache
Definition: vulkan.hpp:12482
VkResult vkGetFramebufferTilePropertiesQCOM(VkDevice device, VkFramebuffer framebuffer, uint32_t *pPropertiesCount, VkTilePropertiesQCOM *pProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5802
PFN_vkGetImageSubresourceLayout2EXT vkGetImageSubresourceLayout2EXT
Definition: vulkan.hpp:13262
PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 vkGetPhysicalDeviceSparseImageFormatProperties2
Definition: vulkan.hpp:12575
VkResult(VKAPI_PTR * PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorSetLayout *pSetLayout)
Definition: vulkan_core.h:3978
DispatchLoaderDynamic() VULKAN_HPP_NOEXCEPT=default
PFN_vkGetPerformanceParameterINTEL vkGetPerformanceParameterINTEL
Definition: vulkan.hpp:13099
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClampEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable)
VKAPI_ATTR void VKAPI_CALL vkCmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace)
void(VKAPI_PTR * PFN_vkCmdInsertDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo)
VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport *pViewports)
LayerNotPresentError(char const *message)
Definition: vulkan.hpp:6213
void(VKAPI_PTR * PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
Definition: vulkan_core.h:3999
VKAPI_ATTR VkResult VKAPI_CALL vkCreateImagePipeSurfaceFUCHSIA(VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
VkResult vkRegisterDeviceEventEXT(VkDevice device, const VkDeviceEventInfoEXT *pDeviceEventInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3613
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryZirconHandlePropertiesFUCHSIA(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, VkMemoryZirconHandlePropertiesFUCHSIA *pMemoryZirconHandleProperties)
VkImageType
Definition: vulkan_core.h:1699
void(VKAPI_PTR * PFN_vkCmdSetRasterizerDiscardEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable)
VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageModulationTableNV(VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float *pCoverageModulationTable)
VkResult(VKAPI_PTR * PFN_vkCreateMacOSSurfaceMVK)(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
Definition: vulkan_macos.h:33
void(VKAPI_PTR * PFN_vkCmdBindDescriptorBuffersEXT)(VkCommandBuffer commandBuffer, uint32_t bufferCount, const VkDescriptorBufferBindingInfoEXT *pBindingInfos)
PFN_vkGetDescriptorEXT vkGetDescriptorEXT
Definition: vulkan.hpp:13235
FormatNotSupportedError(std::string const &message)
Definition: vulkan.hpp:6247
PFN_vkGetFramebufferTilePropertiesQCOM vkGetFramebufferTilePropertiesQCOM
Definition: vulkan.hpp:13450
VkResult vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4120
void vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2349
PFN_vkGetMicromapBuildSizesEXT vkGetMicromapBuildSizesEXT
Definition: vulkan.hpp:13383
VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo *pBindInfo, VkFence fence)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties)
Definition: vulkan_core.h:3912
PFN_vkGetPhysicalDeviceSurfaceFormatsKHR vkGetPhysicalDeviceSurfaceFormatsKHR
Definition: vulkan.hpp:12646
PFN_vkCmdSetColorWriteEnableEXT vkCmdSetColorWriteEnableEXT
Definition: vulkan.hpp:13360
VkResult(VKAPI_PTR * PFN_vkDeferredOperationJoinKHR)(VkDevice device, VkDeferredOperationKHR operation)
Definition: vulkan_core.h:9357
PFN_vkGetDeviceImageSparseMemoryRequirements vkGetDeviceImageSparseMemoryRequirements
Definition: vulkan.hpp:12640
PFN_vkResetCommandPool vkResetCommandPool
Definition: vulkan.hpp:12507
void(VKAPI_PTR * PFN_vkCmdBlitImage2)(VkCommandBuffer commandBuffer, const VkBlitImageInfo2 *pBlitImageInfo)
Definition: vulkan_core.h:7306
const T & back() const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:872
PFN_vkGetDescriptorSetHostMappingVALVE vkGetDescriptorSetHostMappingVALVE
Definition: vulkan.hpp:13395
void(VKAPI_PTR * PFN_vkCmdDrawIndirectByteCountEXT)(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride)
void(VKAPI_PTR * PFN_vkTrimCommandPoolKHR)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
Definition: vulkan_core.h:8140
VKAPI_ATTR void VKAPI_CALL vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index)
PFN_vkGetDeviceAccelerationStructureCompatibilityKHR vkGetDeviceAccelerationStructureCompatibilityKHR
Definition: vulkan.hpp:13017
void vkCmdDrawMultiEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT *pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5370
void(VKAPI_PTR * PFN_vkCmdSetLogicOpEXT)(VkCommandBuffer commandBuffer, VkLogicOp logicOp)
VkResult(VKAPI_PTR * PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages)
Definition: vulkan_core.h:7725
PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties
Definition: vulkan.hpp:12435
bool success() const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:12398
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable)
void vkGetImageSparseMemoryRequirements2KHR(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3961
PFN_vkCmdClearDepthStencilImage vkCmdClearDepthStencilImage
Definition: vulkan.hpp:12540
VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2 *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
void(VKAPI_PTR * PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements *pMemoryRequirements)
Definition: vulkan_core.h:3936
void vkGetQueueCheckpointData2NV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointData2NV *pCheckpointData) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4924
PFN_vkGetPipelineCacheData vkGetPipelineCacheData
Definition: vulkan.hpp:12483
VkResult(VKAPI_PTR * PFN_vkCreateDebugUtilsMessengerEXT)(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugUtilsMessengerEXT *pMessenger)
void vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve *pRegions) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2111
GLdouble t
Definition: glad.h:2397
PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI
Definition: vulkan.hpp:13331
VkResult vkReleasePerformanceConfigurationINTEL(VkDevice device, VkPerformanceConfigurationINTEL configuration) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4480
void vkCmdSetPrimitiveTopology(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2642
VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectCountEXT(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
PFN_vkCmdResetEvent2KHR vkCmdResetEvent2KHR
Definition: vulkan.hpp:13224
VKAPI_ATTR void VKAPI_CALL vkCmdSetLogicOpEnableEXT(VkCommandBuffer commandBuffer, VkBool32 logicOpEnable)
VkConservativeRasterizationModeEXT
GLsizei samples
Definition: glcorearb.h:1298
const T & front() const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:662
PFN_vkCmdPipelineBarrier2KHR vkCmdPipelineBarrier2KHR
Definition: vulkan.hpp:13226
void vkCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV *pViewportWScalings) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3568
PFN_vkGetPhysicalDeviceSurfaceFormats2KHR vkGetPhysicalDeviceSurfaceFormats2KHR
Definition: vulkan.hpp:12949
void(VKAPI_PTR * PFN_vkSetHdrMetadataEXT)(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR *pSwapchains, const VkHdrMetadataEXT *pMetadata)
PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties
Definition: vulkan.hpp:12434
VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizationSamplesEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples)
PFN_vkDestroyPrivateDataSlotEXT vkDestroyPrivateDataSlotEXT
Definition: vulkan.hpp:13204
void vkGetDescriptorSetLayoutSizeEXT(VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize *pLayoutSizeInBytes) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4931
PFN_vkGetDeviceMemoryCommitment vkGetDeviceMemoryCommitment
Definition: vulkan.hpp:12447
VkResult(VKAPI_PTR * PFN_vkCreateDescriptorUpdateTemplate)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
Definition: vulkan_core.h:5553
VkResult(VKAPI_PTR * PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo, VkCommandBuffer *pCommandBuffers)
Definition: vulkan_core.h:3994
PFN_vkGetPhysicalDeviceQueueFamilyProperties2 vkGetPhysicalDeviceQueueFamilyProperties2
Definition: vulkan.hpp:12573
VkResult vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1594
VKAPI_ATTR void VKAPI_CALL vkCmdCopyMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT *pInfo)
GLenum mode
Definition: glcorearb.h:99
VkResult(VKAPI_PTR * PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain)
Definition: vulkan_core.h:7723
VkResult(VKAPI_PTR * PFN_vkCreateOpticalFlowSessionNV)(VkDevice device, const VkOpticalFlowSessionCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkOpticalFlowSessionNV *pSession)
GLint GLint GLsizei GLsizei GLsizei depth
Definition: glcorearb.h:476
MemoryMapFailedError(std::string const &message)
Definition: vulkan.hpp:6205
VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageMemoryRequirementsKHR(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
void vkCmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2564
Optional< const AllocationCallbacks > getAllocator() const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5911
PFN_vkDestroyAccelerationStructureKHR vkDestroyAccelerationStructureKHR
Definition: vulkan.hpp:13004
uint64_t(VKAPI_PTR * PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR)(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo)
Definition: vulkan_core.h:9332
PFN_vkSetHdrMetadataEXT vkSetHdrMetadataEXT
Definition: vulkan.hpp:12914
VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore)
VKAPI_ATTR VkResult VKAPI_CALL vkGetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo *pRenderingInfo, VkTilePropertiesQCOM *pProperties)
VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreZirconHandleFUCHSIA(VkDevice device, const VkSemaphoreGetZirconHandleInfoFUCHSIA *pGetZirconHandleInfo, zx_handle_t *pZirconHandle)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateStreamDescriptorSurfaceGGP(VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable)
VkFlags VkDeviceGroupPresentModeFlagsKHR
Definition: vulkan_core.h:7646
VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
PFN_vkCmdCopyMemoryToAccelerationStructureKHR vkCmdCopyMemoryToAccelerationStructureKHR
Definition: vulkan.hpp:13014
VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL *pMarkerInfo)
StructureChain(StructureChain &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:993
VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreCounterValueKHR(VkDevice device, VkSemaphore semaphore, uint64_t *pValue)
void vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1687
VKAPI_ATTR VkResult VKAPI_CALL vkSetBufferCollectionImageConstraintsFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkImageConstraintsInfoFUCHSIA *pImageConstraintsInfo)
VkFlags VkDependencyFlags
Definition: vulkan_core.h:2710
ObjectFree(OwnerType owner, Optional< const AllocationCallbacks > allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Dispatch const &dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5969
VkResult(VKAPI_PTR * PFN_vkCopyAccelerationStructureToMemoryKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo)
void vkGetDeviceBufferMemoryRequirementsKHR(VkDevice device, const VkDeviceBufferMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5498
void(VKAPI_PTR * PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3968
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceMemoryProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
Definition: vulkan_core.h:8037
void vkCmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfo *pRenderingInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2622
void(VKAPI_PTR * PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3973
void vkSetDeviceMemoryPriorityEXT(VkDevice device, VkDeviceMemory memory, float priority) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5491
PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr
Definition: vulkan.hpp:12429
void vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1449
VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo, const VkSubpassEndInfo *pSubpassEndInfo)
VKAPI_ATTR void VKAPI_CALL vkCmdEndRendering(VkCommandBuffer commandBuffer)
VkResult(VKAPI_PTR * PFN_vkCreateRayTracingPipelinesKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
VKAPI_ATTR void VKAPI_CALL vkCmdSetProvokingVertexModeEXT(VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode)
void(VKAPI_PTR * PFN_vkCmdWriteTimestamp2)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query)
Definition: vulkan_core.h:7300
VkResult vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR *pModes) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2819
VKAPI_ATTR VkResult VKAPI_CALL vkCreateHeadlessSurfaceEXT(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR *pAcquireInfo, uint32_t *pImageIndex)
VkResult vkCopyMemoryToMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT *pInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5431
VkResult vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo *pBindInfo, VkFence fence) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1520
VKAPI_ATTR void VKAPI_CALL vkCmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize)
virtual ~Error() VULKAN_HPP_NOEXCEPT=default
void vkGetDeviceImageMemoryRequirementsKHR(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5505
void vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1975
PFN_vkCmdExecuteCommands vkCmdExecuteCommands
Definition: vulkan.hpp:12556
PFN_vkCmdCopyImageToBuffer vkCmdCopyImageToBuffer
Definition: vulkan.hpp:12536
VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 *pCopyBufferInfo)
VKAPI_ATTR void VKAPI_CALL vkCmdControlVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR *pCodingControlInfo)
VkResult vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2373
PFN_vkGetImageViewHandleNVX vkGetImageViewHandleNVX
Definition: vulkan.hpp:12779
void(VKAPI_PTR * PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3918
VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
VkResult(VKAPI_PTR * PFN_vkAcquireDrmDisplayEXT)(VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display)
VkResult vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2801
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
Definition: vulkan.hpp:3010
VkResult(VKAPI_PTR * PFN_vkReleaseDisplayEXT)(VkPhysicalDevice physicalDevice, VkDisplayKHR display)
PFN_vkQueueEndDebugUtilsLabelEXT vkQueueEndDebugUtilsLabelEXT
Definition: vulkan.hpp:12975
PFN_vkCreateDisplayModeKHR vkCreateDisplayModeKHR
Definition: vulkan.hpp:12665
VKAPI_ATTR void VKAPI_CALL vkCmdWriteMicromapsPropertiesEXT(VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT *pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
void(VKAPI_PTR * PFN_vkCmdResolveImage2KHR)(VkCommandBuffer commandBuffer, const VkResolveImageInfo2 *pResolveImageInfo)
Definition: vulkan_core.h:9697
PFN_vkCmdSetRepresentativeFragmentTestEnableNV vkCmdSetRepresentativeFragmentTestEnableNV
Definition: vulkan.hpp:13435
PFN_vkGetDescriptorSetLayoutBindingOffsetEXT vkGetDescriptorSetLayoutBindingOffsetEXT
Definition: vulkan.hpp:13234
void(VKAPI_PTR * PFN_vkGetDescriptorSetLayoutSupport)(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport)
Definition: vulkan_core.h:5559
UniqueHandle(Type const &value, Deleter const &deleter=Deleter()) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1176
VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
void(VKAPI_PTR * PFN_vkCmdSetDeviceMaskKHR)(VkCommandBuffer commandBuffer, uint32_t deviceMask)
Definition: vulkan_core.h:8102
VULKAN_HPP_CONSTEXPR_14 Flags< BitType > & operator=(Flags< BitType > const &rhs) VULKAN_HPP_NOEXCEPT=default
PFN_vkCreateDebugReportCallbackEXT vkCreateDebugReportCallbackEXT
Definition: vulkan.hpp:12716
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
Definition: vulkan.hpp:5380
PFN_vkGetSemaphoreFdKHR vkGetSemaphoreFdKHR
Definition: vulkan.hpp:12867
PFN_vkGetAccelerationStructureHandleNV vkGetAccelerationStructureHandleNV
Definition: vulkan.hpp:13052
VkResult vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkLayerProperties *pProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1416
void(VKAPI_PTR * PFN_vkGetGeneratedCommandsMemoryRequirementsNV)(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern)
VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageModulationTableEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable)
VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2755
PFN_vkGetSemaphoreCounterValue vkGetSemaphoreCounterValue
Definition: vulkan.hpp:12596
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp)
PFN_vkCmdSetColorBlendAdvancedEXT vkCmdSetColorBlendAdvancedEXT
Definition: vulkan.hpp:13422
VkResult vkQueueSubmit2KHR(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 *pSubmits, VkFence fence) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4913
VKAPI_ATTR void VKAPI_CALL vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks *pAllocator)
void(VKAPI_PTR * PFN_vkCmdSetFragmentShadingRateKHR)(VkCommandBuffer commandBuffer, const VkExtent2D *pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
Definition: vulkan_core.h:9248
void(VKAPI_PTR * PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers)
Definition: vulkan_core.h:3995
PFN_vkCmdWriteTimestamp2KHR vkCmdWriteTimestamp2KHR
Definition: vulkan.hpp:13227
PFN_vkCmdDrawIndexedIndirectCountAMD vkCmdDrawIndexedIndirectCountAMD
Definition: vulkan.hpp:12784
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties)
VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
VkResult vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3346
GLsizeiptr size
Definition: glcorearb.h:664
void(VKAPI_PTR * PFN_vkCmdSetCoverageToColorEnableNV)(VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable)
PFN_vkCmdCopyBufferToImage2KHR vkCmdCopyBufferToImage2KHR
Definition: vulkan.hpp:13256
VkResult vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkShaderModule *pShaderModule) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1679
PFN_vkGetPastPresentationTimingGOOGLE vkGetPastPresentationTimingGOOGLE
Definition: vulkan.hpp:12908
VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
PFN_vkGetQueryPoolResults vkGetQueryPoolResults
Definition: vulkan.hpp:12469
OutOfDateKHRError(std::string const &message)
Definition: vulkan.hpp:6310
VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
VULKAN_HPP_INLINE const std::error_category & errorCategory() VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:6158
PFN_vkCreateComputePipelines vkCreateComputePipelines
Definition: vulkan.hpp:12486
GLenum GLenum dst
Definition: glcorearb.h:1793
VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets
Definition: vulkan.hpp:12523
void(VKAPI_PTR * PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
Definition: vulkan_core.h:4014
PFN_vkGetAccelerationStructureMemoryRequirementsNV vkGetAccelerationStructureMemoryRequirementsNV
Definition: vulkan.hpp:13045
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
Definition: vulkan.hpp:5123
PFN_vkUpdateDescriptorSetWithTemplateKHR vkUpdateDescriptorSetWithTemplateKHR
Definition: vulkan.hpp:12880
void(VKAPI_PTR * PFN_vkCmdSetDepthClipEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable)
VkResult vkGetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR *pGetFdInfo, int *pFd) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3741
void vkCmdSetLogicOpEnableEXT(VkCommandBuffer commandBuffer, VkBool32 logicOpEnable) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5609
GLuint shader
Definition: glcorearb.h:785
VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t *pDataSize, void *pData)
VkResult(VKAPI_PTR * PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCommandPool *pCommandPool)
Definition: vulkan_core.h:3991
VkResult vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1426
VkResult vkCreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugUtilsMessengerEXT *pMessenger) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3890
SystemError(std::error_code ec, std::string const &what)
Definition: vulkan.hpp:6146
VkObjectType
Definition: vulkan_core.h:1303
VkResult vkCreateDeferredOperationKHR(VkDevice device, const VkAllocationCallbacks *pAllocator, VkDeferredOperationKHR *pDeferredOperation) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4728
void vkCmdCopyImageToBuffer2(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 *pCopyImageToBufferInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2607
void(VKAPI_PTR * PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy *pRegions)
Definition: vulkan_core.h:4019
void vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1775
void swap(UniqueHandle< Type, Dispatch > &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1261
void(VKAPI_PTR * PFN_vkCmdCopyMicromapEXT)(VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT *pInfo)
VkResult vkGetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR *pCapabilities) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2878
GLsizeiptr const void GLenum usage
Definition: glcorearb.h:664
VkFragmentShadingRateNV
void vkDestroyOpticalFlowSessionNV(VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5779
void(VKAPI_PTR * PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void *pData)
Definition: vulkan_core.h:4023
VkResult(VKAPI_PTR * PFN_vkRegisterDeviceEventEXT)(VkDevice device, const VkDeviceEventInfoEXT *pDeviceEventInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
VKAPI_ATTR void VKAPI_CALL vkCmdSubpassShadingHUAWEI(VkCommandBuffer commandBuffer)
VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void *pValues)
PFN_vkAcquirePerformanceConfigurationINTEL vkAcquirePerformanceConfigurationINTEL
Definition: vulkan.hpp:13096
void(VKAPI_PTR * PFN_vkCmdSetDepthWriteEnable)(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable)
Definition: vulkan_core.h:7317
Type const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1222
VkResult vkGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t *pDisplayCount, VkDisplayKHR *pDisplays) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2853
VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceVersion(uint32_t *pApiVersion)
const T * end() const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:865
VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride)
VkPipelineBindPoint
Definition: vulkan_core.h:2089
VKAPI_ATTR VkResult VKAPI_CALL vkAcquireDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display)
void vkGetAccelerationStructureBuildSizesKHR(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR *pBuildInfo, const uint32_t *pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR *pSizeInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4087
void vkCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D *pExclusiveScissors) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4408
VKAPI_ATTR uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
VkBool32(VKAPI_PTR * PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct _screen_window *window)
Definition: vulkan_screen.h:35
VkResult(VKAPI_PTR * PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
Definition: vulkan_core.h:3931
PFN_dummy vkGetPhysicalDeviceScreenPresentationSupportQNX_placeholder
Definition: vulkan.hpp:13356
VKAPI_ATTR void VKAPI_CALL vkDestroyCuFunctionNVX(VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks *pAllocator)
VKAPI_ATTR void VKAPI_CALL vkCmdWriteAccelerationStructuresPropertiesKHR(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR *pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
bool operator!=(std::string const &lhs, ArrayWrapper1D< char, N > const &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:360
PFN_vkCreateRayTracingPipelinesNV vkCreateRayTracingPipelinesNV
Definition: vulkan.hpp:13050
PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR
Definition: vulkan.hpp:12998
VkResult vkGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPropertiesKHR *pProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2839
VkResult(VKAPI_PTR * PFN_vkGetPipelineExecutableStatisticsKHR)(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pStatisticCount, VkPipelineExecutableStatisticKHR *pStatistics)
Definition: vulkan_core.h:9450
const T * end() const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:657
PFN_vkCmdSetSampleLocationsEXT vkCmdSetSampleLocationsEXT
Definition: vulkan.hpp:12994
PFN_vkCmdDrawMeshTasksIndirectCountNV vkCmdDrawMeshTasksIndirectCountNV
Definition: vulkan.hpp:13076
void vkCmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5178
void(VKAPI_PTR * PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
Definition: vulkan_core.h:4035
void(VKAPI_PTR * PFN_vkGetDescriptorSetLayoutSizeEXT)(VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize *pLayoutSizeInBytes)
void vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2127
PFN_vkGetBufferDeviceAddressKHR vkGetBufferDeviceAddressKHR
Definition: vulkan.hpp:13154
VkResult(VKAPI_PTR * PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex)
Definition: vulkan_core.h:7726
PFN_vkEnumerateDeviceLayerProperties vkEnumerateDeviceLayerProperties
Definition: vulkan.hpp:12436
VKAPI_ATTR void VKAPI_CALL vkCmdSetShadingRateImageEnableNV(VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable)
VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetAccelerationStructureDeviceAddressKHR(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR *pInfo)
void vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements *pSparseMemoryRequirements) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1500
VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR *pGetFdInfo, int *pFd)
PFN_vkResetDescriptorPool vkResetDescriptorPool
Definition: vulkan.hpp:12496
PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT vkCmdBindDescriptorBufferEmbeddedSamplersEXT
Definition: vulkan.hpp:13238
void vkCmdBeginRenderingKHR(VkCommandBuffer commandBuffer, const VkRenderingInfo *pRenderingInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3278
VKAPI_ATTR VkResult VKAPI_CALL vkCreateIOSSurfaceMVK(VkInstance instance, const VkIOSSurfaceCreateInfoMVK *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
void(VKAPI_PTR * PFN_vkCmdSetCoverageModulationModeNV)(VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode)
void(VKAPI_PTR * PFN_vkCmdEncodeVideoKHR)(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR *pEncodeInfo)
Definition: vulkan_beta.h:503
VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display *dpy, VisualID visualID)
ArrayProxyNoTemporaries(V &v) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:802
VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks *pAllocator)
PFN_vkBindBufferMemory2KHR vkBindBufferMemory2KHR
Definition: vulkan.hpp:13025
PFN_vkCmdSetPrimitiveRestartEnable vkCmdSetPrimitiveRestartEnable
Definition: vulkan.hpp:12637
VkResult(VKAPI_PTR * PFN_vkGetSwapchainStatusKHR)(VkDevice device, VkSwapchainKHR swapchain)
Definition: vulkan_core.h:8497
void(VKAPI_PTR * PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit *pRegions, VkFilter filter)
Definition: vulkan_core.h:4020
SystemError(int ev, std::error_category const &ecat, std::string const &what)
Definition: vulkan.hpp:6149
void vkGetDescriptorSetHostMappingVALVE(VkDevice device, VkDescriptorSet descriptorSet, void **ppData) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5529
void(VKAPI_PTR * PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
Definition: vulkan_core.h:4036
VkResult vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1465
PFN_vkGetDisplayModePropertiesKHR vkGetDisplayModePropertiesKHR
Definition: vulkan.hpp:12664
VkResult vkSetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2547
#define VULKAN_HPP_NAMESPACE_STRING
Definition: vulkan.hpp:234
VKAPI_ATTR VkResult VKAPI_CALL vkCreateValidationCacheEXT(VkDevice device, const VkValidationCacheCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkValidationCacheEXT *pValidationCache)
void vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1490
VULKAN_HPP_CONSTEXPR Flags() VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:390
VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroupsKHR(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties)
VkResult vkCreateCuModuleNVX(VkDevice device, const VkCuModuleCreateInfoNVX *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCuModuleNVX *pModule) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3197
void(VKAPI_PTR * PFN_vkCmdDrawMeshTasksIndirectNV)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
void vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1561
ObjectRelease(OwnerType owner, Dispatch const &dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:6008
VkResult vkGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL *pValue) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4491
VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceMemoryOpaqueCaptureAddress(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo)
void(VKAPI_PTR * PFN_vkDestroyMicromapEXT)(VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks *pAllocator)
void vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2264
VKAPI_ATTR VkResult VKAPI_CALL vkGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL *pValue)
VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetHostMappingVALVE(VkDevice device, VkDescriptorSet descriptorSet, void **ppData)
void(VKAPI_PTR * PFN_vkGetDeviceQueue2)(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue)
Definition: vulkan_core.h:5550
VkResult vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorPool *pDescriptorPool) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1782
void vkCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void *pData) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3519
void vkCmdNextSubpass2(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo, const VkSubpassEndInfo *pSubpassEndInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2478
void(VKAPI_PTR * PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents)
Definition: vulkan_core.h:4040
void vkGetDeviceImageSparseMemoryRequirementsKHR(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5512
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT *pMultisampleProperties)
PFN_vkCreateSwapchainKHR vkCreateSwapchainKHR
Definition: vulkan.hpp:12650
VkResult(VKAPI_PTR * PFN_vkCreateAccelerationStructureNV)(VkDevice device, const VkAccelerationStructureCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureNV *pAccelerationStructure)
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties)
void(VKAPI_PTR * PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
Definition: vulkan_core.h:4016
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties *pImageFormatProperties)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties)
Definition: vulkan_core.h:8521
VkResult vkQueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 *pSubmits, VkFence fence) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2587
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, uint32_t *pPresentModeCount, VkPresentModeKHR *pPresentModes)
Definition: vulkan_win32.h:285
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
Definition: vulkan.hpp:1607
VKAPI_ATTR void VKAPI_CALL vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
VkResult(VKAPI_PTR * PFN_vkCmdSetPerformanceOverrideINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL *pOverrideInfo)
VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectCommandsLayoutNV(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks *pAllocator)
VkSampleCountFlagBits
Definition: vulkan_core.h:2263
VKAPI_ATTR void VKAPI_CALL vkCmdBindPipelineShaderGroupNV(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex)
VkCoverageModulationModeNV
VkResult(VKAPI_PTR * PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
PFN_vkCmdSetRasterizationStreamEXT vkCmdSetRasterizationStreamEXT
Definition: vulkan.hpp:13417
void(VKAPI_PTR * PFN_vkCmdSetViewportWScalingEnableNV)(VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable)
PFN_vkGetDeviceImageSparseMemoryRequirementsKHR vkGetDeviceImageSparseMemoryRequirementsKHR
Definition: vulkan.hpp:13391
PFN_vkGetDeviceFaultInfoEXT vkGetDeviceFaultInfoEXT
Definition: vulkan.hpp:13265
VkResult(VKAPI_PTR * PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool)
Definition: vulkan_core.h:3953
void vkGetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3366
VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo)
VKAPI_ATTR VkResult VKAPI_CALL vkBuildMicromapsEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT *pInfos)
VkResult vkCreateDisplayPlaneSurfaceKHR(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2886
void(VKAPI_PTR * PFN_vkCmdNextSubpass2)(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo, const VkSubpassEndInfo *pSubpassEndInfo)
Definition: vulkan_core.h:6379
PFN_vkEndCommandBuffer vkEndCommandBuffer
Definition: vulkan.hpp:12511
PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR vkGetDeviceMemoryOpaqueCaptureAddressKHR
Definition: vulkan.hpp:13156
VkResult(VKAPI_PTR * PFN_vkCreateHeadlessSurfaceEXT)(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
PFN_vkGetPhysicalDeviceExternalSemaphoreProperties vkGetPhysicalDeviceExternalSemaphoreProperties
Definition: vulkan.hpp:12585
void(VKAPI_PTR * PFN_vkCmdWaitEvents2KHR)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, const VkDependencyInfo *pDependencyInfos)
Definition: vulkan_core.h:9564
VkImageLayout
Definition: vulkan_core.h:1250
PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT
Definition: vulkan.hpp:12981
VkResult vkQueueWaitIdle(VkQueue queue) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1431
DispatchLoaderDynamic(VkInstance instance, PFN_vkGetInstanceProcAddr getInstanceProcAddr, VkDevice device={}, PFN_vkGetDeviceProcAddr getDeviceProcAddr=nullptr) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:13479
void(VKAPI_PTR * PFN_vkGetQueueCheckpointDataNV)(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointDataNV *pCheckpointData)
VkResult(VKAPI_PTR * PFN_vkGetMemoryAndroidHardwareBufferANDROID)(VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID *pInfo, struct AHardwareBuffer **pBuffer)
VKAPI_ATTR VkResult VKAPI_CALL vkCopyMemoryToMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT *pInfo)
PFN_vkCmdCopyAccelerationStructureKHR vkCmdCopyAccelerationStructureKHR
Definition: vulkan.hpp:13012
void(VKAPI_PTR * PFN_vkGetDeviceImageSparseMemoryRequirementsKHR)(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
Definition: vulkan_core.h:9791
VKAPI_ATTR VkResult VKAPI_CALL vkWaitSemaphoresKHR(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout)
PFN_vkCmdSetPatchControlPointsEXT vkCmdSetPatchControlPointsEXT
Definition: vulkan.hpp:13344
StructureChain() VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:978
PFN_vkGetCalibratedTimestampsEXT vkGetCalibratedTimestampsEXT
Definition: vulkan.hpp:13071
VkResult vkSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT *pNameInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3850
void vkDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3003
void(VKAPI_PTR * PFN_vkGetDeviceImageMemoryRequirements)(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
Definition: vulkan_core.h:7326
ArrayProxyNoTemporaries(uint32_t count, T *ptr) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:729
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceSparseImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties)
Definition: vulkan_core.h:5548
ResultValue(Result r, UniqueHandle< Type, Dispatch > &&v) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:6547
VKAPI_ATTR void VKAPI_CALL vkDestroyCuModuleNVX(VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks *pAllocator)
PFN_vkGetPhysicalDeviceDisplayProperties2KHR vkGetPhysicalDeviceDisplayProperties2KHR
Definition: vulkan.hpp:12952
VkResult vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1485
void vkCmdSetLineRasterizationModeEXT(VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5677
uint64_t vkGetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo *pInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2515
PFN_vkGetSwapchainStatusKHR vkGetSwapchainStatusKHR
Definition: vulkan.hpp:12923
VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceFaultInfoEXT(VkDevice device, VkDeviceFaultCountsEXT *pFaultCounts, VkDeviceFaultInfoEXT *pFaultInfo)
VkDeviceSize(VKAPI_PTR * PFN_vkGetRayTracingShaderGroupStackSizeKHR)(VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader)
void vkCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4701
void vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1937
VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
PFN_vkDestroyMicromapEXT vkDestroyMicromapEXT
Definition: vulkan.hpp:13371
VkLogicOp
Definition: vulkan_core.h:1992
VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageModulationModeNV(VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode)
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR *pMemoryWin32HandleProperties)
VKAPI_ATTR VkResult VKAPI_CALL vkAcquireWinrtDisplayNV(VkPhysicalDevice physicalDevice, VkDisplayKHR display)
void vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2411
VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(VkDevice device)
void vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2368
void(VKAPI_PTR * PFN_vkCmdBindPipelineShaderGroupNV)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex)
PFN_vkCmdSetDepthCompareOp vkCmdSetDepthCompareOp
Definition: vulkan.hpp:12631
void(VKAPI_PTR * PFN_vkCmdDebugMarkerInsertEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo)
Definition: vulkan_core.h:9993
PFN_vkGetQueueCheckpointData2NV vkGetQueueCheckpointData2NV
Definition: vulkan.hpp:13230
VkPipelineStageFlagBits
Definition: vulkan_core.h:2365
VkResult vkCopyMemoryToAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4028
PFN_vkCmdDebugMarkerEndEXT vkCmdDebugMarkerEndEXT
Definition: vulkan.hpp:12724
VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t *pCounterCount, VkPerformanceCounterKHR *pCounters, VkPerformanceCounterDescriptionKHR *pCounterDescriptions)
void vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2180
void(VKAPI_PTR * PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory)
Definition: vulkan_core.h:3930
void vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3415
VkFlags VkPeerMemoryFeatureFlags
Definition: vulkan_core.h:4932
PFN_vkCmdEndRenderPass2 vkCmdEndRenderPass2
Definition: vulkan.hpp:12594
void(VKAPI_PTR * PFN_vkSetLocalDimmingAMD)(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable)
LeafData & operator=(const LeafData &)=delete
VKAPI_ATTR void VKAPI_CALL vkGetDeviceMicromapCompatibilityEXT(VkDevice device, const VkMicromapVersionInfoEXT *pVersionInfo, VkAccelerationStructureCompatibilityKHR *pCompatibility)
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPlanePropertiesKHR *pProperties)
VkResult(VKAPI_PTR * PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer)
Definition: vulkan_core.h:3997
VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 *pCopyBufferToImageInfo)
VkResult vkAcquirePerformanceConfigurationINTEL(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL *pAcquireInfo, VkPerformanceConfigurationINTEL *pConfiguration) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4473
PFN_vkCmdBeginRenderingKHR vkCmdBeginRenderingKHR
Definition: vulkan.hpp:12790
PFN_vkGetPhysicalDeviceExternalFenceProperties vkGetPhysicalDeviceExternalFenceProperties
Definition: vulkan.hpp:12584
void(VKAPI_PTR * PFN_vkCmdSetConservativeRasterizationModeEXT)(VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode)
void vkGetDescriptorSetLayoutHostMappingInfoVALVE(VkDevice device, const VkDescriptorSetBindingReferenceVALVE *pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE *pHostMapping) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5522
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR)(VkPhysicalDevice physicalDevice, uint32_t *pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR *pFragmentShadingRates)
Definition: vulkan_core.h:9247
#define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT
Definition: vulkan.hpp:5886
UniqueHandle & operator=(UniqueHandle const &)=delete
VkResult(VKAPI_PTR * PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkShaderModule *pShaderModule)
Definition: vulkan_core.h:3965
PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR
Definition: vulkan.hpp:12811
void(VKAPI_PTR * PFN_vkCmdEndRenderingKHR)(VkCommandBuffer commandBuffer)
Definition: vulkan_core.h:7988
VkResult vkCreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDisplayModeKHR *pMode) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2869
GLuint index
Definition: glcorearb.h:786
VkResult vkCreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2 *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2463
PFN_vkCreateAccelerationStructureNV vkCreateAccelerationStructureNV
Definition: vulkan.hpp:13043
Optional(RefType *ptr) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:899
void vkGetGeneratedCommandsMemoryRequirementsNV(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2 *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4784
bool operator==(std::string const &lhs, ArrayWrapper1D< char, N > const &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:354
VULKAN_HPP_INLINE std::error_code make_error_code(Result e) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:6164
void vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2381
void(VKAPI_PTR * PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet *pDescriptorCopies)
Definition: vulkan_core.h:3985
VULKAN_HPP_CONSTEXPR T const & operator[](int index) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:248
VkResult(VKAPI_PTR * PFN_vkBuildAccelerationStructuresKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkAccelerationStructureBuildRangeInfoKHR *const *ppBuildRangeInfos)
VkResult(VKAPI_PTR * PFN_vkGetDisplayPlaneCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR *pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR *pCapabilities)
Definition: vulkan_core.h:8821
Optional< const AllocationCallbacks > getAllocator() const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5945
void vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void *pValues) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2215
PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR vkGetPhysicalDeviceQueueFamilyProperties2KHR
Definition: vulkan.hpp:12815
void(VKAPI_PTR * PFN_vkDestroySamplerYcbcrConversionKHR)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:8933
void(VKAPI_PTR * PFN_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)
Definition: vulkan_core.h:4031
void vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2318
void vkCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4389
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainEXT *pTimeDomains)
PFN_vkCmdBuildAccelerationStructuresKHR vkCmdBuildAccelerationStructuresKHR
Definition: vulkan.hpp:13005
VkResult(VKAPI_PTR * PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t *pPhysicalDeviceCount, VkPhysicalDevice *pPhysicalDevices)
Definition: vulkan_core.h:3908
void(VKAPI_PTR * PFN_vkDestroyAccelerationStructureNV)(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks *pAllocator)
VkResult vkWriteAccelerationStructuresPropertiesKHR(VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR *pAccelerationStructures, VkQueryType queryType, size_t dataSize, void *pData, size_t stride) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4035
VKAPI_ATTR void VKAPI_CALL vkDestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks *pAllocator)
PFN_vkDestroyShaderModule vkDestroyShaderModule
Definition: vulkan.hpp:12480
VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures)
void(VKAPI_PTR * PFN_vkCmdEndQueryIndexedEXT)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index)
VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks *pAllocator)
VKAPI_ATTR void VKAPI_CALL vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index)
SystemError(int ev, std::error_category const &ecat)
Definition: vulkan.hpp:6148
VkResult(VKAPI_PTR * PFN_vkGetShaderInfoAMD)(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t *pInfoSize, void *pInfo)
void(VKAPI_PTR * PFN_vkCmdCopyBufferToImage2)(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 *pCopyBufferToImageInfo)
Definition: vulkan_core.h:7304
void destroy(T t) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5918
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties)
VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV *pExternalImageFormatProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3302
void(VKAPI_PTR * PFN_vkCmdExecuteGeneratedCommandsNV)(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo)
VKAPI_ATTR VkResult VKAPI_CALL vkCopyMemoryToAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties)
Definition: vulkan_core.h:8192
PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass
Definition: vulkan.hpp:12553
PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV vkGetPhysicalDeviceOpticalFlowImageFormatsNV
Definition: vulkan.hpp:13443
void vkCmdBindPipelineShaderGroupNV(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4803
VkResult vkGetBufferOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT *pInfo, void *pData) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4976
VkResult vkWaitSemaphoresKHR(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4435
#define VK_HEADER_VERSION
Definition: vulkan_core.h:75
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties *pFormatProperties)
Definition: vulkan_core.h:3910
StructureChain(ChainElements const &...elems) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1002
PFN_vkQueueInsertDebugUtilsLabelEXT vkQueueInsertDebugUtilsLabelEXT
Definition: vulkan.hpp:12976
VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageReductionModeNV(VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode)
void vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4908
VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversionKHR(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion)
PFN_vkCmdCopyImageToBuffer2KHR vkCmdCopyImageToBuffer2KHR
Definition: vulkan.hpp:13257
void vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1602
PFN_vkCmdSetVertexInputEXT vkCmdSetVertexInputEXT
Definition: vulkan.hpp:13295
PFN_vkCmdSetCoarseSampleOrderNV vkCmdSetCoarseSampleOrderNV
Definition: vulkan.hpp:13040
PFN_vkCmdDrawMeshTasksEXT vkCmdDrawMeshTasksEXT
Definition: vulkan.hpp:13249
PFN_vkSetDebugUtilsObjectTagEXT vkSetDebugUtilsObjectTagEXT
Definition: vulkan.hpp:12973
void vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource *pSubresource, VkSubresourceLayout *pLayout) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1658
void(VKAPI_PTR * PFN_vkCmdBindShadingRateImageNV)(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
ArrayProxyNoTemporaries(std::initializer_list< typename std::remove_const< T >::type > &list) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:789
VkResult(VKAPI_PTR * PFN_vkCreateIndirectCommandsLayoutNV)(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkIndirectCommandsLayoutNV *pIndirectCommandsLayout)
auto ptr(T p) -> const void *
Definition: format.h:2448
void(VKAPI_PTR * PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions)
Definition: vulkan_core.h:4022
void(VKAPI_PTR * PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue)
Definition: vulkan_core.h:3923
VkResult vkCopyMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT *pInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5419
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32 *pSupported)
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV)(VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV *pOpticalFlowImageFormatInfo, uint32_t *pFormatCount, VkOpticalFlowImageFormatPropertiesNV *pImageFormatProperties)
PFN_vkGetPipelinePropertiesEXT vkGetPipelinePropertiesEXT
Definition: vulkan.hpp:13341
VKAPI_ATTR void VKAPI_CALL vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
VkResult vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2335
PFN_vkCmdSetRasterizerDiscardEnable vkCmdSetRasterizerDiscardEnable
Definition: vulkan.hpp:12635
VKAPI_ATTR VkResult VKAPI_CALL vkGetPastPresentationTimingGOOGLE(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pPresentationTimingCount, VkPastPresentationTimingGOOGLE *pPresentationTimings)
PFN_vkRegisterDeviceEventEXT vkRegisterDeviceEventEXT
Definition: vulkan.hpp:12902
void(VKAPI_PTR * PFN_vkCmdSetFrontFace)(VkCommandBuffer commandBuffer, VkFrontFace frontFace)
Definition: vulkan_core.h:7311
VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
void(VKAPI_PTR * PFN_vkCmdPipelineBarrier2)(VkCommandBuffer commandBuffer, const VkDependencyInfo *pDependencyInfo)
Definition: vulkan_core.h:7299
VkResult vkCreateHeadlessSurfaceEXT(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4614
PFN_vkCmdDrawIndexedIndirectCount vkCmdDrawIndexedIndirectCount
Definition: vulkan.hpp:12590
void(VKAPI_PTR * PFN_vkCmdSetDepthCompareOp)(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp)
Definition: vulkan_core.h:7318
VkResult(VKAPI_PTR * PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
Definition: vulkan_core.h:3934
VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDisplayModeKHR *pMode)
VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
T * data() const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:840
void vkCmdSetStencilOpEXT(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4716
GA_API const UT_StringHolder N
VkResult(VKAPI_PTR * PFN_vkQueuePresentKHR)(VkQueue queue, const VkPresentInfoKHR *pPresentInfo)
Definition: vulkan_core.h:7727
PoolFree(OwnerType owner, PoolType pool, Dispatch const &dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:6038
VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysIndirect2KHR(VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress)
VkResult(VKAPI_PTR * PFN_vkCreateIOSSurfaceMVK)(VkInstance instance, const VkIOSSurfaceCreateInfoMVK *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
Definition: vulkan_ios.h:33
void(VKAPI_PTR * PFN_vkCmdSetAlphaToCoverageEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable)
VKAPI_ATTR void VKAPI_CALL vkDestroyVideoSessionParametersKHR(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks *pAllocator)
VkFlags VkCommandPoolResetFlags
Definition: vulkan_core.h:2753
VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
VKAPI_ATTR VkResult VKAPI_CALL vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data)
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
PFN_vkGetPhysicalDeviceProperties2 vkGetPhysicalDeviceProperties2
Definition: vulkan.hpp:12570
VKAPI_ATTR void VKAPI_CALL vkCmdDecodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR *pDecodeInfo)
VkResult vkBindOpticalFlowSessionImageNV(VkDevice device, VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5784
OutOfHostMemoryError(std::string const &message)
Definition: vulkan.hpp:6177
VkFlags VkImageCreateFlags
Definition: vulkan_core.h:2261
Type * operator->() VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1217
VkResult(VKAPI_PTR * PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore)
Definition: vulkan_core.h:3946
void vkCmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2582
VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
VKAPI_ATTR void VKAPI_CALL vkCmdSetTessellationDomainOriginEXT(VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin)
PFN_vkCmdCopyAccelerationStructureNV vkCmdCopyAccelerationStructureNV
Definition: vulkan.hpp:13048
VkResult(VKAPI_PTR * PFN_vkCreateBufferCollectionFUCHSIA)(VkDevice device, const VkBufferCollectionCreateInfoFUCHSIA *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBufferCollectionFUCHSIA *pCollection)
VkResult(VKAPI_PTR * PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkLayerProperties *pProperties)
Definition: vulkan_core.h:3922
PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE vkGetDescriptorSetLayoutHostMappingInfoVALVE
Definition: vulkan.hpp:13394
PFN_vkSetPrivateDataEXT vkSetPrivateDataEXT
Definition: vulkan.hpp:13205
void(VKAPI_PTR * PFN_vkCmdBuildAccelerationStructureNV)(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV *pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset)
VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks *pAllocator)
void vkGetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t *pData) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2553
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoFormatPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR *pVideoFormatInfo, uint32_t *pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR *pVideoFormatProperties)
PFN_vkCmdSetDepthTestEnable vkCmdSetDepthTestEnable
Definition: vulkan.hpp:12629
PFN_vkCmdCopyQueryPoolResults vkCmdCopyQueryPoolResults
Definition: vulkan.hpp:12551
ArrayProxyNoTemporaries(T &value) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:710
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties *pImageFormatProperties)
Definition: vulkan_core.h:3911
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties)
PFN_vkGetSwapchainCounterEXT vkGetSwapchainCounterEXT
Definition: vulkan.hpp:12904
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties)
Definition: vulkan_core.h:8038
VkResult vkGetDisplayPlaneCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR *pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR *pCapabilities) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3817
VkFormat
Definition: vulkan_core.h:1386
void vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties *pMemoryProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1367
VKAPI_ATTR VkResult VKAPI_CALL vkInitializePerformanceApiINTEL(VkDevice device, const VkInitializePerformanceApiInfoINTEL *pInitializeInfo)
void(VKAPI_PTR * PFN_vkCmdBeginVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR *pBeginInfo)
Definition: vulkan_beta.h:249
VULKAN_HPP_CONSTEXPR_14 Flags< BitType > & operator&=(Flags< BitType > const &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:469
VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo, VkCommandBuffer *pCommandBuffers)
void(VKAPI_PTR * PFN_vkGetPrivateDataEXT)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t *pData)
void(VKAPI_PTR * PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags)
Definition: vulkan_core.h:4033
VkResult vkCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL *pMarkerInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4462
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties)
Definition: vulkan_core.h:5545
VkResult(VKAPI_PTR * PFN_vkBindVideoSessionMemoryKHR)(VkDevice device, VkVideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VkBindVideoSessionMemoryInfoKHR *pBindSessionMemoryInfos)
Definition: vulkan_beta.h:245
MemoryMapFailedError(char const *message)
Definition: vulkan.hpp:6206
PFN_vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures
Definition: vulkan.hpp:12423
PFN_dummy vkGetPhysicalDeviceWin32PresentationSupportKHR_placeholder
Definition: vulkan.hpp:12712
PFN_vkGetDeferredOperationResultKHR vkGetDeferredOperationResultKHR
Definition: vulkan.hpp:13182
PFN_vkGetPhysicalDeviceFormatProperties2 vkGetPhysicalDeviceFormatProperties2
Definition: vulkan.hpp:12571
void vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1832
PFN_vkWriteMicromapsPropertiesEXT vkWriteMicromapsPropertiesEXT
Definition: vulkan.hpp:13377
void(VKAPI_PTR * PFN_vkCmdSetExclusiveScissorNV)(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D *pExclusiveScissors)
PFN_vkCmdSetViewportWScalingNV vkCmdSetViewportWScalingNV
Definition: vulkan.hpp:12883
void(VKAPI_PTR * PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3975
PFN_vkCreateDisplayPlaneSurfaceKHR vkCreateDisplayPlaneSurfaceKHR
Definition: vulkan.hpp:12667
GLint GLsizei width
Definition: glcorearb.h:103
PFN_vkGetImageSparseMemoryRequirements vkGetImageSparseMemoryRequirements
Definition: vulkan.hpp:12452
StructureChain & operator=(StructureChain const &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1008
VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks *pAllocator)
PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT vkGetSamplerOpaqueCaptureDescriptorDataEXT
Definition: vulkan.hpp:13242
VKAPI_ATTR VkResult VKAPI_CALL vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo)
VkResult(VKAPI_PTR * PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
Definition: vulkan_core.h:3982
void vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer, const VkCopyImageInfo2 *pCopyImageInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5047
VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceDirectFBPresentationSupportEXT(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, IDirectFB *dfb)
VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
void(VKAPI_PTR * PFN_vkDestroyDeferredOperationKHR)(VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:9354
VKAPI_ATTR VkResult VKAPI_CALL vkCreateCuFunctionNVX(VkDevice device, const VkCuFunctionCreateInfoNVX *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCuFunctionNVX *pFunction)
VkResult vkCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL *pMarkerInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4457
VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator)
VkResult(VKAPI_PTR * PFN_vkGetDynamicRenderingTilePropertiesQCOM)(VkDevice device, const VkRenderingInfo *pRenderingInfo, VkTilePropertiesQCOM *pProperties)
VKAPI_ATTR VkResult VKAPI_CALL vkGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT *pTimestampInfos, uint64_t *pTimestamps, uint64_t *pMaxDeviation)
Optional< const AllocationCallbacks > getAllocator() const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5983
VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass(VkCommandBuffer commandBuffer)
void vkCmdSetAlphaToCoverageEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5599
UniqueHandle(UniqueHandle &&other) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1184
VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit *pRegions, VkFilter filter)
PFN_vkCmdPipelineBarrier2 vkCmdPipelineBarrier2
Definition: vulkan.hpp:12612
PFN_vkCmdResolveImage2 vkCmdResolveImage2
Definition: vulkan.hpp:12620
void vkCmdExecuteGeneratedCommandsNV(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4796
VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4])
void(VKAPI_PTR * PFN_vkCmdSetPolygonModeEXT)(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode)
void vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1333
Definition: core.h:982
VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pCallback)
VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer(VkCommandBuffer commandBuffer)
VKAPI_ATTR void VKAPI_CALL vkQueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo)
void vkCmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3044
PFN_vkAcquireNextImage2KHR vkAcquireNextImage2KHR
Definition: vulkan.hpp:12658
VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void *pData, VkDeviceSize stride, VkQueryResultFlags flags)
VKAPI_ATTR void VKAPI_CALL 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)
VKAPI_ATTR VkResult VKAPI_CALL vkReleasePerformanceConfigurationINTEL(VkDevice device, VkPerformanceConfigurationINTEL configuration)
uint64_t VkDeviceSize
Definition: vulkan_core.h:95
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties)
VkResult vkCopyAccelerationStructureToMemoryKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4021
VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData)
OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5978
PFN_vkDestroySwapchainKHR vkDestroySwapchainKHR
Definition: vulkan.hpp:12651
VkResult(VKAPI_PTR * PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout)
Definition: vulkan_core.h:3974
void vkCmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2678
VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV *pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset)
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClipNegativeOneToOneEXT(VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne)
VULKAN_HPP_CONSTEXPR ArrayWrapper2D(std::array< std::array< T, M >, N > const &data) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:371
VkLineRasterizationModeEXT
void(VKAPI_PTR * PFN_vkCmdSetLogicOpEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 logicOpEnable)
void(VKAPI_PTR * PFN_vkCmdCopyAccelerationStructureToMemoryKHR)(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo)
VkResult vkCreateAccelerationStructureNV(VkDevice device, const VkAccelerationStructureCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureNV *pAccelerationStructure) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4187
PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR vkGetPhysicalDeviceDisplayPlanePropertiesKHR
Definition: vulkan.hpp:12662
void vkCmdSetColorBlendEnableEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32 *pColorBlendEnables) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5614
void vkCmdSetColorWriteMaskEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags *pColorWriteMasks) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5630
InvalidShaderNVError(std::string const &message)
Definition: vulkan.hpp:6331
VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer, const VkBlitImageInfo2 *pBlitImageInfo)
VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSparseMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
PFN_vkCmdSubpassShadingHUAWEI vkCmdSubpassShadingHUAWEI
Definition: vulkan.hpp:13332
PFN_vkCreateValidationCacheEXT vkCreateValidationCacheEXT
Definition: vulkan.hpp:13032
void(VKAPI_PTR * PFN_vkQueueInsertDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo)
void destroy(T t) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5990
VKAPI_ATTR void VKAPI_CALL vkGetGeneratedCommandsMemoryRequirementsNV(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
VkResult vkGetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t *pInfoSize, void *pInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3266
PFN_vkDestroySamplerYcbcrConversion vkDestroySamplerYcbcrConversion
Definition: vulkan.hpp:12579
void vkCmdDrawMeshTasksEXT(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5018
PFN_vkCmdPushDescriptorSetKHR vkCmdPushDescriptorSetKHR
Definition: vulkan.hpp:12870
void vkCmdPipelineBarrier2(VkCommandBuffer commandBuffer, const VkDependencyInfo *pDependencyInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2577
VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
VkResult(VKAPI_PTR * PFN_vkGetDisplayModeProperties2KHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t *pPropertyCount, VkDisplayModeProperties2KHR *pProperties)
Definition: vulkan_core.h:8820
PFN_vkCmdSetStencilTestEnable vkCmdSetStencilTestEnable
Definition: vulkan.hpp:12633
void vkCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV *pCustomSampleOrders) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4177
void vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3536
void vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2296
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
Definition: vulkan.hpp:2132
PFN_vkGetShaderModuleIdentifierEXT vkGetShaderModuleIdentifierEXT
Definition: vulkan.hpp:13439
PFN_vkCreateCuFunctionNVX vkCreateCuFunctionNVX
Definition: vulkan.hpp:12773
~DynamicLoader() VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:12372
VkResult vkDebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT *pNameInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3029
VKAPI_ATTR void VKAPI_CALL vkCmdEndVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR *pEndCodingInfo)
DeviceLostError(std::string const &message)
Definition: vulkan.hpp:6198
VkResult vkGetPipelineExecutableInternalRepresentationsKHR(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR *pInternalRepresentations) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4774
VULKAN_HPP_CONSTEXPR Flags< BitType > operator^(Flags< BitType > const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:450
PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR vkGetPhysicalDeviceFragmentShadingRatesKHR
Definition: vulkan.hpp:13119
void(VKAPI_PTR * PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy *pRegions)
Definition: vulkan_core.h:4018
Definition: core.h:1131
VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator)
PFN_vkCmdSetPolygonModeEXT vkCmdSetPolygonModeEXT
Definition: vulkan.hpp:13408
TooManyObjectsError(char const *message)
Definition: vulkan.hpp:6241
void(VKAPI_PTR * PFN_vkCmdSetViewportSwizzleNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV *pViewportSwizzles)
PFN_vkGetRayTracingShaderGroupHandlesNV vkGetRayTracingShaderGroupHandlesNV
Definition: vulkan.hpp:13051
uint32_t VkSampleMask
Definition: vulkan_core.h:97
void vkCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV *pShadingRatePalettes) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4169
PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties
Definition: vulkan.hpp:12427
void(VKAPI_PTR * PFN_vkCmdSetDescriptorBufferOffsetsEXT)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t *pBufferIndices, const VkDeviceSize *pOffsets)
void vkDestroyDescriptorUpdateTemplateKHR(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3551
void(VKAPI_PTR * PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3942
PFN_vkGetDeferredOperationMaxConcurrencyKHR vkGetDeferredOperationMaxConcurrencyKHR
Definition: vulkan.hpp:13181
VkResult(VKAPI_PTR * PFN_vkGetDeviceGroupPresentCapabilitiesKHR)(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR *pDeviceGroupPresentCapabilities)
Definition: vulkan_core.h:7728
VkResult vkCreateSamplerYcbcrConversionKHR(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4098
void vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4696
VULKAN_HPP_CONSTEXPR Flags< BitType > operator~() const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:455
typename std::tuple_element< Index, std::tuple< ChainElements...>>::type TestType
Definition: vulkan.hpp:962
VkResult(VKAPI_PTR * PFN_vkGetMemoryFdPropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR *pMemoryFdProperties)
Definition: vulkan_core.h:8238
void vkGetDescriptorEXT(VkDevice device, const VkDescriptorGetInfoEXT *pDescriptorInfo, size_t dataSize, void *pDescriptor) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4944
PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout
Definition: vulkan.hpp:12492
VKAPI_ATTR void VKAPI_CALL vkCmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void *pCheckpointMarker)
VULKAN_HPP_CONSTEXPR Flags< BitType > operator|(Flags< BitType > const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:445
PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR vkGetPhysicalDeviceExternalSemaphorePropertiesKHR
Definition: vulkan.hpp:12854
VkResult vkCreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSampler *pSampler) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1754
PFN_vkImportFenceFdKHR vkImportFenceFdKHR
Definition: vulkan.hpp:12938
VkCoarseSampleOrderTypeNV
void(VKAPI_PTR * PFN_vkGetPrivateData)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t *pData)
Definition: vulkan_core.h:7295
PFN_vkCmdSetDeviceMask vkCmdSetDeviceMask
Definition: vulkan.hpp:12563
void vkUninitializePerformanceApiINTEL(VkDevice device) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4452
void vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2000
VkDeviceAddress vkGetBufferDeviceAddressEXT(VkDevice device, const VkBufferDeviceAddressInfo *pInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4545
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceQueueFamilyProperties2)(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties)
Definition: vulkan_core.h:5546
VULKAN_HPP_INLINE std::vector< typename UniqueType::element_type > uniqueToRaw(std::vector< UniqueType > const &handles)
Definition: vulkan.hpp:1272
void(VKAPI_PTR * PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3966
VkResult vkCopyAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR *pInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4014
VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHR(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle)
VKAPI_ATTR VkResult VKAPI_CALL vkWriteAccelerationStructuresPropertiesKHR(VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR *pAccelerationStructures, VkQueryType queryType, size_t dataSize, void *pData, size_t stride)
PFN_vkCmdDrawIndirectByteCountEXT vkCmdDrawIndirectByteCountEXT
Definition: vulkan.hpp:12769
void(VKAPI_PTR * PFN_vkDebugReportMessageEXT)(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char *pLayerPrefix, const char *pMessage)
Definition: vulkan_core.h:9893
VULKAN_HPP_CONSTEXPR ArrayWrapper1D() VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:242
void(VKAPI_PTR * PFN_vkDestroyValidationCacheEXT)(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks *pAllocator)
void vkUpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3558
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR)(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR *pPerformanceQueryCreateInfo, uint32_t *pNumPasses)
Definition: vulkan_core.h:8690
VkResult(VKAPI_PTR * PFN_vkGetPipelinePropertiesEXT)(VkDevice device, const VkPipelineInfoEXT *pPipelineInfo, VkBaseOutStructure *pPipelineProperties)
VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, const VkSubpassBeginInfo *pSubpassBeginInfo)
void(VKAPI_PTR * PFN_vkGetMicromapBuildSizesEXT)(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT *pBuildInfo, VkMicromapBuildSizesInfoEXT *pSizeInfo)
PFN_vkCmdSetBlendConstants vkCmdSetBlendConstants
Definition: vulkan.hpp:12518
VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable)
PFN_vkCmdResetQueryPool vkCmdResetQueryPool
Definition: vulkan.hpp:12549
GLboolean r
Definition: glcorearb.h:1222
VkResult(VKAPI_PTR * PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorPool *pDescriptorPool)
Definition: vulkan_core.h:3980
VkResult(VKAPI_PTR * PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
Definition: vulkan_core.h:3998
VULKAN_HPP_CONSTEXPR bool operator!() const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:434
VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query)
VkResult vkGetPhysicalDeviceOpticalFlowImageFormatsNV(VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV *pOpticalFlowImageFormatInfo, uint32_t *pFormatCount, VkOpticalFlowImageFormatPropertiesNV *pImageFormatProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5763
VKAPI_ATTR void VKAPI_CALL vkDestroyVideoSessionKHR(VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks *pAllocator)
void vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D *pGranularity) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1850
PFN_vkCmdWriteBufferMarkerAMD vkCmdWriteBufferMarkerAMD
Definition: vulkan.hpp:13067
PFN_vkCmdNextSubpass2KHR vkCmdNextSubpass2KHR
Definition: vulkan.hpp:12919
VkShaderInfoTypeAMD
void(VKAPI_PTR * PFN_vkCmdDrawMeshTasksEXT)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
void vkCmdSetRasterizationSamplesEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5589
VULKAN_HPP_INLINE std::string to_string(FormatFeatureFlags value)
void vkCmdCopyAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR *pInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4046
VkResult(VKAPI_PTR * PFN_vkEnumerateInstanceExtensionProperties)(const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties)
Definition: vulkan_core.h:3919
void vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport *pViewports) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1909
void vkCmdDrawMeshTasksIndirectCountEXT(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5029
PFN_vkDisplayPowerControlEXT vkDisplayPowerControlEXT
Definition: vulkan.hpp:12901
VkResult vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties *pImageFormatProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1344
VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus(VkDevice device, VkEvent event)
VKAPI_ATTR void VKAPI_CALL vkCmdSetVertexInputEXT(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT *pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT *pVertexAttributeDescriptions)
void vkReleaseProfilingLockKHR(VkDevice device) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3771
VkResult(VKAPI_PTR * PFN_vkGetMemoryFdKHR)(VkDevice device, const VkMemoryGetFdInfoKHR *pGetFdInfo, int *pFd)
Definition: vulkan_core.h:8237
VkResult(VKAPI_PTR * PFN_vkSignalSemaphore)(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo)
Definition: vulkan_core.h:6384
void vkCmdBindDescriptorBuffersEXT(VkCommandBuffer commandBuffer, uint32_t bufferCount, const VkDescriptorBufferBindingInfoEXT *pBindingInfos) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4949
void(VKAPI_PTR * PFN_vkCmdBeginRenderPass2)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, const VkSubpassBeginInfo *pSubpassBeginInfo)
Definition: vulkan_core.h:6378
void destroy(T t) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:6021
VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice device, const char *pName)
VKAPI_ATTR void VKAPI_CALL vkSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData)
PFN_vkReleaseDisplayEXT vkReleaseDisplayEXT
Definition: vulkan.hpp:12886
PFN_vkCmdBuildAccelerationStructureNV vkCmdBuildAccelerationStructureNV
Definition: vulkan.hpp:13047
void vkCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4711
VkResult vkGetDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t *pPropertyCount, VkDisplayModeProperties2KHR *pProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3809
VkResult(VKAPI_PTR * PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties)
Definition: vulkan_core.h:3920
VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointData2NV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointData2NV *pCheckpointData)
PFN_vkCmdSetDeviceMaskKHR vkCmdSetDeviceMaskKHR
Definition: vulkan.hpp:12821
VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions)
VkResult vkGetDeferredOperationResultKHR(VkDevice device, VkDeferredOperationKHR operation) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4745
PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout
Definition: vulkan.hpp:12493
void(VKAPI_PTR * PFN_vkCmdSetColorWriteMaskEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags *pColorWriteMasks)
void vkGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT *pMultisampleProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3938
VKAPI_ATTR void VKAPI_CALL vkGetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t *pData)
uint32_t(VKAPI_PTR * PFN_vkGetImageViewHandleNVX)(VkDevice device, const VkImageViewHandleInfoNVX *pInfo)
uint64_t vkGetBufferOpaqueCaptureAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo *pInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4629
VkResult(VKAPI_PTR * PFN_vkCreateRayTracingPipelinesNV)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR(VkDevice device, const VkMemoryGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle)
PFN_vkCmdSetCoverageToColorLocationNV vkCmdSetCoverageToColorLocationNV
Definition: vulkan.hpp:13430
void vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1880
VkResult vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1868
VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutBindingOffsetEXT(VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize *pOffset)
VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue)
VKAPI_ATTR VkResult VKAPI_CALL vkWriteMicromapsPropertiesEXT(VkDevice device, uint32_t micromapCount, const VkMicromapEXT *pMicromaps, VkQueryType queryType, size_t dataSize, void *pData, size_t stride)
VKAPI_ATTR VkResult VKAPI_CALL vkGetSamplerOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT *pInfo, void *pData)
VkResult(VKAPI_PTR * PFN_vkUpdateVideoSessionParametersKHR)(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR *pUpdateInfo)
Definition: vulkan_beta.h:247
VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask)
VkResult(VKAPI_PTR * PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence)
Definition: vulkan_core.h:3924
void vkGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2432
PFN_vkCreateMicromapEXT vkCreateMicromapEXT
Definition: vulkan.hpp:13370
void vkCmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2485
VkResult(VKAPI_PTR * PFN_vkQueueSubmit2KHR)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 *pSubmits, VkFence fence)
Definition: vulkan_core.h:9567
VKAPI_ATTR VkResult VKAPI_CALL vkGetImageViewOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT *pInfo, void *pData)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateRayTracingPipelinesKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
PFN_vkGetDisplayPlaneCapabilities2KHR vkGetDisplayPlaneCapabilities2KHR
Definition: vulkan.hpp:12955
void(VKAPI_PTR * PFN_vkCmdSetDepthBoundsTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable)
VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo, const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory)
VKAPI_ATTR void VKAPI_CALL vkCmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode)
void(VKAPI_PTR * PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3964
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR *pVideoFormatInfo, uint32_t *pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR *pVideoFormatProperties)
Definition: vulkan_beta.h:241
PFN_vkAcquireProfilingLockKHR vkAcquireProfilingLockKHR
Definition: vulkan.hpp:12944
void(VKAPI_PTR * PFN_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)
VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout)
VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorBuffersEXT(VkCommandBuffer commandBuffer, uint32_t bufferCount, const VkDescriptorBufferBindingInfoEXT *pBindingInfos)
void vkDestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2542
VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
PFN_dummy vkGetPhysicalDeviceXcbPresentationSupportKHR_placeholder
Definition: vulkan.hpp:12687
SystemError(std::error_code ec)
Definition: vulkan.hpp:6145
VKAPI_ATTR VkResult VKAPI_CALL vkAcquirePerformanceConfigurationINTEL(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL *pAcquireInfo, VkPerformanceConfigurationINTEL *pConfiguration)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateAccelerationStructureNV(VkDevice device, const VkAccelerationStructureCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureNV *pAccelerationStructure)
that also have some descendant prim *whose name begins with which in turn has a child named baz where *the predicate and *a name There is also one special expression reference
PFN_vkCmdDrawMeshTasksIndirectNV vkCmdDrawMeshTasksIndirectNV
Definition: vulkan.hpp:13075
void(VKAPI_PTR * PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3949
VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass2(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo, const VkSubpassEndInfo *pSubpassEndInfo)
VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
VkResult vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2505
PFN_vkCmdSetLogicOpEnableEXT vkCmdSetLogicOpEnableEXT
Definition: vulkan.hpp:13413
PFN_vkUpdateDescriptorSetWithTemplate vkUpdateDescriptorSetWithTemplate
Definition: vulkan.hpp:12582
void vkCmdSetColorBlendAdvancedEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT *pColorBlendAdvanced) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5664
PFN_vkGetDescriptorSetLayoutSupport vkGetDescriptorSetLayoutSupport
Definition: vulkan.hpp:12586
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR *pPerformanceQueryCreateInfo, uint32_t *pNumPasses)
PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR vkGetPhysicalDeviceDisplayPlaneProperties2KHR
Definition: vulkan.hpp:12953
VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureBuildSizesKHR(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR *pBuildInfo, const uint32_t *pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR *pSizeInfo)
bool operator>(ArrayWrapper1D< char, N > const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:303
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceOpticalFlowImageFormatsNV(VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV *pOpticalFlowImageFormatInfo, uint32_t *pFormatCount, VkOpticalFlowImageFormatPropertiesNV *pImageFormatProperties)
PFN_vkDestroyAccelerationStructureNV vkDestroyAccelerationStructureNV
Definition: vulkan.hpp:13044
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceToolPropertiesEXT(VkPhysicalDevice physicalDevice, uint32_t *pToolCount, VkPhysicalDeviceToolProperties *pToolProperties)
VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport *pViewports)
VkResult(VKAPI_PTR * PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImageView *pView)
Definition: vulkan_core.h:3963
PFN_vkCmdSetColorWriteMaskEXT vkCmdSetColorWriteMaskEXT
Definition: vulkan.hpp:13416
VkResult vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo, const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1441
VKAPI_ATTR VkResult VKAPI_CALL vkWaitForPresentKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout)
void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3472
VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderingKHR(VkCommandBuffer commandBuffer, const VkRenderingInfo *pRenderingInfo)
#define VULKAN_HPP_STORAGE_API
Definition: vulkan.hpp:5847
PFN_vkGetRefreshCycleDurationGOOGLE vkGetRefreshCycleDurationGOOGLE
Definition: vulkan.hpp:12907
void(VKAPI_PTR * PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy *pRegions)
Definition: vulkan_core.h:4021
VkStencilOp
Definition: vulkan_core.h:1980
void vkGetMicromapBuildSizesEXT(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT *pBuildInfo, VkMicromapBuildSizesInfoEXT *pSizeInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5481
void vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5325
PFN_vkCmdEndRenderingKHR vkCmdEndRenderingKHR
Definition: vulkan.hpp:12791
VkFlags VkQueryResultFlags
Definition: vulkan_core.h:2461
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, VkSurfaceCapabilities2KHR *pSurfaceCapabilities)
Definition: vulkan_core.h:8758
VkResult vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCommandPool *pCommandPool) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1855
void(VKAPI_PTR * PFN_vkCmdEndRenderPass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo)
Definition: vulkan_core.h:8463
void vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1863
type
Definition: core.h:1059
void(VKAPI_PTR * PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
Definition: vulkan_core.h:4017
VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
VkResult vkDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT *pTagInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3024
VULKAN_HPP_CONSTEXPR Flags< BitType > operator&(BitType bit, Flags< BitType > const &flags) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:541
VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectEXT(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
void(VKAPI_PTR * PFN_vkCmdSetColorBlendEnableEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32 *pColorBlendEnables)
PFN_vkGetPhysicalDeviceSurfacePresentModesKHR vkGetPhysicalDeviceSurfacePresentModesKHR
Definition: vulkan.hpp:12647
VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT *pNameInfo)
VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t *connection, xcb_visualid_t visual_id)
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties *pMemoryProperties)
VKAPI_ATTR VkResult VKAPI_CALL vkGetVideoSessionMemoryRequirementsKHR(VkDevice device, VkVideoSessionKHR videoSession, uint32_t *pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR *pMemoryRequirements)
VkResult(VKAPI_PTR * PFN_vkGetBufferCollectionPropertiesFUCHSIA)(VkDevice device, VkBufferCollectionFUCHSIA collection, VkBufferCollectionPropertiesFUCHSIA *pProperties)
VKAPI_ATTR void VKAPI_CALL vkCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D *pExclusiveScissors)
VKAPI_ATTR VkResult VKAPI_CALL vkCopyMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT *pInfo)
void init(VkInstance instance, PFN_vkGetInstanceProcAddr getInstanceProcAddr, VkDevice device={}, PFN_vkGetDeviceProcAddr=nullptr) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:13488
void(VKAPI_PTR * PFN_vkCmdPushDescriptorSetKHR)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites)
Definition: vulkan_core.h:8333
VKAPI_ATTR VkResult VKAPI_CALL vkDeferredOperationJoinKHR(VkDevice device, VkDeferredOperationKHR operation)
void(VKAPI_PTR * PFN_vkCmdSetShadingRateImageEnableNV)(VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable)
void(VKAPI_PTR * PFN_vkCmdSetCullModeEXT)(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode)
PFN_vkGetGeneratedCommandsMemoryRequirementsNV vkGetGeneratedCommandsMemoryRequirementsNV
Definition: vulkan.hpp:13191
VkResult(VKAPI_PTR * PFN_vkCreateScreenSurfaceQNX)(VkInstance instance, const VkScreenSurfaceCreateInfoQNX *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
Definition: vulkan_screen.h:34
VkResult(VKAPI_PTR * PFN_vkSignalSemaphoreKHR)(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo)
Definition: vulkan_core.h:9151
PFN_vkDestroyCuFunctionNVX vkDestroyCuFunctionNVX
Definition: vulkan.hpp:12775
VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable)
VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements)
VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle(VkQueue queue)
VULKAN_HPP_CONSTEXPR ArrayWrapper2D() VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:369
VkResult vkGetSwapchainCounterEXT(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t *pCounterValue) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3630
VkResult(VKAPI_PTR * PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer)
Definition: vulkan_core.h:3986
void(VKAPI_PTR * PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets)
Definition: vulkan_core.h:4011
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice, uint32_t *pToolCount, VkPhysicalDeviceToolProperties *pToolProperties)
VkResult(VKAPI_PTR * PFN_vkGetFenceStatus)(VkDevice device, VkFence fence)
Definition: vulkan_core.h:3944
PFN_vkGetValidationCacheDataEXT vkGetValidationCacheDataEXT
Definition: vulkan.hpp:13035
void(VKAPI_PTR * PFN_vkCmdSetLineStippleEXT)(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern)
VKAPI_ATTR void VKAPI_CALL vkDestroyOpticalFlowSessionNV(VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks *pAllocator)
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable)
PFN_vkCmdTraceRaysIndirectKHR vkCmdTraceRaysIndirectKHR
Definition: vulkan.hpp:13290
VkResult(VKAPI_PTR * PFN_vkGetWinrtDisplayNV)(VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR *pDisplay)
Definition: vulkan_win32.h:316
PFN_vkCreateSamplerYcbcrConversion vkCreateSamplerYcbcrConversion
Definition: vulkan.hpp:12578
DeviceLostError(char const *message)
Definition: vulkan.hpp:6199
PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT vkGetPhysicalDeviceMultisamplePropertiesEXT
Definition: vulkan.hpp:12995
VkResult(VKAPI_PTR * PFN_vkGetMemoryZirconHandleFUCHSIA)(VkDevice device, const VkMemoryGetZirconHandleInfoFUCHSIA *pGetZirconHandleInfo, zx_handle_t *pZirconHandle)
VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator)
uint64_t VkDeviceAddress
Definition: vulkan_core.h:94
VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
void vkCmdSetViewportWScalingEnableNV(VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5692
void(VKAPI_PTR * PFN_vkQueueEndDebugUtilsLabelEXT)(VkQueue queue)
VkSubpassContents
Definition: vulkan_core.h:2113
VkResult(VKAPI_PTR * PFN_vkImportFenceFdKHR)(VkDevice device, const VkImportFenceFdInfoKHR *pImportFenceFdInfo)
Definition: vulkan_core.h:8561
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(VkPhysicalDevice physicalDevice, uint32_t *pCombinationCount, VkFramebufferMixedSamplesCombinationNV *pCombinations)
PFN_vkCmdSetDepthTestEnableEXT vkCmdSetDepthTestEnableEXT
Definition: vulkan.hpp:13171
void(VKAPI_PTR * PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
Definition: vulkan_core.h:4030
VULKAN_HPP_INLINE ResultValueType< void >::type createResultValueType(Result result)
Definition: vulkan.hpp:6608
void vkGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2310
VkResult vkCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureKHR *pAccelerationStructure) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3971
PFN_vkGetAccelerationStructureDeviceAddressKHR vkGetAccelerationStructureDeviceAddressKHR
Definition: vulkan.hpp:13015
PFN_vkEnumeratePhysicalDeviceGroups vkEnumeratePhysicalDeviceGroups
Definition: vulkan.hpp:12565
void(VKAPI_PTR * PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query)
Definition: vulkan_core.h:4034
void vkCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4395
VKAPI_ATTR void VKAPI_CALL vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer)
void vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3173
VkResult(VKAPI_PTR * PFN_vkGetSemaphoreCounterValue)(VkDevice device, VkSemaphore semaphore, uint64_t *pValue)
Definition: vulkan_core.h:6382
VkResult(VKAPI_PTR * PFN_vkCreateSamplerYcbcrConversion)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion)
Definition: vulkan_core.h:5551
VkResult vkCreateOpticalFlowSessionNV(VkDevice device, const VkOpticalFlowSessionCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkOpticalFlowSessionNV *pSession) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5771
VkResult vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2780
void vkCmdBuildMicromapsEXT(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT *pInfos) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5406
PFN_vkCmdWriteTimestamp2 vkCmdWriteTimestamp2
Definition: vulkan.hpp:12613
PFN_dummy vkGetPhysicalDeviceXlibPresentationSupportKHR_placeholder
Definition: vulkan.hpp:12678
VKAPI_ATTR VkResult VKAPI_CALL vkBuildAccelerationStructuresKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkAccelerationStructureBuildRangeInfoKHR *const *ppBuildRangeInfos)
VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets)
VkResult(VKAPI_PTR * PFN_vkGetMemoryRemoteAddressNV)(VkDevice device, const VkMemoryGetRemoteAddressInfoNV *pMemoryGetRemoteAddressInfo, VkRemoteAddressNV *pAddress)
VkResult(VKAPI_PTR * PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSampler *pSampler)
Definition: vulkan_core.h:3976
VKAPI_ATTR VkResult VKAPI_CALL vkGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, size_t *pDataSize, void *pData)
PFN_vkCmdSetDepthClipNegativeOneToOneEXT vkCmdSetDepthClipNegativeOneToOneEXT
Definition: vulkan.hpp:13426
VKAPI_ATTR VkResult VKAPI_CALL vkGetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display *dpy, RROutput rrOutput, VkDisplayKHR *pDisplay)
void vkCmdTraceRaysIndirect2KHR(VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5363
VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator)
VkResult vkCreatePrivateDataSlot(VkDevice device, const VkPrivateDataSlotCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPrivateDataSlot *pPrivateDataSlot) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2534
OutOfPoolMemoryError(char const *message)
Definition: vulkan.hpp:6269
void vkDestroySamplerYcbcrConversionKHR(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4106
void(VKAPI_PTR * PFN_vkCmdCopyMemoryToMicromapEXT)(VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT *pInfo)
void(VKAPI_PTR * PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
Definition: vulkan_core.h:4005
VkResult vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1480
VULKAN_HPP_INLINE void swap(UniqueHandle< Type, Dispatch > &lhs, UniqueHandle< Type, Dispatch > &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1280
void vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3339
VKAPI_ATTR VkResult VKAPI_CALL vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT *pInfo, void *pData)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorPool *pDescriptorPool)
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceDisplayProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayProperties2KHR *pProperties)
Definition: vulkan_core.h:8818
void(VKAPI_PTR * PFN_vkGetDescriptorSetLayoutSupportKHR)(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport)
Definition: vulkan_core.h:8981
VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysIndirectKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress)
GLuint64 GLenum GLint fd
Definition: RE_OGL.h:262
void(VKAPI_PTR * PFN_vkCmdEndRendering)(VkCommandBuffer commandBuffer)
Definition: vulkan_core.h:7309
VkResult vkGetRefreshCycleDurationGOOGLE(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE *pDisplayTimingProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3640
VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t *pDisplayCount, VkDisplayKHR *pDisplays)
void vkGetQueueCheckpointDataNV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointDataNV *pCheckpointData) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4423
CompressionExhaustedEXTError(std::string const &message)
Definition: vulkan.hpp:6444
VkResult(VKAPI_PTR * PFN_vkCompileDeferredNV)(VkDevice device, VkPipeline pipeline, uint32_t shader)
VkResult vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT *pInfo, void *pData) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5000
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceMemoryProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
Definition: vulkan_core.h:5547
PFN_vkQueueBeginDebugUtilsLabelEXT vkQueueBeginDebugUtilsLabelEXT
Definition: vulkan.hpp:12974
void(VKAPI_PTR * PFN_vkCmdDrawMeshTasksIndirectCountEXT)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
PFN_vkGetPhysicalDeviceExternalBufferProperties vkGetPhysicalDeviceExternalBufferProperties
Definition: vulkan.hpp:12583
PFN_vkDestroyImageView vkDestroyImageView
Definition: vulkan.hpp:12478
VkResult vkCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2 *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3677
PFN_vkGetDisplayPlaneSupportedDisplaysKHR vkGetDisplayPlaneSupportedDisplaysKHR
Definition: vulkan.hpp:12663
ArrayProxyNoTemporaries(uint32_t count, typename std::remove_const< T >::type *ptr) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:736
PFN_vkCmdSetViewportWithCount vkCmdSetViewportWithCount
Definition: vulkan.hpp:12626
VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
VULKAN_HPP_CONSTEXPR ArrayProxy() VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:588
PFN_vkGetRayTracingShaderGroupStackSizeKHR vkGetRayTracingShaderGroupStackSizeKHR
Definition: vulkan.hpp:13291
void vkCmdEndRendering(VkCommandBuffer commandBuffer) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2627
VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
void vkGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3713
void vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1970
VULKAN_HPP_CONSTEXPR Flags< BitType > operator|(BitType bit, Flags< BitType > const &flags) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:547
InvalidOpaqueCaptureAddressError(std::string const &message)
Definition: vulkan.hpp:6289
virtual const char * what() const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:6152
VKAPI_ATTR uint32_t VKAPI_CALL vkGetImageViewHandleNVX(VkDevice device, const VkImageViewHandleInfoNVX *pInfo)
void(VKAPI_PTR * PFN_vkCmdSetCoverageToColorLocationNV)(VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation)
VkResult(VKAPI_PTR * PFN_vkImportSemaphoreWin32HandleKHR)(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR *pImportSemaphoreWin32HandleInfo)
Definition: vulkan_win32.h:153
VKAPI_ATTR VkResult VKAPI_CALL vkGetWinrtDisplayNV(VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR *pDisplay)
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDevicePresentRectanglesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pRectCount, VkRect2D *pRects)
Definition: vulkan_core.h:7730
GLint GLsizei count
Definition: glcorearb.h:405
VkResult vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2254
VKAPI_ATTR void VKAPI_CALL vkCmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D *pScissors)
void vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 *pCopyBufferInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5042
VKAPI_ATTR void VKAPI_CALL vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D *pGranularity)
PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets
Definition: vulkan.hpp:12497
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPlaneProperties2KHR *pProperties)
Definition: format.h:895
PFN_vkCmdCopyMicromapToMemoryEXT vkCmdCopyMicromapToMemoryEXT
Definition: vulkan.hpp:13379
PFN_vkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXT
Definition: vulkan.hpp:12911
VKAPI_ATTR VkResult VKAPI_CALL vkCreateViSurfaceNN(VkInstance instance, const VkViSurfaceCreateInfoNN *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
void vkCmdSetPolygonModeEXT(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5584
VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
VkResult(VKAPI_PTR * PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImage *pImage)
Definition: vulkan_core.h:3960
PFN_vkGetPipelineExecutableInternalRepresentationsKHR vkGetPipelineExecutableInternalRepresentationsKHR
Definition: vulkan.hpp:13188
PFN_vkDestroyDeferredOperationKHR vkDestroyDeferredOperationKHR
Definition: vulkan.hpp:13180
void(VKAPI_PTR * PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3977
VkFlags64 VkPipelineStageFlags2
Definition: vulkan_core.h:6497
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceFormatProperties2)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties)
Definition: vulkan_core.h:5544
PFN_vkReleasePerformanceConfigurationINTEL vkReleasePerformanceConfigurationINTEL
Definition: vulkan.hpp:13097
PFN_vkBindAccelerationStructureMemoryNV vkBindAccelerationStructureMemoryNV
Definition: vulkan.hpp:13046
VkResult vkEndCommandBuffer(VkCommandBuffer commandBuffer) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1893
UniqueHandle & operator=(UniqueHandle &&other) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1200
void(VKAPI_PTR * PFN_vkGetShaderModuleCreateInfoIdentifierEXT)(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, VkShaderModuleIdentifierEXT *pIdentifier)
PFN_vkCmdBeginConditionalRenderingEXT vkCmdBeginConditionalRenderingEXT
Definition: vulkan.hpp:12874
void vkCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3034
PFN_vkQueueSetPerformanceConfigurationINTEL vkQueueSetPerformanceConfigurationINTEL
Definition: vulkan.hpp:13098
uint64_t(VKAPI_PTR * PFN_vkGetDeviceMemoryOpaqueCaptureAddress)(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo)
Definition: vulkan_core.h:6387
VKAPI_ATTR void VKAPI_CALL vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace)
void(VKAPI_PTR * PFN_vkCmdSetRasterizationStreamEXT)(VkCommandBuffer commandBuffer, uint32_t rasterizationStream)
VULKAN_HPP_CONSTEXPR ArrayProxy(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:594
void vkCmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 *pCopyBufferToImageInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5052
VkResult(VKAPI_PTR * PFN_vkGetAndroidHardwareBufferPropertiesANDROID)(VkDevice device, const struct AHardwareBuffer *buffer, VkAndroidHardwareBufferPropertiesANDROID *pProperties)
SurfaceLostKHRError(std::string const &message)
Definition: vulkan.hpp:6296
VKAPI_ATTR void VKAPI_CALL vkDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks *pAllocator)
VkResult vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2793
VkResult(VKAPI_PTR * PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR *pCapabilities)
Definition: vulkan_core.h:7863
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
Definition: vulkan.hpp:3994
VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineCache *pPipelineCache)
uint32_t vkGetDeferredOperationMaxConcurrencyKHR(VkDevice device, VkDeferredOperationKHR operation) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4740
NotPermittedKHRError(char const *message)
Definition: vulkan.hpp:6427
VkResult(VKAPI_PTR * PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, const VkWin32SurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
Definition: vulkan_win32.h:34
VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t *pValue)
**Note that the tasks the is the thread number *for the pool
Definition: thread.h:637
VkResult vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1553
void(VKAPI_PTR * PFN_vkCmdWriteAccelerationStructuresPropertiesNV)(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV *pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
void(VKAPI_PTR * PFN_vkDestroyOpticalFlowSessionNV)(VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks *pAllocator)
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV *pExternalImageFormatProperties)
VkFlags VkShaderStageFlags
Definition: vulkan_core.h:2660
VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage2(VkCommandBuffer commandBuffer, const VkResolveImageInfo2 *pResolveImageInfo)
PFN_vkGetDeviceGroupPresentCapabilitiesKHR vkGetDeviceGroupPresentCapabilitiesKHR
Definition: vulkan.hpp:12655
VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, VkSubpassContents contents)
void(VKAPI_PTR * PFN_vkCmdSetStencilTestEnable)(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable)
Definition: vulkan_core.h:7320
void vkCmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5330
void vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2273
VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugUtilsMessengerEXT *pMessenger)
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags< BitType > operator~(BitType bit) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:578
VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT *pSampleLocationsInfo)
struct VkBaseOutStructure * pNext
Definition: vulkan_core.h:2817
VkIndexType
Definition: vulkan_core.h:2104
VKAPI_ATTR void VKAPI_CALL vkUnmapMemory(VkDevice device, VkDeviceMemory memory)
FMT_CONSTEXPR auto find(Ptr first, Ptr last, T value, Ptr &out) -> bool
Definition: core.h:2089
void(VKAPI_PTR * PFN_vkDestroyDescriptorUpdateTemplateKHR)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:8407
VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT *pNameInfo)
VKAPI_ATTR void VKAPI_CALL vkCmdSetRepresentativeFragmentTestEnableNV(VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable)
VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureToMemoryKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo)
VkResult vkCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImageView *pView) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1666
void vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2788
DynamicLoader & operator=(DynamicLoader const &)=delete
VkResult vkDeviceWaitIdle(VkDevice device) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1436
PFN_vkFreeCommandBuffers vkFreeCommandBuffers
Definition: vulkan.hpp:12509
VKAPI_ATTR void VKAPI_CALL vkGetDeviceBufferMemoryRequirementsKHR(VkDevice device, const VkDeviceBufferMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
void(VKAPI_PTR * PFN_vkCmdDrawMeshTasksIndirectCountNV)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
VkResult(VKAPI_PTR * PFN_vkDebugMarkerSetObjectNameEXT)(VkDevice device, const VkDebugMarkerObjectNameInfoEXT *pNameInfo)
Definition: vulkan_core.h:9990
PFN_vkDestroyDescriptorUpdateTemplate vkDestroyDescriptorUpdateTemplate
Definition: vulkan.hpp:12581
#define VULKAN_HPP_INLINE
Definition: vulkan.hpp:172
void(VKAPI_PTR * PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
Definition: vulkan_core.h:4037
PFN_vkCreateSharedSwapchainsKHR vkCreateSharedSwapchainsKHR
Definition: vulkan.hpp:12670
VKAPI_ATTR VkResult VKAPI_CALL vkReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display)
T & operator[](int index) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:253
void(VKAPI_PTR * PFN_vkCmdSetScissorWithCount)(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D *pScissors)
Definition: vulkan_core.h:7314
PFN_vkCmdSetCoverageModulationTableEnableNV vkCmdSetCoverageModulationTableEnableNV
Definition: vulkan.hpp:13432
VkPerformanceParameterTypeINTEL
PFN_vkGetImageSparseMemoryRequirements2 vkGetImageSparseMemoryRequirements2
Definition: vulkan.hpp:12568
void vkCmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2693
VKAPI_ATTR VkResult VKAPI_CALL vkCopyAccelerationStructureToMemoryKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo)
Optional(std::nullptr_t) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:903
GLint GLint GLint GLint GLint GLint GLint GLbitfield GLenum filter
Definition: glcorearb.h:1297
VKAPI_ATTR VkResult VKAPI_CALL vkCreateDirectFBSurfaceEXT(VkInstance instance, const VkDirectFBSurfaceCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
GLenum src
Definition: glcorearb.h:1793
PFN_vkCmdBuildAccelerationStructuresIndirectKHR vkCmdBuildAccelerationStructuresIndirectKHR
Definition: vulkan.hpp:13006
void vkCmdSetCoverageModulationTableEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5720
VkResult(VKAPI_PTR * PFN_vkGetEventStatus)(VkDevice device, VkEvent event)
Definition: vulkan_core.h:3950
VkResult(VKAPI_PTR * PFN_vkDebugMarkerSetObjectTagEXT)(VkDevice device, const VkDebugMarkerObjectTagInfoEXT *pTagInfo)
Definition: vulkan_core.h:9989
PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR vkGetRayTracingCaptureReplayShaderGroupHandlesKHR
Definition: vulkan.hpp:13289
void(VKAPI_PTR * PFN_vkCmdSetViewportWScalingNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV *pViewportWScalings)
SurfaceLostKHRError(char const *message)
Definition: vulkan.hpp:6297
VkResult vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2500
PFN_vkCmdSetConservativeRasterizationModeEXT vkCmdSetConservativeRasterizationModeEXT
Definition: vulkan.hpp:13418
VkResult vkEnumerateInstanceLayerProperties(uint32_t *pPropertyCount, VkLayerProperties *pProperties) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:1410
void vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer, const VkBlitImageInfo2 *pBlitImageInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5062
void vkCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:3253
VkBool32(VKAPI_PTR * PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex)
Definition: vulkan_win32.h:35
VkResult(VKAPI_PTR * PFN_vkEnumeratePhysicalDeviceGroupsKHR)(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties)
Definition: vulkan_core.h:8158
void vkCmdSetLineStippleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:5682
VkResult vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:2807
PFN_vkCreateShaderModule vkCreateShaderModule
Definition: vulkan.hpp:12479
VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer2(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 *pCopyImageToBufferInfo)
PcpNodeRef_ChildrenIterator begin(const PcpNodeRef::child_const_range &r)
Support for range-based for loops for PcpNodeRef children ranges.
Definition: node.h:558
VkResult vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos) const VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:4115
PFN_vkTrimCommandPoolKHR vkTrimCommandPoolKHR
Definition: vulkan.hpp:12832