1 // Copyright 2015-2023 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 #include <algorithm>
12 #include <array> // ArrayWrapperND
13 #include <string> // std::string
14 #include <vulkan/vulkan_sc_core.h>
15 #include <vulkan/vulkan_hpp_macros.hpp>
16
17 #if 17 <= VULKAN_HPP_CPP_VERSION
18 # include <string_view> // std::string_view
19 #endif
20
21 #if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
22 # include <tuple> // std::tie
23 # include <vector> // std::vector
24 #endif
25
26 #if !defined( VULKAN_HPP_NO_EXCEPTIONS )
27 # include <system_error> // std::is_error_code_enum
28 #endif
29
30 #if ( VULKAN_HPP_ASSERT == assert )
31 # include <cassert>
32 #endif
33
34 #if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL == 1
35 # if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNX__ ) || defined(__Fuchsia__)
36 # include <dlfcn.h>
37 # elif defined( _WIN32 )
38 typedef struct HINSTANCE__ * HINSTANCE;
39 # if defined( _WIN64 )
40 typedef int64_t( __stdcall * FARPROC )();
41 # else
42 typedef int( __stdcall * FARPROC )();
43 # endif
44 extern "C" __declspec( dllimport ) HINSTANCE __stdcall LoadLibraryA( char const * lpLibFileName );
45 extern "C" __declspec( dllimport ) int __stdcall FreeLibrary( HINSTANCE hLibModule );
46 extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE hModule, const char * lpProcName );
47 # endif
48 #endif
49
50 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
51 # include <compare>
52 #endif
53
54 #if defined( VULKAN_HPP_SUPPORT_SPAN )
55 # include <span>
56 #endif
57
58
59 static_assert( VK_HEADER_VERSION == 13, "Wrong VK_HEADER_VERSION!" );
60
61 // <tuple> includes <sys/sysmacros.h> through some other header
62 // this results in major(x) being resolved to gnu_dev_major(x)
63 // which is an expression in a constructor initializer list.
64 #if defined( major )
65 # undef major
66 #endif
67 #if defined( minor )
68 # undef minor
69 #endif
70
71 // Windows defines MemoryBarrier which is deprecated and collides
72 // with the VULKAN_HPP_NAMESPACE::MemoryBarrier struct.
73 #if defined( MemoryBarrier )
74 # undef MemoryBarrier
75 #endif
76
77 // XLib.h defines True/False, which collides with our vk::True/vk::False
78 // -> undef them and provide some namepace-secure constexpr
79 #if defined( True )
80 # undef True
81 constexpr int True = 1;
82 #endif
83 #if defined( False )
84 # undef False
85 constexpr int False = 0;
86 #endif
87
88
89 namespace VULKAN_HPP_NAMESPACE
90 {
91 template <typename T, size_t N>
92 class ArrayWrapper1D : public std::array<T, N>
93 {
94 public:
ArrayWrapper1D()95 VULKAN_HPP_CONSTEXPR ArrayWrapper1D() VULKAN_HPP_NOEXCEPT : std::array<T, N>() {}
96
ArrayWrapper1D(std::array<T,N> const & data)97 VULKAN_HPP_CONSTEXPR ArrayWrapper1D( std::array<T, N> const & data ) VULKAN_HPP_NOEXCEPT : std::array<T, N>( data ) {}
98
99 template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
ArrayWrapper1D(std::string const & data)100 VULKAN_HPP_CONSTEXPR_14 ArrayWrapper1D( std::string const & data ) VULKAN_HPP_NOEXCEPT
101 {
102 copy( data.data(), data.length() );
103 }
104
105 #if 17 <= VULKAN_HPP_CPP_VERSION
106 template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
ArrayWrapper1D(std::string_view data)107 VULKAN_HPP_CONSTEXPR_14 ArrayWrapper1D( std::string_view data ) VULKAN_HPP_NOEXCEPT
108 {
109 copy( data.data(), data.length() );
110 }
111 #endif
112
113 #if ( VK_USE_64_BIT_PTR_DEFINES == 0 )
114 // on 32 bit compiles, needs overloads on index type int to resolve ambiguities
operator [](int index) const115 VULKAN_HPP_CONSTEXPR T const & operator[]( int index ) const VULKAN_HPP_NOEXCEPT
116 {
117 return std::array<T, N>::operator[]( index );
118 }
119
operator [](int index)120 T & operator[]( int index ) VULKAN_HPP_NOEXCEPT
121 {
122 return std::array<T, N>::operator[]( index );
123 }
124 #endif
125
operator T const*() const126 operator T const *() const VULKAN_HPP_NOEXCEPT
127 {
128 return this->data();
129 }
130
operator T*()131 operator T *() VULKAN_HPP_NOEXCEPT
132 {
133 return this->data();
134 }
135
136 template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
operator std::string() const137 operator std::string() const
138 {
139 return std::string( this->data(), N );
140 }
141
142 #if 17 <= VULKAN_HPP_CPP_VERSION
143 template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
operator std::string_view() const144 operator std::string_view() const
145 {
146 return std::string_view( this->data(), N );
147 }
148 #endif
149
150 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
151 template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
operator <=>(ArrayWrapper1D<char,N> const & rhs) const152 std::strong_ordering operator<=>( ArrayWrapper1D<char, N> const & rhs ) const VULKAN_HPP_NOEXCEPT
153 {
154 return *static_cast<std::array<char, N> const *>( this ) <=> *static_cast<std::array<char, N> const *>( &rhs );
155 }
156 #else
157 template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
operator <(ArrayWrapper1D<char,N> const & rhs) const158 bool operator<( ArrayWrapper1D<char, N> const & rhs ) const VULKAN_HPP_NOEXCEPT
159 {
160 return *static_cast<std::array<char, N> const *>( this ) < *static_cast<std::array<char, N> const *>( &rhs );
161 }
162
163 template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
operator <=(ArrayWrapper1D<char,N> const & rhs) const164 bool operator<=( ArrayWrapper1D<char, N> const & rhs ) const VULKAN_HPP_NOEXCEPT
165 {
166 return *static_cast<std::array<char, N> const *>( this ) <= *static_cast<std::array<char, N> const *>( &rhs );
167 }
168
169 template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
operator >(ArrayWrapper1D<char,N> const & rhs) const170 bool operator>( ArrayWrapper1D<char, N> const & rhs ) const VULKAN_HPP_NOEXCEPT
171 {
172 return *static_cast<std::array<char, N> const *>( this ) > *static_cast<std::array<char, N> const *>( &rhs );
173 }
174
175 template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
operator >=(ArrayWrapper1D<char,N> const & rhs) const176 bool operator>=( ArrayWrapper1D<char, N> const & rhs ) const VULKAN_HPP_NOEXCEPT
177 {
178 return *static_cast<std::array<char, N> const *>( this ) >= *static_cast<std::array<char, N> const *>( &rhs );
179 }
180 #endif
181
182 template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
operator ==(ArrayWrapper1D<char,N> const & rhs) const183 bool operator==( ArrayWrapper1D<char, N> const & rhs ) const VULKAN_HPP_NOEXCEPT
184 {
185 return *static_cast<std::array<char, N> const *>( this ) == *static_cast<std::array<char, N> const *>( &rhs );
186 }
187
188 template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
operator !=(ArrayWrapper1D<char,N> const & rhs) const189 bool operator!=( ArrayWrapper1D<char, N> const & rhs ) const VULKAN_HPP_NOEXCEPT
190 {
191 return *static_cast<std::array<char, N> const *>( this ) != *static_cast<std::array<char, N> const *>( &rhs );
192 }
193
194 private:
copy(char const * data,size_t len)195 VULKAN_HPP_CONSTEXPR_14 void copy( char const * data, size_t len ) VULKAN_HPP_NOEXCEPT
196 {
197 size_t n = std::min( N, len );
198 for ( size_t i = 0; i < n; ++i )
199 {
200 ( *this )[i] = data[i];
201 }
202 for ( size_t i = n; i < N; ++i )
203 {
204 ( *this )[i] = 0;
205 }
206 }
207 };
208
209 // specialization of relational operators between std::string and arrays of chars
210 template <size_t N>
operator <(std::string const & lhs,ArrayWrapper1D<char,N> const & rhs)211 bool operator<( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
212 {
213 return lhs < rhs.data();
214 }
215
216 template <size_t N>
operator <=(std::string const & lhs,ArrayWrapper1D<char,N> const & rhs)217 bool operator<=( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
218 {
219 return lhs <= rhs.data();
220 }
221
222 template <size_t N>
operator >(std::string const & lhs,ArrayWrapper1D<char,N> const & rhs)223 bool operator>( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
224 {
225 return lhs > rhs.data();
226 }
227
228 template <size_t N>
operator >=(std::string const & lhs,ArrayWrapper1D<char,N> const & rhs)229 bool operator>=( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
230 {
231 return lhs >= rhs.data();
232 }
233
234 template <size_t N>
operator ==(std::string const & lhs,ArrayWrapper1D<char,N> const & rhs)235 bool operator==( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
236 {
237 return lhs == rhs.data();
238 }
239
240 template <size_t N>
operator !=(std::string const & lhs,ArrayWrapper1D<char,N> const & rhs)241 bool operator!=( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
242 {
243 return lhs != rhs.data();
244 }
245
246 template <typename T, size_t N, size_t M>
247 class ArrayWrapper2D : public std::array<ArrayWrapper1D<T, M>, N>
248 {
249 public:
ArrayWrapper2D()250 VULKAN_HPP_CONSTEXPR ArrayWrapper2D() VULKAN_HPP_NOEXCEPT
251 : std::array<ArrayWrapper1D<T, M>, N>()
252 {}
253
ArrayWrapper2D(std::array<std::array<T,M>,N> const & data)254 VULKAN_HPP_CONSTEXPR ArrayWrapper2D( std::array<std::array<T, M>, N> const & data ) VULKAN_HPP_NOEXCEPT
255 : std::array<ArrayWrapper1D<T, M>, N>( *reinterpret_cast<std::array<ArrayWrapper1D<T, M>, N> const *>( &data ) )
256 {}
257 };
258
259 #if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
260 template <typename T>
261 class ArrayProxy
262 {
263 public:
ArrayProxy()264 VULKAN_HPP_CONSTEXPR ArrayProxy() VULKAN_HPP_NOEXCEPT
265 : m_count( 0 )
266 , m_ptr( nullptr )
267 {}
268
ArrayProxy(std::nullptr_t)269 VULKAN_HPP_CONSTEXPR ArrayProxy( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
270 : m_count( 0 )
271 , m_ptr( nullptr )
272 {}
273
ArrayProxy(T const & value)274 ArrayProxy( T const & value ) VULKAN_HPP_NOEXCEPT
275 : m_count( 1 )
276 , m_ptr( &value )
277 {}
278
ArrayProxy(uint32_t count,T const * ptr)279 ArrayProxy( uint32_t count, T const * ptr ) VULKAN_HPP_NOEXCEPT
280 : m_count( count )
281 , m_ptr( ptr )
282 {}
283
284 template <std::size_t C>
ArrayProxy(T const (& ptr)[C])285 ArrayProxy( T const ( &ptr )[C] ) VULKAN_HPP_NOEXCEPT
286 : m_count( C )
287 , m_ptr( ptr )
288 {}
289
290 # if __GNUC__ >= 9
291 # pragma GCC diagnostic push
292 # pragma GCC diagnostic ignored "-Winit-list-lifetime"
293 # endif
294
ArrayProxy(std::initializer_list<T> const & list)295 ArrayProxy( std::initializer_list<T> const & list ) VULKAN_HPP_NOEXCEPT
296 : m_count( static_cast<uint32_t>( list.size() ) )
297 , m_ptr( list.begin() )
298 {}
299
300 template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
ArrayProxy(std::initializer_list<typename std::remove_const<T>::type> const & list)301 ArrayProxy( std::initializer_list<typename std::remove_const<T>::type> const & list ) VULKAN_HPP_NOEXCEPT
302 : m_count( static_cast<uint32_t>( list.size() ) )
303 , m_ptr( list.begin() )
304 {
305 }
306
307 #if __GNUC__ >= 9
308 # pragma GCC diagnostic pop
309 # endif
310
311 // Any type with a .data() return type implicitly convertible to T*, and a .size() return type implicitly
312 // convertible to size_t. The const version can capture temporaries, with lifetime ending at end of statement.
313 template <typename V,
314 typename std::enable_if<
315 std::is_convertible<decltype( std::declval<V>().data() ), T *>::value &&
316 std::is_convertible<decltype( std::declval<V>().size() ), std::size_t>::value>::type * = nullptr>
ArrayProxy(V const & v)317 ArrayProxy( V const & v ) VULKAN_HPP_NOEXCEPT
318 : m_count( static_cast<uint32_t>( v.size() ) )
319 , m_ptr( v.data() )
320 {}
321
begin() const322 const T * begin() const VULKAN_HPP_NOEXCEPT
323 {
324 return m_ptr;
325 }
326
end() const327 const T * end() const VULKAN_HPP_NOEXCEPT
328 {
329 return m_ptr + m_count;
330 }
331
front() const332 const T & front() const VULKAN_HPP_NOEXCEPT
333 {
334 VULKAN_HPP_ASSERT( m_count && m_ptr );
335 return *m_ptr;
336 }
337
back() const338 const T & back() const VULKAN_HPP_NOEXCEPT
339 {
340 VULKAN_HPP_ASSERT( m_count && m_ptr );
341 return *( m_ptr + m_count - 1 );
342 }
343
empty() const344 bool empty() const VULKAN_HPP_NOEXCEPT
345 {
346 return ( m_count == 0 );
347 }
348
size() const349 uint32_t size() const VULKAN_HPP_NOEXCEPT
350 {
351 return m_count;
352 }
353
data() const354 T const * data() const VULKAN_HPP_NOEXCEPT
355 {
356 return m_ptr;
357 }
358
359 private:
360 uint32_t m_count;
361 T const * m_ptr;
362 };
363
364 template <typename T>
365 class ArrayProxyNoTemporaries
366 {
367 public:
ArrayProxyNoTemporaries()368 VULKAN_HPP_CONSTEXPR ArrayProxyNoTemporaries() VULKAN_HPP_NOEXCEPT
369 : m_count( 0 )
370 , m_ptr( nullptr )
371 {}
372
ArrayProxyNoTemporaries(std::nullptr_t)373 VULKAN_HPP_CONSTEXPR ArrayProxyNoTemporaries( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
374 : m_count( 0 )
375 , m_ptr( nullptr )
376 {}
377
ArrayProxyNoTemporaries(T & value)378 ArrayProxyNoTemporaries( T & value ) VULKAN_HPP_NOEXCEPT
379 : m_count( 1 )
380 , m_ptr( &value )
381 {}
382
383 template <typename V>
384 ArrayProxyNoTemporaries( V && value ) = delete;
385
386 template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
ArrayProxyNoTemporaries(typename std::remove_const<T>::type & value)387 ArrayProxyNoTemporaries( typename std::remove_const<T>::type & value ) VULKAN_HPP_NOEXCEPT
388 : m_count( 1 )
389 , m_ptr( &value )
390 {}
391
392 template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
393 ArrayProxyNoTemporaries( typename std::remove_const<T>::type && value ) = delete;
394
ArrayProxyNoTemporaries(uint32_t count,T * ptr)395 ArrayProxyNoTemporaries( uint32_t count, T * ptr ) VULKAN_HPP_NOEXCEPT
396 : m_count( count )
397 , m_ptr( ptr )
398 {}
399
400 template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
ArrayProxyNoTemporaries(uint32_t count,typename std::remove_const<T>::type * ptr)401 ArrayProxyNoTemporaries( uint32_t count, typename std::remove_const<T>::type * ptr ) VULKAN_HPP_NOEXCEPT
402 : m_count( count )
403 , m_ptr( ptr )
404 {}
405
406 template <std::size_t C>
ArrayProxyNoTemporaries(T (& ptr)[C])407 ArrayProxyNoTemporaries( T (& ptr)[C] ) VULKAN_HPP_NOEXCEPT
408 : m_count( C )
409 , m_ptr( ptr )
410 {}
411
412 template <std::size_t C>
413 ArrayProxyNoTemporaries( T (&& ptr)[C] ) = delete;
414
415 template <std::size_t C, typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
ArrayProxyNoTemporaries(typename std::remove_const<T>::type (& ptr)[C])416 ArrayProxyNoTemporaries( typename std::remove_const<T>::type (& ptr)[C] ) VULKAN_HPP_NOEXCEPT
417 : m_count( C )
418 , m_ptr( ptr )
419 {}
420
421 template <std::size_t C, typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
422 ArrayProxyNoTemporaries( typename std::remove_const<T>::type (&& ptr)[C] ) = delete;
423
ArrayProxyNoTemporaries(std::initializer_list<T> const & list)424 ArrayProxyNoTemporaries( std::initializer_list<T> const & list ) VULKAN_HPP_NOEXCEPT
425 : m_count( static_cast<uint32_t>( list.size() ) )
426 , m_ptr( list.begin() )
427 {}
428
429 ArrayProxyNoTemporaries( std::initializer_list<T> const && list ) = delete;
430
431 template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
ArrayProxyNoTemporaries(std::initializer_list<typename std::remove_const<T>::type> const & list)432 ArrayProxyNoTemporaries( std::initializer_list<typename std::remove_const<T>::type> const & list )
433 VULKAN_HPP_NOEXCEPT
434 : m_count( static_cast<uint32_t>( list.size() ) )
435 , m_ptr( list.begin() )
436 {}
437
438 template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
439 ArrayProxyNoTemporaries( std::initializer_list<typename std::remove_const<T>::type> const && list ) = delete;
440
ArrayProxyNoTemporaries(std::initializer_list<T> & list)441 ArrayProxyNoTemporaries( std::initializer_list<T> & list ) VULKAN_HPP_NOEXCEPT
442 : m_count( static_cast<uint32_t>( list.size() ) )
443 , m_ptr( list.begin() )
444 {}
445
446 ArrayProxyNoTemporaries( std::initializer_list<T> && list ) = delete;
447
448 template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
ArrayProxyNoTemporaries(std::initializer_list<typename std::remove_const<T>::type> & list)449 ArrayProxyNoTemporaries( std::initializer_list<typename std::remove_const<T>::type> & list ) VULKAN_HPP_NOEXCEPT
450 : m_count( static_cast<uint32_t>( list.size() ) )
451 , m_ptr( list.begin() )
452 {}
453
454 template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
455 ArrayProxyNoTemporaries( std::initializer_list<typename std::remove_const<T>::type> && list ) = delete;
456
457 // Any type with a .data() return type implicitly convertible to T*, and a .size() return type implicitly convertible to size_t.
458 template <typename V,
459 typename std::enable_if<
460 std::is_convertible<decltype( std::declval<V>().data() ), T *>::value &&
461 std::is_convertible<decltype( std::declval<V>().size() ), std::size_t>::value>::type * = nullptr>
ArrayProxyNoTemporaries(V & v)462 ArrayProxyNoTemporaries( V & v ) VULKAN_HPP_NOEXCEPT
463 : m_count( static_cast<uint32_t>( v.size() ) )
464 , m_ptr( v.data() )
465 {}
466
begin() const467 const T * begin() const VULKAN_HPP_NOEXCEPT
468 {
469 return m_ptr;
470 }
471
end() const472 const T * end() const VULKAN_HPP_NOEXCEPT
473 {
474 return m_ptr + m_count;
475 }
476
front() const477 const T & front() const VULKAN_HPP_NOEXCEPT
478 {
479 VULKAN_HPP_ASSERT( m_count && m_ptr );
480 return *m_ptr;
481 }
482
back() const483 const T & back() const VULKAN_HPP_NOEXCEPT
484 {
485 VULKAN_HPP_ASSERT( m_count && m_ptr );
486 return *( m_ptr + m_count - 1 );
487 }
488
empty() const489 bool empty() const VULKAN_HPP_NOEXCEPT
490 {
491 return ( m_count == 0 );
492 }
493
size() const494 uint32_t size() const VULKAN_HPP_NOEXCEPT
495 {
496 return m_count;
497 }
498
data() const499 T * data() const VULKAN_HPP_NOEXCEPT
500 {
501 return m_ptr;
502 }
503
504 private:
505 uint32_t m_count;
506 T * m_ptr;
507 };
508
509 template <typename T>
510 class StridedArrayProxy : protected ArrayProxy<T>
511 {
512 public:
513 using ArrayProxy<T>::ArrayProxy;
514
StridedArrayProxy(uint32_t count,T const * ptr,uint32_t stride)515 StridedArrayProxy( uint32_t count, T const * ptr, uint32_t stride ) VULKAN_HPP_NOEXCEPT
516 : ArrayProxy<T>( count, ptr )
517 , m_stride( stride )
518 {
519 VULKAN_HPP_ASSERT( sizeof( T ) <= stride );
520 }
521
522 using ArrayProxy<T>::begin;
523
end() const524 const T * end() const VULKAN_HPP_NOEXCEPT
525 {
526 return reinterpret_cast<T const *>( static_cast<uint8_t const *>( begin() ) + size() * m_stride );
527 }
528
529 using ArrayProxy<T>::front;
530
back() const531 const T & back() const VULKAN_HPP_NOEXCEPT
532 {
533 VULKAN_HPP_ASSERT( begin() && size() );
534 return *reinterpret_cast<T const *>( static_cast<uint8_t const *>( begin() ) + ( size() - 1 ) * m_stride );
535 }
536
537 using ArrayProxy<T>::empty;
538 using ArrayProxy<T>::size;
539 using ArrayProxy<T>::data;
540
stride() const541 uint32_t stride() const
542 {
543 return m_stride;
544 }
545
546 private:
547 uint32_t m_stride = sizeof( T );
548 };
549
550 template <typename RefType>
551 class Optional
552 {
553 public:
Optional(RefType & reference)554 Optional( RefType & reference ) VULKAN_HPP_NOEXCEPT
555 {
556 m_ptr = &reference;
557 }
Optional(RefType * ptr)558 Optional( RefType * ptr ) VULKAN_HPP_NOEXCEPT
559 {
560 m_ptr = ptr;
561 }
Optional(std::nullptr_t)562 Optional( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
563 {
564 m_ptr = nullptr;
565 }
566
operator RefType*() const567 operator RefType *() const VULKAN_HPP_NOEXCEPT
568 {
569 return m_ptr;
570 }
operator ->() const571 RefType const * operator->() const VULKAN_HPP_NOEXCEPT
572 {
573 return m_ptr;
574 }
operator bool() const575 explicit operator bool() const VULKAN_HPP_NOEXCEPT
576 {
577 return !!m_ptr;
578 }
579
580 private:
581 RefType * m_ptr;
582 };
583
584 template <typename X, typename Y>
585 struct StructExtends
586 {
587 enum
588 {
589 value = false
590 };
591 };
592
593 template <typename Type, class...>
594 struct IsPartOfStructureChain
595 {
596 static const bool valid = false;
597 };
598
599 template <typename Type, typename Head, typename... Tail>
600 struct IsPartOfStructureChain<Type, Head, Tail...>
601 {
602 static const bool valid = std::is_same<Type, Head>::value || IsPartOfStructureChain<Type, Tail...>::valid;
603 };
604
605 template <size_t Index, typename T, typename... ChainElements>
606 struct StructureChainContains
607 {
608 static const bool value = std::is_same<T, typename std::tuple_element<Index, std::tuple<ChainElements...>>::type>::value ||
609 StructureChainContains<Index - 1, T, ChainElements...>::value;
610 };
611
612 template <typename T, typename... ChainElements>
613 struct StructureChainContains<0, T, ChainElements...>
614 {
615 static const bool value = std::is_same<T, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value;
616 };
617
618 template <size_t Index, typename... ChainElements>
619 struct StructureChainValidation
620 {
621 using TestType = typename std::tuple_element<Index, std::tuple<ChainElements...>>::type;
622 static const bool valid = StructExtends<TestType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value &&
623 ( TestType::allowDuplicate || !StructureChainContains<Index - 1, TestType, ChainElements...>::value ) &&
624 StructureChainValidation<Index - 1, ChainElements...>::valid;
625 };
626
627 template <typename... ChainElements>
628 struct StructureChainValidation<0, ChainElements...>
629 {
630 static const bool valid = true;
631 };
632
633 template <typename... ChainElements>
634 class StructureChain : public std::tuple<ChainElements...>
635 {
636 public:
StructureChain()637 StructureChain() VULKAN_HPP_NOEXCEPT
638 {
639 static_assert( StructureChainValidation<sizeof...( ChainElements ) - 1, ChainElements...>::valid, "The structure chain is not valid!" );
640 link<sizeof...( ChainElements ) - 1>();
641 }
642
StructureChain(StructureChain const & rhs)643 StructureChain( StructureChain const & rhs ) VULKAN_HPP_NOEXCEPT : std::tuple<ChainElements...>( rhs )
644 {
645 static_assert( StructureChainValidation<sizeof...( ChainElements ) - 1, ChainElements...>::valid, "The structure chain is not valid!" );
646 link( &std::get<0>( *this ),
647 &std::get<0>( rhs ),
648 reinterpret_cast<VkBaseOutStructure *>( &std::get<0>( *this ) ),
649 reinterpret_cast<VkBaseInStructure const *>( &std::get<0>( rhs ) ) );
650 }
651
StructureChain(StructureChain && rhs)652 StructureChain( StructureChain && rhs ) VULKAN_HPP_NOEXCEPT : std::tuple<ChainElements...>( std::forward<std::tuple<ChainElements...>>( rhs ) )
653 {
654 static_assert( StructureChainValidation<sizeof...( ChainElements ) - 1, ChainElements...>::valid, "The structure chain is not valid!" );
655 link( &std::get<0>( *this ),
656 &std::get<0>( rhs ),
657 reinterpret_cast<VkBaseOutStructure *>( &std::get<0>( *this ) ),
658 reinterpret_cast<VkBaseInStructure const *>( &std::get<0>( rhs ) ) );
659 }
660
StructureChain(ChainElements const &...elems)661 StructureChain( ChainElements const &... elems ) VULKAN_HPP_NOEXCEPT : std::tuple<ChainElements...>( elems... )
662 {
663 static_assert( StructureChainValidation<sizeof...( ChainElements ) - 1, ChainElements...>::valid, "The structure chain is not valid!" );
664 link<sizeof...( ChainElements ) - 1>();
665 }
666
operator =(StructureChain const & rhs)667 StructureChain & operator=( StructureChain const & rhs ) VULKAN_HPP_NOEXCEPT
668 {
669 std::tuple<ChainElements...>::operator=( rhs );
670 link( &std::get<0>( *this ),
671 &std::get<0>( rhs ),
672 reinterpret_cast<VkBaseOutStructure *>( &std::get<0>( *this ) ),
673 reinterpret_cast<VkBaseInStructure const *>( &std::get<0>( rhs ) ) );
674 return *this;
675 }
676
677 StructureChain & operator=( StructureChain && rhs ) = delete;
678
679 template <typename T = typename std::tuple_element<0, std::tuple<ChainElements...>>::type, size_t Which = 0>
get()680 T & get() VULKAN_HPP_NOEXCEPT
681 {
682 return std::get<ChainElementIndex<0, T, Which, void, ChainElements...>::value>( static_cast<std::tuple<ChainElements...> &>( *this ) );
683 }
684
685 template <typename T = typename std::tuple_element<0, std::tuple<ChainElements...>>::type, size_t Which = 0>
get() const686 T const & get() const VULKAN_HPP_NOEXCEPT
687 {
688 return std::get<ChainElementIndex<0, T, Which, void, ChainElements...>::value>( static_cast<std::tuple<ChainElements...> const &>( *this ) );
689 }
690
691 template <typename T0, typename T1, typename... Ts>
get()692 std::tuple<T0 &, T1 &, Ts &...> get() VULKAN_HPP_NOEXCEPT
693 {
694 return std::tie( get<T0>(), get<T1>(), get<Ts>()... );
695 }
696
697 template <typename T0, typename T1, typename... Ts>
get() const698 std::tuple<T0 const &, T1 const &, Ts const &...> get() const VULKAN_HPP_NOEXCEPT
699 {
700 return std::tie( get<T0>(), get<T1>(), get<Ts>()... );
701 }
702
703 // assign a complete structure to the StructureChain without modifying the chaining
704 template <typename T = typename std::tuple_element<0, std::tuple<ChainElements...>>::type, size_t Which = 0>
assign(const T & rhs)705 StructureChain & assign( const T & rhs ) VULKAN_HPP_NOEXCEPT
706 {
707 T & lhs = get<T, Which>();
708 void * pNext = lhs.pNext;
709 lhs = rhs;
710 lhs.pNext = pNext;
711 return *this;
712 }
713
714 template <typename ClassType, size_t Which = 0>
715 typename std::enable_if<std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value && ( Which == 0 ), bool>::type
isLinked() const716 isLinked() const VULKAN_HPP_NOEXCEPT
717 {
718 return true;
719 }
720
721 template <typename ClassType, size_t Which = 0>
722 typename std::enable_if<!std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value || ( Which != 0 ), bool>::type
isLinked() const723 isLinked() const VULKAN_HPP_NOEXCEPT
724 {
725 static_assert( IsPartOfStructureChain<ClassType, ChainElements...>::valid, "Can't unlink Structure that's not part of this StructureChain!" );
726 return isLinked( reinterpret_cast<VkBaseInStructure const *>( &get<ClassType, Which>() ) );
727 }
728
729 template <typename ClassType, size_t Which = 0>
730 typename std::enable_if<!std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value || ( Which != 0 ), void>::type
relink()731 relink() VULKAN_HPP_NOEXCEPT
732 {
733 static_assert( IsPartOfStructureChain<ClassType, ChainElements...>::valid, "Can't relink Structure that's not part of this StructureChain!" );
734 auto pNext = reinterpret_cast<VkBaseInStructure *>( &get<ClassType, Which>() );
735 VULKAN_HPP_ASSERT( !isLinked( pNext ) );
736 auto & headElement = std::get<0>( static_cast<std::tuple<ChainElements...> &>( *this ) );
737 pNext->pNext = reinterpret_cast<VkBaseInStructure const *>( headElement.pNext );
738 headElement.pNext = pNext;
739 }
740
741 template <typename ClassType, size_t Which = 0>
742 typename std::enable_if<!std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value || ( Which != 0 ), void>::type
unlink()743 unlink() VULKAN_HPP_NOEXCEPT
744 {
745 static_assert( IsPartOfStructureChain<ClassType, ChainElements...>::valid, "Can't unlink Structure that's not part of this StructureChain!" );
746 unlink( reinterpret_cast<VkBaseOutStructure const *>( &get<ClassType, Which>() ) );
747 }
748
749 private:
750 template <int Index, typename T, int Which, typename, class First, class... Types>
751 struct ChainElementIndex : ChainElementIndex<Index + 1, T, Which, void, Types...>
752 {
753 };
754
755 template <int Index, typename T, int Which, class First, class... Types>
756 struct ChainElementIndex<Index, T, Which, typename std::enable_if<!std::is_same<T, First>::value, void>::type, First, Types...>
757 : ChainElementIndex<Index + 1, T, Which, void, Types...>
758 {
759 };
760
761 template <int Index, typename T, int Which, class First, class... Types>
762 struct ChainElementIndex<Index, T, Which, typename std::enable_if<std::is_same<T, First>::value, void>::type, First, Types...>
763 : ChainElementIndex<Index + 1, T, Which - 1, void, Types...>
764 {
765 };
766
767 template <int Index, typename T, class First, class... Types>
768 struct ChainElementIndex<Index, T, 0, typename std::enable_if<std::is_same<T, First>::value, void>::type, First, Types...>
769 : std::integral_constant<int, Index>
770 {
771 };
772
isLinked(VkBaseInStructure const * pNext) const773 bool isLinked( VkBaseInStructure const * pNext ) const VULKAN_HPP_NOEXCEPT
774 {
775 VkBaseInStructure const * elementPtr =
776 reinterpret_cast<VkBaseInStructure const *>( &std::get<0>( static_cast<std::tuple<ChainElements...> const &>( *this ) ) );
777 while ( elementPtr )
778 {
779 if ( elementPtr->pNext == pNext )
780 {
781 return true;
782 }
783 elementPtr = elementPtr->pNext;
784 }
785 return false;
786 }
787
788 template <size_t Index>
link()789 typename std::enable_if<Index != 0, void>::type link() VULKAN_HPP_NOEXCEPT
790 {
791 auto & x = std::get<Index - 1>( static_cast<std::tuple<ChainElements...> &>( *this ) );
792 x.pNext = &std::get<Index>( static_cast<std::tuple<ChainElements...> &>( *this ) );
793 link<Index - 1>();
794 }
795
796 template <size_t Index>
link()797 typename std::enable_if<Index == 0, void>::type link() VULKAN_HPP_NOEXCEPT
798 {
799 }
800
link(void * dstBase,void const * srcBase,VkBaseOutStructure * dst,VkBaseInStructure const * src)801 void link( void * dstBase, void const * srcBase, VkBaseOutStructure * dst, VkBaseInStructure const * src )
802 {
803 while ( src->pNext )
804 {
805 std::ptrdiff_t offset = reinterpret_cast<char const *>( src->pNext ) - reinterpret_cast<char const *>( srcBase );
806 dst->pNext = reinterpret_cast<VkBaseOutStructure *>( reinterpret_cast<char *>( dstBase ) + offset );
807 dst = dst->pNext;
808 src = src->pNext;
809 }
810 dst->pNext = nullptr;
811 }
812
unlink(VkBaseOutStructure const * pNext)813 void unlink( VkBaseOutStructure const * pNext ) VULKAN_HPP_NOEXCEPT
814 {
815 VkBaseOutStructure * elementPtr = reinterpret_cast<VkBaseOutStructure *>( &std::get<0>( static_cast<std::tuple<ChainElements...> &>( *this ) ) );
816 while ( elementPtr && ( elementPtr->pNext != pNext ) )
817 {
818 elementPtr = elementPtr->pNext;
819 }
820 if ( elementPtr )
821 {
822 elementPtr->pNext = pNext->pNext;
823 }
824 else
825 {
826 VULKAN_HPP_ASSERT( false ); // fires, if the ClassType member has already been unlinked !
827 }
828 }
829 };
830 // interupt the VULKAN_HPP_NAMESPACE for a moment to add specializations of std::tuple_size and std::tuple_element for the StructureChain!
831 }
832
833 namespace std
834 {
835 template <typename... Elements>
836 struct tuple_size<VULKAN_HPP_NAMESPACE::StructureChain<Elements...>>
837 {
838 static constexpr size_t value = std::tuple_size<std::tuple<Elements...>>::value;
839 };
840
841 template <std::size_t Index, typename... Elements>
842 struct tuple_element<Index, VULKAN_HPP_NAMESPACE::StructureChain<Elements...>>
843 {
844 using type = typename std::tuple_element<Index, std::tuple<Elements...>>::type;
845 };
846 } // namespace std
847
848 namespace VULKAN_HPP_NAMESPACE
849 {
850
851 #if !defined( VULKAN_HPP_NO_SMART_HANDLE )
852 template <typename Type, typename Dispatch>
853 class UniqueHandleTraits;
854
855 template <typename Type, typename Dispatch>
856 class UniqueHandle : public UniqueHandleTraits<Type, Dispatch>::deleter
857 {
858 private:
859 using Deleter = typename UniqueHandleTraits<Type, Dispatch>::deleter;
860
861 public:
862 using element_type = Type;
863
UniqueHandle()864 UniqueHandle()
865 : Deleter()
866 , m_value()
867 {}
868
UniqueHandle(Type const & value,Deleter const & deleter=Deleter ())869 explicit UniqueHandle( Type const & value, Deleter const & deleter = Deleter() ) VULKAN_HPP_NOEXCEPT
870 : Deleter( deleter )
871 , m_value( value )
872 {}
873
874 UniqueHandle( UniqueHandle const & ) = delete;
875
UniqueHandle(UniqueHandle && other)876 UniqueHandle( UniqueHandle && other ) VULKAN_HPP_NOEXCEPT
877 : Deleter( std::move( static_cast<Deleter &>( other ) ) )
878 , m_value( other.release() )
879 {}
880
~UniqueHandle()881 ~UniqueHandle() VULKAN_HPP_NOEXCEPT
882 {
883 if ( m_value )
884 {
885 this->destroy( m_value );
886 }
887 }
888
889 UniqueHandle & operator=( UniqueHandle const & ) = delete;
890
operator =(UniqueHandle && other)891 UniqueHandle & operator=( UniqueHandle && other ) VULKAN_HPP_NOEXCEPT
892 {
893 reset( other.release() );
894 *static_cast<Deleter *>( this ) = std::move( static_cast<Deleter &>( other ) );
895 return *this;
896 }
897
operator bool() const898 explicit operator bool() const VULKAN_HPP_NOEXCEPT
899 {
900 return m_value.operator bool();
901 }
902
operator ->() const903 Type const * operator->() const VULKAN_HPP_NOEXCEPT
904 {
905 return &m_value;
906 }
907
operator ->()908 Type * operator->() VULKAN_HPP_NOEXCEPT
909 {
910 return &m_value;
911 }
912
operator *() const913 Type const & operator*() const VULKAN_HPP_NOEXCEPT
914 {
915 return m_value;
916 }
917
operator *()918 Type & operator*() VULKAN_HPP_NOEXCEPT
919 {
920 return m_value;
921 }
922
get() const923 const Type & get() const VULKAN_HPP_NOEXCEPT
924 {
925 return m_value;
926 }
927
get()928 Type & get() VULKAN_HPP_NOEXCEPT
929 {
930 return m_value;
931 }
932
reset(Type const & value=Type ())933 void reset( Type const & value = Type() ) VULKAN_HPP_NOEXCEPT
934 {
935 if ( m_value != value )
936 {
937 if ( m_value )
938 {
939 this->destroy( m_value );
940 }
941 m_value = value;
942 }
943 }
944
release()945 Type release() VULKAN_HPP_NOEXCEPT
946 {
947 Type value = m_value;
948 m_value = nullptr;
949 return value;
950 }
951
swap(UniqueHandle<Type,Dispatch> & rhs)952 void swap( UniqueHandle<Type, Dispatch> & rhs ) VULKAN_HPP_NOEXCEPT
953 {
954 std::swap( m_value, rhs.m_value );
955 std::swap( static_cast<Deleter &>( *this ), static_cast<Deleter &>( rhs ) );
956 }
957
958 private:
959 Type m_value;
960 };
961
962 template <typename UniqueType>
963 VULKAN_HPP_INLINE std::vector<typename UniqueType::element_type>
uniqueToRaw(std::vector<UniqueType> const & handles)964 uniqueToRaw( std::vector<UniqueType> const & handles )
965 {
966 std::vector<typename UniqueType::element_type> newBuffer( handles.size() );
967 std::transform( handles.begin(), handles.end(), newBuffer.begin(), []( UniqueType const & handle ) { return handle.get(); } );
968 return newBuffer;
969 }
970
971 template <typename Type, typename Dispatch>
swap(UniqueHandle<Type,Dispatch> & lhs,UniqueHandle<Type,Dispatch> & rhs)972 VULKAN_HPP_INLINE void swap( UniqueHandle<Type, Dispatch> & lhs,
973 UniqueHandle<Type, Dispatch> & rhs ) VULKAN_HPP_NOEXCEPT
974 {
975 lhs.swap( rhs );
976 }
977 #endif
978 #endif // VULKAN_HPP_DISABLE_ENHANCED_MODE
979
980 class DispatchLoaderBase
981 {
982 public:
983 DispatchLoaderBase() = default;
DispatchLoaderBase(std::nullptr_t)984 DispatchLoaderBase( std::nullptr_t )
985 #if !defined( NDEBUG )
986 : m_valid( false )
987 #endif
988 {}
989
990 #if !defined( NDEBUG )
getVkHeaderVersion() const991 size_t getVkHeaderVersion() const
992 {
993 VULKAN_HPP_ASSERT( m_valid );
994 return vkHeaderVersion;
995 }
996
997 private:
998 size_t vkHeaderVersion = VK_HEADER_VERSION;
999 bool m_valid = true;
1000 #endif
1001 };
1002
1003
1004 #if !defined( VK_NO_PROTOTYPES )
1005 class DispatchLoaderStatic : public DispatchLoaderBase
1006 {
1007 public:
1008
1009 //=== VK_VERSION_1_0 ===
1010
1011
vkCreateInstance(const VkInstanceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkInstance * pInstance) const1012 VkResult vkCreateInstance( const VkInstanceCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkInstance * pInstance ) const VULKAN_HPP_NOEXCEPT
1013 {
1014 return ::vkCreateInstance( pCreateInfo, pAllocator, pInstance );
1015 }
1016
1017
vkDestroyInstance(VkInstance instance,const VkAllocationCallbacks * pAllocator) const1018 void vkDestroyInstance( VkInstance instance, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1019 {
1020 return ::vkDestroyInstance( instance, pAllocator );
1021 }
1022
1023
vkEnumeratePhysicalDevices(VkInstance instance,uint32_t * pPhysicalDeviceCount,VkPhysicalDevice * pPhysicalDevices) const1024 VkResult vkEnumeratePhysicalDevices( VkInstance instance, uint32_t * pPhysicalDeviceCount, VkPhysicalDevice * pPhysicalDevices ) const VULKAN_HPP_NOEXCEPT
1025 {
1026 return ::vkEnumeratePhysicalDevices( instance, pPhysicalDeviceCount, pPhysicalDevices );
1027 }
1028
1029
vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures * pFeatures) const1030 void vkGetPhysicalDeviceFeatures( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures * pFeatures ) const VULKAN_HPP_NOEXCEPT
1031 {
1032 return ::vkGetPhysicalDeviceFeatures( physicalDevice, pFeatures );
1033 }
1034
1035
vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties * pFormatProperties) const1036 void vkGetPhysicalDeviceFormatProperties( VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties * pFormatProperties ) const VULKAN_HPP_NOEXCEPT
1037 {
1038 return ::vkGetPhysicalDeviceFormatProperties( physicalDevice, format, pFormatProperties );
1039 }
1040
1041
vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkImageTiling tiling,VkImageUsageFlags usage,VkImageCreateFlags flags,VkImageFormatProperties * pImageFormatProperties) const1042 VkResult vkGetPhysicalDeviceImageFormatProperties( VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties * pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
1043 {
1044 return ::vkGetPhysicalDeviceImageFormatProperties( physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties );
1045 }
1046
1047
vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties * pProperties) const1048 void vkGetPhysicalDeviceProperties( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
1049 {
1050 return ::vkGetPhysicalDeviceProperties( physicalDevice, pProperties );
1051 }
1052
1053
vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties * pQueueFamilyProperties) const1054 void vkGetPhysicalDeviceQueueFamilyProperties( VkPhysicalDevice physicalDevice, uint32_t * pQueueFamilyPropertyCount, VkQueueFamilyProperties * pQueueFamilyProperties ) const VULKAN_HPP_NOEXCEPT
1055 {
1056 return ::vkGetPhysicalDeviceQueueFamilyProperties( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties );
1057 }
1058
1059
vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties * pMemoryProperties) const1060 void vkGetPhysicalDeviceMemoryProperties( VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties * pMemoryProperties ) const VULKAN_HPP_NOEXCEPT
1061 {
1062 return ::vkGetPhysicalDeviceMemoryProperties( physicalDevice, pMemoryProperties );
1063 }
1064
1065
vkGetInstanceProcAddr(VkInstance instance,const char * pName) const1066 PFN_vkVoidFunction vkGetInstanceProcAddr( VkInstance instance, const char * pName ) const VULKAN_HPP_NOEXCEPT
1067 {
1068 return ::vkGetInstanceProcAddr( instance, pName );
1069 }
1070
1071
vkGetDeviceProcAddr(VkDevice device,const char * pName) const1072 PFN_vkVoidFunction vkGetDeviceProcAddr( VkDevice device, const char * pName ) const VULKAN_HPP_NOEXCEPT
1073 {
1074 return ::vkGetDeviceProcAddr( device, pName );
1075 }
1076
1077
vkCreateDevice(VkPhysicalDevice physicalDevice,const VkDeviceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDevice * pDevice) const1078 VkResult vkCreateDevice( VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkDevice * pDevice ) const VULKAN_HPP_NOEXCEPT
1079 {
1080 return ::vkCreateDevice( physicalDevice, pCreateInfo, pAllocator, pDevice );
1081 }
1082
1083
vkDestroyDevice(VkDevice device,const VkAllocationCallbacks * pAllocator) const1084 void vkDestroyDevice( VkDevice device, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1085 {
1086 return ::vkDestroyDevice( device, pAllocator );
1087 }
1088
1089
vkEnumerateInstanceExtensionProperties(const char * pLayerName,uint32_t * pPropertyCount,VkExtensionProperties * pProperties) const1090 VkResult vkEnumerateInstanceExtensionProperties( const char * pLayerName, uint32_t * pPropertyCount, VkExtensionProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
1091 {
1092 return ::vkEnumerateInstanceExtensionProperties( pLayerName, pPropertyCount, pProperties );
1093 }
1094
1095
vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,const char * pLayerName,uint32_t * pPropertyCount,VkExtensionProperties * pProperties) const1096 VkResult vkEnumerateDeviceExtensionProperties( VkPhysicalDevice physicalDevice, const char * pLayerName, uint32_t * pPropertyCount, VkExtensionProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
1097 {
1098 return ::vkEnumerateDeviceExtensionProperties( physicalDevice, pLayerName, pPropertyCount, pProperties );
1099 }
1100
1101
vkEnumerateInstanceLayerProperties(uint32_t * pPropertyCount,VkLayerProperties * pProperties) const1102 VkResult vkEnumerateInstanceLayerProperties( uint32_t * pPropertyCount, VkLayerProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
1103 {
1104 return ::vkEnumerateInstanceLayerProperties( pPropertyCount, pProperties );
1105 }
1106
1107
vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkLayerProperties * pProperties) const1108 VkResult vkEnumerateDeviceLayerProperties( VkPhysicalDevice physicalDevice, uint32_t * pPropertyCount, VkLayerProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
1109 {
1110 return ::vkEnumerateDeviceLayerProperties( physicalDevice, pPropertyCount, pProperties );
1111 }
1112
1113
vkGetDeviceQueue(VkDevice device,uint32_t queueFamilyIndex,uint32_t queueIndex,VkQueue * pQueue) const1114 void vkGetDeviceQueue( VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue * pQueue ) const VULKAN_HPP_NOEXCEPT
1115 {
1116 return ::vkGetDeviceQueue( device, queueFamilyIndex, queueIndex, pQueue );
1117 }
1118
1119
vkQueueSubmit(VkQueue queue,uint32_t submitCount,const VkSubmitInfo * pSubmits,VkFence fence) const1120 VkResult vkQueueSubmit( VkQueue queue, uint32_t submitCount, const VkSubmitInfo * pSubmits, VkFence fence ) const VULKAN_HPP_NOEXCEPT
1121 {
1122 return ::vkQueueSubmit( queue, submitCount, pSubmits, fence );
1123 }
1124
1125
vkQueueWaitIdle(VkQueue queue) const1126 VkResult vkQueueWaitIdle( VkQueue queue ) const VULKAN_HPP_NOEXCEPT
1127 {
1128 return ::vkQueueWaitIdle( queue );
1129 }
1130
1131
vkDeviceWaitIdle(VkDevice device) const1132 VkResult vkDeviceWaitIdle( VkDevice device ) const VULKAN_HPP_NOEXCEPT
1133 {
1134 return ::vkDeviceWaitIdle( device );
1135 }
1136
1137
vkAllocateMemory(VkDevice device,const VkMemoryAllocateInfo * pAllocateInfo,const VkAllocationCallbacks * pAllocator,VkDeviceMemory * pMemory) const1138 VkResult vkAllocateMemory( VkDevice device, const VkMemoryAllocateInfo * pAllocateInfo, const VkAllocationCallbacks * pAllocator, VkDeviceMemory * pMemory ) const VULKAN_HPP_NOEXCEPT
1139 {
1140 return ::vkAllocateMemory( device, pAllocateInfo, pAllocator, pMemory );
1141 }
1142
1143
vkMapMemory(VkDevice device,VkDeviceMemory memory,VkDeviceSize offset,VkDeviceSize size,VkMemoryMapFlags flags,void ** ppData) const1144 VkResult vkMapMemory( VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void ** ppData ) const VULKAN_HPP_NOEXCEPT
1145 {
1146 return ::vkMapMemory( device, memory, offset, size, flags, ppData );
1147 }
1148
1149
vkUnmapMemory(VkDevice device,VkDeviceMemory memory) const1150 void vkUnmapMemory( VkDevice device, VkDeviceMemory memory ) const VULKAN_HPP_NOEXCEPT
1151 {
1152 return ::vkUnmapMemory( device, memory );
1153 }
1154
1155
vkFlushMappedMemoryRanges(VkDevice device,uint32_t memoryRangeCount,const VkMappedMemoryRange * pMemoryRanges) const1156 VkResult vkFlushMappedMemoryRanges( VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange * pMemoryRanges ) const VULKAN_HPP_NOEXCEPT
1157 {
1158 return ::vkFlushMappedMemoryRanges( device, memoryRangeCount, pMemoryRanges );
1159 }
1160
1161
vkInvalidateMappedMemoryRanges(VkDevice device,uint32_t memoryRangeCount,const VkMappedMemoryRange * pMemoryRanges) const1162 VkResult vkInvalidateMappedMemoryRanges( VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange * pMemoryRanges ) const VULKAN_HPP_NOEXCEPT
1163 {
1164 return ::vkInvalidateMappedMemoryRanges( device, memoryRangeCount, pMemoryRanges );
1165 }
1166
1167
vkGetDeviceMemoryCommitment(VkDevice device,VkDeviceMemory memory,VkDeviceSize * pCommittedMemoryInBytes) const1168 void vkGetDeviceMemoryCommitment( VkDevice device, VkDeviceMemory memory, VkDeviceSize * pCommittedMemoryInBytes ) const VULKAN_HPP_NOEXCEPT
1169 {
1170 return ::vkGetDeviceMemoryCommitment( device, memory, pCommittedMemoryInBytes );
1171 }
1172
1173
vkBindBufferMemory(VkDevice device,VkBuffer buffer,VkDeviceMemory memory,VkDeviceSize memoryOffset) const1174 VkResult vkBindBufferMemory( VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset ) const VULKAN_HPP_NOEXCEPT
1175 {
1176 return ::vkBindBufferMemory( device, buffer, memory, memoryOffset );
1177 }
1178
1179
vkBindImageMemory(VkDevice device,VkImage image,VkDeviceMemory memory,VkDeviceSize memoryOffset) const1180 VkResult vkBindImageMemory( VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset ) const VULKAN_HPP_NOEXCEPT
1181 {
1182 return ::vkBindImageMemory( device, image, memory, memoryOffset );
1183 }
1184
1185
vkGetBufferMemoryRequirements(VkDevice device,VkBuffer buffer,VkMemoryRequirements * pMemoryRequirements) const1186 void vkGetBufferMemoryRequirements( VkDevice device, VkBuffer buffer, VkMemoryRequirements * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
1187 {
1188 return ::vkGetBufferMemoryRequirements( device, buffer, pMemoryRequirements );
1189 }
1190
1191
vkGetImageMemoryRequirements(VkDevice device,VkImage image,VkMemoryRequirements * pMemoryRequirements) const1192 void vkGetImageMemoryRequirements( VkDevice device, VkImage image, VkMemoryRequirements * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
1193 {
1194 return ::vkGetImageMemoryRequirements( device, image, pMemoryRequirements );
1195 }
1196
1197
vkCreateFence(VkDevice device,const VkFenceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkFence * pFence) const1198 VkResult vkCreateFence( VkDevice device, const VkFenceCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkFence * pFence ) const VULKAN_HPP_NOEXCEPT
1199 {
1200 return ::vkCreateFence( device, pCreateInfo, pAllocator, pFence );
1201 }
1202
1203
vkDestroyFence(VkDevice device,VkFence fence,const VkAllocationCallbacks * pAllocator) const1204 void vkDestroyFence( VkDevice device, VkFence fence, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1205 {
1206 return ::vkDestroyFence( device, fence, pAllocator );
1207 }
1208
1209
vkResetFences(VkDevice device,uint32_t fenceCount,const VkFence * pFences) const1210 VkResult vkResetFences( VkDevice device, uint32_t fenceCount, const VkFence * pFences ) const VULKAN_HPP_NOEXCEPT
1211 {
1212 return ::vkResetFences( device, fenceCount, pFences );
1213 }
1214
1215
vkGetFenceStatus(VkDevice device,VkFence fence) const1216 VkResult vkGetFenceStatus( VkDevice device, VkFence fence ) const VULKAN_HPP_NOEXCEPT
1217 {
1218 return ::vkGetFenceStatus( device, fence );
1219 }
1220
1221
vkWaitForFences(VkDevice device,uint32_t fenceCount,const VkFence * pFences,VkBool32 waitAll,uint64_t timeout) const1222 VkResult vkWaitForFences( VkDevice device, uint32_t fenceCount, const VkFence * pFences, VkBool32 waitAll, uint64_t timeout ) const VULKAN_HPP_NOEXCEPT
1223 {
1224 return ::vkWaitForFences( device, fenceCount, pFences, waitAll, timeout );
1225 }
1226
1227
vkCreateSemaphore(VkDevice device,const VkSemaphoreCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSemaphore * pSemaphore) const1228 VkResult vkCreateSemaphore( VkDevice device, const VkSemaphoreCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkSemaphore * pSemaphore ) const VULKAN_HPP_NOEXCEPT
1229 {
1230 return ::vkCreateSemaphore( device, pCreateInfo, pAllocator, pSemaphore );
1231 }
1232
1233
vkDestroySemaphore(VkDevice device,VkSemaphore semaphore,const VkAllocationCallbacks * pAllocator) const1234 void vkDestroySemaphore( VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1235 {
1236 return ::vkDestroySemaphore( device, semaphore, pAllocator );
1237 }
1238
1239
vkCreateEvent(VkDevice device,const VkEventCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkEvent * pEvent) const1240 VkResult vkCreateEvent( VkDevice device, const VkEventCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkEvent * pEvent ) const VULKAN_HPP_NOEXCEPT
1241 {
1242 return ::vkCreateEvent( device, pCreateInfo, pAllocator, pEvent );
1243 }
1244
1245
vkDestroyEvent(VkDevice device,VkEvent event,const VkAllocationCallbacks * pAllocator) const1246 void vkDestroyEvent( VkDevice device, VkEvent event, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1247 {
1248 return ::vkDestroyEvent( device, event, pAllocator );
1249 }
1250
1251
vkGetEventStatus(VkDevice device,VkEvent event) const1252 VkResult vkGetEventStatus( VkDevice device, VkEvent event ) const VULKAN_HPP_NOEXCEPT
1253 {
1254 return ::vkGetEventStatus( device, event );
1255 }
1256
1257
vkSetEvent(VkDevice device,VkEvent event) const1258 VkResult vkSetEvent( VkDevice device, VkEvent event ) const VULKAN_HPP_NOEXCEPT
1259 {
1260 return ::vkSetEvent( device, event );
1261 }
1262
1263
vkResetEvent(VkDevice device,VkEvent event) const1264 VkResult vkResetEvent( VkDevice device, VkEvent event ) const VULKAN_HPP_NOEXCEPT
1265 {
1266 return ::vkResetEvent( device, event );
1267 }
1268
1269
vkCreateQueryPool(VkDevice device,const VkQueryPoolCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkQueryPool * pQueryPool) const1270 VkResult vkCreateQueryPool( VkDevice device, const VkQueryPoolCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkQueryPool * pQueryPool ) const VULKAN_HPP_NOEXCEPT
1271 {
1272 return ::vkCreateQueryPool( device, pCreateInfo, pAllocator, pQueryPool );
1273 }
1274
1275
vkGetQueryPoolResults(VkDevice device,VkQueryPool queryPool,uint32_t firstQuery,uint32_t queryCount,size_t dataSize,void * pData,VkDeviceSize stride,VkQueryResultFlags flags) const1276 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
1277 {
1278 return ::vkGetQueryPoolResults( device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags );
1279 }
1280
1281
vkCreateBuffer(VkDevice device,const VkBufferCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkBuffer * pBuffer) const1282 VkResult vkCreateBuffer( VkDevice device, const VkBufferCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkBuffer * pBuffer ) const VULKAN_HPP_NOEXCEPT
1283 {
1284 return ::vkCreateBuffer( device, pCreateInfo, pAllocator, pBuffer );
1285 }
1286
1287
vkDestroyBuffer(VkDevice device,VkBuffer buffer,const VkAllocationCallbacks * pAllocator) const1288 void vkDestroyBuffer( VkDevice device, VkBuffer buffer, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1289 {
1290 return ::vkDestroyBuffer( device, buffer, pAllocator );
1291 }
1292
1293
vkCreateBufferView(VkDevice device,const VkBufferViewCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkBufferView * pView) const1294 VkResult vkCreateBufferView( VkDevice device, const VkBufferViewCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkBufferView * pView ) const VULKAN_HPP_NOEXCEPT
1295 {
1296 return ::vkCreateBufferView( device, pCreateInfo, pAllocator, pView );
1297 }
1298
1299
vkDestroyBufferView(VkDevice device,VkBufferView bufferView,const VkAllocationCallbacks * pAllocator) const1300 void vkDestroyBufferView( VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1301 {
1302 return ::vkDestroyBufferView( device, bufferView, pAllocator );
1303 }
1304
1305
vkCreateImage(VkDevice device,const VkImageCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkImage * pImage) const1306 VkResult vkCreateImage( VkDevice device, const VkImageCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkImage * pImage ) const VULKAN_HPP_NOEXCEPT
1307 {
1308 return ::vkCreateImage( device, pCreateInfo, pAllocator, pImage );
1309 }
1310
1311
vkDestroyImage(VkDevice device,VkImage image,const VkAllocationCallbacks * pAllocator) const1312 void vkDestroyImage( VkDevice device, VkImage image, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1313 {
1314 return ::vkDestroyImage( device, image, pAllocator );
1315 }
1316
1317
vkGetImageSubresourceLayout(VkDevice device,VkImage image,const VkImageSubresource * pSubresource,VkSubresourceLayout * pLayout) const1318 void vkGetImageSubresourceLayout( VkDevice device, VkImage image, const VkImageSubresource * pSubresource, VkSubresourceLayout * pLayout ) const VULKAN_HPP_NOEXCEPT
1319 {
1320 return ::vkGetImageSubresourceLayout( device, image, pSubresource, pLayout );
1321 }
1322
1323
vkCreateImageView(VkDevice device,const VkImageViewCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkImageView * pView) const1324 VkResult vkCreateImageView( VkDevice device, const VkImageViewCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkImageView * pView ) const VULKAN_HPP_NOEXCEPT
1325 {
1326 return ::vkCreateImageView( device, pCreateInfo, pAllocator, pView );
1327 }
1328
1329
vkDestroyImageView(VkDevice device,VkImageView imageView,const VkAllocationCallbacks * pAllocator) const1330 void vkDestroyImageView( VkDevice device, VkImageView imageView, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1331 {
1332 return ::vkDestroyImageView( device, imageView, pAllocator );
1333 }
1334
1335
vkCreatePipelineCache(VkDevice device,const VkPipelineCacheCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkPipelineCache * pPipelineCache) const1336 VkResult vkCreatePipelineCache( VkDevice device, const VkPipelineCacheCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkPipelineCache * pPipelineCache ) const VULKAN_HPP_NOEXCEPT
1337 {
1338 return ::vkCreatePipelineCache( device, pCreateInfo, pAllocator, pPipelineCache );
1339 }
1340
1341
vkDestroyPipelineCache(VkDevice device,VkPipelineCache pipelineCache,const VkAllocationCallbacks * pAllocator) const1342 void vkDestroyPipelineCache( VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1343 {
1344 return ::vkDestroyPipelineCache( device, pipelineCache, pAllocator );
1345 }
1346
1347
vkCreateGraphicsPipelines(VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkGraphicsPipelineCreateInfo * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines) const1348 VkResult vkCreateGraphicsPipelines( VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo * pCreateInfos, const VkAllocationCallbacks * pAllocator, VkPipeline * pPipelines ) const VULKAN_HPP_NOEXCEPT
1349 {
1350 return ::vkCreateGraphicsPipelines( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
1351 }
1352
1353
vkCreateComputePipelines(VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkComputePipelineCreateInfo * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines) const1354 VkResult vkCreateComputePipelines( VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo * pCreateInfos, const VkAllocationCallbacks * pAllocator, VkPipeline * pPipelines ) const VULKAN_HPP_NOEXCEPT
1355 {
1356 return ::vkCreateComputePipelines( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
1357 }
1358
1359
vkDestroyPipeline(VkDevice device,VkPipeline pipeline,const VkAllocationCallbacks * pAllocator) const1360 void vkDestroyPipeline( VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1361 {
1362 return ::vkDestroyPipeline( device, pipeline, pAllocator );
1363 }
1364
1365
vkCreatePipelineLayout(VkDevice device,const VkPipelineLayoutCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkPipelineLayout * pPipelineLayout) const1366 VkResult vkCreatePipelineLayout( VkDevice device, const VkPipelineLayoutCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkPipelineLayout * pPipelineLayout ) const VULKAN_HPP_NOEXCEPT
1367 {
1368 return ::vkCreatePipelineLayout( device, pCreateInfo, pAllocator, pPipelineLayout );
1369 }
1370
1371
vkDestroyPipelineLayout(VkDevice device,VkPipelineLayout pipelineLayout,const VkAllocationCallbacks * pAllocator) const1372 void vkDestroyPipelineLayout( VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1373 {
1374 return ::vkDestroyPipelineLayout( device, pipelineLayout, pAllocator );
1375 }
1376
1377
vkCreateSampler(VkDevice device,const VkSamplerCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSampler * pSampler) const1378 VkResult vkCreateSampler( VkDevice device, const VkSamplerCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkSampler * pSampler ) const VULKAN_HPP_NOEXCEPT
1379 {
1380 return ::vkCreateSampler( device, pCreateInfo, pAllocator, pSampler );
1381 }
1382
1383
vkDestroySampler(VkDevice device,VkSampler sampler,const VkAllocationCallbacks * pAllocator) const1384 void vkDestroySampler( VkDevice device, VkSampler sampler, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1385 {
1386 return ::vkDestroySampler( device, sampler, pAllocator );
1387 }
1388
1389
vkCreateDescriptorSetLayout(VkDevice device,const VkDescriptorSetLayoutCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDescriptorSetLayout * pSetLayout) const1390 VkResult vkCreateDescriptorSetLayout( VkDevice device, const VkDescriptorSetLayoutCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkDescriptorSetLayout * pSetLayout ) const VULKAN_HPP_NOEXCEPT
1391 {
1392 return ::vkCreateDescriptorSetLayout( device, pCreateInfo, pAllocator, pSetLayout );
1393 }
1394
1395
vkDestroyDescriptorSetLayout(VkDevice device,VkDescriptorSetLayout descriptorSetLayout,const VkAllocationCallbacks * pAllocator) const1396 void vkDestroyDescriptorSetLayout( VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1397 {
1398 return ::vkDestroyDescriptorSetLayout( device, descriptorSetLayout, pAllocator );
1399 }
1400
1401
vkCreateDescriptorPool(VkDevice device,const VkDescriptorPoolCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDescriptorPool * pDescriptorPool) const1402 VkResult vkCreateDescriptorPool( VkDevice device, const VkDescriptorPoolCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkDescriptorPool * pDescriptorPool ) const VULKAN_HPP_NOEXCEPT
1403 {
1404 return ::vkCreateDescriptorPool( device, pCreateInfo, pAllocator, pDescriptorPool );
1405 }
1406
1407
vkResetDescriptorPool(VkDevice device,VkDescriptorPool descriptorPool,VkDescriptorPoolResetFlags flags) const1408 VkResult vkResetDescriptorPool( VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags ) const VULKAN_HPP_NOEXCEPT
1409 {
1410 return ::vkResetDescriptorPool( device, descriptorPool, flags );
1411 }
1412
1413
vkAllocateDescriptorSets(VkDevice device,const VkDescriptorSetAllocateInfo * pAllocateInfo,VkDescriptorSet * pDescriptorSets) const1414 VkResult vkAllocateDescriptorSets( VkDevice device, const VkDescriptorSetAllocateInfo * pAllocateInfo, VkDescriptorSet * pDescriptorSets ) const VULKAN_HPP_NOEXCEPT
1415 {
1416 return ::vkAllocateDescriptorSets( device, pAllocateInfo, pDescriptorSets );
1417 }
1418
1419
vkFreeDescriptorSets(VkDevice device,VkDescriptorPool descriptorPool,uint32_t descriptorSetCount,const VkDescriptorSet * pDescriptorSets) const1420 VkResult vkFreeDescriptorSets( VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet * pDescriptorSets ) const VULKAN_HPP_NOEXCEPT
1421 {
1422 return ::vkFreeDescriptorSets( device, descriptorPool, descriptorSetCount, pDescriptorSets );
1423 }
1424
1425
vkUpdateDescriptorSets(VkDevice device,uint32_t descriptorWriteCount,const VkWriteDescriptorSet * pDescriptorWrites,uint32_t descriptorCopyCount,const VkCopyDescriptorSet * pDescriptorCopies) const1426 void vkUpdateDescriptorSets( VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet * pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet * pDescriptorCopies ) const VULKAN_HPP_NOEXCEPT
1427 {
1428 return ::vkUpdateDescriptorSets( device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies );
1429 }
1430
1431
vkCreateFramebuffer(VkDevice device,const VkFramebufferCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkFramebuffer * pFramebuffer) const1432 VkResult vkCreateFramebuffer( VkDevice device, const VkFramebufferCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkFramebuffer * pFramebuffer ) const VULKAN_HPP_NOEXCEPT
1433 {
1434 return ::vkCreateFramebuffer( device, pCreateInfo, pAllocator, pFramebuffer );
1435 }
1436
1437
vkDestroyFramebuffer(VkDevice device,VkFramebuffer framebuffer,const VkAllocationCallbacks * pAllocator) const1438 void vkDestroyFramebuffer( VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1439 {
1440 return ::vkDestroyFramebuffer( device, framebuffer, pAllocator );
1441 }
1442
1443
vkCreateRenderPass(VkDevice device,const VkRenderPassCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkRenderPass * pRenderPass) const1444 VkResult vkCreateRenderPass( VkDevice device, const VkRenderPassCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkRenderPass * pRenderPass ) const VULKAN_HPP_NOEXCEPT
1445 {
1446 return ::vkCreateRenderPass( device, pCreateInfo, pAllocator, pRenderPass );
1447 }
1448
1449
vkDestroyRenderPass(VkDevice device,VkRenderPass renderPass,const VkAllocationCallbacks * pAllocator) const1450 void vkDestroyRenderPass( VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1451 {
1452 return ::vkDestroyRenderPass( device, renderPass, pAllocator );
1453 }
1454
1455
vkGetRenderAreaGranularity(VkDevice device,VkRenderPass renderPass,VkExtent2D * pGranularity) const1456 void vkGetRenderAreaGranularity( VkDevice device, VkRenderPass renderPass, VkExtent2D * pGranularity ) const VULKAN_HPP_NOEXCEPT
1457 {
1458 return ::vkGetRenderAreaGranularity( device, renderPass, pGranularity );
1459 }
1460
1461
vkCreateCommandPool(VkDevice device,const VkCommandPoolCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkCommandPool * pCommandPool) const1462 VkResult vkCreateCommandPool( VkDevice device, const VkCommandPoolCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkCommandPool * pCommandPool ) const VULKAN_HPP_NOEXCEPT
1463 {
1464 return ::vkCreateCommandPool( device, pCreateInfo, pAllocator, pCommandPool );
1465 }
1466
1467
vkResetCommandPool(VkDevice device,VkCommandPool commandPool,VkCommandPoolResetFlags flags) const1468 VkResult vkResetCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags ) const VULKAN_HPP_NOEXCEPT
1469 {
1470 return ::vkResetCommandPool( device, commandPool, flags );
1471 }
1472
1473
vkAllocateCommandBuffers(VkDevice device,const VkCommandBufferAllocateInfo * pAllocateInfo,VkCommandBuffer * pCommandBuffers) const1474 VkResult vkAllocateCommandBuffers( VkDevice device, const VkCommandBufferAllocateInfo * pAllocateInfo, VkCommandBuffer * pCommandBuffers ) const VULKAN_HPP_NOEXCEPT
1475 {
1476 return ::vkAllocateCommandBuffers( device, pAllocateInfo, pCommandBuffers );
1477 }
1478
1479
vkFreeCommandBuffers(VkDevice device,VkCommandPool commandPool,uint32_t commandBufferCount,const VkCommandBuffer * pCommandBuffers) const1480 void vkFreeCommandBuffers( VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer * pCommandBuffers ) const VULKAN_HPP_NOEXCEPT
1481 {
1482 return ::vkFreeCommandBuffers( device, commandPool, commandBufferCount, pCommandBuffers );
1483 }
1484
1485
vkBeginCommandBuffer(VkCommandBuffer commandBuffer,const VkCommandBufferBeginInfo * pBeginInfo) const1486 VkResult vkBeginCommandBuffer( VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo * pBeginInfo ) const VULKAN_HPP_NOEXCEPT
1487 {
1488 return ::vkBeginCommandBuffer( commandBuffer, pBeginInfo );
1489 }
1490
1491
vkEndCommandBuffer(VkCommandBuffer commandBuffer) const1492 VkResult vkEndCommandBuffer( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
1493 {
1494 return ::vkEndCommandBuffer( commandBuffer );
1495 }
1496
1497
vkResetCommandBuffer(VkCommandBuffer commandBuffer,VkCommandBufferResetFlags flags) const1498 VkResult vkResetCommandBuffer( VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags ) const VULKAN_HPP_NOEXCEPT
1499 {
1500 return ::vkResetCommandBuffer( commandBuffer, flags );
1501 }
1502
1503
vkCmdBindPipeline(VkCommandBuffer commandBuffer,VkPipelineBindPoint pipelineBindPoint,VkPipeline pipeline) const1504 void vkCmdBindPipeline( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline ) const VULKAN_HPP_NOEXCEPT
1505 {
1506 return ::vkCmdBindPipeline( commandBuffer, pipelineBindPoint, pipeline );
1507 }
1508
1509
vkCmdSetViewport(VkCommandBuffer commandBuffer,uint32_t firstViewport,uint32_t viewportCount,const VkViewport * pViewports) const1510 void vkCmdSetViewport( VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport * pViewports ) const VULKAN_HPP_NOEXCEPT
1511 {
1512 return ::vkCmdSetViewport( commandBuffer, firstViewport, viewportCount, pViewports );
1513 }
1514
1515
vkCmdSetScissor(VkCommandBuffer commandBuffer,uint32_t firstScissor,uint32_t scissorCount,const VkRect2D * pScissors) const1516 void vkCmdSetScissor( VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D * pScissors ) const VULKAN_HPP_NOEXCEPT
1517 {
1518 return ::vkCmdSetScissor( commandBuffer, firstScissor, scissorCount, pScissors );
1519 }
1520
1521
vkCmdSetLineWidth(VkCommandBuffer commandBuffer,float lineWidth) const1522 void vkCmdSetLineWidth( VkCommandBuffer commandBuffer, float lineWidth ) const VULKAN_HPP_NOEXCEPT
1523 {
1524 return ::vkCmdSetLineWidth( commandBuffer, lineWidth );
1525 }
1526
1527
vkCmdSetDepthBias(VkCommandBuffer commandBuffer,float depthBiasConstantFactor,float depthBiasClamp,float depthBiasSlopeFactor) const1528 void vkCmdSetDepthBias( VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor ) const VULKAN_HPP_NOEXCEPT
1529 {
1530 return ::vkCmdSetDepthBias( commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor );
1531 }
1532
1533
vkCmdSetBlendConstants(VkCommandBuffer commandBuffer,const float blendConstants[4]) const1534 void vkCmdSetBlendConstants( VkCommandBuffer commandBuffer, const float blendConstants[4] ) const VULKAN_HPP_NOEXCEPT
1535 {
1536 return ::vkCmdSetBlendConstants( commandBuffer, blendConstants );
1537 }
1538
1539
vkCmdSetDepthBounds(VkCommandBuffer commandBuffer,float minDepthBounds,float maxDepthBounds) const1540 void vkCmdSetDepthBounds( VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds ) const VULKAN_HPP_NOEXCEPT
1541 {
1542 return ::vkCmdSetDepthBounds( commandBuffer, minDepthBounds, maxDepthBounds );
1543 }
1544
1545
vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer,VkStencilFaceFlags faceMask,uint32_t compareMask) const1546 void vkCmdSetStencilCompareMask( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask ) const VULKAN_HPP_NOEXCEPT
1547 {
1548 return ::vkCmdSetStencilCompareMask( commandBuffer, faceMask, compareMask );
1549 }
1550
1551
vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer,VkStencilFaceFlags faceMask,uint32_t writeMask) const1552 void vkCmdSetStencilWriteMask( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask ) const VULKAN_HPP_NOEXCEPT
1553 {
1554 return ::vkCmdSetStencilWriteMask( commandBuffer, faceMask, writeMask );
1555 }
1556
1557
vkCmdSetStencilReference(VkCommandBuffer commandBuffer,VkStencilFaceFlags faceMask,uint32_t reference) const1558 void vkCmdSetStencilReference( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference ) const VULKAN_HPP_NOEXCEPT
1559 {
1560 return ::vkCmdSetStencilReference( commandBuffer, faceMask, reference );
1561 }
1562
1563
vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer,VkPipelineBindPoint pipelineBindPoint,VkPipelineLayout layout,uint32_t firstSet,uint32_t descriptorSetCount,const VkDescriptorSet * pDescriptorSets,uint32_t dynamicOffsetCount,const uint32_t * pDynamicOffsets) const1564 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
1565 {
1566 return ::vkCmdBindDescriptorSets( commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets );
1567 }
1568
1569
vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer,VkBuffer buffer,VkDeviceSize offset,VkIndexType indexType) const1570 void vkCmdBindIndexBuffer( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType ) const VULKAN_HPP_NOEXCEPT
1571 {
1572 return ::vkCmdBindIndexBuffer( commandBuffer, buffer, offset, indexType );
1573 }
1574
1575
vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer,uint32_t firstBinding,uint32_t bindingCount,const VkBuffer * pBuffers,const VkDeviceSize * pOffsets) const1576 void vkCmdBindVertexBuffers( VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer * pBuffers, const VkDeviceSize * pOffsets ) const VULKAN_HPP_NOEXCEPT
1577 {
1578 return ::vkCmdBindVertexBuffers( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets );
1579 }
1580
1581
vkCmdDraw(VkCommandBuffer commandBuffer,uint32_t vertexCount,uint32_t instanceCount,uint32_t firstVertex,uint32_t firstInstance) const1582 void vkCmdDraw( VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT
1583 {
1584 return ::vkCmdDraw( commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance );
1585 }
1586
1587
vkCmdDrawIndexed(VkCommandBuffer commandBuffer,uint32_t indexCount,uint32_t instanceCount,uint32_t firstIndex,int32_t vertexOffset,uint32_t firstInstance) const1588 void vkCmdDrawIndexed( VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT
1589 {
1590 return ::vkCmdDrawIndexed( commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance );
1591 }
1592
1593
vkCmdDrawIndirect(VkCommandBuffer commandBuffer,VkBuffer buffer,VkDeviceSize offset,uint32_t drawCount,uint32_t stride) const1594 void vkCmdDrawIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const VULKAN_HPP_NOEXCEPT
1595 {
1596 return ::vkCmdDrawIndirect( commandBuffer, buffer, offset, drawCount, stride );
1597 }
1598
1599
vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer,VkBuffer buffer,VkDeviceSize offset,uint32_t drawCount,uint32_t stride) const1600 void vkCmdDrawIndexedIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const VULKAN_HPP_NOEXCEPT
1601 {
1602 return ::vkCmdDrawIndexedIndirect( commandBuffer, buffer, offset, drawCount, stride );
1603 }
1604
1605
vkCmdDispatch(VkCommandBuffer commandBuffer,uint32_t groupCountX,uint32_t groupCountY,uint32_t groupCountZ) const1606 void vkCmdDispatch( VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
1607 {
1608 return ::vkCmdDispatch( commandBuffer, groupCountX, groupCountY, groupCountZ );
1609 }
1610
1611
vkCmdDispatchIndirect(VkCommandBuffer commandBuffer,VkBuffer buffer,VkDeviceSize offset) const1612 void vkCmdDispatchIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset ) const VULKAN_HPP_NOEXCEPT
1613 {
1614 return ::vkCmdDispatchIndirect( commandBuffer, buffer, offset );
1615 }
1616
1617
vkCmdCopyBuffer(VkCommandBuffer commandBuffer,VkBuffer srcBuffer,VkBuffer dstBuffer,uint32_t regionCount,const VkBufferCopy * pRegions) const1618 void vkCmdCopyBuffer( VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy * pRegions ) const VULKAN_HPP_NOEXCEPT
1619 {
1620 return ::vkCmdCopyBuffer( commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions );
1621 }
1622
1623
vkCmdCopyImage(VkCommandBuffer commandBuffer,VkImage srcImage,VkImageLayout srcImageLayout,VkImage dstImage,VkImageLayout dstImageLayout,uint32_t regionCount,const VkImageCopy * pRegions) const1624 void vkCmdCopyImage( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy * pRegions ) const VULKAN_HPP_NOEXCEPT
1625 {
1626 return ::vkCmdCopyImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions );
1627 }
1628
1629
vkCmdBlitImage(VkCommandBuffer commandBuffer,VkImage srcImage,VkImageLayout srcImageLayout,VkImage dstImage,VkImageLayout dstImageLayout,uint32_t regionCount,const VkImageBlit * pRegions,VkFilter filter) const1630 void vkCmdBlitImage( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit * pRegions, VkFilter filter ) const VULKAN_HPP_NOEXCEPT
1631 {
1632 return ::vkCmdBlitImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter );
1633 }
1634
1635
vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer,VkBuffer srcBuffer,VkImage dstImage,VkImageLayout dstImageLayout,uint32_t regionCount,const VkBufferImageCopy * pRegions) const1636 void vkCmdCopyBufferToImage( VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy * pRegions ) const VULKAN_HPP_NOEXCEPT
1637 {
1638 return ::vkCmdCopyBufferToImage( commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions );
1639 }
1640
1641
vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer,VkImage srcImage,VkImageLayout srcImageLayout,VkBuffer dstBuffer,uint32_t regionCount,const VkBufferImageCopy * pRegions) const1642 void vkCmdCopyImageToBuffer( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy * pRegions ) const VULKAN_HPP_NOEXCEPT
1643 {
1644 return ::vkCmdCopyImageToBuffer( commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions );
1645 }
1646
1647
vkCmdUpdateBuffer(VkCommandBuffer commandBuffer,VkBuffer dstBuffer,VkDeviceSize dstOffset,VkDeviceSize dataSize,const void * pData) const1648 void vkCmdUpdateBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void * pData ) const VULKAN_HPP_NOEXCEPT
1649 {
1650 return ::vkCmdUpdateBuffer( commandBuffer, dstBuffer, dstOffset, dataSize, pData );
1651 }
1652
1653
vkCmdFillBuffer(VkCommandBuffer commandBuffer,VkBuffer dstBuffer,VkDeviceSize dstOffset,VkDeviceSize size,uint32_t data) const1654 void vkCmdFillBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data ) const VULKAN_HPP_NOEXCEPT
1655 {
1656 return ::vkCmdFillBuffer( commandBuffer, dstBuffer, dstOffset, size, data );
1657 }
1658
1659
vkCmdClearColorImage(VkCommandBuffer commandBuffer,VkImage image,VkImageLayout imageLayout,const VkClearColorValue * pColor,uint32_t rangeCount,const VkImageSubresourceRange * pRanges) const1660 void vkCmdClearColorImage( VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue * pColor, uint32_t rangeCount, const VkImageSubresourceRange * pRanges ) const VULKAN_HPP_NOEXCEPT
1661 {
1662 return ::vkCmdClearColorImage( commandBuffer, image, imageLayout, pColor, rangeCount, pRanges );
1663 }
1664
1665
vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer,VkImage image,VkImageLayout imageLayout,const VkClearDepthStencilValue * pDepthStencil,uint32_t rangeCount,const VkImageSubresourceRange * pRanges) const1666 void vkCmdClearDepthStencilImage( VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue * pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange * pRanges ) const VULKAN_HPP_NOEXCEPT
1667 {
1668 return ::vkCmdClearDepthStencilImage( commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges );
1669 }
1670
1671
vkCmdClearAttachments(VkCommandBuffer commandBuffer,uint32_t attachmentCount,const VkClearAttachment * pAttachments,uint32_t rectCount,const VkClearRect * pRects) const1672 void vkCmdClearAttachments( VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment * pAttachments, uint32_t rectCount, const VkClearRect * pRects ) const VULKAN_HPP_NOEXCEPT
1673 {
1674 return ::vkCmdClearAttachments( commandBuffer, attachmentCount, pAttachments, rectCount, pRects );
1675 }
1676
1677
vkCmdResolveImage(VkCommandBuffer commandBuffer,VkImage srcImage,VkImageLayout srcImageLayout,VkImage dstImage,VkImageLayout dstImageLayout,uint32_t regionCount,const VkImageResolve * pRegions) const1678 void vkCmdResolveImage( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve * pRegions ) const VULKAN_HPP_NOEXCEPT
1679 {
1680 return ::vkCmdResolveImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions );
1681 }
1682
1683
vkCmdSetEvent(VkCommandBuffer commandBuffer,VkEvent event,VkPipelineStageFlags stageMask) const1684 void vkCmdSetEvent( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask ) const VULKAN_HPP_NOEXCEPT
1685 {
1686 return ::vkCmdSetEvent( commandBuffer, event, stageMask );
1687 }
1688
1689
vkCmdResetEvent(VkCommandBuffer commandBuffer,VkEvent event,VkPipelineStageFlags stageMask) const1690 void vkCmdResetEvent( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask ) const VULKAN_HPP_NOEXCEPT
1691 {
1692 return ::vkCmdResetEvent( commandBuffer, event, stageMask );
1693 }
1694
1695
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) const1696 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
1697 {
1698 return ::vkCmdWaitEvents( commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers );
1699 }
1700
1701
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) const1702 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
1703 {
1704 return ::vkCmdPipelineBarrier( commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers );
1705 }
1706
1707
vkCmdBeginQuery(VkCommandBuffer commandBuffer,VkQueryPool queryPool,uint32_t query,VkQueryControlFlags flags) const1708 void vkCmdBeginQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags ) const VULKAN_HPP_NOEXCEPT
1709 {
1710 return ::vkCmdBeginQuery( commandBuffer, queryPool, query, flags );
1711 }
1712
1713
vkCmdEndQuery(VkCommandBuffer commandBuffer,VkQueryPool queryPool,uint32_t query) const1714 void vkCmdEndQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT
1715 {
1716 return ::vkCmdEndQuery( commandBuffer, queryPool, query );
1717 }
1718
1719
vkCmdResetQueryPool(VkCommandBuffer commandBuffer,VkQueryPool queryPool,uint32_t firstQuery,uint32_t queryCount) const1720 void vkCmdResetQueryPool( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT
1721 {
1722 return ::vkCmdResetQueryPool( commandBuffer, queryPool, firstQuery, queryCount );
1723 }
1724
1725
vkCmdWriteTimestamp(VkCommandBuffer commandBuffer,VkPipelineStageFlagBits pipelineStage,VkQueryPool queryPool,uint32_t query) const1726 void vkCmdWriteTimestamp( VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT
1727 {
1728 return ::vkCmdWriteTimestamp( commandBuffer, pipelineStage, queryPool, query );
1729 }
1730
1731
vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer,VkQueryPool queryPool,uint32_t firstQuery,uint32_t queryCount,VkBuffer dstBuffer,VkDeviceSize dstOffset,VkDeviceSize stride,VkQueryResultFlags flags) const1732 void vkCmdCopyQueryPoolResults( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags ) const VULKAN_HPP_NOEXCEPT
1733 {
1734 return ::vkCmdCopyQueryPoolResults( commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags );
1735 }
1736
1737
vkCmdPushConstants(VkCommandBuffer commandBuffer,VkPipelineLayout layout,VkShaderStageFlags stageFlags,uint32_t offset,uint32_t size,const void * pValues) const1738 void vkCmdPushConstants( VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void * pValues ) const VULKAN_HPP_NOEXCEPT
1739 {
1740 return ::vkCmdPushConstants( commandBuffer, layout, stageFlags, offset, size, pValues );
1741 }
1742
1743
vkCmdBeginRenderPass(VkCommandBuffer commandBuffer,const VkRenderPassBeginInfo * pRenderPassBegin,VkSubpassContents contents) const1744 void vkCmdBeginRenderPass( VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo * pRenderPassBegin, VkSubpassContents contents ) const VULKAN_HPP_NOEXCEPT
1745 {
1746 return ::vkCmdBeginRenderPass( commandBuffer, pRenderPassBegin, contents );
1747 }
1748
1749
vkCmdNextSubpass(VkCommandBuffer commandBuffer,VkSubpassContents contents) const1750 void vkCmdNextSubpass( VkCommandBuffer commandBuffer, VkSubpassContents contents ) const VULKAN_HPP_NOEXCEPT
1751 {
1752 return ::vkCmdNextSubpass( commandBuffer, contents );
1753 }
1754
1755
vkCmdEndRenderPass(VkCommandBuffer commandBuffer) const1756 void vkCmdEndRenderPass( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
1757 {
1758 return ::vkCmdEndRenderPass( commandBuffer );
1759 }
1760
1761
vkCmdExecuteCommands(VkCommandBuffer commandBuffer,uint32_t commandBufferCount,const VkCommandBuffer * pCommandBuffers) const1762 void vkCmdExecuteCommands( VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer * pCommandBuffers ) const VULKAN_HPP_NOEXCEPT
1763 {
1764 return ::vkCmdExecuteCommands( commandBuffer, commandBufferCount, pCommandBuffers );
1765 }
1766
1767 //=== VK_VERSION_1_1 ===
1768
1769
vkEnumerateInstanceVersion(uint32_t * pApiVersion) const1770 VkResult vkEnumerateInstanceVersion( uint32_t * pApiVersion ) const VULKAN_HPP_NOEXCEPT
1771 {
1772 return ::vkEnumerateInstanceVersion( pApiVersion );
1773 }
1774
1775
vkBindBufferMemory2(VkDevice device,uint32_t bindInfoCount,const VkBindBufferMemoryInfo * pBindInfos) const1776 VkResult vkBindBufferMemory2( VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT
1777 {
1778 return ::vkBindBufferMemory2( device, bindInfoCount, pBindInfos );
1779 }
1780
1781
vkBindImageMemory2(VkDevice device,uint32_t bindInfoCount,const VkBindImageMemoryInfo * pBindInfos) const1782 VkResult vkBindImageMemory2( VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT
1783 {
1784 return ::vkBindImageMemory2( device, bindInfoCount, pBindInfos );
1785 }
1786
1787
vkGetDeviceGroupPeerMemoryFeatures(VkDevice device,uint32_t heapIndex,uint32_t localDeviceIndex,uint32_t remoteDeviceIndex,VkPeerMemoryFeatureFlags * pPeerMemoryFeatures) const1788 void vkGetDeviceGroupPeerMemoryFeatures( VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags * pPeerMemoryFeatures ) const VULKAN_HPP_NOEXCEPT
1789 {
1790 return ::vkGetDeviceGroupPeerMemoryFeatures( device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures );
1791 }
1792
1793
vkCmdSetDeviceMask(VkCommandBuffer commandBuffer,uint32_t deviceMask) const1794 void vkCmdSetDeviceMask( VkCommandBuffer commandBuffer, uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT
1795 {
1796 return ::vkCmdSetDeviceMask( commandBuffer, deviceMask );
1797 }
1798
1799
vkCmdDispatchBase(VkCommandBuffer commandBuffer,uint32_t baseGroupX,uint32_t baseGroupY,uint32_t baseGroupZ,uint32_t groupCountX,uint32_t groupCountY,uint32_t groupCountZ) const1800 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
1801 {
1802 return ::vkCmdDispatchBase( commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
1803 }
1804
1805
vkEnumeratePhysicalDeviceGroups(VkInstance instance,uint32_t * pPhysicalDeviceGroupCount,VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties) const1806 VkResult vkEnumeratePhysicalDeviceGroups( VkInstance instance, uint32_t * pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties ) const VULKAN_HPP_NOEXCEPT
1807 {
1808 return ::vkEnumeratePhysicalDeviceGroups( instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties );
1809 }
1810
1811
vkGetImageMemoryRequirements2(VkDevice device,const VkImageMemoryRequirementsInfo2 * pInfo,VkMemoryRequirements2 * pMemoryRequirements) const1812 void vkGetImageMemoryRequirements2( VkDevice device, const VkImageMemoryRequirementsInfo2 * pInfo, VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
1813 {
1814 return ::vkGetImageMemoryRequirements2( device, pInfo, pMemoryRequirements );
1815 }
1816
1817
vkGetBufferMemoryRequirements2(VkDevice device,const VkBufferMemoryRequirementsInfo2 * pInfo,VkMemoryRequirements2 * pMemoryRequirements) const1818 void vkGetBufferMemoryRequirements2( VkDevice device, const VkBufferMemoryRequirementsInfo2 * pInfo, VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
1819 {
1820 return ::vkGetBufferMemoryRequirements2( device, pInfo, pMemoryRequirements );
1821 }
1822
1823
vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures2 * pFeatures) const1824 void vkGetPhysicalDeviceFeatures2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 * pFeatures ) const VULKAN_HPP_NOEXCEPT
1825 {
1826 return ::vkGetPhysicalDeviceFeatures2( physicalDevice, pFeatures );
1827 }
1828
1829
vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties2 * pProperties) const1830 void vkGetPhysicalDeviceProperties2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 * pProperties ) const VULKAN_HPP_NOEXCEPT
1831 {
1832 return ::vkGetPhysicalDeviceProperties2( physicalDevice, pProperties );
1833 }
1834
1835
vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties2 * pFormatProperties) const1836 void vkGetPhysicalDeviceFormatProperties2( VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 * pFormatProperties ) const VULKAN_HPP_NOEXCEPT
1837 {
1838 return ::vkGetPhysicalDeviceFormatProperties2( physicalDevice, format, pFormatProperties );
1839 }
1840
1841
vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,VkImageFormatProperties2 * pImageFormatProperties) const1842 VkResult vkGetPhysicalDeviceImageFormatProperties2( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo, VkImageFormatProperties2 * pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
1843 {
1844 return ::vkGetPhysicalDeviceImageFormatProperties2( physicalDevice, pImageFormatInfo, pImageFormatProperties );
1845 }
1846
1847
vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties2 * pQueueFamilyProperties) const1848 void vkGetPhysicalDeviceQueueFamilyProperties2( VkPhysicalDevice physicalDevice, uint32_t * pQueueFamilyPropertyCount, VkQueueFamilyProperties2 * pQueueFamilyProperties ) const VULKAN_HPP_NOEXCEPT
1849 {
1850 return ::vkGetPhysicalDeviceQueueFamilyProperties2( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties );
1851 }
1852
1853
vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties2 * pMemoryProperties) const1854 void vkGetPhysicalDeviceMemoryProperties2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 * pMemoryProperties ) const VULKAN_HPP_NOEXCEPT
1855 {
1856 return ::vkGetPhysicalDeviceMemoryProperties2( physicalDevice, pMemoryProperties );
1857 }
1858
1859
vkGetDeviceQueue2(VkDevice device,const VkDeviceQueueInfo2 * pQueueInfo,VkQueue * pQueue) const1860 void vkGetDeviceQueue2( VkDevice device, const VkDeviceQueueInfo2 * pQueueInfo, VkQueue * pQueue ) const VULKAN_HPP_NOEXCEPT
1861 {
1862 return ::vkGetDeviceQueue2( device, pQueueInfo, pQueue );
1863 }
1864
1865
vkCreateSamplerYcbcrConversion(VkDevice device,const VkSamplerYcbcrConversionCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSamplerYcbcrConversion * pYcbcrConversion) const1866 VkResult vkCreateSamplerYcbcrConversion( VkDevice device, const VkSamplerYcbcrConversionCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkSamplerYcbcrConversion * pYcbcrConversion ) const VULKAN_HPP_NOEXCEPT
1867 {
1868 return ::vkCreateSamplerYcbcrConversion( device, pCreateInfo, pAllocator, pYcbcrConversion );
1869 }
1870
1871
vkDestroySamplerYcbcrConversion(VkDevice device,VkSamplerYcbcrConversion ycbcrConversion,const VkAllocationCallbacks * pAllocator) const1872 void vkDestroySamplerYcbcrConversion( VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1873 {
1874 return ::vkDestroySamplerYcbcrConversion( device, ycbcrConversion, pAllocator );
1875 }
1876
1877
vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,VkExternalBufferProperties * pExternalBufferProperties) const1878 void vkGetPhysicalDeviceExternalBufferProperties( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo, VkExternalBufferProperties * pExternalBufferProperties ) const VULKAN_HPP_NOEXCEPT
1879 {
1880 return ::vkGetPhysicalDeviceExternalBufferProperties( physicalDevice, pExternalBufferInfo, pExternalBufferProperties );
1881 }
1882
1883
vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,VkExternalFenceProperties * pExternalFenceProperties) const1884 void vkGetPhysicalDeviceExternalFenceProperties( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo, VkExternalFenceProperties * pExternalFenceProperties ) const VULKAN_HPP_NOEXCEPT
1885 {
1886 return ::vkGetPhysicalDeviceExternalFenceProperties( physicalDevice, pExternalFenceInfo, pExternalFenceProperties );
1887 }
1888
1889
vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,VkExternalSemaphoreProperties * pExternalSemaphoreProperties) const1890 void vkGetPhysicalDeviceExternalSemaphoreProperties( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo, VkExternalSemaphoreProperties * pExternalSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT
1891 {
1892 return ::vkGetPhysicalDeviceExternalSemaphoreProperties( physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties );
1893 }
1894
1895
vkGetDescriptorSetLayoutSupport(VkDevice device,const VkDescriptorSetLayoutCreateInfo * pCreateInfo,VkDescriptorSetLayoutSupport * pSupport) const1896 void vkGetDescriptorSetLayoutSupport( VkDevice device, const VkDescriptorSetLayoutCreateInfo * pCreateInfo, VkDescriptorSetLayoutSupport * pSupport ) const VULKAN_HPP_NOEXCEPT
1897 {
1898 return ::vkGetDescriptorSetLayoutSupport( device, pCreateInfo, pSupport );
1899 }
1900
1901 //=== VK_VERSION_1_2 ===
1902
1903
vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer,VkBuffer buffer,VkDeviceSize offset,VkBuffer countBuffer,VkDeviceSize countBufferOffset,uint32_t maxDrawCount,uint32_t stride) const1904 void vkCmdDrawIndirectCount( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const VULKAN_HPP_NOEXCEPT
1905 {
1906 return ::vkCmdDrawIndirectCount( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
1907 }
1908
1909
vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer,VkBuffer buffer,VkDeviceSize offset,VkBuffer countBuffer,VkDeviceSize countBufferOffset,uint32_t maxDrawCount,uint32_t stride) const1910 void vkCmdDrawIndexedIndirectCount( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const VULKAN_HPP_NOEXCEPT
1911 {
1912 return ::vkCmdDrawIndexedIndirectCount( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
1913 }
1914
1915
vkCreateRenderPass2(VkDevice device,const VkRenderPassCreateInfo2 * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkRenderPass * pRenderPass) const1916 VkResult vkCreateRenderPass2( VkDevice device, const VkRenderPassCreateInfo2 * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkRenderPass * pRenderPass ) const VULKAN_HPP_NOEXCEPT
1917 {
1918 return ::vkCreateRenderPass2( device, pCreateInfo, pAllocator, pRenderPass );
1919 }
1920
1921
vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer,const VkRenderPassBeginInfo * pRenderPassBegin,const VkSubpassBeginInfo * pSubpassBeginInfo) const1922 void vkCmdBeginRenderPass2( VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo * pRenderPassBegin, const VkSubpassBeginInfo * pSubpassBeginInfo ) const VULKAN_HPP_NOEXCEPT
1923 {
1924 return ::vkCmdBeginRenderPass2( commandBuffer, pRenderPassBegin, pSubpassBeginInfo );
1925 }
1926
1927
vkCmdNextSubpass2(VkCommandBuffer commandBuffer,const VkSubpassBeginInfo * pSubpassBeginInfo,const VkSubpassEndInfo * pSubpassEndInfo) const1928 void vkCmdNextSubpass2( VkCommandBuffer commandBuffer, const VkSubpassBeginInfo * pSubpassBeginInfo, const VkSubpassEndInfo * pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT
1929 {
1930 return ::vkCmdNextSubpass2( commandBuffer, pSubpassBeginInfo, pSubpassEndInfo );
1931 }
1932
1933
vkCmdEndRenderPass2(VkCommandBuffer commandBuffer,const VkSubpassEndInfo * pSubpassEndInfo) const1934 void vkCmdEndRenderPass2( VkCommandBuffer commandBuffer, const VkSubpassEndInfo * pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT
1935 {
1936 return ::vkCmdEndRenderPass2( commandBuffer, pSubpassEndInfo );
1937 }
1938
1939
vkResetQueryPool(VkDevice device,VkQueryPool queryPool,uint32_t firstQuery,uint32_t queryCount) const1940 void vkResetQueryPool( VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT
1941 {
1942 return ::vkResetQueryPool( device, queryPool, firstQuery, queryCount );
1943 }
1944
1945
vkGetSemaphoreCounterValue(VkDevice device,VkSemaphore semaphore,uint64_t * pValue) const1946 VkResult vkGetSemaphoreCounterValue( VkDevice device, VkSemaphore semaphore, uint64_t * pValue ) const VULKAN_HPP_NOEXCEPT
1947 {
1948 return ::vkGetSemaphoreCounterValue( device, semaphore, pValue );
1949 }
1950
1951
vkWaitSemaphores(VkDevice device,const VkSemaphoreWaitInfo * pWaitInfo,uint64_t timeout) const1952 VkResult vkWaitSemaphores( VkDevice device, const VkSemaphoreWaitInfo * pWaitInfo, uint64_t timeout ) const VULKAN_HPP_NOEXCEPT
1953 {
1954 return ::vkWaitSemaphores( device, pWaitInfo, timeout );
1955 }
1956
1957
vkSignalSemaphore(VkDevice device,const VkSemaphoreSignalInfo * pSignalInfo) const1958 VkResult vkSignalSemaphore( VkDevice device, const VkSemaphoreSignalInfo * pSignalInfo ) const VULKAN_HPP_NOEXCEPT
1959 {
1960 return ::vkSignalSemaphore( device, pSignalInfo );
1961 }
1962
1963
vkGetBufferDeviceAddress(VkDevice device,const VkBufferDeviceAddressInfo * pInfo) const1964 VkDeviceAddress vkGetBufferDeviceAddress( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
1965 {
1966 return ::vkGetBufferDeviceAddress( device, pInfo );
1967 }
1968
1969
vkGetBufferOpaqueCaptureAddress(VkDevice device,const VkBufferDeviceAddressInfo * pInfo) const1970 uint64_t vkGetBufferOpaqueCaptureAddress( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
1971 {
1972 return ::vkGetBufferOpaqueCaptureAddress( device, pInfo );
1973 }
1974
1975
vkGetDeviceMemoryOpaqueCaptureAddress(VkDevice device,const VkDeviceMemoryOpaqueCaptureAddressInfo * pInfo) const1976 uint64_t vkGetDeviceMemoryOpaqueCaptureAddress( VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
1977 {
1978 return ::vkGetDeviceMemoryOpaqueCaptureAddress( device, pInfo );
1979 }
1980
1981 //=== VK_VERSION_1_3 ===
1982
1983
vkGetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice,uint32_t * pToolCount,VkPhysicalDeviceToolProperties * pToolProperties) const1984 VkResult vkGetPhysicalDeviceToolProperties( VkPhysicalDevice physicalDevice, uint32_t * pToolCount, VkPhysicalDeviceToolProperties * pToolProperties ) const VULKAN_HPP_NOEXCEPT
1985 {
1986 return ::vkGetPhysicalDeviceToolProperties( physicalDevice, pToolCount, pToolProperties );
1987 }
1988
1989
vkCreatePrivateDataSlot(VkDevice device,const VkPrivateDataSlotCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkPrivateDataSlot * pPrivateDataSlot) const1990 VkResult vkCreatePrivateDataSlot( VkDevice device, const VkPrivateDataSlotCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkPrivateDataSlot * pPrivateDataSlot ) const VULKAN_HPP_NOEXCEPT
1991 {
1992 return ::vkCreatePrivateDataSlot( device, pCreateInfo, pAllocator, pPrivateDataSlot );
1993 }
1994
1995
vkDestroyPrivateDataSlot(VkDevice device,VkPrivateDataSlot privateDataSlot,const VkAllocationCallbacks * pAllocator) const1996 void vkDestroyPrivateDataSlot( VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
1997 {
1998 return ::vkDestroyPrivateDataSlot( device, privateDataSlot, pAllocator );
1999 }
2000
2001
vkSetPrivateData(VkDevice device,VkObjectType objectType,uint64_t objectHandle,VkPrivateDataSlot privateDataSlot,uint64_t data) const2002 VkResult vkSetPrivateData( VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data ) const VULKAN_HPP_NOEXCEPT
2003 {
2004 return ::vkSetPrivateData( device, objectType, objectHandle, privateDataSlot, data );
2005 }
2006
2007
vkGetPrivateData(VkDevice device,VkObjectType objectType,uint64_t objectHandle,VkPrivateDataSlot privateDataSlot,uint64_t * pData) const2008 void vkGetPrivateData( VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t * pData ) const VULKAN_HPP_NOEXCEPT
2009 {
2010 return ::vkGetPrivateData( device, objectType, objectHandle, privateDataSlot, pData );
2011 }
2012
2013
vkCmdSetEvent2(VkCommandBuffer commandBuffer,VkEvent event,const VkDependencyInfo * pDependencyInfo) const2014 void vkCmdSetEvent2( VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT
2015 {
2016 return ::vkCmdSetEvent2( commandBuffer, event, pDependencyInfo );
2017 }
2018
2019
vkCmdResetEvent2(VkCommandBuffer commandBuffer,VkEvent event,VkPipelineStageFlags2 stageMask) const2020 void vkCmdResetEvent2( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask ) const VULKAN_HPP_NOEXCEPT
2021 {
2022 return ::vkCmdResetEvent2( commandBuffer, event, stageMask );
2023 }
2024
2025
vkCmdWaitEvents2(VkCommandBuffer commandBuffer,uint32_t eventCount,const VkEvent * pEvents,const VkDependencyInfo * pDependencyInfos) const2026 void vkCmdWaitEvents2( VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent * pEvents, const VkDependencyInfo * pDependencyInfos ) const VULKAN_HPP_NOEXCEPT
2027 {
2028 return ::vkCmdWaitEvents2( commandBuffer, eventCount, pEvents, pDependencyInfos );
2029 }
2030
2031
vkCmdPipelineBarrier2(VkCommandBuffer commandBuffer,const VkDependencyInfo * pDependencyInfo) const2032 void vkCmdPipelineBarrier2( VkCommandBuffer commandBuffer, const VkDependencyInfo * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT
2033 {
2034 return ::vkCmdPipelineBarrier2( commandBuffer, pDependencyInfo );
2035 }
2036
2037
vkCmdWriteTimestamp2(VkCommandBuffer commandBuffer,VkPipelineStageFlags2 stage,VkQueryPool queryPool,uint32_t query) const2038 void vkCmdWriteTimestamp2( VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT
2039 {
2040 return ::vkCmdWriteTimestamp2( commandBuffer, stage, queryPool, query );
2041 }
2042
2043
vkQueueSubmit2(VkQueue queue,uint32_t submitCount,const VkSubmitInfo2 * pSubmits,VkFence fence) const2044 VkResult vkQueueSubmit2( VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 * pSubmits, VkFence fence ) const VULKAN_HPP_NOEXCEPT
2045 {
2046 return ::vkQueueSubmit2( queue, submitCount, pSubmits, fence );
2047 }
2048
2049
vkCmdCopyBuffer2(VkCommandBuffer commandBuffer,const VkCopyBufferInfo2 * pCopyBufferInfo) const2050 void vkCmdCopyBuffer2( VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 * pCopyBufferInfo ) const VULKAN_HPP_NOEXCEPT
2051 {
2052 return ::vkCmdCopyBuffer2( commandBuffer, pCopyBufferInfo );
2053 }
2054
2055
vkCmdCopyImage2(VkCommandBuffer commandBuffer,const VkCopyImageInfo2 * pCopyImageInfo) const2056 void vkCmdCopyImage2( VkCommandBuffer commandBuffer, const VkCopyImageInfo2 * pCopyImageInfo ) const VULKAN_HPP_NOEXCEPT
2057 {
2058 return ::vkCmdCopyImage2( commandBuffer, pCopyImageInfo );
2059 }
2060
2061
vkCmdCopyBufferToImage2(VkCommandBuffer commandBuffer,const VkCopyBufferToImageInfo2 * pCopyBufferToImageInfo) const2062 void vkCmdCopyBufferToImage2( VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 * pCopyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT
2063 {
2064 return ::vkCmdCopyBufferToImage2( commandBuffer, pCopyBufferToImageInfo );
2065 }
2066
2067
vkCmdCopyImageToBuffer2(VkCommandBuffer commandBuffer,const VkCopyImageToBufferInfo2 * pCopyImageToBufferInfo) const2068 void vkCmdCopyImageToBuffer2( VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 * pCopyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT
2069 {
2070 return ::vkCmdCopyImageToBuffer2( commandBuffer, pCopyImageToBufferInfo );
2071 }
2072
2073
vkCmdBlitImage2(VkCommandBuffer commandBuffer,const VkBlitImageInfo2 * pBlitImageInfo) const2074 void vkCmdBlitImage2( VkCommandBuffer commandBuffer, const VkBlitImageInfo2 * pBlitImageInfo ) const VULKAN_HPP_NOEXCEPT
2075 {
2076 return ::vkCmdBlitImage2( commandBuffer, pBlitImageInfo );
2077 }
2078
2079
vkCmdResolveImage2(VkCommandBuffer commandBuffer,const VkResolveImageInfo2 * pResolveImageInfo) const2080 void vkCmdResolveImage2( VkCommandBuffer commandBuffer, const VkResolveImageInfo2 * pResolveImageInfo ) const VULKAN_HPP_NOEXCEPT
2081 {
2082 return ::vkCmdResolveImage2( commandBuffer, pResolveImageInfo );
2083 }
2084
2085
vkCmdBeginRendering(VkCommandBuffer commandBuffer,const VkRenderingInfo * pRenderingInfo) const2086 void vkCmdBeginRendering( VkCommandBuffer commandBuffer, const VkRenderingInfo * pRenderingInfo ) const VULKAN_HPP_NOEXCEPT
2087 {
2088 return ::vkCmdBeginRendering( commandBuffer, pRenderingInfo );
2089 }
2090
2091
vkCmdEndRendering(VkCommandBuffer commandBuffer) const2092 void vkCmdEndRendering( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
2093 {
2094 return ::vkCmdEndRendering( commandBuffer );
2095 }
2096
2097
vkCmdSetCullMode(VkCommandBuffer commandBuffer,VkCullModeFlags cullMode) const2098 void vkCmdSetCullMode( VkCommandBuffer commandBuffer, VkCullModeFlags cullMode ) const VULKAN_HPP_NOEXCEPT
2099 {
2100 return ::vkCmdSetCullMode( commandBuffer, cullMode );
2101 }
2102
2103
vkCmdSetFrontFace(VkCommandBuffer commandBuffer,VkFrontFace frontFace) const2104 void vkCmdSetFrontFace( VkCommandBuffer commandBuffer, VkFrontFace frontFace ) const VULKAN_HPP_NOEXCEPT
2105 {
2106 return ::vkCmdSetFrontFace( commandBuffer, frontFace );
2107 }
2108
2109
vkCmdSetPrimitiveTopology(VkCommandBuffer commandBuffer,VkPrimitiveTopology primitiveTopology) const2110 void vkCmdSetPrimitiveTopology( VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT
2111 {
2112 return ::vkCmdSetPrimitiveTopology( commandBuffer, primitiveTopology );
2113 }
2114
2115
vkCmdSetViewportWithCount(VkCommandBuffer commandBuffer,uint32_t viewportCount,const VkViewport * pViewports) const2116 void vkCmdSetViewportWithCount( VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport * pViewports ) const VULKAN_HPP_NOEXCEPT
2117 {
2118 return ::vkCmdSetViewportWithCount( commandBuffer, viewportCount, pViewports );
2119 }
2120
2121
vkCmdSetScissorWithCount(VkCommandBuffer commandBuffer,uint32_t scissorCount,const VkRect2D * pScissors) const2122 void vkCmdSetScissorWithCount( VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D * pScissors ) const VULKAN_HPP_NOEXCEPT
2123 {
2124 return ::vkCmdSetScissorWithCount( commandBuffer, scissorCount, pScissors );
2125 }
2126
2127
vkCmdBindVertexBuffers2(VkCommandBuffer commandBuffer,uint32_t firstBinding,uint32_t bindingCount,const VkBuffer * pBuffers,const VkDeviceSize * pOffsets,const VkDeviceSize * pSizes,const VkDeviceSize * pStrides) const2128 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
2129 {
2130 return ::vkCmdBindVertexBuffers2( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides );
2131 }
2132
2133
vkCmdSetDepthTestEnable(VkCommandBuffer commandBuffer,VkBool32 depthTestEnable) const2134 void vkCmdSetDepthTestEnable( VkCommandBuffer commandBuffer, VkBool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT
2135 {
2136 return ::vkCmdSetDepthTestEnable( commandBuffer, depthTestEnable );
2137 }
2138
2139
vkCmdSetDepthWriteEnable(VkCommandBuffer commandBuffer,VkBool32 depthWriteEnable) const2140 void vkCmdSetDepthWriteEnable( VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT
2141 {
2142 return ::vkCmdSetDepthWriteEnable( commandBuffer, depthWriteEnable );
2143 }
2144
2145
vkCmdSetDepthCompareOp(VkCommandBuffer commandBuffer,VkCompareOp depthCompareOp) const2146 void vkCmdSetDepthCompareOp( VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT
2147 {
2148 return ::vkCmdSetDepthCompareOp( commandBuffer, depthCompareOp );
2149 }
2150
2151
vkCmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer,VkBool32 depthBoundsTestEnable) const2152 void vkCmdSetDepthBoundsTestEnable( VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT
2153 {
2154 return ::vkCmdSetDepthBoundsTestEnable( commandBuffer, depthBoundsTestEnable );
2155 }
2156
2157
vkCmdSetStencilTestEnable(VkCommandBuffer commandBuffer,VkBool32 stencilTestEnable) const2158 void vkCmdSetStencilTestEnable( VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT
2159 {
2160 return ::vkCmdSetStencilTestEnable( commandBuffer, stencilTestEnable );
2161 }
2162
2163
vkCmdSetStencilOp(VkCommandBuffer commandBuffer,VkStencilFaceFlags faceMask,VkStencilOp failOp,VkStencilOp passOp,VkStencilOp depthFailOp,VkCompareOp compareOp) const2164 void vkCmdSetStencilOp( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp ) const VULKAN_HPP_NOEXCEPT
2165 {
2166 return ::vkCmdSetStencilOp( commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp );
2167 }
2168
2169
vkCmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer,VkBool32 rasterizerDiscardEnable) const2170 void vkCmdSetRasterizerDiscardEnable( VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT
2171 {
2172 return ::vkCmdSetRasterizerDiscardEnable( commandBuffer, rasterizerDiscardEnable );
2173 }
2174
2175
vkCmdSetDepthBiasEnable(VkCommandBuffer commandBuffer,VkBool32 depthBiasEnable) const2176 void vkCmdSetDepthBiasEnable( VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT
2177 {
2178 return ::vkCmdSetDepthBiasEnable( commandBuffer, depthBiasEnable );
2179 }
2180
2181
vkCmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer,VkBool32 primitiveRestartEnable) const2182 void vkCmdSetPrimitiveRestartEnable( VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT
2183 {
2184 return ::vkCmdSetPrimitiveRestartEnable( commandBuffer, primitiveRestartEnable );
2185 }
2186
2187
vkGetDeviceBufferMemoryRequirements(VkDevice device,const VkDeviceBufferMemoryRequirements * pInfo,VkMemoryRequirements2 * pMemoryRequirements) const2188 void vkGetDeviceBufferMemoryRequirements( VkDevice device, const VkDeviceBufferMemoryRequirements * pInfo, VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
2189 {
2190 return ::vkGetDeviceBufferMemoryRequirements( device, pInfo, pMemoryRequirements );
2191 }
2192
2193
vkGetDeviceImageMemoryRequirements(VkDevice device,const VkDeviceImageMemoryRequirements * pInfo,VkMemoryRequirements2 * pMemoryRequirements) const2194 void vkGetDeviceImageMemoryRequirements( VkDevice device, const VkDeviceImageMemoryRequirements * pInfo, VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
2195 {
2196 return ::vkGetDeviceImageMemoryRequirements( device, pInfo, pMemoryRequirements );
2197 }
2198
2199
vkGetDeviceImageSparseMemoryRequirements(VkDevice device,const VkDeviceImageMemoryRequirements * pInfo,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements) const2200 void vkGetDeviceImageSparseMemoryRequirements( VkDevice device, const VkDeviceImageMemoryRequirements * pInfo, uint32_t * pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
2201 {
2202 return ::vkGetDeviceImageSparseMemoryRequirements( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
2203 }
2204
2205 //=== VKSC_VERSION_1_0 ===
2206
2207
vkGetCommandPoolMemoryConsumption(VkDevice device,VkCommandPool commandPool,VkCommandBuffer commandBuffer,VkCommandPoolMemoryConsumption * pConsumption) const2208 void vkGetCommandPoolMemoryConsumption( VkDevice device, VkCommandPool commandPool, VkCommandBuffer commandBuffer, VkCommandPoolMemoryConsumption * pConsumption ) const VULKAN_HPP_NOEXCEPT
2209 {
2210 return ::vkGetCommandPoolMemoryConsumption( device, commandPool, commandBuffer, pConsumption );
2211 }
2212
2213
vkGetFaultData(VkDevice device,VkFaultQueryBehavior faultQueryBehavior,VkBool32 * pUnrecordedFaults,uint32_t * pFaultCount,VkFaultData * pFaults) const2214 VkResult vkGetFaultData( VkDevice device, VkFaultQueryBehavior faultQueryBehavior, VkBool32 * pUnrecordedFaults, uint32_t * pFaultCount, VkFaultData * pFaults ) const VULKAN_HPP_NOEXCEPT
2215 {
2216 return ::vkGetFaultData( device, faultQueryBehavior, pUnrecordedFaults, pFaultCount, pFaults );
2217 }
2218
2219 //=== VK_KHR_surface ===
2220
2221
vkDestroySurfaceKHR(VkInstance instance,VkSurfaceKHR surface,const VkAllocationCallbacks * pAllocator) const2222 void vkDestroySurfaceKHR( VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
2223 {
2224 return ::vkDestroySurfaceKHR( instance, surface, pAllocator );
2225 }
2226
2227
vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice,uint32_t queueFamilyIndex,VkSurfaceKHR surface,VkBool32 * pSupported) const2228 VkResult vkGetPhysicalDeviceSurfaceSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32 * pSupported ) const VULKAN_HPP_NOEXCEPT
2229 {
2230 return ::vkGetPhysicalDeviceSurfaceSupportKHR( physicalDevice, queueFamilyIndex, surface, pSupported );
2231 }
2232
2233
vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice,VkSurfaceKHR surface,VkSurfaceCapabilitiesKHR * pSurfaceCapabilities) const2234 VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR * pSurfaceCapabilities ) const VULKAN_HPP_NOEXCEPT
2235 {
2236 return ::vkGetPhysicalDeviceSurfaceCapabilitiesKHR( physicalDevice, surface, pSurfaceCapabilities );
2237 }
2238
2239
vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice,VkSurfaceKHR surface,uint32_t * pSurfaceFormatCount,VkSurfaceFormatKHR * pSurfaceFormats) const2240 VkResult vkGetPhysicalDeviceSurfaceFormatsKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t * pSurfaceFormatCount, VkSurfaceFormatKHR * pSurfaceFormats ) const VULKAN_HPP_NOEXCEPT
2241 {
2242 return ::vkGetPhysicalDeviceSurfaceFormatsKHR( physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats );
2243 }
2244
2245
vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice,VkSurfaceKHR surface,uint32_t * pPresentModeCount,VkPresentModeKHR * pPresentModes) const2246 VkResult vkGetPhysicalDeviceSurfacePresentModesKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t * pPresentModeCount, VkPresentModeKHR * pPresentModes ) const VULKAN_HPP_NOEXCEPT
2247 {
2248 return ::vkGetPhysicalDeviceSurfacePresentModesKHR( physicalDevice, surface, pPresentModeCount, pPresentModes );
2249 }
2250
2251 //=== VK_KHR_swapchain ===
2252
2253
vkCreateSwapchainKHR(VkDevice device,const VkSwapchainCreateInfoKHR * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSwapchainKHR * pSwapchain) const2254 VkResult vkCreateSwapchainKHR( VkDevice device, const VkSwapchainCreateInfoKHR * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkSwapchainKHR * pSwapchain ) const VULKAN_HPP_NOEXCEPT
2255 {
2256 return ::vkCreateSwapchainKHR( device, pCreateInfo, pAllocator, pSwapchain );
2257 }
2258
2259
vkGetSwapchainImagesKHR(VkDevice device,VkSwapchainKHR swapchain,uint32_t * pSwapchainImageCount,VkImage * pSwapchainImages) const2260 VkResult vkGetSwapchainImagesKHR( VkDevice device, VkSwapchainKHR swapchain, uint32_t * pSwapchainImageCount, VkImage * pSwapchainImages ) const VULKAN_HPP_NOEXCEPT
2261 {
2262 return ::vkGetSwapchainImagesKHR( device, swapchain, pSwapchainImageCount, pSwapchainImages );
2263 }
2264
2265
vkAcquireNextImageKHR(VkDevice device,VkSwapchainKHR swapchain,uint64_t timeout,VkSemaphore semaphore,VkFence fence,uint32_t * pImageIndex) const2266 VkResult vkAcquireNextImageKHR( VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t * pImageIndex ) const VULKAN_HPP_NOEXCEPT
2267 {
2268 return ::vkAcquireNextImageKHR( device, swapchain, timeout, semaphore, fence, pImageIndex );
2269 }
2270
2271
vkQueuePresentKHR(VkQueue queue,const VkPresentInfoKHR * pPresentInfo) const2272 VkResult vkQueuePresentKHR( VkQueue queue, const VkPresentInfoKHR * pPresentInfo ) const VULKAN_HPP_NOEXCEPT
2273 {
2274 return ::vkQueuePresentKHR( queue, pPresentInfo );
2275 }
2276
2277
vkGetDeviceGroupPresentCapabilitiesKHR(VkDevice device,VkDeviceGroupPresentCapabilitiesKHR * pDeviceGroupPresentCapabilities) const2278 VkResult vkGetDeviceGroupPresentCapabilitiesKHR( VkDevice device, VkDeviceGroupPresentCapabilitiesKHR * pDeviceGroupPresentCapabilities ) const VULKAN_HPP_NOEXCEPT
2279 {
2280 return ::vkGetDeviceGroupPresentCapabilitiesKHR( device, pDeviceGroupPresentCapabilities );
2281 }
2282
2283
vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device,VkSurfaceKHR surface,VkDeviceGroupPresentModeFlagsKHR * pModes) const2284 VkResult vkGetDeviceGroupSurfacePresentModesKHR( VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR * pModes ) const VULKAN_HPP_NOEXCEPT
2285 {
2286 return ::vkGetDeviceGroupSurfacePresentModesKHR( device, surface, pModes );
2287 }
2288
2289
vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice,VkSurfaceKHR surface,uint32_t * pRectCount,VkRect2D * pRects) const2290 VkResult vkGetPhysicalDevicePresentRectanglesKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t * pRectCount, VkRect2D * pRects ) const VULKAN_HPP_NOEXCEPT
2291 {
2292 return ::vkGetPhysicalDevicePresentRectanglesKHR( physicalDevice, surface, pRectCount, pRects );
2293 }
2294
2295
vkAcquireNextImage2KHR(VkDevice device,const VkAcquireNextImageInfoKHR * pAcquireInfo,uint32_t * pImageIndex) const2296 VkResult vkAcquireNextImage2KHR( VkDevice device, const VkAcquireNextImageInfoKHR * pAcquireInfo, uint32_t * pImageIndex ) const VULKAN_HPP_NOEXCEPT
2297 {
2298 return ::vkAcquireNextImage2KHR( device, pAcquireInfo, pImageIndex );
2299 }
2300
2301 //=== VK_KHR_display ===
2302
2303
vkGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkDisplayPropertiesKHR * pProperties) const2304 VkResult vkGetPhysicalDeviceDisplayPropertiesKHR( VkPhysicalDevice physicalDevice, uint32_t * pPropertyCount, VkDisplayPropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT
2305 {
2306 return ::vkGetPhysicalDeviceDisplayPropertiesKHR( physicalDevice, pPropertyCount, pProperties );
2307 }
2308
2309
vkGetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkDisplayPlanePropertiesKHR * pProperties) const2310 VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR( VkPhysicalDevice physicalDevice, uint32_t * pPropertyCount, VkDisplayPlanePropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT
2311 {
2312 return ::vkGetPhysicalDeviceDisplayPlanePropertiesKHR( physicalDevice, pPropertyCount, pProperties );
2313 }
2314
2315
vkGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice,uint32_t planeIndex,uint32_t * pDisplayCount,VkDisplayKHR * pDisplays) const2316 VkResult vkGetDisplayPlaneSupportedDisplaysKHR( VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t * pDisplayCount, VkDisplayKHR * pDisplays ) const VULKAN_HPP_NOEXCEPT
2317 {
2318 return ::vkGetDisplayPlaneSupportedDisplaysKHR( physicalDevice, planeIndex, pDisplayCount, pDisplays );
2319 }
2320
2321
vkGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice,VkDisplayKHR display,uint32_t * pPropertyCount,VkDisplayModePropertiesKHR * pProperties) const2322 VkResult vkGetDisplayModePropertiesKHR( VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t * pPropertyCount, VkDisplayModePropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT
2323 {
2324 return ::vkGetDisplayModePropertiesKHR( physicalDevice, display, pPropertyCount, pProperties );
2325 }
2326
2327
vkCreateDisplayModeKHR(VkPhysicalDevice physicalDevice,VkDisplayKHR display,const VkDisplayModeCreateInfoKHR * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDisplayModeKHR * pMode) const2328 VkResult vkCreateDisplayModeKHR( VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkDisplayModeKHR * pMode ) const VULKAN_HPP_NOEXCEPT
2329 {
2330 return ::vkCreateDisplayModeKHR( physicalDevice, display, pCreateInfo, pAllocator, pMode );
2331 }
2332
2333
vkGetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice,VkDisplayModeKHR mode,uint32_t planeIndex,VkDisplayPlaneCapabilitiesKHR * pCapabilities) const2334 VkResult vkGetDisplayPlaneCapabilitiesKHR( VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR * pCapabilities ) const VULKAN_HPP_NOEXCEPT
2335 {
2336 return ::vkGetDisplayPlaneCapabilitiesKHR( physicalDevice, mode, planeIndex, pCapabilities );
2337 }
2338
2339
vkCreateDisplayPlaneSurfaceKHR(VkInstance instance,const VkDisplaySurfaceCreateInfoKHR * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface) const2340 VkResult vkCreateDisplayPlaneSurfaceKHR( VkInstance instance, const VkDisplaySurfaceCreateInfoKHR * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
2341 {
2342 return ::vkCreateDisplayPlaneSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
2343 }
2344
2345 //=== VK_KHR_display_swapchain ===
2346
2347
vkCreateSharedSwapchainsKHR(VkDevice device,uint32_t swapchainCount,const VkSwapchainCreateInfoKHR * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkSwapchainKHR * pSwapchains) const2348 VkResult vkCreateSharedSwapchainsKHR( VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR * pCreateInfos, const VkAllocationCallbacks * pAllocator, VkSwapchainKHR * pSwapchains ) const VULKAN_HPP_NOEXCEPT
2349 {
2350 return ::vkCreateSharedSwapchainsKHR( device, swapchainCount, pCreateInfos, pAllocator, pSwapchains );
2351 }
2352
2353 //=== VK_KHR_external_memory_fd ===
2354
2355
vkGetMemoryFdKHR(VkDevice device,const VkMemoryGetFdInfoKHR * pGetFdInfo,int * pFd) const2356 VkResult vkGetMemoryFdKHR( VkDevice device, const VkMemoryGetFdInfoKHR * pGetFdInfo, int * pFd ) const VULKAN_HPP_NOEXCEPT
2357 {
2358 return ::vkGetMemoryFdKHR( device, pGetFdInfo, pFd );
2359 }
2360
2361
vkGetMemoryFdPropertiesKHR(VkDevice device,VkExternalMemoryHandleTypeFlagBits handleType,int fd,VkMemoryFdPropertiesKHR * pMemoryFdProperties) const2362 VkResult vkGetMemoryFdPropertiesKHR( VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR * pMemoryFdProperties ) const VULKAN_HPP_NOEXCEPT
2363 {
2364 return ::vkGetMemoryFdPropertiesKHR( device, handleType, fd, pMemoryFdProperties );
2365 }
2366
2367 //=== VK_KHR_external_semaphore_fd ===
2368
2369
vkImportSemaphoreFdKHR(VkDevice device,const VkImportSemaphoreFdInfoKHR * pImportSemaphoreFdInfo) const2370 VkResult vkImportSemaphoreFdKHR( VkDevice device, const VkImportSemaphoreFdInfoKHR * pImportSemaphoreFdInfo ) const VULKAN_HPP_NOEXCEPT
2371 {
2372 return ::vkImportSemaphoreFdKHR( device, pImportSemaphoreFdInfo );
2373 }
2374
2375
vkGetSemaphoreFdKHR(VkDevice device,const VkSemaphoreGetFdInfoKHR * pGetFdInfo,int * pFd) const2376 VkResult vkGetSemaphoreFdKHR( VkDevice device, const VkSemaphoreGetFdInfoKHR * pGetFdInfo, int * pFd ) const VULKAN_HPP_NOEXCEPT
2377 {
2378 return ::vkGetSemaphoreFdKHR( device, pGetFdInfo, pFd );
2379 }
2380
2381 //=== VK_EXT_direct_mode_display ===
2382
2383
vkReleaseDisplayEXT(VkPhysicalDevice physicalDevice,VkDisplayKHR display) const2384 VkResult vkReleaseDisplayEXT( VkPhysicalDevice physicalDevice, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT
2385 {
2386 return ::vkReleaseDisplayEXT( physicalDevice, display );
2387 }
2388
2389 //=== VK_EXT_display_surface_counter ===
2390
2391
vkGetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice,VkSurfaceKHR surface,VkSurfaceCapabilities2EXT * pSurfaceCapabilities) const2392 VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT * pSurfaceCapabilities ) const VULKAN_HPP_NOEXCEPT
2393 {
2394 return ::vkGetPhysicalDeviceSurfaceCapabilities2EXT( physicalDevice, surface, pSurfaceCapabilities );
2395 }
2396
2397 //=== VK_EXT_display_control ===
2398
2399
vkDisplayPowerControlEXT(VkDevice device,VkDisplayKHR display,const VkDisplayPowerInfoEXT * pDisplayPowerInfo) const2400 VkResult vkDisplayPowerControlEXT( VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT * pDisplayPowerInfo ) const VULKAN_HPP_NOEXCEPT
2401 {
2402 return ::vkDisplayPowerControlEXT( device, display, pDisplayPowerInfo );
2403 }
2404
2405
vkRegisterDeviceEventEXT(VkDevice device,const VkDeviceEventInfoEXT * pDeviceEventInfo,const VkAllocationCallbacks * pAllocator,VkFence * pFence) const2406 VkResult vkRegisterDeviceEventEXT( VkDevice device, const VkDeviceEventInfoEXT * pDeviceEventInfo, const VkAllocationCallbacks * pAllocator, VkFence * pFence ) const VULKAN_HPP_NOEXCEPT
2407 {
2408 return ::vkRegisterDeviceEventEXT( device, pDeviceEventInfo, pAllocator, pFence );
2409 }
2410
2411
vkRegisterDisplayEventEXT(VkDevice device,VkDisplayKHR display,const VkDisplayEventInfoEXT * pDisplayEventInfo,const VkAllocationCallbacks * pAllocator,VkFence * pFence) const2412 VkResult vkRegisterDisplayEventEXT( VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT * pDisplayEventInfo, const VkAllocationCallbacks * pAllocator, VkFence * pFence ) const VULKAN_HPP_NOEXCEPT
2413 {
2414 return ::vkRegisterDisplayEventEXT( device, display, pDisplayEventInfo, pAllocator, pFence );
2415 }
2416
2417
vkGetSwapchainCounterEXT(VkDevice device,VkSwapchainKHR swapchain,VkSurfaceCounterFlagBitsEXT counter,uint64_t * pCounterValue) const2418 VkResult vkGetSwapchainCounterEXT( VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t * pCounterValue ) const VULKAN_HPP_NOEXCEPT
2419 {
2420 return ::vkGetSwapchainCounterEXT( device, swapchain, counter, pCounterValue );
2421 }
2422
2423 //=== VK_EXT_discard_rectangles ===
2424
2425
vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer,uint32_t firstDiscardRectangle,uint32_t discardRectangleCount,const VkRect2D * pDiscardRectangles) const2426 void vkCmdSetDiscardRectangleEXT( VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D * pDiscardRectangles ) const VULKAN_HPP_NOEXCEPT
2427 {
2428 return ::vkCmdSetDiscardRectangleEXT( commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles );
2429 }
2430
2431
vkCmdSetDiscardRectangleEnableEXT(VkCommandBuffer commandBuffer,VkBool32 discardRectangleEnable) const2432 void vkCmdSetDiscardRectangleEnableEXT( VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable ) const VULKAN_HPP_NOEXCEPT
2433 {
2434 return ::vkCmdSetDiscardRectangleEnableEXT( commandBuffer, discardRectangleEnable );
2435 }
2436
2437
vkCmdSetDiscardRectangleModeEXT(VkCommandBuffer commandBuffer,VkDiscardRectangleModeEXT discardRectangleMode) const2438 void vkCmdSetDiscardRectangleModeEXT( VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode ) const VULKAN_HPP_NOEXCEPT
2439 {
2440 return ::vkCmdSetDiscardRectangleModeEXT( commandBuffer, discardRectangleMode );
2441 }
2442
2443 //=== VK_EXT_hdr_metadata ===
2444
2445
vkSetHdrMetadataEXT(VkDevice device,uint32_t swapchainCount,const VkSwapchainKHR * pSwapchains,const VkHdrMetadataEXT * pMetadata) const2446 void vkSetHdrMetadataEXT( VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR * pSwapchains, const VkHdrMetadataEXT * pMetadata ) const VULKAN_HPP_NOEXCEPT
2447 {
2448 return ::vkSetHdrMetadataEXT( device, swapchainCount, pSwapchains, pMetadata );
2449 }
2450
2451 //=== VK_KHR_shared_presentable_image ===
2452
2453
vkGetSwapchainStatusKHR(VkDevice device,VkSwapchainKHR swapchain) const2454 VkResult vkGetSwapchainStatusKHR( VkDevice device, VkSwapchainKHR swapchain ) const VULKAN_HPP_NOEXCEPT
2455 {
2456 return ::vkGetSwapchainStatusKHR( device, swapchain );
2457 }
2458
2459 //=== VK_KHR_external_fence_fd ===
2460
2461
vkImportFenceFdKHR(VkDevice device,const VkImportFenceFdInfoKHR * pImportFenceFdInfo) const2462 VkResult vkImportFenceFdKHR( VkDevice device, const VkImportFenceFdInfoKHR * pImportFenceFdInfo ) const VULKAN_HPP_NOEXCEPT
2463 {
2464 return ::vkImportFenceFdKHR( device, pImportFenceFdInfo );
2465 }
2466
2467
vkGetFenceFdKHR(VkDevice device,const VkFenceGetFdInfoKHR * pGetFdInfo,int * pFd) const2468 VkResult vkGetFenceFdKHR( VkDevice device, const VkFenceGetFdInfoKHR * pGetFdInfo, int * pFd ) const VULKAN_HPP_NOEXCEPT
2469 {
2470 return ::vkGetFenceFdKHR( device, pGetFdInfo, pFd );
2471 }
2472
2473 //=== VK_KHR_performance_query ===
2474
2475
vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(VkPhysicalDevice physicalDevice,uint32_t queueFamilyIndex,uint32_t * pCounterCount,VkPerformanceCounterKHR * pCounters,VkPerformanceCounterDescriptionKHR * pCounterDescriptions) const2476 VkResult vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t * pCounterCount, VkPerformanceCounterKHR * pCounters, VkPerformanceCounterDescriptionKHR * pCounterDescriptions ) const VULKAN_HPP_NOEXCEPT
2477 {
2478 return ::vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions );
2479 }
2480
2481
vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(VkPhysicalDevice physicalDevice,const VkQueryPoolPerformanceCreateInfoKHR * pPerformanceQueryCreateInfo,uint32_t * pNumPasses) const2482 void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR * pPerformanceQueryCreateInfo, uint32_t * pNumPasses ) const VULKAN_HPP_NOEXCEPT
2483 {
2484 return ::vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( physicalDevice, pPerformanceQueryCreateInfo, pNumPasses );
2485 }
2486
2487
vkAcquireProfilingLockKHR(VkDevice device,const VkAcquireProfilingLockInfoKHR * pInfo) const2488 VkResult vkAcquireProfilingLockKHR( VkDevice device, const VkAcquireProfilingLockInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
2489 {
2490 return ::vkAcquireProfilingLockKHR( device, pInfo );
2491 }
2492
2493
vkReleaseProfilingLockKHR(VkDevice device) const2494 void vkReleaseProfilingLockKHR( VkDevice device ) const VULKAN_HPP_NOEXCEPT
2495 {
2496 return ::vkReleaseProfilingLockKHR( device );
2497 }
2498
2499 //=== VK_KHR_get_surface_capabilities2 ===
2500
2501
vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,VkSurfaceCapabilities2KHR * pSurfaceCapabilities) const2502 VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, VkSurfaceCapabilities2KHR * pSurfaceCapabilities ) const VULKAN_HPP_NOEXCEPT
2503 {
2504 return ::vkGetPhysicalDeviceSurfaceCapabilities2KHR( physicalDevice, pSurfaceInfo, pSurfaceCapabilities );
2505 }
2506
2507
vkGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,uint32_t * pSurfaceFormatCount,VkSurfaceFormat2KHR * pSurfaceFormats) const2508 VkResult vkGetPhysicalDeviceSurfaceFormats2KHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, uint32_t * pSurfaceFormatCount, VkSurfaceFormat2KHR * pSurfaceFormats ) const VULKAN_HPP_NOEXCEPT
2509 {
2510 return ::vkGetPhysicalDeviceSurfaceFormats2KHR( physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats );
2511 }
2512
2513 //=== VK_KHR_get_display_properties2 ===
2514
2515
vkGetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkDisplayProperties2KHR * pProperties) const2516 VkResult vkGetPhysicalDeviceDisplayProperties2KHR( VkPhysicalDevice physicalDevice, uint32_t * pPropertyCount, VkDisplayProperties2KHR * pProperties ) const VULKAN_HPP_NOEXCEPT
2517 {
2518 return ::vkGetPhysicalDeviceDisplayProperties2KHR( physicalDevice, pPropertyCount, pProperties );
2519 }
2520
2521
vkGetPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkDisplayPlaneProperties2KHR * pProperties) const2522 VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR( VkPhysicalDevice physicalDevice, uint32_t * pPropertyCount, VkDisplayPlaneProperties2KHR * pProperties ) const VULKAN_HPP_NOEXCEPT
2523 {
2524 return ::vkGetPhysicalDeviceDisplayPlaneProperties2KHR( physicalDevice, pPropertyCount, pProperties );
2525 }
2526
2527
vkGetDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice,VkDisplayKHR display,uint32_t * pPropertyCount,VkDisplayModeProperties2KHR * pProperties) const2528 VkResult vkGetDisplayModeProperties2KHR( VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t * pPropertyCount, VkDisplayModeProperties2KHR * pProperties ) const VULKAN_HPP_NOEXCEPT
2529 {
2530 return ::vkGetDisplayModeProperties2KHR( physicalDevice, display, pPropertyCount, pProperties );
2531 }
2532
2533
vkGetDisplayPlaneCapabilities2KHR(VkPhysicalDevice physicalDevice,const VkDisplayPlaneInfo2KHR * pDisplayPlaneInfo,VkDisplayPlaneCapabilities2KHR * pCapabilities) const2534 VkResult vkGetDisplayPlaneCapabilities2KHR( VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR * pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR * pCapabilities ) const VULKAN_HPP_NOEXCEPT
2535 {
2536 return ::vkGetDisplayPlaneCapabilities2KHR( physicalDevice, pDisplayPlaneInfo, pCapabilities );
2537 }
2538
2539 //=== VK_EXT_debug_utils ===
2540
2541
vkSetDebugUtilsObjectNameEXT(VkDevice device,const VkDebugUtilsObjectNameInfoEXT * pNameInfo) const2542 VkResult vkSetDebugUtilsObjectNameEXT( VkDevice device, const VkDebugUtilsObjectNameInfoEXT * pNameInfo ) const VULKAN_HPP_NOEXCEPT
2543 {
2544 return ::vkSetDebugUtilsObjectNameEXT( device, pNameInfo );
2545 }
2546
2547
vkSetDebugUtilsObjectTagEXT(VkDevice device,const VkDebugUtilsObjectTagInfoEXT * pTagInfo) const2548 VkResult vkSetDebugUtilsObjectTagEXT( VkDevice device, const VkDebugUtilsObjectTagInfoEXT * pTagInfo ) const VULKAN_HPP_NOEXCEPT
2549 {
2550 return ::vkSetDebugUtilsObjectTagEXT( device, pTagInfo );
2551 }
2552
2553
vkQueueBeginDebugUtilsLabelEXT(VkQueue queue,const VkDebugUtilsLabelEXT * pLabelInfo) const2554 void vkQueueBeginDebugUtilsLabelEXT( VkQueue queue, const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT
2555 {
2556 return ::vkQueueBeginDebugUtilsLabelEXT( queue, pLabelInfo );
2557 }
2558
2559
vkQueueEndDebugUtilsLabelEXT(VkQueue queue) const2560 void vkQueueEndDebugUtilsLabelEXT( VkQueue queue ) const VULKAN_HPP_NOEXCEPT
2561 {
2562 return ::vkQueueEndDebugUtilsLabelEXT( queue );
2563 }
2564
2565
vkQueueInsertDebugUtilsLabelEXT(VkQueue queue,const VkDebugUtilsLabelEXT * pLabelInfo) const2566 void vkQueueInsertDebugUtilsLabelEXT( VkQueue queue, const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT
2567 {
2568 return ::vkQueueInsertDebugUtilsLabelEXT( queue, pLabelInfo );
2569 }
2570
2571
vkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer,const VkDebugUtilsLabelEXT * pLabelInfo) const2572 void vkCmdBeginDebugUtilsLabelEXT( VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT
2573 {
2574 return ::vkCmdBeginDebugUtilsLabelEXT( commandBuffer, pLabelInfo );
2575 }
2576
2577
vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer) const2578 void vkCmdEndDebugUtilsLabelEXT( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
2579 {
2580 return ::vkCmdEndDebugUtilsLabelEXT( commandBuffer );
2581 }
2582
2583
vkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer,const VkDebugUtilsLabelEXT * pLabelInfo) const2584 void vkCmdInsertDebugUtilsLabelEXT( VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT
2585 {
2586 return ::vkCmdInsertDebugUtilsLabelEXT( commandBuffer, pLabelInfo );
2587 }
2588
2589
vkCreateDebugUtilsMessengerEXT(VkInstance instance,const VkDebugUtilsMessengerCreateInfoEXT * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDebugUtilsMessengerEXT * pMessenger) const2590 VkResult vkCreateDebugUtilsMessengerEXT( VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkDebugUtilsMessengerEXT * pMessenger ) const VULKAN_HPP_NOEXCEPT
2591 {
2592 return ::vkCreateDebugUtilsMessengerEXT( instance, pCreateInfo, pAllocator, pMessenger );
2593 }
2594
2595
vkDestroyDebugUtilsMessengerEXT(VkInstance instance,VkDebugUtilsMessengerEXT messenger,const VkAllocationCallbacks * pAllocator) const2596 void vkDestroyDebugUtilsMessengerEXT( VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
2597 {
2598 return ::vkDestroyDebugUtilsMessengerEXT( instance, messenger, pAllocator );
2599 }
2600
2601
vkSubmitDebugUtilsMessageEXT(VkInstance instance,VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,VkDebugUtilsMessageTypeFlagsEXT messageTypes,const VkDebugUtilsMessengerCallbackDataEXT * pCallbackData) const2602 void vkSubmitDebugUtilsMessageEXT( VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT * pCallbackData ) const VULKAN_HPP_NOEXCEPT
2603 {
2604 return ::vkSubmitDebugUtilsMessageEXT( instance, messageSeverity, messageTypes, pCallbackData );
2605 }
2606
2607 //=== VK_EXT_sample_locations ===
2608
2609
vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer,const VkSampleLocationsInfoEXT * pSampleLocationsInfo) const2610 void vkCmdSetSampleLocationsEXT( VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT * pSampleLocationsInfo ) const VULKAN_HPP_NOEXCEPT
2611 {
2612 return ::vkCmdSetSampleLocationsEXT( commandBuffer, pSampleLocationsInfo );
2613 }
2614
2615
vkGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice,VkSampleCountFlagBits samples,VkMultisamplePropertiesEXT * pMultisampleProperties) const2616 void vkGetPhysicalDeviceMultisamplePropertiesEXT( VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT * pMultisampleProperties ) const VULKAN_HPP_NOEXCEPT
2617 {
2618 return ::vkGetPhysicalDeviceMultisamplePropertiesEXT( physicalDevice, samples, pMultisampleProperties );
2619 }
2620
2621 //=== VK_EXT_image_drm_format_modifier ===
2622
2623
vkGetImageDrmFormatModifierPropertiesEXT(VkDevice device,VkImage image,VkImageDrmFormatModifierPropertiesEXT * pProperties) const2624 VkResult vkGetImageDrmFormatModifierPropertiesEXT( VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT * pProperties ) const VULKAN_HPP_NOEXCEPT
2625 {
2626 return ::vkGetImageDrmFormatModifierPropertiesEXT( device, image, pProperties );
2627 }
2628
2629 //=== VK_EXT_external_memory_host ===
2630
2631
vkGetMemoryHostPointerPropertiesEXT(VkDevice device,VkExternalMemoryHandleTypeFlagBits handleType,const void * pHostPointer,VkMemoryHostPointerPropertiesEXT * pMemoryHostPointerProperties) const2632 VkResult vkGetMemoryHostPointerPropertiesEXT( VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void * pHostPointer, VkMemoryHostPointerPropertiesEXT * pMemoryHostPointerProperties ) const VULKAN_HPP_NOEXCEPT
2633 {
2634 return ::vkGetMemoryHostPointerPropertiesEXT( device, handleType, pHostPointer, pMemoryHostPointerProperties );
2635 }
2636
2637 //=== VK_EXT_calibrated_timestamps ===
2638
2639
vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice,uint32_t * pTimeDomainCount,VkTimeDomainEXT * pTimeDomains) const2640 VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( VkPhysicalDevice physicalDevice, uint32_t * pTimeDomainCount, VkTimeDomainEXT * pTimeDomains ) const VULKAN_HPP_NOEXCEPT
2641 {
2642 return ::vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( physicalDevice, pTimeDomainCount, pTimeDomains );
2643 }
2644
2645
vkGetCalibratedTimestampsEXT(VkDevice device,uint32_t timestampCount,const VkCalibratedTimestampInfoEXT * pTimestampInfos,uint64_t * pTimestamps,uint64_t * pMaxDeviation) const2646 VkResult vkGetCalibratedTimestampsEXT( VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT * pTimestampInfos, uint64_t * pTimestamps, uint64_t * pMaxDeviation ) const VULKAN_HPP_NOEXCEPT
2647 {
2648 return ::vkGetCalibratedTimestampsEXT( device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation );
2649 }
2650
2651 //=== VK_KHR_fragment_shading_rate ===
2652
2653
vkGetPhysicalDeviceFragmentShadingRatesKHR(VkPhysicalDevice physicalDevice,uint32_t * pFragmentShadingRateCount,VkPhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates) const2654 VkResult vkGetPhysicalDeviceFragmentShadingRatesKHR( VkPhysicalDevice physicalDevice, uint32_t * pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates ) const VULKAN_HPP_NOEXCEPT
2655 {
2656 return ::vkGetPhysicalDeviceFragmentShadingRatesKHR( physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates );
2657 }
2658
2659
vkCmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer,const VkExtent2D * pFragmentSize,const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) const2660 void vkCmdSetFragmentShadingRateKHR( VkCommandBuffer commandBuffer, const VkExtent2D * pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT
2661 {
2662 return ::vkCmdSetFragmentShadingRateKHR( commandBuffer, pFragmentSize, combinerOps );
2663 }
2664
2665 //=== VK_EXT_headless_surface ===
2666
2667
vkCreateHeadlessSurfaceEXT(VkInstance instance,const VkHeadlessSurfaceCreateInfoEXT * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface) const2668 VkResult vkCreateHeadlessSurfaceEXT( VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
2669 {
2670 return ::vkCreateHeadlessSurfaceEXT( instance, pCreateInfo, pAllocator, pSurface );
2671 }
2672
2673 //=== VK_EXT_line_rasterization ===
2674
2675
vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer,uint32_t lineStippleFactor,uint16_t lineStipplePattern) const2676 void vkCmdSetLineStippleEXT( VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT
2677 {
2678 return ::vkCmdSetLineStippleEXT( commandBuffer, lineStippleFactor, lineStipplePattern );
2679 }
2680
2681 //=== VK_EXT_extended_dynamic_state ===
2682
2683
vkCmdSetCullModeEXT(VkCommandBuffer commandBuffer,VkCullModeFlags cullMode) const2684 void vkCmdSetCullModeEXT( VkCommandBuffer commandBuffer, VkCullModeFlags cullMode ) const VULKAN_HPP_NOEXCEPT
2685 {
2686 return ::vkCmdSetCullModeEXT( commandBuffer, cullMode );
2687 }
2688
2689
vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer,VkFrontFace frontFace) const2690 void vkCmdSetFrontFaceEXT( VkCommandBuffer commandBuffer, VkFrontFace frontFace ) const VULKAN_HPP_NOEXCEPT
2691 {
2692 return ::vkCmdSetFrontFaceEXT( commandBuffer, frontFace );
2693 }
2694
2695
vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer,VkPrimitiveTopology primitiveTopology) const2696 void vkCmdSetPrimitiveTopologyEXT( VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT
2697 {
2698 return ::vkCmdSetPrimitiveTopologyEXT( commandBuffer, primitiveTopology );
2699 }
2700
2701
vkCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer,uint32_t viewportCount,const VkViewport * pViewports) const2702 void vkCmdSetViewportWithCountEXT( VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport * pViewports ) const VULKAN_HPP_NOEXCEPT
2703 {
2704 return ::vkCmdSetViewportWithCountEXT( commandBuffer, viewportCount, pViewports );
2705 }
2706
2707
vkCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer,uint32_t scissorCount,const VkRect2D * pScissors) const2708 void vkCmdSetScissorWithCountEXT( VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D * pScissors ) const VULKAN_HPP_NOEXCEPT
2709 {
2710 return ::vkCmdSetScissorWithCountEXT( commandBuffer, scissorCount, pScissors );
2711 }
2712
2713
vkCmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer,uint32_t firstBinding,uint32_t bindingCount,const VkBuffer * pBuffers,const VkDeviceSize * pOffsets,const VkDeviceSize * pSizes,const VkDeviceSize * pStrides) const2714 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
2715 {
2716 return ::vkCmdBindVertexBuffers2EXT( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides );
2717 }
2718
2719
vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer,VkBool32 depthTestEnable) const2720 void vkCmdSetDepthTestEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT
2721 {
2722 return ::vkCmdSetDepthTestEnableEXT( commandBuffer, depthTestEnable );
2723 }
2724
2725
vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer,VkBool32 depthWriteEnable) const2726 void vkCmdSetDepthWriteEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT
2727 {
2728 return ::vkCmdSetDepthWriteEnableEXT( commandBuffer, depthWriteEnable );
2729 }
2730
2731
vkCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer,VkCompareOp depthCompareOp) const2732 void vkCmdSetDepthCompareOpEXT( VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT
2733 {
2734 return ::vkCmdSetDepthCompareOpEXT( commandBuffer, depthCompareOp );
2735 }
2736
2737
vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer,VkBool32 depthBoundsTestEnable) const2738 void vkCmdSetDepthBoundsTestEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT
2739 {
2740 return ::vkCmdSetDepthBoundsTestEnableEXT( commandBuffer, depthBoundsTestEnable );
2741 }
2742
2743
vkCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer,VkBool32 stencilTestEnable) const2744 void vkCmdSetStencilTestEnableEXT( VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT
2745 {
2746 return ::vkCmdSetStencilTestEnableEXT( commandBuffer, stencilTestEnable );
2747 }
2748
2749
vkCmdSetStencilOpEXT(VkCommandBuffer commandBuffer,VkStencilFaceFlags faceMask,VkStencilOp failOp,VkStencilOp passOp,VkStencilOp depthFailOp,VkCompareOp compareOp) const2750 void vkCmdSetStencilOpEXT( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp ) const VULKAN_HPP_NOEXCEPT
2751 {
2752 return ::vkCmdSetStencilOpEXT( commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp );
2753 }
2754
2755 //=== VK_KHR_object_refresh ===
2756
2757
vkCmdRefreshObjectsKHR(VkCommandBuffer commandBuffer,const VkRefreshObjectListKHR * pRefreshObjects) const2758 void vkCmdRefreshObjectsKHR( VkCommandBuffer commandBuffer, const VkRefreshObjectListKHR * pRefreshObjects ) const VULKAN_HPP_NOEXCEPT
2759 {
2760 return ::vkCmdRefreshObjectsKHR( commandBuffer, pRefreshObjects );
2761 }
2762
2763
vkGetPhysicalDeviceRefreshableObjectTypesKHR(VkPhysicalDevice physicalDevice,uint32_t * pRefreshableObjectTypeCount,VkObjectType * pRefreshableObjectTypes) const2764 VkResult vkGetPhysicalDeviceRefreshableObjectTypesKHR( VkPhysicalDevice physicalDevice, uint32_t * pRefreshableObjectTypeCount, VkObjectType * pRefreshableObjectTypes ) const VULKAN_HPP_NOEXCEPT
2765 {
2766 return ::vkGetPhysicalDeviceRefreshableObjectTypesKHR( physicalDevice, pRefreshableObjectTypeCount, pRefreshableObjectTypes );
2767 }
2768
2769 //=== VK_KHR_synchronization2 ===
2770
2771
vkCmdSetEvent2KHR(VkCommandBuffer commandBuffer,VkEvent event,const VkDependencyInfo * pDependencyInfo) const2772 void vkCmdSetEvent2KHR( VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT
2773 {
2774 return ::vkCmdSetEvent2KHR( commandBuffer, event, pDependencyInfo );
2775 }
2776
2777
vkCmdResetEvent2KHR(VkCommandBuffer commandBuffer,VkEvent event,VkPipelineStageFlags2 stageMask) const2778 void vkCmdResetEvent2KHR( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask ) const VULKAN_HPP_NOEXCEPT
2779 {
2780 return ::vkCmdResetEvent2KHR( commandBuffer, event, stageMask );
2781 }
2782
2783
vkCmdWaitEvents2KHR(VkCommandBuffer commandBuffer,uint32_t eventCount,const VkEvent * pEvents,const VkDependencyInfo * pDependencyInfos) const2784 void vkCmdWaitEvents2KHR( VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent * pEvents, const VkDependencyInfo * pDependencyInfos ) const VULKAN_HPP_NOEXCEPT
2785 {
2786 return ::vkCmdWaitEvents2KHR( commandBuffer, eventCount, pEvents, pDependencyInfos );
2787 }
2788
2789
vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer,const VkDependencyInfo * pDependencyInfo) const2790 void vkCmdPipelineBarrier2KHR( VkCommandBuffer commandBuffer, const VkDependencyInfo * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT
2791 {
2792 return ::vkCmdPipelineBarrier2KHR( commandBuffer, pDependencyInfo );
2793 }
2794
2795
vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer,VkPipelineStageFlags2 stage,VkQueryPool queryPool,uint32_t query) const2796 void vkCmdWriteTimestamp2KHR( VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT
2797 {
2798 return ::vkCmdWriteTimestamp2KHR( commandBuffer, stage, queryPool, query );
2799 }
2800
2801
vkQueueSubmit2KHR(VkQueue queue,uint32_t submitCount,const VkSubmitInfo2 * pSubmits,VkFence fence) const2802 VkResult vkQueueSubmit2KHR( VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 * pSubmits, VkFence fence ) const VULKAN_HPP_NOEXCEPT
2803 {
2804 return ::vkQueueSubmit2KHR( queue, submitCount, pSubmits, fence );
2805 }
2806
2807
vkCmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer,VkPipelineStageFlags2 stage,VkBuffer dstBuffer,VkDeviceSize dstOffset,uint32_t marker) const2808 void vkCmdWriteBufferMarker2AMD( VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker ) const VULKAN_HPP_NOEXCEPT
2809 {
2810 return ::vkCmdWriteBufferMarker2AMD( commandBuffer, stage, dstBuffer, dstOffset, marker );
2811 }
2812
2813
vkGetQueueCheckpointData2NV(VkQueue queue,uint32_t * pCheckpointDataCount,VkCheckpointData2NV * pCheckpointData) const2814 void vkGetQueueCheckpointData2NV( VkQueue queue, uint32_t * pCheckpointDataCount, VkCheckpointData2NV * pCheckpointData ) const VULKAN_HPP_NOEXCEPT
2815 {
2816 return ::vkGetQueueCheckpointData2NV( queue, pCheckpointDataCount, pCheckpointData );
2817 }
2818
2819 //=== VK_KHR_copy_commands2 ===
2820
2821
vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer,const VkCopyBufferInfo2 * pCopyBufferInfo) const2822 void vkCmdCopyBuffer2KHR( VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 * pCopyBufferInfo ) const VULKAN_HPP_NOEXCEPT
2823 {
2824 return ::vkCmdCopyBuffer2KHR( commandBuffer, pCopyBufferInfo );
2825 }
2826
2827
vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer,const VkCopyImageInfo2 * pCopyImageInfo) const2828 void vkCmdCopyImage2KHR( VkCommandBuffer commandBuffer, const VkCopyImageInfo2 * pCopyImageInfo ) const VULKAN_HPP_NOEXCEPT
2829 {
2830 return ::vkCmdCopyImage2KHR( commandBuffer, pCopyImageInfo );
2831 }
2832
2833
vkCmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer,const VkCopyBufferToImageInfo2 * pCopyBufferToImageInfo) const2834 void vkCmdCopyBufferToImage2KHR( VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 * pCopyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT
2835 {
2836 return ::vkCmdCopyBufferToImage2KHR( commandBuffer, pCopyBufferToImageInfo );
2837 }
2838
2839
vkCmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer,const VkCopyImageToBufferInfo2 * pCopyImageToBufferInfo) const2840 void vkCmdCopyImageToBuffer2KHR( VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 * pCopyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT
2841 {
2842 return ::vkCmdCopyImageToBuffer2KHR( commandBuffer, pCopyImageToBufferInfo );
2843 }
2844
2845
vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer,const VkBlitImageInfo2 * pBlitImageInfo) const2846 void vkCmdBlitImage2KHR( VkCommandBuffer commandBuffer, const VkBlitImageInfo2 * pBlitImageInfo ) const VULKAN_HPP_NOEXCEPT
2847 {
2848 return ::vkCmdBlitImage2KHR( commandBuffer, pBlitImageInfo );
2849 }
2850
2851
vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer,const VkResolveImageInfo2 * pResolveImageInfo) const2852 void vkCmdResolveImage2KHR( VkCommandBuffer commandBuffer, const VkResolveImageInfo2 * pResolveImageInfo ) const VULKAN_HPP_NOEXCEPT
2853 {
2854 return ::vkCmdResolveImage2KHR( commandBuffer, pResolveImageInfo );
2855 }
2856
2857 //=== VK_EXT_vertex_input_dynamic_state ===
2858
2859
vkCmdSetVertexInputEXT(VkCommandBuffer commandBuffer,uint32_t vertexBindingDescriptionCount,const VkVertexInputBindingDescription2EXT * pVertexBindingDescriptions,uint32_t vertexAttributeDescriptionCount,const VkVertexInputAttributeDescription2EXT * pVertexAttributeDescriptions) const2860 void vkCmdSetVertexInputEXT( VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT * pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT * pVertexAttributeDescriptions ) const VULKAN_HPP_NOEXCEPT
2861 {
2862 return ::vkCmdSetVertexInputEXT( commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions );
2863 }
2864
2865 #if defined( VK_USE_PLATFORM_SCI )
2866 //=== VK_NV_external_sci_sync ===
2867
2868
vkGetFenceSciSyncFenceNV(VkDevice device,const VkFenceGetSciSyncInfoNV * pGetSciSyncHandleInfo,void * pHandle) const2869 VkResult vkGetFenceSciSyncFenceNV( VkDevice device, const VkFenceGetSciSyncInfoNV * pGetSciSyncHandleInfo, void * pHandle ) const VULKAN_HPP_NOEXCEPT
2870 {
2871 return ::vkGetFenceSciSyncFenceNV( device, pGetSciSyncHandleInfo, pHandle );
2872 }
2873
2874
vkGetFenceSciSyncObjNV(VkDevice device,const VkFenceGetSciSyncInfoNV * pGetSciSyncHandleInfo,void * pHandle) const2875 VkResult vkGetFenceSciSyncObjNV( VkDevice device, const VkFenceGetSciSyncInfoNV * pGetSciSyncHandleInfo, void * pHandle ) const VULKAN_HPP_NOEXCEPT
2876 {
2877 return ::vkGetFenceSciSyncObjNV( device, pGetSciSyncHandleInfo, pHandle );
2878 }
2879
2880
vkImportFenceSciSyncFenceNV(VkDevice device,const VkImportFenceSciSyncInfoNV * pImportFenceSciSyncInfo) const2881 VkResult vkImportFenceSciSyncFenceNV( VkDevice device, const VkImportFenceSciSyncInfoNV * pImportFenceSciSyncInfo ) const VULKAN_HPP_NOEXCEPT
2882 {
2883 return ::vkImportFenceSciSyncFenceNV( device, pImportFenceSciSyncInfo );
2884 }
2885
2886
vkImportFenceSciSyncObjNV(VkDevice device,const VkImportFenceSciSyncInfoNV * pImportFenceSciSyncInfo) const2887 VkResult vkImportFenceSciSyncObjNV( VkDevice device, const VkImportFenceSciSyncInfoNV * pImportFenceSciSyncInfo ) const VULKAN_HPP_NOEXCEPT
2888 {
2889 return ::vkImportFenceSciSyncObjNV( device, pImportFenceSciSyncInfo );
2890 }
2891
2892
vkGetPhysicalDeviceSciSyncAttributesNV(VkPhysicalDevice physicalDevice,const VkSciSyncAttributesInfoNV * pSciSyncAttributesInfo,NvSciSyncAttrList pAttributes) const2893 VkResult vkGetPhysicalDeviceSciSyncAttributesNV( VkPhysicalDevice physicalDevice, const VkSciSyncAttributesInfoNV * pSciSyncAttributesInfo, NvSciSyncAttrList pAttributes ) const VULKAN_HPP_NOEXCEPT
2894 {
2895 return ::vkGetPhysicalDeviceSciSyncAttributesNV( physicalDevice, pSciSyncAttributesInfo, pAttributes );
2896 }
2897
2898
vkGetSemaphoreSciSyncObjNV(VkDevice device,const VkSemaphoreGetSciSyncInfoNV * pGetSciSyncInfo,void * pHandle) const2899 VkResult vkGetSemaphoreSciSyncObjNV( VkDevice device, const VkSemaphoreGetSciSyncInfoNV * pGetSciSyncInfo, void * pHandle ) const VULKAN_HPP_NOEXCEPT
2900 {
2901 return ::vkGetSemaphoreSciSyncObjNV( device, pGetSciSyncInfo, pHandle );
2902 }
2903
2904
vkImportSemaphoreSciSyncObjNV(VkDevice device,const VkImportSemaphoreSciSyncInfoNV * pImportSemaphoreSciSyncInfo) const2905 VkResult vkImportSemaphoreSciSyncObjNV( VkDevice device, const VkImportSemaphoreSciSyncInfoNV * pImportSemaphoreSciSyncInfo ) const VULKAN_HPP_NOEXCEPT
2906 {
2907 return ::vkImportSemaphoreSciSyncObjNV( device, pImportSemaphoreSciSyncInfo );
2908 }
2909 #endif /*VK_USE_PLATFORM_SCI*/
2910
2911 #if defined( VK_USE_PLATFORM_SCI )
2912 //=== VK_NV_external_memory_sci_buf ===
2913
2914
vkGetMemorySciBufNV(VkDevice device,const VkMemoryGetSciBufInfoNV * pGetSciBufInfo,NvSciBufObj * pHandle) const2915 VkResult vkGetMemorySciBufNV( VkDevice device, const VkMemoryGetSciBufInfoNV * pGetSciBufInfo, NvSciBufObj * pHandle ) const VULKAN_HPP_NOEXCEPT
2916 {
2917 return ::vkGetMemorySciBufNV( device, pGetSciBufInfo, pHandle );
2918 }
2919
2920
vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV(VkPhysicalDevice physicalDevice,VkExternalMemoryHandleTypeFlagBits handleType,NvSciBufObj handle,VkMemorySciBufPropertiesNV * pMemorySciBufProperties) const2921 VkResult vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV( VkPhysicalDevice physicalDevice, VkExternalMemoryHandleTypeFlagBits handleType, NvSciBufObj handle, VkMemorySciBufPropertiesNV * pMemorySciBufProperties ) const VULKAN_HPP_NOEXCEPT
2922 {
2923 return ::vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV( physicalDevice, handleType, handle, pMemorySciBufProperties );
2924 }
2925
2926
vkGetPhysicalDeviceSciBufAttributesNV(VkPhysicalDevice physicalDevice,NvSciBufAttrList pAttributes) const2927 VkResult vkGetPhysicalDeviceSciBufAttributesNV( VkPhysicalDevice physicalDevice, NvSciBufAttrList pAttributes ) const VULKAN_HPP_NOEXCEPT
2928 {
2929 return ::vkGetPhysicalDeviceSciBufAttributesNV( physicalDevice, pAttributes );
2930 }
2931 #endif /*VK_USE_PLATFORM_SCI*/
2932
2933 //=== VK_EXT_extended_dynamic_state2 ===
2934
2935
vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer,uint32_t patchControlPoints) const2936 void vkCmdSetPatchControlPointsEXT( VkCommandBuffer commandBuffer, uint32_t patchControlPoints ) const VULKAN_HPP_NOEXCEPT
2937 {
2938 return ::vkCmdSetPatchControlPointsEXT( commandBuffer, patchControlPoints );
2939 }
2940
2941
vkCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer,VkBool32 rasterizerDiscardEnable) const2942 void vkCmdSetRasterizerDiscardEnableEXT( VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT
2943 {
2944 return ::vkCmdSetRasterizerDiscardEnableEXT( commandBuffer, rasterizerDiscardEnable );
2945 }
2946
2947
vkCmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer,VkBool32 depthBiasEnable) const2948 void vkCmdSetDepthBiasEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT
2949 {
2950 return ::vkCmdSetDepthBiasEnableEXT( commandBuffer, depthBiasEnable );
2951 }
2952
2953
vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer,VkLogicOp logicOp) const2954 void vkCmdSetLogicOpEXT( VkCommandBuffer commandBuffer, VkLogicOp logicOp ) const VULKAN_HPP_NOEXCEPT
2955 {
2956 return ::vkCmdSetLogicOpEXT( commandBuffer, logicOp );
2957 }
2958
2959
vkCmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer,VkBool32 primitiveRestartEnable) const2960 void vkCmdSetPrimitiveRestartEnableEXT( VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT
2961 {
2962 return ::vkCmdSetPrimitiveRestartEnableEXT( commandBuffer, primitiveRestartEnable );
2963 }
2964
2965 //=== VK_EXT_color_write_enable ===
2966
2967
vkCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer,uint32_t attachmentCount,const VkBool32 * pColorWriteEnables) const2968 void vkCmdSetColorWriteEnableEXT( VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32 * pColorWriteEnables ) const VULKAN_HPP_NOEXCEPT
2969 {
2970 return ::vkCmdSetColorWriteEnableEXT( commandBuffer, attachmentCount, pColorWriteEnables );
2971 }
2972
2973 #if defined( VK_USE_PLATFORM_SCI )
2974 //=== VK_NV_external_sci_sync2 ===
2975
2976
vkCreateSemaphoreSciSyncPoolNV(VkDevice device,const VkSemaphoreSciSyncPoolCreateInfoNV * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSemaphoreSciSyncPoolNV * pSemaphorePool) const2977 VkResult vkCreateSemaphoreSciSyncPoolNV( VkDevice device, const VkSemaphoreSciSyncPoolCreateInfoNV * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkSemaphoreSciSyncPoolNV * pSemaphorePool ) const VULKAN_HPP_NOEXCEPT
2978 {
2979 return ::vkCreateSemaphoreSciSyncPoolNV( device, pCreateInfo, pAllocator, pSemaphorePool );
2980 }
2981 #endif /*VK_USE_PLATFORM_SCI*/
2982
2983 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
2984 //=== VK_QNX_external_memory_screen_buffer ===
2985
2986
vkGetScreenBufferPropertiesQNX(VkDevice device,const struct _screen_buffer * buffer,VkScreenBufferPropertiesQNX * pProperties) const2987 VkResult vkGetScreenBufferPropertiesQNX( VkDevice device, const struct _screen_buffer * buffer, VkScreenBufferPropertiesQNX * pProperties ) const VULKAN_HPP_NOEXCEPT
2988 {
2989 return ::vkGetScreenBufferPropertiesQNX( device, buffer, pProperties );
2990 }
2991 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
2992
2993 };
2994
getDispatchLoaderStatic()2995 inline ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic & getDispatchLoaderStatic()
2996 {
2997 static ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic dls;
2998 return dls;
2999 }
3000 #endif
3001
3002 #if !defined( VULKAN_HPP_NO_SMART_HANDLE )
3003 struct AllocationCallbacks;
3004
3005 template <typename OwnerType, typename Dispatch>
3006 class ObjectDestroy
3007 {
3008 public:
3009 ObjectDestroy() = default;
3010
ObjectDestroy(OwnerType owner,Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT)3011 ObjectDestroy( OwnerType owner,
3012 Optional<const AllocationCallbacks> allocationCallbacks
3013 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
3014 Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
3015 : m_owner( owner )
3016 , m_allocationCallbacks( allocationCallbacks )
3017 , m_dispatch( &dispatch )
3018 {}
3019
getOwner() const3020 OwnerType getOwner() const VULKAN_HPP_NOEXCEPT { return m_owner; }
getAllocator() const3021 Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT { return m_allocationCallbacks; }
getDispatch() const3022 Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT { return *m_dispatch; }
3023
3024 protected:
3025 template <typename T>
destroy(T t)3026 void destroy(T t) VULKAN_HPP_NOEXCEPT
3027 {
3028 VULKAN_HPP_ASSERT( m_owner && m_dispatch );
3029 m_owner.destroy( t, m_allocationCallbacks, *m_dispatch );
3030 }
3031
3032 private:
3033 OwnerType m_owner = {};
3034 Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
3035 Dispatch const * m_dispatch = nullptr;
3036 };
3037
3038 class NoParent;
3039
3040 template <typename Dispatch>
3041 class ObjectDestroy<NoParent, Dispatch>
3042 {
3043 public:
3044 ObjectDestroy() = default;
3045
ObjectDestroy(Optional<const AllocationCallbacks> allocationCallbacks,Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT)3046 ObjectDestroy( Optional<const AllocationCallbacks> allocationCallbacks,
3047 Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
3048 : m_allocationCallbacks( allocationCallbacks )
3049 , m_dispatch( &dispatch )
3050 {}
3051
getAllocator() const3052 Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT { return m_allocationCallbacks; }
getDispatch() const3053 Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT { return *m_dispatch; }
3054
3055 protected:
3056 template <typename T>
destroy(T t)3057 void destroy(T t) VULKAN_HPP_NOEXCEPT
3058 {
3059 VULKAN_HPP_ASSERT( m_dispatch );
3060 t.destroy( m_allocationCallbacks, *m_dispatch );
3061 }
3062
3063 private:
3064 Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
3065 Dispatch const * m_dispatch = nullptr;
3066 };
3067
3068 template <typename OwnerType, typename Dispatch>
3069 class ObjectFree
3070 {
3071 public:
3072 ObjectFree() = default;
3073
ObjectFree(OwnerType owner,Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT)3074 ObjectFree( OwnerType owner,
3075 Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
3076 Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
3077 : m_owner( owner )
3078 , m_allocationCallbacks( allocationCallbacks )
3079 , m_dispatch( &dispatch )
3080 {}
3081
getOwner() const3082 OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
3083 {
3084 return m_owner;
3085 }
3086
getAllocator() const3087 Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT
3088 {
3089 return m_allocationCallbacks;
3090 }
3091
getDispatch() const3092 Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT
3093 {
3094 return *m_dispatch;
3095 }
3096
3097 protected:
3098 template <typename T>
destroy(T t)3099 void destroy( T t ) VULKAN_HPP_NOEXCEPT
3100 {
3101 VULKAN_HPP_ASSERT( m_owner && m_dispatch );
3102 ( m_owner.free )( t, m_allocationCallbacks, *m_dispatch );
3103 }
3104
3105 private:
3106 OwnerType m_owner = {};
3107 Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
3108 Dispatch const * m_dispatch = nullptr;
3109 };
3110
3111 template <typename OwnerType, typename Dispatch>
3112 class ObjectRelease
3113 {
3114 public:
3115 ObjectRelease() = default;
3116
ObjectRelease(OwnerType owner,Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT)3117 ObjectRelease( OwnerType owner,
3118 Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
3119 : m_owner( owner )
3120 , m_dispatch( &dispatch )
3121 {}
3122
getOwner() const3123 OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
3124 {
3125 return m_owner;
3126 }
3127
getDispatch() const3128 Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT
3129 {
3130 return *m_dispatch;
3131 }
3132
3133 protected:
3134 template <typename T>
destroy(T t)3135 void destroy( T t ) VULKAN_HPP_NOEXCEPT
3136 {
3137 VULKAN_HPP_ASSERT( m_owner && m_dispatch );
3138 m_owner.release( t, *m_dispatch );
3139 }
3140
3141 private:
3142 OwnerType m_owner = {};
3143 Dispatch const * m_dispatch = nullptr;
3144 };
3145
3146 template <typename OwnerType, typename PoolType, typename Dispatch>
3147 class PoolFree
3148 {
3149 public:
3150 PoolFree() = default;
3151
PoolFree(OwnerType owner,PoolType pool,Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT)3152 PoolFree( OwnerType owner,
3153 PoolType pool,
3154 Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
3155 : m_owner( owner )
3156 , m_pool( pool )
3157 , m_dispatch( &dispatch )
3158 {}
3159
getOwner() const3160 OwnerType getOwner() const VULKAN_HPP_NOEXCEPT { return m_owner; }
getPool() const3161 PoolType getPool() const VULKAN_HPP_NOEXCEPT { return m_pool; }
getDispatch() const3162 Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT { return *m_dispatch; }
3163
3164 protected:
3165 template <typename T>
destroy(T t)3166 void destroy(T t) VULKAN_HPP_NOEXCEPT
3167 {
3168 ( m_owner.free )( m_pool, t, *m_dispatch );
3169 }
3170
3171 private:
3172 OwnerType m_owner = OwnerType();
3173 PoolType m_pool = PoolType();
3174 Dispatch const * m_dispatch = nullptr;
3175 };
3176
3177 #endif // !VULKAN_HPP_NO_SMART_HANDLE
3178
3179 //==================
3180 //=== BASE TYPEs ===
3181 //==================
3182
3183 using Bool32 = uint32_t;
3184 using DeviceAddress = uint64_t;
3185 using DeviceSize = uint64_t;
3186 using RemoteAddressNV = void *;
3187 using SampleMask = uint32_t;
3188
3189
3190 } // namespace VULKAN_HPP_NAMESPACE
3191
3192 #include <vulkan/vulkansc_enums.hpp>
3193 #if !defined( VULKAN_HPP_NO_TO_STRING )
3194 #include <vulkan/vulkansc_to_string.hpp>
3195 #endif
3196
3197 #ifndef VULKAN_HPP_NO_EXCEPTIONS
3198 namespace std
3199 {
3200 template <>
3201 struct is_error_code_enum<VULKAN_HPP_NAMESPACE::Result> : public true_type
3202 {};
3203 } // namespace std
3204 #endif
3205
3206 namespace VULKAN_HPP_NAMESPACE
3207 {
3208 #ifndef VULKAN_HPP_NO_EXCEPTIONS
3209 class ErrorCategoryImpl : public std::error_category
3210 {
3211 public:
name() const3212 virtual const char* name() const VULKAN_HPP_NOEXCEPT override { return VULKAN_HPP_NAMESPACE_STRING"::Result"; }
message(int ev) const3213 virtual std::string message(int ev) const override
3214 {
3215 #if defined( VULKAN_HPP_NO_TO_STRING )
3216 return std::to_string( ev );
3217 #else
3218 return VULKAN_HPP_NAMESPACE::to_string(static_cast<VULKAN_HPP_NAMESPACE::Result>(ev));
3219 #endif
3220 }
3221 };
3222
3223 class Error
3224 {
3225 public:
3226 Error() VULKAN_HPP_NOEXCEPT = default;
3227 Error(const Error&) VULKAN_HPP_NOEXCEPT = default;
3228 virtual ~Error() VULKAN_HPP_NOEXCEPT = default;
3229
3230 virtual const char* what() const VULKAN_HPP_NOEXCEPT = 0;
3231 };
3232
3233 class LogicError : public Error, public std::logic_error
3234 {
3235 public:
LogicError(const std::string & what)3236 explicit LogicError( const std::string& what )
3237 : Error(), std::logic_error(what) {}
LogicError(char const * what)3238 explicit LogicError( char const * what )
3239 : Error(), std::logic_error(what) {}
3240
what() const3241 virtual const char* what() const VULKAN_HPP_NOEXCEPT { return std::logic_error::what(); }
3242 };
3243
3244 class SystemError : public Error, public std::system_error
3245 {
3246 public:
SystemError(std::error_code ec)3247 SystemError( std::error_code ec )
3248 : Error(), std::system_error(ec) {}
SystemError(std::error_code ec,std::string const & what)3249 SystemError( std::error_code ec, std::string const & what )
3250 : Error(), std::system_error(ec, what) {}
SystemError(std::error_code ec,char const * what)3251 SystemError( std::error_code ec, char const * what )
3252 : Error(), std::system_error(ec, what) {}
SystemError(int ev,std::error_category const & ecat)3253 SystemError( int ev, std::error_category const & ecat )
3254 : Error(), std::system_error(ev, ecat) {}
SystemError(int ev,std::error_category const & ecat,std::string const & what)3255 SystemError( int ev, std::error_category const & ecat, std::string const & what)
3256 : Error(), std::system_error(ev, ecat, what) {}
SystemError(int ev,std::error_category const & ecat,char const * what)3257 SystemError( int ev, std::error_category const & ecat, char const * what)
3258 : Error(), std::system_error(ev, ecat, what) {}
3259
what() const3260 virtual const char* what() const VULKAN_HPP_NOEXCEPT { return std::system_error::what(); }
3261 };
3262
errorCategory()3263 VULKAN_HPP_INLINE const std::error_category& errorCategory() VULKAN_HPP_NOEXCEPT
3264 {
3265 static ErrorCategoryImpl instance;
3266 return instance;
3267 }
3268
make_error_code(Result e)3269 VULKAN_HPP_INLINE std::error_code make_error_code(Result e) VULKAN_HPP_NOEXCEPT
3270 {
3271 return std::error_code(static_cast<int>(e), errorCategory());
3272 }
3273
make_error_condition(Result e)3274 VULKAN_HPP_INLINE std::error_condition make_error_condition(Result e) VULKAN_HPP_NOEXCEPT
3275 {
3276 return std::error_condition(static_cast<int>(e), errorCategory());
3277 }
3278
3279
3280 class OutOfHostMemoryError : public SystemError
3281 {
3282 public:
OutOfHostMemoryError(std::string const & message)3283 OutOfHostMemoryError( std::string const & message )
3284 : SystemError( make_error_code( Result::eErrorOutOfHostMemory ), message ) {}
OutOfHostMemoryError(char const * message)3285 OutOfHostMemoryError( char const * message )
3286 : SystemError( make_error_code( Result::eErrorOutOfHostMemory ), message ) {}
3287 };
3288
3289 class OutOfDeviceMemoryError : public SystemError
3290 {
3291 public:
OutOfDeviceMemoryError(std::string const & message)3292 OutOfDeviceMemoryError( std::string const & message )
3293 : SystemError( make_error_code( Result::eErrorOutOfDeviceMemory ), message ) {}
OutOfDeviceMemoryError(char const * message)3294 OutOfDeviceMemoryError( char const * message )
3295 : SystemError( make_error_code( Result::eErrorOutOfDeviceMemory ), message ) {}
3296 };
3297
3298 class InitializationFailedError : public SystemError
3299 {
3300 public:
InitializationFailedError(std::string const & message)3301 InitializationFailedError( std::string const & message )
3302 : SystemError( make_error_code( Result::eErrorInitializationFailed ), message ) {}
InitializationFailedError(char const * message)3303 InitializationFailedError( char const * message )
3304 : SystemError( make_error_code( Result::eErrorInitializationFailed ), message ) {}
3305 };
3306
3307 class DeviceLostError : public SystemError
3308 {
3309 public:
DeviceLostError(std::string const & message)3310 DeviceLostError( std::string const & message )
3311 : SystemError( make_error_code( Result::eErrorDeviceLost ), message ) {}
DeviceLostError(char const * message)3312 DeviceLostError( char const * message )
3313 : SystemError( make_error_code( Result::eErrorDeviceLost ), message ) {}
3314 };
3315
3316 class MemoryMapFailedError : public SystemError
3317 {
3318 public:
MemoryMapFailedError(std::string const & message)3319 MemoryMapFailedError( std::string const & message )
3320 : SystemError( make_error_code( Result::eErrorMemoryMapFailed ), message ) {}
MemoryMapFailedError(char const * message)3321 MemoryMapFailedError( char const * message )
3322 : SystemError( make_error_code( Result::eErrorMemoryMapFailed ), message ) {}
3323 };
3324
3325 class LayerNotPresentError : public SystemError
3326 {
3327 public:
LayerNotPresentError(std::string const & message)3328 LayerNotPresentError( std::string const & message )
3329 : SystemError( make_error_code( Result::eErrorLayerNotPresent ), message ) {}
LayerNotPresentError(char const * message)3330 LayerNotPresentError( char const * message )
3331 : SystemError( make_error_code( Result::eErrorLayerNotPresent ), message ) {}
3332 };
3333
3334 class ExtensionNotPresentError : public SystemError
3335 {
3336 public:
ExtensionNotPresentError(std::string const & message)3337 ExtensionNotPresentError( std::string const & message )
3338 : SystemError( make_error_code( Result::eErrorExtensionNotPresent ), message ) {}
ExtensionNotPresentError(char const * message)3339 ExtensionNotPresentError( char const * message )
3340 : SystemError( make_error_code( Result::eErrorExtensionNotPresent ), message ) {}
3341 };
3342
3343 class FeatureNotPresentError : public SystemError
3344 {
3345 public:
FeatureNotPresentError(std::string const & message)3346 FeatureNotPresentError( std::string const & message )
3347 : SystemError( make_error_code( Result::eErrorFeatureNotPresent ), message ) {}
FeatureNotPresentError(char const * message)3348 FeatureNotPresentError( char const * message )
3349 : SystemError( make_error_code( Result::eErrorFeatureNotPresent ), message ) {}
3350 };
3351
3352 class IncompatibleDriverError : public SystemError
3353 {
3354 public:
IncompatibleDriverError(std::string const & message)3355 IncompatibleDriverError( std::string const & message )
3356 : SystemError( make_error_code( Result::eErrorIncompatibleDriver ), message ) {}
IncompatibleDriverError(char const * message)3357 IncompatibleDriverError( char const * message )
3358 : SystemError( make_error_code( Result::eErrorIncompatibleDriver ), message ) {}
3359 };
3360
3361 class TooManyObjectsError : public SystemError
3362 {
3363 public:
TooManyObjectsError(std::string const & message)3364 TooManyObjectsError( std::string const & message )
3365 : SystemError( make_error_code( Result::eErrorTooManyObjects ), message ) {}
TooManyObjectsError(char const * message)3366 TooManyObjectsError( char const * message )
3367 : SystemError( make_error_code( Result::eErrorTooManyObjects ), message ) {}
3368 };
3369
3370 class FormatNotSupportedError : public SystemError
3371 {
3372 public:
FormatNotSupportedError(std::string const & message)3373 FormatNotSupportedError( std::string const & message )
3374 : SystemError( make_error_code( Result::eErrorFormatNotSupported ), message ) {}
FormatNotSupportedError(char const * message)3375 FormatNotSupportedError( char const * message )
3376 : SystemError( make_error_code( Result::eErrorFormatNotSupported ), message ) {}
3377 };
3378
3379 class FragmentedPoolError : public SystemError
3380 {
3381 public:
FragmentedPoolError(std::string const & message)3382 FragmentedPoolError( std::string const & message )
3383 : SystemError( make_error_code( Result::eErrorFragmentedPool ), message ) {}
FragmentedPoolError(char const * message)3384 FragmentedPoolError( char const * message )
3385 : SystemError( make_error_code( Result::eErrorFragmentedPool ), message ) {}
3386 };
3387
3388 class UnknownError : public SystemError
3389 {
3390 public:
UnknownError(std::string const & message)3391 UnknownError( std::string const & message )
3392 : SystemError( make_error_code( Result::eErrorUnknown ), message ) {}
UnknownError(char const * message)3393 UnknownError( char const * message )
3394 : SystemError( make_error_code( Result::eErrorUnknown ), message ) {}
3395 };
3396
3397 class OutOfPoolMemoryError : public SystemError
3398 {
3399 public:
OutOfPoolMemoryError(std::string const & message)3400 OutOfPoolMemoryError( std::string const & message )
3401 : SystemError( make_error_code( Result::eErrorOutOfPoolMemory ), message ) {}
OutOfPoolMemoryError(char const * message)3402 OutOfPoolMemoryError( char const * message )
3403 : SystemError( make_error_code( Result::eErrorOutOfPoolMemory ), message ) {}
3404 };
3405
3406 class InvalidExternalHandleError : public SystemError
3407 {
3408 public:
InvalidExternalHandleError(std::string const & message)3409 InvalidExternalHandleError( std::string const & message )
3410 : SystemError( make_error_code( Result::eErrorInvalidExternalHandle ), message ) {}
InvalidExternalHandleError(char const * message)3411 InvalidExternalHandleError( char const * message )
3412 : SystemError( make_error_code( Result::eErrorInvalidExternalHandle ), message ) {}
3413 };
3414
3415 class FragmentationError : public SystemError
3416 {
3417 public:
FragmentationError(std::string const & message)3418 FragmentationError( std::string const & message )
3419 : SystemError( make_error_code( Result::eErrorFragmentation ), message ) {}
FragmentationError(char const * message)3420 FragmentationError( char const * message )
3421 : SystemError( make_error_code( Result::eErrorFragmentation ), message ) {}
3422 };
3423
3424 class InvalidOpaqueCaptureAddressError : public SystemError
3425 {
3426 public:
InvalidOpaqueCaptureAddressError(std::string const & message)3427 InvalidOpaqueCaptureAddressError( std::string const & message )
3428 : SystemError( make_error_code( Result::eErrorInvalidOpaqueCaptureAddress ), message ) {}
InvalidOpaqueCaptureAddressError(char const * message)3429 InvalidOpaqueCaptureAddressError( char const * message )
3430 : SystemError( make_error_code( Result::eErrorInvalidOpaqueCaptureAddress ), message ) {}
3431 };
3432
3433 class ValidationFailedError : public SystemError
3434 {
3435 public:
ValidationFailedError(std::string const & message)3436 ValidationFailedError( std::string const & message )
3437 : SystemError( make_error_code( Result::eErrorValidationFailed ), message ) {}
ValidationFailedError(char const * message)3438 ValidationFailedError( char const * message )
3439 : SystemError( make_error_code( Result::eErrorValidationFailed ), message ) {}
3440 };
3441
3442 class InvalidPipelineCacheDataError : public SystemError
3443 {
3444 public:
InvalidPipelineCacheDataError(std::string const & message)3445 InvalidPipelineCacheDataError( std::string const & message )
3446 : SystemError( make_error_code( Result::eErrorInvalidPipelineCacheData ), message ) {}
InvalidPipelineCacheDataError(char const * message)3447 InvalidPipelineCacheDataError( char const * message )
3448 : SystemError( make_error_code( Result::eErrorInvalidPipelineCacheData ), message ) {}
3449 };
3450
3451 class NoPipelineMatchError : public SystemError
3452 {
3453 public:
NoPipelineMatchError(std::string const & message)3454 NoPipelineMatchError( std::string const & message )
3455 : SystemError( make_error_code( Result::eErrorNoPipelineMatch ), message ) {}
NoPipelineMatchError(char const * message)3456 NoPipelineMatchError( char const * message )
3457 : SystemError( make_error_code( Result::eErrorNoPipelineMatch ), message ) {}
3458 };
3459
3460 class SurfaceLostKHRError : public SystemError
3461 {
3462 public:
SurfaceLostKHRError(std::string const & message)3463 SurfaceLostKHRError( std::string const & message )
3464 : SystemError( make_error_code( Result::eErrorSurfaceLostKHR ), message ) {}
SurfaceLostKHRError(char const * message)3465 SurfaceLostKHRError( char const * message )
3466 : SystemError( make_error_code( Result::eErrorSurfaceLostKHR ), message ) {}
3467 };
3468
3469 class NativeWindowInUseKHRError : public SystemError
3470 {
3471 public:
NativeWindowInUseKHRError(std::string const & message)3472 NativeWindowInUseKHRError( std::string const & message )
3473 : SystemError( make_error_code( Result::eErrorNativeWindowInUseKHR ), message ) {}
NativeWindowInUseKHRError(char const * message)3474 NativeWindowInUseKHRError( char const * message )
3475 : SystemError( make_error_code( Result::eErrorNativeWindowInUseKHR ), message ) {}
3476 };
3477
3478 class OutOfDateKHRError : public SystemError
3479 {
3480 public:
OutOfDateKHRError(std::string const & message)3481 OutOfDateKHRError( std::string const & message )
3482 : SystemError( make_error_code( Result::eErrorOutOfDateKHR ), message ) {}
OutOfDateKHRError(char const * message)3483 OutOfDateKHRError( char const * message )
3484 : SystemError( make_error_code( Result::eErrorOutOfDateKHR ), message ) {}
3485 };
3486
3487 class IncompatibleDisplayKHRError : public SystemError
3488 {
3489 public:
IncompatibleDisplayKHRError(std::string const & message)3490 IncompatibleDisplayKHRError( std::string const & message )
3491 : SystemError( make_error_code( Result::eErrorIncompatibleDisplayKHR ), message ) {}
IncompatibleDisplayKHRError(char const * message)3492 IncompatibleDisplayKHRError( char const * message )
3493 : SystemError( make_error_code( Result::eErrorIncompatibleDisplayKHR ), message ) {}
3494 };
3495
3496 class InvalidDrmFormatModifierPlaneLayoutEXTError : public SystemError
3497 {
3498 public:
InvalidDrmFormatModifierPlaneLayoutEXTError(std::string const & message)3499 InvalidDrmFormatModifierPlaneLayoutEXTError( std::string const & message )
3500 : SystemError( make_error_code( Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT ), message ) {}
InvalidDrmFormatModifierPlaneLayoutEXTError(char const * message)3501 InvalidDrmFormatModifierPlaneLayoutEXTError( char const * message )
3502 : SystemError( make_error_code( Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT ), message ) {}
3503 };
3504
3505
3506 namespace detail
3507 {
throwResultException(Result result,char const * message)3508 [[noreturn]] VULKAN_HPP_INLINE void throwResultException( Result result, char const * message )
3509 {
3510 switch ( result )
3511 {
3512 case Result::eErrorOutOfHostMemory: throw OutOfHostMemoryError( message );
3513 case Result::eErrorOutOfDeviceMemory: throw OutOfDeviceMemoryError( message );
3514 case Result::eErrorInitializationFailed: throw InitializationFailedError( message );
3515 case Result::eErrorDeviceLost: throw DeviceLostError( message );
3516 case Result::eErrorMemoryMapFailed: throw MemoryMapFailedError( message );
3517 case Result::eErrorLayerNotPresent: throw LayerNotPresentError( message );
3518 case Result::eErrorExtensionNotPresent: throw ExtensionNotPresentError( message );
3519 case Result::eErrorFeatureNotPresent: throw FeatureNotPresentError( message );
3520 case Result::eErrorIncompatibleDriver: throw IncompatibleDriverError( message );
3521 case Result::eErrorTooManyObjects: throw TooManyObjectsError( message );
3522 case Result::eErrorFormatNotSupported: throw FormatNotSupportedError( message );
3523 case Result::eErrorFragmentedPool: throw FragmentedPoolError( message );
3524 case Result::eErrorUnknown: throw UnknownError( message );
3525 case Result::eErrorOutOfPoolMemory: throw OutOfPoolMemoryError( message );
3526 case Result::eErrorInvalidExternalHandle: throw InvalidExternalHandleError( message );
3527 case Result::eErrorFragmentation: throw FragmentationError( message );
3528 case Result::eErrorInvalidOpaqueCaptureAddress: throw InvalidOpaqueCaptureAddressError( message );
3529 case Result::eErrorValidationFailed: throw ValidationFailedError( message );
3530 case Result::eErrorInvalidPipelineCacheData: throw InvalidPipelineCacheDataError( message );
3531 case Result::eErrorNoPipelineMatch: throw NoPipelineMatchError( message );
3532 case Result::eErrorSurfaceLostKHR: throw SurfaceLostKHRError( message );
3533 case Result::eErrorNativeWindowInUseKHR: throw NativeWindowInUseKHRError( message );
3534 case Result::eErrorOutOfDateKHR: throw OutOfDateKHRError( message );
3535 case Result::eErrorIncompatibleDisplayKHR: throw IncompatibleDisplayKHRError( message );
3536 case Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT: throw InvalidDrmFormatModifierPlaneLayoutEXTError( message );
3537 default: throw SystemError( make_error_code( result ), message );
3538 }
3539 }
3540 }
3541 #endif
3542
ignore(T const &)3543 template <typename T> void ignore(T const &) VULKAN_HPP_NOEXCEPT {}
3544
3545 template <typename T>
3546 struct ResultValue
3547 {
3548 #ifdef VULKAN_HPP_HAS_NOEXCEPT
ResultValueVULKAN_HPP_NAMESPACE::ResultValue3549 ResultValue( Result r, T & v ) VULKAN_HPP_NOEXCEPT(VULKAN_HPP_NOEXCEPT(T(v)))
3550 #else
3551 ResultValue( Result r, T & v )
3552 #endif
3553 : result( r )
3554 , value( v )
3555 {}
3556
3557 #ifdef VULKAN_HPP_HAS_NOEXCEPT
ResultValueVULKAN_HPP_NAMESPACE::ResultValue3558 ResultValue( Result r, T && v ) VULKAN_HPP_NOEXCEPT(VULKAN_HPP_NOEXCEPT(T(std::move(v))))
3559 #else
3560 ResultValue( Result r, T && v )
3561 #endif
3562 : result( r )
3563 , value( std::move( v ) )
3564 {}
3565
3566 Result result;
3567 T value;
3568
operator std::tuple<Result&,T&>VULKAN_HPP_NAMESPACE::ResultValue3569 operator std::tuple<Result&, T&>() VULKAN_HPP_NOEXCEPT { return std::tuple<Result&, T&>(result, value); }
3570 };
3571
3572 #if !defined( VULKAN_HPP_NO_SMART_HANDLE )
3573 template <typename Type, typename Dispatch>
3574 struct ResultValue<UniqueHandle<Type, Dispatch>>
3575 {
3576 #ifdef VULKAN_HPP_HAS_NOEXCEPT
ResultValueVULKAN_HPP_NAMESPACE::ResultValue3577 ResultValue(Result r, UniqueHandle<Type, Dispatch> && v) VULKAN_HPP_NOEXCEPT
3578 #else
3579 ResultValue(Result r, UniqueHandle<Type, Dispatch> && v)
3580 #endif
3581 : result(r)
3582 , value(std::move(v))
3583 {}
3584
3585 VULKAN_HPP_DEPRECATED(
3586 "asTuple() on an l-value is deprecated, as it implicitly moves the UniqueHandle out of the ResultValue. Use asTuple() on an r-value instead, requiring to explicitly move the UniqueHandle." )
3587 std::tuple<Result, UniqueHandle<Type, Dispatch>>
asTupleVULKAN_HPP_NAMESPACE::ResultValue3588 asTuple() &
3589 {
3590 return std::make_tuple( result, std::move( value ) );
3591 }
3592
asTupleVULKAN_HPP_NAMESPACE::ResultValue3593 std::tuple<Result, UniqueHandle<Type, Dispatch>> asTuple() &&
3594 {
3595 return std::make_tuple( result, std::move( value ) );
3596 }
3597
3598 Result result;
3599 UniqueHandle<Type, Dispatch> value;
3600 };
3601
3602 template <typename Type, typename Dispatch>
3603 struct ResultValue<std::vector<UniqueHandle<Type, Dispatch>>>
3604 {
3605 # ifdef VULKAN_HPP_HAS_NOEXCEPT
ResultValueVULKAN_HPP_NAMESPACE::ResultValue3606 ResultValue( Result r, std::vector<UniqueHandle<Type, Dispatch>> && v ) VULKAN_HPP_NOEXCEPT
3607 # else
3608 ResultValue( Result r, std::vector<UniqueHandle<Type, Dispatch>> && v )
3609 # endif
3610 : result( r )
3611 , value( std::move( v ) )
3612 {}
3613
3614 VULKAN_HPP_DEPRECATED(
3615 "asTuple() on an l-value is deprecated, as it implicitly moves the UniqueHandle out of the ResultValue. Use asTuple() on an r-value instead, requiring to explicitly move the UniqueHandle." )
3616 std::tuple<Result, std::vector<UniqueHandle<Type, Dispatch>>>
asTupleVULKAN_HPP_NAMESPACE::ResultValue3617 asTuple() &
3618 {
3619 return std::make_tuple( result, std::move( value ) );
3620 }
3621
asTupleVULKAN_HPP_NAMESPACE::ResultValue3622 std::tuple<Result, std::vector<UniqueHandle<Type, Dispatch>>> asTuple() &&
3623 {
3624 return std::make_tuple( result, std::move( value ) );
3625 }
3626
3627 Result result;
3628 std::vector<UniqueHandle<Type, Dispatch>> value;
3629 };
3630 #endif
3631
3632 template <typename T>
3633 struct ResultValueType
3634 {
3635 #ifdef VULKAN_HPP_NO_EXCEPTIONS
3636 typedef ResultValue<T> type;
3637 #else
3638 typedef T type;
3639 #endif
3640 };
3641
3642 template <>
3643 struct ResultValueType<void>
3644 {
3645 #ifdef VULKAN_HPP_NO_EXCEPTIONS
3646 typedef Result type;
3647 #else
3648 typedef void type;
3649 #endif
3650 };
3651
createResultValueType(Result result)3652 VULKAN_HPP_INLINE typename ResultValueType<void>::type createResultValueType( Result result )
3653 {
3654 #ifdef VULKAN_HPP_NO_EXCEPTIONS
3655 return result;
3656 #else
3657 ignore( result );
3658 #endif
3659 }
3660
3661 template <typename T>
createResultValueType(Result result,T & data)3662 VULKAN_HPP_INLINE typename ResultValueType<T>::type createResultValueType( Result result, T & data )
3663 {
3664 #ifdef VULKAN_HPP_NO_EXCEPTIONS
3665 return ResultValue<T>( result, data );
3666 #else
3667 ignore( result );
3668 return data;
3669 #endif
3670 }
3671
3672 template <typename T>
createResultValueType(Result result,T && data)3673 VULKAN_HPP_INLINE typename ResultValueType<T>::type createResultValueType( Result result, T && data )
3674 {
3675 #ifdef VULKAN_HPP_NO_EXCEPTIONS
3676 return ResultValue<T>( result, std::move( data ) );
3677 #else
3678 ignore( result );
3679 return std::move( data );
3680 #endif
3681 }
3682
resultCheck(Result result,char const * message)3683 VULKAN_HPP_INLINE void resultCheck( Result result, char const * message )
3684 {
3685 #ifdef VULKAN_HPP_NO_EXCEPTIONS
3686 ignore( result ); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
3687 ignore( message );
3688 VULKAN_HPP_ASSERT_ON_RESULT( result == Result::eSuccess );
3689 #else
3690 if ( result != Result::eSuccess )
3691 {
3692 detail::throwResultException( result, message );
3693 }
3694 #endif
3695 }
3696
resultCheck(Result result,char const * message,std::initializer_list<Result> successCodes)3697 VULKAN_HPP_INLINE void resultCheck( Result result, char const * message, std::initializer_list<Result> successCodes )
3698 {
3699 #ifdef VULKAN_HPP_NO_EXCEPTIONS
3700 ignore( result ); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
3701 ignore( message );
3702 ignore( successCodes ); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
3703 VULKAN_HPP_ASSERT_ON_RESULT( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() );
3704 #else
3705 if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() )
3706 {
3707 detail::throwResultException( result, message );
3708 }
3709 #endif
3710 }
3711
3712 //===========================
3713 //=== CONSTEXPR CONSTANTs ===
3714 //===========================
3715
3716 //=== VK_VERSION_1_0 ===
3717 VULKAN_HPP_CONSTEXPR_INLINE uint32_t AttachmentUnused = VK_ATTACHMENT_UNUSED;
3718 VULKAN_HPP_CONSTEXPR_INLINE uint32_t False = VK_FALSE;
3719 VULKAN_HPP_CONSTEXPR_INLINE float LodClampNone = VK_LOD_CLAMP_NONE;
3720 VULKAN_HPP_CONSTEXPR_INLINE uint32_t QueueFamilyIgnored = VK_QUEUE_FAMILY_IGNORED;
3721 VULKAN_HPP_CONSTEXPR_INLINE uint32_t RemainingArrayLayers = VK_REMAINING_ARRAY_LAYERS;
3722 VULKAN_HPP_CONSTEXPR_INLINE uint32_t RemainingMipLevels = VK_REMAINING_MIP_LEVELS;
3723 VULKAN_HPP_CONSTEXPR_INLINE uint32_t SubpassExternal = VK_SUBPASS_EXTERNAL;
3724 VULKAN_HPP_CONSTEXPR_INLINE uint32_t True = VK_TRUE;
3725 VULKAN_HPP_CONSTEXPR_INLINE uint64_t WholeSize = VK_WHOLE_SIZE;
3726 VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxMemoryTypes = VK_MAX_MEMORY_TYPES;
3727 VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxPhysicalDeviceNameSize = VK_MAX_PHYSICAL_DEVICE_NAME_SIZE;
3728 VULKAN_HPP_CONSTEXPR_INLINE uint32_t UuidSize = VK_UUID_SIZE;
3729 VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxExtensionNameSize = VK_MAX_EXTENSION_NAME_SIZE;
3730 VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxDescriptionSize = VK_MAX_DESCRIPTION_SIZE;
3731 VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxMemoryHeaps = VK_MAX_MEMORY_HEAPS;
3732
3733 //=== VK_VERSION_1_1 ===
3734 VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxDeviceGroupSize = VK_MAX_DEVICE_GROUP_SIZE;
3735 VULKAN_HPP_CONSTEXPR_INLINE uint32_t LuidSize = VK_LUID_SIZE;
3736 VULKAN_HPP_CONSTEXPR_INLINE uint32_t QueueFamilyExternal = VK_QUEUE_FAMILY_EXTERNAL;
3737
3738 //=== VK_VERSION_1_2 ===
3739 VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxDriverNameSize = VK_MAX_DRIVER_NAME_SIZE;
3740 VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxDriverInfoSize = VK_MAX_DRIVER_INFO_SIZE;
3741
3742 //=== VK_EXT_queue_family_foreign ===
3743 VULKAN_HPP_CONSTEXPR_INLINE uint32_t QueueFamilyForeignEXT = VK_QUEUE_FAMILY_FOREIGN_EXT;
3744
3745 //========================
3746 //=== CONSTEXPR VALUEs ===
3747 //========================
3748 VULKAN_HPP_CONSTEXPR_INLINE uint32_t HeaderVersion = VK_HEADER_VERSION;
3749
3750 //=========================
3751 //=== CONSTEXPR CALLEEs ===
3752 //=========================
3753 template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
apiVersionMajor(T const version)3754 VULKAN_HPP_CONSTEXPR uint32_t apiVersionMajor( T const version )
3755 {
3756 return (((uint32_t)(version) >> 22U) & 0x7FU);
3757 }
3758 template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
apiVersionMinor(T const version)3759 VULKAN_HPP_CONSTEXPR uint32_t apiVersionMinor( T const version )
3760 {
3761 return (((uint32_t)(version) >> 12U) & 0x3FFU);
3762 }
3763 template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
apiVersionPatch(T const version)3764 VULKAN_HPP_CONSTEXPR uint32_t apiVersionPatch( T const version )
3765 {
3766 return ((uint32_t)(version) & 0xFFFU);
3767 }
3768 template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
apiVersionVariant(T const version)3769 VULKAN_HPP_CONSTEXPR uint32_t apiVersionVariant( T const version )
3770 {
3771 return ((uint32_t)(version) >> 29U);
3772 }
3773 template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
makeApiVersion(T const variant,T const major,T const minor,T const patch)3774 VULKAN_HPP_CONSTEXPR uint32_t makeApiVersion( T const variant, T const major, T const minor, T const patch )
3775 {
3776 return ((((uint32_t)(variant)) << 29U) | (((uint32_t)(major)) << 22U) | (((uint32_t)(minor)) << 12U) | ((uint32_t)(patch)));
3777 }
3778 template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
makeVersion(T const major,T const minor,T const patch)3779 VULKAN_HPP_DEPRECATED("This define is deprecated. VK_MAKE_API_VERSION should be used instead.") VULKAN_HPP_CONSTEXPR uint32_t makeVersion( T const major, T const minor, T const patch )
3780 {
3781 return ((((uint32_t)(major)) << 22U) | (((uint32_t)(minor)) << 12U) | ((uint32_t)(patch)));
3782 }
3783 template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
versionMajor(T const version)3784 VULKAN_HPP_DEPRECATED("This define is deprecated. VK_API_VERSION_MAJOR should be used instead.") VULKAN_HPP_CONSTEXPR uint32_t versionMajor( T const version )
3785 {
3786 return ((uint32_t)(version) >> 22U);
3787 }
3788 template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
versionMinor(T const version)3789 VULKAN_HPP_DEPRECATED("This define is deprecated. VK_API_VERSION_MINOR should be used instead.") VULKAN_HPP_CONSTEXPR uint32_t versionMinor( T const version )
3790 {
3791 return (((uint32_t)(version) >> 12U) & 0x3FFU);
3792 }
3793 template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
versionPatch(T const version)3794 VULKAN_HPP_DEPRECATED("This define is deprecated. VK_API_VERSION_PATCH should be used instead.") VULKAN_HPP_CONSTEXPR uint32_t versionPatch( T const version )
3795 {
3796 return ((uint32_t)(version) & 0xFFFU);
3797 }
3798
3799 //=========================
3800 //=== CONSTEXPR CALLERs ===
3801 //=========================
3802 VULKAN_HPP_CONSTEXPR_INLINE auto ApiVersion = makeApiVersion( 0, 1, 0, 0 );
3803 VULKAN_HPP_CONSTEXPR_INLINE auto ApiVersion10 = makeApiVersion( 0, 1, 0, 0 );
3804 VULKAN_HPP_CONSTEXPR_INLINE auto ApiVersion11 = makeApiVersion( 0, 1, 1, 0 );
3805 VULKAN_HPP_CONSTEXPR_INLINE auto ApiVersion12 = makeApiVersion( 0, 1, 2, 0 );
3806 VULKAN_HPP_CONSTEXPR_INLINE auto ApiVersion13 = makeApiVersion( 0, 1, 3, 0 );
3807 VULKAN_HPP_CONSTEXPR_INLINE auto HeaderVersionComplete = makeApiVersion( VKSC_API_VARIANT, 1, 0, VK_HEADER_VERSION );
3808
3809 //=================================
3810 //=== CONSTEXPR EXTENSION NAMEs ===
3811 //=================================
3812
3813
3814 //=== VK_KHR_surface ===
3815 VULKAN_HPP_CONSTEXPR_INLINE auto KHRSurfaceExtensionName = VK_KHR_SURFACE_EXTENSION_NAME;
3816 VULKAN_HPP_CONSTEXPR_INLINE auto KHRSurfaceSpecVersion = VK_KHR_SURFACE_SPEC_VERSION;
3817
3818 //=== VK_KHR_swapchain ===
3819 VULKAN_HPP_CONSTEXPR_INLINE auto KHRSwapchainExtensionName = VK_KHR_SWAPCHAIN_EXTENSION_NAME;
3820 VULKAN_HPP_CONSTEXPR_INLINE auto KHRSwapchainSpecVersion = VK_KHR_SWAPCHAIN_SPEC_VERSION;
3821
3822 //=== VK_KHR_display ===
3823 VULKAN_HPP_CONSTEXPR_INLINE auto KHRDisplayExtensionName = VK_KHR_DISPLAY_EXTENSION_NAME;
3824 VULKAN_HPP_CONSTEXPR_INLINE auto KHRDisplaySpecVersion = VK_KHR_DISPLAY_SPEC_VERSION;
3825
3826 //=== VK_KHR_display_swapchain ===
3827 VULKAN_HPP_CONSTEXPR_INLINE auto KHRDisplaySwapchainExtensionName = VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME;
3828 VULKAN_HPP_CONSTEXPR_INLINE auto KHRDisplaySwapchainSpecVersion = VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION;
3829
3830 //=== VK_EXT_depth_range_unrestricted ===
3831 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthRangeUnrestrictedExtensionName = VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME;
3832 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthRangeUnrestrictedSpecVersion = VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION;
3833
3834 //=== VK_NV_private_vendor_info ===
3835 VULKAN_HPP_CONSTEXPR_INLINE auto NVPrivateVendorInfoExtensionName = VK_NV_PRIVATE_VENDOR_INFO_EXTENSION_NAME;
3836 VULKAN_HPP_CONSTEXPR_INLINE auto NVPrivateVendorInfoSpecVersion = VK_NV_PRIVATE_VENDOR_INFO_SPEC_VERSION;
3837
3838 //=== VK_EXT_texture_compression_astc_hdr ===
3839 VULKAN_HPP_DEPRECATED( "The VK_EXT_texture_compression_astc_hdr extension has been promoted to core in version 1.3." ) VULKAN_HPP_CONSTEXPR_INLINE auto EXTTextureCompressionAstcHdrExtensionName = VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME;
3840 VULKAN_HPP_DEPRECATED( "The VK_EXT_texture_compression_astc_hdr extension has been promoted to core in version 1.3." ) VULKAN_HPP_CONSTEXPR_INLINE auto EXTTextureCompressionAstcHdrSpecVersion = VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_SPEC_VERSION;
3841
3842 //=== VK_EXT_astc_decode_mode ===
3843 VULKAN_HPP_CONSTEXPR_INLINE auto EXTAstcDecodeModeExtensionName = VK_EXT_ASTC_DECODE_MODE_EXTENSION_NAME;
3844 VULKAN_HPP_CONSTEXPR_INLINE auto EXTAstcDecodeModeSpecVersion = VK_EXT_ASTC_DECODE_MODE_SPEC_VERSION;
3845
3846 //=== VK_KHR_external_memory_fd ===
3847 VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalMemoryFdExtensionName = VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME;
3848 VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalMemoryFdSpecVersion = VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION;
3849
3850 //=== VK_KHR_external_semaphore_fd ===
3851 VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalSemaphoreFdExtensionName = VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME;
3852 VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalSemaphoreFdSpecVersion = VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION;
3853
3854 //=== VK_KHR_incremental_present ===
3855 VULKAN_HPP_CONSTEXPR_INLINE auto KHRIncrementalPresentExtensionName = VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME;
3856 VULKAN_HPP_CONSTEXPR_INLINE auto KHRIncrementalPresentSpecVersion = VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION;
3857
3858 //=== VK_EXT_direct_mode_display ===
3859 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDirectModeDisplayExtensionName = VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME;
3860 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDirectModeDisplaySpecVersion = VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION;
3861
3862 //=== VK_EXT_display_surface_counter ===
3863 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDisplaySurfaceCounterExtensionName = VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME;
3864 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDisplaySurfaceCounterSpecVersion = VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION;
3865
3866 //=== VK_EXT_display_control ===
3867 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDisplayControlExtensionName = VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME;
3868 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDisplayControlSpecVersion = VK_EXT_DISPLAY_CONTROL_SPEC_VERSION;
3869
3870 //=== VK_EXT_discard_rectangles ===
3871 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDiscardRectanglesExtensionName = VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME;
3872 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDiscardRectanglesSpecVersion = VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION;
3873
3874 //=== VK_EXT_conservative_rasterization ===
3875 VULKAN_HPP_CONSTEXPR_INLINE auto EXTConservativeRasterizationExtensionName = VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME;
3876 VULKAN_HPP_CONSTEXPR_INLINE auto EXTConservativeRasterizationSpecVersion = VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION;
3877
3878 //=== VK_EXT_depth_clip_enable ===
3879 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthClipEnableExtensionName = VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME;
3880 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthClipEnableSpecVersion = VK_EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION;
3881
3882 //=== VK_EXT_swapchain_colorspace ===
3883 VULKAN_HPP_CONSTEXPR_INLINE auto EXTSwapchainColorSpaceExtensionName = VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME;
3884 VULKAN_HPP_CONSTEXPR_INLINE auto EXTSwapchainColorSpaceSpecVersion = VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION;
3885
3886 //=== VK_EXT_hdr_metadata ===
3887 VULKAN_HPP_CONSTEXPR_INLINE auto EXTHdrMetadataExtensionName = VK_EXT_HDR_METADATA_EXTENSION_NAME;
3888 VULKAN_HPP_CONSTEXPR_INLINE auto EXTHdrMetadataSpecVersion = VK_EXT_HDR_METADATA_SPEC_VERSION;
3889
3890 //=== VK_KHR_shared_presentable_image ===
3891 VULKAN_HPP_CONSTEXPR_INLINE auto KHRSharedPresentableImageExtensionName = VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME;
3892 VULKAN_HPP_CONSTEXPR_INLINE auto KHRSharedPresentableImageSpecVersion = VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION;
3893
3894 //=== VK_KHR_external_fence_fd ===
3895 VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalFenceFdExtensionName = VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME;
3896 VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalFenceFdSpecVersion = VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION;
3897
3898 //=== VK_KHR_performance_query ===
3899 VULKAN_HPP_CONSTEXPR_INLINE auto KHRPerformanceQueryExtensionName = VK_KHR_PERFORMANCE_QUERY_EXTENSION_NAME;
3900 VULKAN_HPP_CONSTEXPR_INLINE auto KHRPerformanceQuerySpecVersion = VK_KHR_PERFORMANCE_QUERY_SPEC_VERSION;
3901
3902 //=== VK_KHR_get_surface_capabilities2 ===
3903 VULKAN_HPP_CONSTEXPR_INLINE auto KHRGetSurfaceCapabilities2ExtensionName = VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME;
3904 VULKAN_HPP_CONSTEXPR_INLINE auto KHRGetSurfaceCapabilities2SpecVersion = VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION;
3905
3906 //=== VK_KHR_get_display_properties2 ===
3907 VULKAN_HPP_CONSTEXPR_INLINE auto KHRGetDisplayProperties2ExtensionName = VK_KHR_GET_DISPLAY_PROPERTIES_2_EXTENSION_NAME;
3908 VULKAN_HPP_CONSTEXPR_INLINE auto KHRGetDisplayProperties2SpecVersion = VK_KHR_GET_DISPLAY_PROPERTIES_2_SPEC_VERSION;
3909
3910 //=== VK_EXT_external_memory_dma_buf ===
3911 VULKAN_HPP_CONSTEXPR_INLINE auto EXTExternalMemoryDmaBufExtensionName = VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME;
3912 VULKAN_HPP_CONSTEXPR_INLINE auto EXTExternalMemoryDmaBufSpecVersion = VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION;
3913
3914 //=== VK_EXT_queue_family_foreign ===
3915 VULKAN_HPP_CONSTEXPR_INLINE auto EXTQueueFamilyForeignExtensionName = VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME;
3916 VULKAN_HPP_CONSTEXPR_INLINE auto EXTQueueFamilyForeignSpecVersion = VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION;
3917
3918 //=== VK_EXT_debug_utils ===
3919 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDebugUtilsExtensionName = VK_EXT_DEBUG_UTILS_EXTENSION_NAME;
3920 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDebugUtilsSpecVersion = VK_EXT_DEBUG_UTILS_SPEC_VERSION;
3921
3922 //=== VK_EXT_shader_stencil_export ===
3923 VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderStencilExportExtensionName = VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME;
3924 VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderStencilExportSpecVersion = VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION;
3925
3926 //=== VK_EXT_sample_locations ===
3927 VULKAN_HPP_CONSTEXPR_INLINE auto EXTSampleLocationsExtensionName = VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME;
3928 VULKAN_HPP_CONSTEXPR_INLINE auto EXTSampleLocationsSpecVersion = VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION;
3929
3930 //=== VK_EXT_blend_operation_advanced ===
3931 VULKAN_HPP_CONSTEXPR_INLINE auto EXTBlendOperationAdvancedExtensionName = VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME;
3932 VULKAN_HPP_CONSTEXPR_INLINE auto EXTBlendOperationAdvancedSpecVersion = VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION;
3933
3934 //=== VK_EXT_post_depth_coverage ===
3935 VULKAN_HPP_CONSTEXPR_INLINE auto EXTPostDepthCoverageExtensionName = VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME;
3936 VULKAN_HPP_CONSTEXPR_INLINE auto EXTPostDepthCoverageSpecVersion = VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION;
3937
3938 //=== VK_EXT_image_drm_format_modifier ===
3939 VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageDrmFormatModifierExtensionName = VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME;
3940 VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageDrmFormatModifierSpecVersion = VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION;
3941
3942 //=== VK_EXT_filter_cubic ===
3943 VULKAN_HPP_CONSTEXPR_INLINE auto EXTFilterCubicExtensionName = VK_EXT_FILTER_CUBIC_EXTENSION_NAME;
3944 VULKAN_HPP_CONSTEXPR_INLINE auto EXTFilterCubicSpecVersion = VK_EXT_FILTER_CUBIC_SPEC_VERSION;
3945
3946 //=== VK_EXT_global_priority ===
3947 VULKAN_HPP_DEPRECATED( "The VK_EXT_global_priority extension has been promoted to VK_KHR_global_priority." ) VULKAN_HPP_CONSTEXPR_INLINE auto EXTGlobalPriorityExtensionName = VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME;
3948 VULKAN_HPP_DEPRECATED( "The VK_EXT_global_priority extension has been promoted to VK_KHR_global_priority." ) VULKAN_HPP_CONSTEXPR_INLINE auto EXTGlobalPrioritySpecVersion = VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION;
3949
3950 //=== VK_EXT_external_memory_host ===
3951 VULKAN_HPP_CONSTEXPR_INLINE auto EXTExternalMemoryHostExtensionName = VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME;
3952 VULKAN_HPP_CONSTEXPR_INLINE auto EXTExternalMemoryHostSpecVersion = VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION;
3953
3954 //=== VK_KHR_shader_clock ===
3955 VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderClockExtensionName = VK_KHR_SHADER_CLOCK_EXTENSION_NAME;
3956 VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderClockSpecVersion = VK_KHR_SHADER_CLOCK_SPEC_VERSION;
3957
3958 //=== VK_EXT_calibrated_timestamps ===
3959 VULKAN_HPP_CONSTEXPR_INLINE auto EXTCalibratedTimestampsExtensionName = VK_EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME;
3960 VULKAN_HPP_CONSTEXPR_INLINE auto EXTCalibratedTimestampsSpecVersion = VK_EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION;
3961
3962 //=== VK_EXT_vertex_attribute_divisor ===
3963 VULKAN_HPP_CONSTEXPR_INLINE auto EXTVertexAttributeDivisorExtensionName = VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME;
3964 VULKAN_HPP_CONSTEXPR_INLINE auto EXTVertexAttributeDivisorSpecVersion = VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION;
3965
3966 //=== VK_KHR_swapchain_mutable_format ===
3967 VULKAN_HPP_CONSTEXPR_INLINE auto KHRSwapchainMutableFormatExtensionName = VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME;
3968 VULKAN_HPP_CONSTEXPR_INLINE auto KHRSwapchainMutableFormatSpecVersion = VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_SPEC_VERSION;
3969
3970 //=== VK_EXT_pci_bus_info ===
3971 VULKAN_HPP_CONSTEXPR_INLINE auto EXTPciBusInfoExtensionName = VK_EXT_PCI_BUS_INFO_EXTENSION_NAME;
3972 VULKAN_HPP_CONSTEXPR_INLINE auto EXTPciBusInfoSpecVersion = VK_EXT_PCI_BUS_INFO_SPEC_VERSION;
3973
3974 //=== VK_KHR_shader_terminate_invocation ===
3975 VULKAN_HPP_DEPRECATED( "The VK_KHR_shader_terminate_invocation extension has been promoted to core in version 1.3." ) VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderTerminateInvocationExtensionName = VK_KHR_SHADER_TERMINATE_INVOCATION_EXTENSION_NAME;
3976 VULKAN_HPP_DEPRECATED( "The VK_KHR_shader_terminate_invocation extension has been promoted to core in version 1.3." ) VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderTerminateInvocationSpecVersion = VK_KHR_SHADER_TERMINATE_INVOCATION_SPEC_VERSION;
3977
3978 //=== VK_EXT_subgroup_size_control ===
3979 VULKAN_HPP_DEPRECATED( "The VK_EXT_subgroup_size_control extension has been promoted to core in version 1.3." ) VULKAN_HPP_CONSTEXPR_INLINE auto EXTSubgroupSizeControlExtensionName = VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME;
3980 VULKAN_HPP_DEPRECATED( "The VK_EXT_subgroup_size_control extension has been promoted to core in version 1.3." ) VULKAN_HPP_CONSTEXPR_INLINE auto EXTSubgroupSizeControlSpecVersion = VK_EXT_SUBGROUP_SIZE_CONTROL_SPEC_VERSION;
3981
3982 //=== VK_KHR_fragment_shading_rate ===
3983 VULKAN_HPP_CONSTEXPR_INLINE auto KHRFragmentShadingRateExtensionName = VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME;
3984 VULKAN_HPP_CONSTEXPR_INLINE auto KHRFragmentShadingRateSpecVersion = VK_KHR_FRAGMENT_SHADING_RATE_SPEC_VERSION;
3985
3986 //=== VK_EXT_shader_image_atomic_int64 ===
3987 VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderImageAtomicInt64ExtensionName = VK_EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME;
3988 VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderImageAtomicInt64SpecVersion = VK_EXT_SHADER_IMAGE_ATOMIC_INT64_SPEC_VERSION;
3989
3990 //=== VK_EXT_memory_budget ===
3991 VULKAN_HPP_CONSTEXPR_INLINE auto EXTMemoryBudgetExtensionName = VK_EXT_MEMORY_BUDGET_EXTENSION_NAME;
3992 VULKAN_HPP_CONSTEXPR_INLINE auto EXTMemoryBudgetSpecVersion = VK_EXT_MEMORY_BUDGET_SPEC_VERSION;
3993
3994 //=== VK_EXT_validation_features ===
3995 VULKAN_HPP_CONSTEXPR_INLINE auto EXTValidationFeaturesExtensionName = VK_EXT_VALIDATION_FEATURES_EXTENSION_NAME;
3996 VULKAN_HPP_CONSTEXPR_INLINE auto EXTValidationFeaturesSpecVersion = VK_EXT_VALIDATION_FEATURES_SPEC_VERSION;
3997
3998 //=== VK_EXT_fragment_shader_interlock ===
3999 VULKAN_HPP_CONSTEXPR_INLINE auto EXTFragmentShaderInterlockExtensionName = VK_EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME;
4000 VULKAN_HPP_CONSTEXPR_INLINE auto EXTFragmentShaderInterlockSpecVersion = VK_EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION;
4001
4002 //=== VK_EXT_ycbcr_image_arrays ===
4003 VULKAN_HPP_CONSTEXPR_INLINE auto EXTYcbcrImageArraysExtensionName = VK_EXT_YCBCR_IMAGE_ARRAYS_EXTENSION_NAME;
4004 VULKAN_HPP_CONSTEXPR_INLINE auto EXTYcbcrImageArraysSpecVersion = VK_EXT_YCBCR_IMAGE_ARRAYS_SPEC_VERSION;
4005
4006 //=== VK_EXT_headless_surface ===
4007 VULKAN_HPP_CONSTEXPR_INLINE auto EXTHeadlessSurfaceExtensionName = VK_EXT_HEADLESS_SURFACE_EXTENSION_NAME;
4008 VULKAN_HPP_CONSTEXPR_INLINE auto EXTHeadlessSurfaceSpecVersion = VK_EXT_HEADLESS_SURFACE_SPEC_VERSION;
4009
4010 //=== VK_EXT_line_rasterization ===
4011 VULKAN_HPP_CONSTEXPR_INLINE auto EXTLineRasterizationExtensionName = VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME;
4012 VULKAN_HPP_CONSTEXPR_INLINE auto EXTLineRasterizationSpecVersion = VK_EXT_LINE_RASTERIZATION_SPEC_VERSION;
4013
4014 //=== VK_EXT_shader_atomic_float ===
4015 VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderAtomicFloatExtensionName = VK_EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME;
4016 VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderAtomicFloatSpecVersion = VK_EXT_SHADER_ATOMIC_FLOAT_SPEC_VERSION;
4017
4018 //=== VK_EXT_index_type_uint8 ===
4019 VULKAN_HPP_CONSTEXPR_INLINE auto EXTIndexTypeUint8ExtensionName = VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME;
4020 VULKAN_HPP_CONSTEXPR_INLINE auto EXTIndexTypeUint8SpecVersion = VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION;
4021
4022 //=== VK_EXT_extended_dynamic_state ===
4023 VULKAN_HPP_DEPRECATED( "The VK_EXT_extended_dynamic_state extension has been promoted to core in version 1.3." ) VULKAN_HPP_CONSTEXPR_INLINE auto EXTExtendedDynamicStateExtensionName = VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME;
4024 VULKAN_HPP_DEPRECATED( "The VK_EXT_extended_dynamic_state extension has been promoted to core in version 1.3." ) VULKAN_HPP_CONSTEXPR_INLINE auto EXTExtendedDynamicStateSpecVersion = VK_EXT_EXTENDED_DYNAMIC_STATE_SPEC_VERSION;
4025
4026 //=== VK_EXT_shader_demote_to_helper_invocation ===
4027 VULKAN_HPP_DEPRECATED( "The VK_EXT_shader_demote_to_helper_invocation extension has been promoted to core in version 1.3." ) VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderDemoteToHelperInvocationExtensionName = VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME;
4028 VULKAN_HPP_DEPRECATED( "The VK_EXT_shader_demote_to_helper_invocation extension has been promoted to core in version 1.3." ) VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderDemoteToHelperInvocationSpecVersion = VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_SPEC_VERSION;
4029
4030 //=== VK_EXT_texel_buffer_alignment ===
4031 VULKAN_HPP_DEPRECATED( "The VK_EXT_texel_buffer_alignment extension has been promoted to core in version 1.3." ) VULKAN_HPP_CONSTEXPR_INLINE auto EXTTexelBufferAlignmentExtensionName = VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME;
4032 VULKAN_HPP_DEPRECATED( "The VK_EXT_texel_buffer_alignment extension has been promoted to core in version 1.3." ) VULKAN_HPP_CONSTEXPR_INLINE auto EXTTexelBufferAlignmentSpecVersion = VK_EXT_TEXEL_BUFFER_ALIGNMENT_SPEC_VERSION;
4033
4034 //=== VK_EXT_robustness2 ===
4035 VULKAN_HPP_CONSTEXPR_INLINE auto EXTRobustness2ExtensionName = VK_EXT_ROBUSTNESS_2_EXTENSION_NAME;
4036 VULKAN_HPP_CONSTEXPR_INLINE auto EXTRobustness2SpecVersion = VK_EXT_ROBUSTNESS_2_SPEC_VERSION;
4037
4038 //=== VK_EXT_custom_border_color ===
4039 VULKAN_HPP_CONSTEXPR_INLINE auto EXTCustomBorderColorExtensionName = VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME;
4040 VULKAN_HPP_CONSTEXPR_INLINE auto EXTCustomBorderColorSpecVersion = VK_EXT_CUSTOM_BORDER_COLOR_SPEC_VERSION;
4041
4042 //=== VK_KHR_object_refresh ===
4043 VULKAN_HPP_CONSTEXPR_INLINE auto KHRObjectRefreshExtensionName = VK_KHR_OBJECT_REFRESH_EXTENSION_NAME;
4044 VULKAN_HPP_CONSTEXPR_INLINE auto KHRObjectRefreshSpecVersion = VK_KHR_OBJECT_REFRESH_SPEC_VERSION;
4045
4046 //=== VK_KHR_synchronization2 ===
4047 VULKAN_HPP_DEPRECATED( "The VK_KHR_synchronization2 extension has been promoted to core in version 1.3." ) VULKAN_HPP_CONSTEXPR_INLINE auto KHRSynchronization2ExtensionName = VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME;
4048 VULKAN_HPP_DEPRECATED( "The VK_KHR_synchronization2 extension has been promoted to core in version 1.3." ) VULKAN_HPP_CONSTEXPR_INLINE auto KHRSynchronization2SpecVersion = VK_KHR_SYNCHRONIZATION_2_SPEC_VERSION;
4049
4050 //=== VK_EXT_ycbcr_2plane_444_formats ===
4051 VULKAN_HPP_DEPRECATED( "The VK_EXT_ycbcr_2plane_444_formats extension has been promoted to core in version 1.3." ) VULKAN_HPP_CONSTEXPR_INLINE auto EXTYcbcr2Plane444FormatsExtensionName = VK_EXT_YCBCR_2PLANE_444_FORMATS_EXTENSION_NAME;
4052 VULKAN_HPP_DEPRECATED( "The VK_EXT_ycbcr_2plane_444_formats extension has been promoted to core in version 1.3." ) VULKAN_HPP_CONSTEXPR_INLINE auto EXTYcbcr2Plane444FormatsSpecVersion = VK_EXT_YCBCR_2PLANE_444_FORMATS_SPEC_VERSION;
4053
4054 //=== VK_EXT_image_robustness ===
4055 VULKAN_HPP_DEPRECATED( "The VK_EXT_image_robustness extension has been promoted to core in version 1.3." ) VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageRobustnessExtensionName = VK_EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME;
4056 VULKAN_HPP_DEPRECATED( "The VK_EXT_image_robustness extension has been promoted to core in version 1.3." ) VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageRobustnessSpecVersion = VK_EXT_IMAGE_ROBUSTNESS_SPEC_VERSION;
4057
4058 //=== VK_KHR_copy_commands2 ===
4059 VULKAN_HPP_DEPRECATED( "The VK_KHR_copy_commands2 extension has been promoted to core in version 1.3." ) VULKAN_HPP_CONSTEXPR_INLINE auto KHRCopyCommands2ExtensionName = VK_KHR_COPY_COMMANDS_2_EXTENSION_NAME;
4060 VULKAN_HPP_DEPRECATED( "The VK_KHR_copy_commands2 extension has been promoted to core in version 1.3." ) VULKAN_HPP_CONSTEXPR_INLINE auto KHRCopyCommands2SpecVersion = VK_KHR_COPY_COMMANDS_2_SPEC_VERSION;
4061
4062 //=== VK_EXT_4444_formats ===
4063 VULKAN_HPP_DEPRECATED( "The VK_EXT_4444_formats extension has been promoted to core in version 1.3." ) VULKAN_HPP_CONSTEXPR_INLINE auto EXT4444FormatsExtensionName = VK_EXT_4444_FORMATS_EXTENSION_NAME;
4064 VULKAN_HPP_DEPRECATED( "The VK_EXT_4444_formats extension has been promoted to core in version 1.3." ) VULKAN_HPP_CONSTEXPR_INLINE auto EXT4444FormatsSpecVersion = VK_EXT_4444_FORMATS_SPEC_VERSION;
4065
4066 //=== VK_EXT_vertex_input_dynamic_state ===
4067 VULKAN_HPP_CONSTEXPR_INLINE auto EXTVertexInputDynamicStateExtensionName = VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME;
4068 VULKAN_HPP_CONSTEXPR_INLINE auto EXTVertexInputDynamicStateSpecVersion = VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_SPEC_VERSION;
4069
4070 #if defined( VK_USE_PLATFORM_SCI )
4071 //=== VK_NV_external_sci_sync ===
4072 VULKAN_HPP_DEPRECATED( "The VK_NV_external_sci_sync extension has been deprecated by VK_NV_external_sci_sync2." ) VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalSciSyncExtensionName = VK_NV_EXTERNAL_SCI_SYNC_EXTENSION_NAME;
4073 VULKAN_HPP_DEPRECATED( "The VK_NV_external_sci_sync extension has been deprecated by VK_NV_external_sci_sync2." ) VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalSciSyncSpecVersion = VK_NV_EXTERNAL_SCI_SYNC_SPEC_VERSION;
4074 #endif /*VK_USE_PLATFORM_SCI*/
4075
4076 #if defined( VK_USE_PLATFORM_SCI )
4077 //=== VK_NV_external_memory_sci_buf ===
4078 VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalMemorySciBufExtensionName = VK_NV_EXTERNAL_MEMORY_SCI_BUF_EXTENSION_NAME;
4079 VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalMemorySciBufSpecVersion = VK_NV_EXTERNAL_MEMORY_SCI_BUF_SPEC_VERSION;
4080 #endif /*VK_USE_PLATFORM_SCI*/
4081
4082 //=== VK_EXT_extended_dynamic_state2 ===
4083 VULKAN_HPP_DEPRECATED( "The VK_EXT_extended_dynamic_state2 extension has been promoted to core in version 1.3." ) VULKAN_HPP_CONSTEXPR_INLINE auto EXTExtendedDynamicState2ExtensionName = VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME;
4084 VULKAN_HPP_DEPRECATED( "The VK_EXT_extended_dynamic_state2 extension has been promoted to core in version 1.3." ) VULKAN_HPP_CONSTEXPR_INLINE auto EXTExtendedDynamicState2SpecVersion = VK_EXT_EXTENDED_DYNAMIC_STATE_2_SPEC_VERSION;
4085
4086 //=== VK_EXT_color_write_enable ===
4087 VULKAN_HPP_CONSTEXPR_INLINE auto EXTColorWriteEnableExtensionName = VK_EXT_COLOR_WRITE_ENABLE_EXTENSION_NAME;
4088 VULKAN_HPP_CONSTEXPR_INLINE auto EXTColorWriteEnableSpecVersion = VK_EXT_COLOR_WRITE_ENABLE_SPEC_VERSION;
4089
4090 //=== VK_EXT_application_parameters ===
4091 VULKAN_HPP_CONSTEXPR_INLINE auto EXTApplicationParametersExtensionName = VK_EXT_APPLICATION_PARAMETERS_EXTENSION_NAME;
4092 VULKAN_HPP_CONSTEXPR_INLINE auto EXTApplicationParametersSpecVersion = VK_EXT_APPLICATION_PARAMETERS_SPEC_VERSION;
4093
4094 #if defined( VK_USE_PLATFORM_SCI )
4095 //=== VK_NV_external_sci_sync2 ===
4096 VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalSciSync2ExtensionName = VK_NV_EXTERNAL_SCI_SYNC_2_EXTENSION_NAME;
4097 VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalSciSync2SpecVersion = VK_NV_EXTERNAL_SCI_SYNC_2_SPEC_VERSION;
4098 #endif /*VK_USE_PLATFORM_SCI*/
4099
4100 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
4101 //=== VK_QNX_external_memory_screen_buffer ===
4102 VULKAN_HPP_CONSTEXPR_INLINE auto QNXExternalMemoryScreenBufferExtensionName = VK_QNX_EXTERNAL_MEMORY_SCREEN_BUFFER_EXTENSION_NAME;
4103 VULKAN_HPP_CONSTEXPR_INLINE auto QNXExternalMemoryScreenBufferSpecVersion = VK_QNX_EXTERNAL_MEMORY_SCREEN_BUFFER_SPEC_VERSION;
4104 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
4105
4106
4107 } // namespace VULKAN_HPP_NAMESPACE
4108
4109 // clang-format off
4110 #include <vulkan/vulkansc_handles.hpp>
4111 #include <vulkan/vulkansc_structs.hpp>
4112 #include <vulkan/vulkansc_funcs.hpp>
4113 // clang-format on
4114
4115
4116 namespace VULKAN_HPP_NAMESPACE
4117 {
4118 #if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
4119
4120 //=======================
4121 //=== STRUCTS EXTENDS ===
4122 //=======================
4123
4124
4125 //=== VK_VERSION_1_1 ===
4126 template <> struct StructExtends<PhysicalDeviceSubgroupProperties, PhysicalDeviceProperties2>{ enum { value = true }; };
4127 template <> struct StructExtends<PhysicalDevice16BitStorageFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
4128 template <> struct StructExtends<PhysicalDevice16BitStorageFeatures, DeviceCreateInfo>{ enum { value = true }; };
4129 template <> struct StructExtends<MemoryDedicatedRequirements, MemoryRequirements2>{ enum { value = true }; };
4130 template <> struct StructExtends<MemoryDedicatedAllocateInfo, MemoryAllocateInfo>{ enum { value = true }; };
4131 template <> struct StructExtends<MemoryAllocateFlagsInfo, MemoryAllocateInfo>{ enum { value = true }; };
4132 template <> struct StructExtends<DeviceGroupRenderPassBeginInfo, RenderPassBeginInfo>{ enum { value = true }; };
4133 template <> struct StructExtends<DeviceGroupRenderPassBeginInfo, RenderingInfo>{ enum { value = true }; };
4134 template <> struct StructExtends<DeviceGroupCommandBufferBeginInfo, CommandBufferBeginInfo>{ enum { value = true }; };
4135 template <> struct StructExtends<DeviceGroupSubmitInfo, SubmitInfo>{ enum { value = true }; };
4136 template <> struct StructExtends<BindBufferMemoryDeviceGroupInfo, BindBufferMemoryInfo>{ enum { value = true }; };
4137 template <> struct StructExtends<BindImageMemoryDeviceGroupInfo, BindImageMemoryInfo>{ enum { value = true }; };
4138 template <> struct StructExtends<DeviceGroupDeviceCreateInfo, DeviceCreateInfo>{ enum { value = true }; };
4139 template <> struct StructExtends<PhysicalDeviceFeatures2, DeviceCreateInfo>{ enum { value = true }; };
4140 template <> struct StructExtends<PhysicalDevicePointClippingProperties, PhysicalDeviceProperties2>{ enum { value = true }; };
4141 template <> struct StructExtends<RenderPassInputAttachmentAspectCreateInfo, RenderPassCreateInfo>{ enum { value = true }; };
4142 template <> struct StructExtends<ImageViewUsageCreateInfo, ImageViewCreateInfo>{ enum { value = true }; };
4143 template <> struct StructExtends<PipelineTessellationDomainOriginStateCreateInfo, PipelineTessellationStateCreateInfo>{ enum { value = true }; };
4144 template <> struct StructExtends<RenderPassMultiviewCreateInfo, RenderPassCreateInfo>{ enum { value = true }; };
4145 template <> struct StructExtends<PhysicalDeviceMultiviewFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
4146 template <> struct StructExtends<PhysicalDeviceMultiviewFeatures, DeviceCreateInfo>{ enum { value = true }; };
4147 template <> struct StructExtends<PhysicalDeviceMultiviewProperties, PhysicalDeviceProperties2>{ enum { value = true }; };
4148 template <> struct StructExtends<PhysicalDeviceVariablePointersFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
4149 template <> struct StructExtends<PhysicalDeviceVariablePointersFeatures, DeviceCreateInfo>{ enum { value = true }; };
4150 template <> struct StructExtends<PhysicalDeviceProtectedMemoryFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
4151 template <> struct StructExtends<PhysicalDeviceProtectedMemoryFeatures, DeviceCreateInfo>{ enum { value = true }; };
4152 template <> struct StructExtends<PhysicalDeviceProtectedMemoryProperties, PhysicalDeviceProperties2>{ enum { value = true }; };
4153 template <> struct StructExtends<ProtectedSubmitInfo, SubmitInfo>{ enum { value = true }; };
4154 template <> struct StructExtends<SamplerYcbcrConversionInfo, SamplerCreateInfo>{ enum { value = true }; };
4155 template <> struct StructExtends<SamplerYcbcrConversionInfo, ImageViewCreateInfo>{ enum { value = true }; };
4156 template <> struct StructExtends<BindImagePlaneMemoryInfo, BindImageMemoryInfo>{ enum { value = true }; };
4157 template <> struct StructExtends<ImagePlaneMemoryRequirementsInfo, ImageMemoryRequirementsInfo2>{ enum { value = true }; };
4158 template <> struct StructExtends<PhysicalDeviceSamplerYcbcrConversionFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
4159 template <> struct StructExtends<PhysicalDeviceSamplerYcbcrConversionFeatures, DeviceCreateInfo>{ enum { value = true }; };
4160 template <> struct StructExtends<SamplerYcbcrConversionImageFormatProperties, ImageFormatProperties2>{ enum { value = true }; };
4161 template <> struct StructExtends<PhysicalDeviceExternalImageFormatInfo, PhysicalDeviceImageFormatInfo2>{ enum { value = true }; };
4162 template <> struct StructExtends<ExternalImageFormatProperties, ImageFormatProperties2>{ enum { value = true }; };
4163 template <> struct StructExtends<PhysicalDeviceIDProperties, PhysicalDeviceProperties2>{ enum { value = true }; };
4164 template <> struct StructExtends<ExternalMemoryImageCreateInfo, ImageCreateInfo>{ enum { value = true }; };
4165 template <> struct StructExtends<ExternalMemoryBufferCreateInfo, BufferCreateInfo>{ enum { value = true }; };
4166 template <> struct StructExtends<ExportMemoryAllocateInfo, MemoryAllocateInfo>{ enum { value = true }; };
4167 template <> struct StructExtends<ExportFenceCreateInfo, FenceCreateInfo>{ enum { value = true }; };
4168 template <> struct StructExtends<ExportSemaphoreCreateInfo, SemaphoreCreateInfo>{ enum { value = true }; };
4169 template <> struct StructExtends<PhysicalDeviceMaintenance3Properties, PhysicalDeviceProperties2>{ enum { value = true }; };
4170 template <> struct StructExtends<PhysicalDeviceShaderDrawParametersFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
4171 template <> struct StructExtends<PhysicalDeviceShaderDrawParametersFeatures, DeviceCreateInfo>{ enum { value = true }; };
4172
4173 //=== VK_VERSION_1_2 ===
4174 template <> struct StructExtends<PhysicalDeviceVulkan11Features, PhysicalDeviceFeatures2>{ enum { value = true }; };
4175 template <> struct StructExtends<PhysicalDeviceVulkan11Features, DeviceCreateInfo>{ enum { value = true }; };
4176 template <> struct StructExtends<PhysicalDeviceVulkan11Properties, PhysicalDeviceProperties2>{ enum { value = true }; };
4177 template <> struct StructExtends<PhysicalDeviceVulkan12Features, PhysicalDeviceFeatures2>{ enum { value = true }; };
4178 template <> struct StructExtends<PhysicalDeviceVulkan12Features, DeviceCreateInfo>{ enum { value = true }; };
4179 template <> struct StructExtends<PhysicalDeviceVulkan12Properties, PhysicalDeviceProperties2>{ enum { value = true }; };
4180 template <> struct StructExtends<ImageFormatListCreateInfo, ImageCreateInfo>{ enum { value = true }; };
4181 template <> struct StructExtends<ImageFormatListCreateInfo, SwapchainCreateInfoKHR>{ enum { value = true }; };
4182 template <> struct StructExtends<ImageFormatListCreateInfo, PhysicalDeviceImageFormatInfo2>{ enum { value = true }; };
4183 template <> struct StructExtends<PhysicalDevice8BitStorageFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
4184 template <> struct StructExtends<PhysicalDevice8BitStorageFeatures, DeviceCreateInfo>{ enum { value = true }; };
4185 template <> struct StructExtends<PhysicalDeviceDriverProperties, PhysicalDeviceProperties2>{ enum { value = true }; };
4186 template <> struct StructExtends<PhysicalDeviceShaderAtomicInt64Features, PhysicalDeviceFeatures2>{ enum { value = true }; };
4187 template <> struct StructExtends<PhysicalDeviceShaderAtomicInt64Features, DeviceCreateInfo>{ enum { value = true }; };
4188 template <> struct StructExtends<PhysicalDeviceShaderFloat16Int8Features, PhysicalDeviceFeatures2>{ enum { value = true }; };
4189 template <> struct StructExtends<PhysicalDeviceShaderFloat16Int8Features, DeviceCreateInfo>{ enum { value = true }; };
4190 template <> struct StructExtends<PhysicalDeviceFloatControlsProperties, PhysicalDeviceProperties2>{ enum { value = true }; };
4191 template <> struct StructExtends<DescriptorSetLayoutBindingFlagsCreateInfo, DescriptorSetLayoutCreateInfo>{ enum { value = true }; };
4192 template <> struct StructExtends<PhysicalDeviceDescriptorIndexingFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
4193 template <> struct StructExtends<PhysicalDeviceDescriptorIndexingFeatures, DeviceCreateInfo>{ enum { value = true }; };
4194 template <> struct StructExtends<PhysicalDeviceDescriptorIndexingProperties, PhysicalDeviceProperties2>{ enum { value = true }; };
4195 template <> struct StructExtends<DescriptorSetVariableDescriptorCountAllocateInfo, DescriptorSetAllocateInfo>{ enum { value = true }; };
4196 template <> struct StructExtends<DescriptorSetVariableDescriptorCountLayoutSupport, DescriptorSetLayoutSupport>{ enum { value = true }; };
4197 template <> struct StructExtends<SubpassDescriptionDepthStencilResolve, SubpassDescription2>{ enum { value = true }; };
4198 template <> struct StructExtends<PhysicalDeviceDepthStencilResolveProperties, PhysicalDeviceProperties2>{ enum { value = true }; };
4199 template <> struct StructExtends<PhysicalDeviceScalarBlockLayoutFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
4200 template <> struct StructExtends<PhysicalDeviceScalarBlockLayoutFeatures, DeviceCreateInfo>{ enum { value = true }; };
4201 template <> struct StructExtends<ImageStencilUsageCreateInfo, ImageCreateInfo>{ enum { value = true }; };
4202 template <> struct StructExtends<ImageStencilUsageCreateInfo, PhysicalDeviceImageFormatInfo2>{ enum { value = true }; };
4203 template <> struct StructExtends<SamplerReductionModeCreateInfo, SamplerCreateInfo>{ enum { value = true }; };
4204 template <> struct StructExtends<PhysicalDeviceSamplerFilterMinmaxProperties, PhysicalDeviceProperties2>{ enum { value = true }; };
4205 template <> struct StructExtends<PhysicalDeviceVulkanMemoryModelFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
4206 template <> struct StructExtends<PhysicalDeviceVulkanMemoryModelFeatures, DeviceCreateInfo>{ enum { value = true }; };
4207 template <> struct StructExtends<PhysicalDeviceImagelessFramebufferFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
4208 template <> struct StructExtends<PhysicalDeviceImagelessFramebufferFeatures, DeviceCreateInfo>{ enum { value = true }; };
4209 template <> struct StructExtends<FramebufferAttachmentsCreateInfo, FramebufferCreateInfo>{ enum { value = true }; };
4210 template <> struct StructExtends<RenderPassAttachmentBeginInfo, RenderPassBeginInfo>{ enum { value = true }; };
4211 template <> struct StructExtends<PhysicalDeviceUniformBufferStandardLayoutFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
4212 template <> struct StructExtends<PhysicalDeviceUniformBufferStandardLayoutFeatures, DeviceCreateInfo>{ enum { value = true }; };
4213 template <> struct StructExtends<PhysicalDeviceShaderSubgroupExtendedTypesFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
4214 template <> struct StructExtends<PhysicalDeviceShaderSubgroupExtendedTypesFeatures, DeviceCreateInfo>{ enum { value = true }; };
4215 template <> struct StructExtends<PhysicalDeviceSeparateDepthStencilLayoutsFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
4216 template <> struct StructExtends<PhysicalDeviceSeparateDepthStencilLayoutsFeatures, DeviceCreateInfo>{ enum { value = true }; };
4217 template <> struct StructExtends<AttachmentReferenceStencilLayout, AttachmentReference2>{ enum { value = true }; };
4218 template <> struct StructExtends<AttachmentDescriptionStencilLayout, AttachmentDescription2>{ enum { value = true }; };
4219 template <> struct StructExtends<PhysicalDeviceHostQueryResetFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
4220 template <> struct StructExtends<PhysicalDeviceHostQueryResetFeatures, DeviceCreateInfo>{ enum { value = true }; };
4221 template <> struct StructExtends<PhysicalDeviceTimelineSemaphoreFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
4222 template <> struct StructExtends<PhysicalDeviceTimelineSemaphoreFeatures, DeviceCreateInfo>{ enum { value = true }; };
4223 template <> struct StructExtends<PhysicalDeviceTimelineSemaphoreProperties, PhysicalDeviceProperties2>{ enum { value = true }; };
4224 template <> struct StructExtends<SemaphoreTypeCreateInfo, SemaphoreCreateInfo>{ enum { value = true }; };
4225 template <> struct StructExtends<SemaphoreTypeCreateInfo, PhysicalDeviceExternalSemaphoreInfo>{ enum { value = true }; };
4226 template <> struct StructExtends<TimelineSemaphoreSubmitInfo, SubmitInfo>{ enum { value = true }; };
4227 template <> struct StructExtends<TimelineSemaphoreSubmitInfo, BindSparseInfo>{ enum { value = true }; };
4228 template <> struct StructExtends<PhysicalDeviceBufferDeviceAddressFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
4229 template <> struct StructExtends<PhysicalDeviceBufferDeviceAddressFeatures, DeviceCreateInfo>{ enum { value = true }; };
4230 template <> struct StructExtends<BufferOpaqueCaptureAddressCreateInfo, BufferCreateInfo>{ enum { value = true }; };
4231 template <> struct StructExtends<MemoryOpaqueCaptureAddressAllocateInfo, MemoryAllocateInfo>{ enum { value = true }; };
4232
4233 //=== VK_VERSION_1_3 ===
4234 template <> struct StructExtends<PhysicalDeviceVulkan13Features, PhysicalDeviceFeatures2>{ enum { value = true }; };
4235 template <> struct StructExtends<PhysicalDeviceVulkan13Features, DeviceCreateInfo>{ enum { value = true }; };
4236 template <> struct StructExtends<PhysicalDeviceVulkan13Properties, PhysicalDeviceProperties2>{ enum { value = true }; };
4237 template <> struct StructExtends<PipelineCreationFeedbackCreateInfo, GraphicsPipelineCreateInfo>{ enum { value = true }; };
4238 template <> struct StructExtends<PipelineCreationFeedbackCreateInfo, ComputePipelineCreateInfo>{ enum { value = true }; };
4239 template <> struct StructExtends<PipelineCreationFeedbackCreateInfo, RayTracingPipelineCreateInfoNV>{ enum { value = true }; };
4240 template <> struct StructExtends<PipelineCreationFeedbackCreateInfo, RayTracingPipelineCreateInfoKHR>{ enum { value = true }; };
4241 template <> struct StructExtends<PipelineCreationFeedbackCreateInfo, ExecutionGraphPipelineCreateInfoAMDX>{ enum { value = true }; };
4242 template <> struct StructExtends<PhysicalDeviceShaderTerminateInvocationFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
4243 template <> struct StructExtends<PhysicalDeviceShaderTerminateInvocationFeatures, DeviceCreateInfo>{ enum { value = true }; };
4244 template <> struct StructExtends<PhysicalDeviceShaderDemoteToHelperInvocationFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
4245 template <> struct StructExtends<PhysicalDeviceShaderDemoteToHelperInvocationFeatures, DeviceCreateInfo>{ enum { value = true }; };
4246 template <> struct StructExtends<PhysicalDevicePrivateDataFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
4247 template <> struct StructExtends<PhysicalDevicePrivateDataFeatures, DeviceCreateInfo>{ enum { value = true }; };
4248 template <> struct StructExtends<DevicePrivateDataCreateInfo, DeviceCreateInfo>{ enum { value = true }; };
4249 template <> struct StructExtends<PhysicalDevicePipelineCreationCacheControlFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
4250 template <> struct StructExtends<PhysicalDevicePipelineCreationCacheControlFeatures, DeviceCreateInfo>{ enum { value = true }; };
4251 template <> struct StructExtends<MemoryBarrier2, SubpassDependency2>{ enum { value = true }; };
4252 template <> struct StructExtends<PhysicalDeviceSynchronization2Features, PhysicalDeviceFeatures2>{ enum { value = true }; };
4253 template <> struct StructExtends<PhysicalDeviceSynchronization2Features, DeviceCreateInfo>{ enum { value = true }; };
4254 template <> struct StructExtends<PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
4255 template <> struct StructExtends<PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures, DeviceCreateInfo>{ enum { value = true }; };
4256 template <> struct StructExtends<PhysicalDeviceImageRobustnessFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
4257 template <> struct StructExtends<PhysicalDeviceImageRobustnessFeatures, DeviceCreateInfo>{ enum { value = true }; };
4258 template <> struct StructExtends<PhysicalDeviceSubgroupSizeControlFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
4259 template <> struct StructExtends<PhysicalDeviceSubgroupSizeControlFeatures, DeviceCreateInfo>{ enum { value = true }; };
4260 template <> struct StructExtends<PhysicalDeviceSubgroupSizeControlProperties, PhysicalDeviceProperties2>{ enum { value = true }; };
4261 template <> struct StructExtends<PipelineShaderStageRequiredSubgroupSizeCreateInfo, PipelineShaderStageCreateInfo>{ enum { value = true }; };
4262 template <> struct StructExtends<PipelineShaderStageRequiredSubgroupSizeCreateInfo, ShaderCreateInfoEXT>{ enum { value = true }; };
4263 template <> struct StructExtends<PhysicalDeviceInlineUniformBlockFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
4264 template <> struct StructExtends<PhysicalDeviceInlineUniformBlockFeatures, DeviceCreateInfo>{ enum { value = true }; };
4265 template <> struct StructExtends<PhysicalDeviceInlineUniformBlockProperties, PhysicalDeviceProperties2>{ enum { value = true }; };
4266 template <> struct StructExtends<WriteDescriptorSetInlineUniformBlock, WriteDescriptorSet>{ enum { value = true }; };
4267 template <> struct StructExtends<DescriptorPoolInlineUniformBlockCreateInfo, DescriptorPoolCreateInfo>{ enum { value = true }; };
4268 template <> struct StructExtends<PhysicalDeviceTextureCompressionASTCHDRFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
4269 template <> struct StructExtends<PhysicalDeviceTextureCompressionASTCHDRFeatures, DeviceCreateInfo>{ enum { value = true }; };
4270 template <> struct StructExtends<PipelineRenderingCreateInfo, GraphicsPipelineCreateInfo>{ enum { value = true }; };
4271 template <> struct StructExtends<PhysicalDeviceDynamicRenderingFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
4272 template <> struct StructExtends<PhysicalDeviceDynamicRenderingFeatures, DeviceCreateInfo>{ enum { value = true }; };
4273 template <> struct StructExtends<CommandBufferInheritanceRenderingInfo, CommandBufferInheritanceInfo>{ enum { value = true }; };
4274 template <> struct StructExtends<PhysicalDeviceShaderIntegerDotProductFeatures, PhysicalDeviceFeatures2>{ enum { value = true }; };
4275 template <> struct StructExtends<PhysicalDeviceShaderIntegerDotProductFeatures, DeviceCreateInfo>{ enum { value = true }; };
4276 template <> struct StructExtends<PhysicalDeviceShaderIntegerDotProductProperties, PhysicalDeviceProperties2>{ enum { value = true }; };
4277 template <> struct StructExtends<PhysicalDeviceTexelBufferAlignmentProperties, PhysicalDeviceProperties2>{ enum { value = true }; };
4278 template <> struct StructExtends<FormatProperties3, FormatProperties2>{ enum { value = true }; };
4279 template <> struct StructExtends<PhysicalDeviceMaintenance4Features, PhysicalDeviceFeatures2>{ enum { value = true }; };
4280 template <> struct StructExtends<PhysicalDeviceMaintenance4Features, DeviceCreateInfo>{ enum { value = true }; };
4281 template <> struct StructExtends<PhysicalDeviceMaintenance4Properties, PhysicalDeviceProperties2>{ enum { value = true }; };
4282
4283 //=== VKSC_VERSION_1_0 ===
4284 template <> struct StructExtends<PhysicalDeviceVulkanSC10Features, PhysicalDeviceFeatures2>{ enum { value = true }; };
4285 template <> struct StructExtends<PhysicalDeviceVulkanSC10Features, DeviceCreateInfo>{ enum { value = true }; };
4286 template <> struct StructExtends<PhysicalDeviceVulkanSC10Properties, PhysicalDeviceProperties2>{ enum { value = true }; };
4287 template <> struct StructExtends<DeviceObjectReservationCreateInfo, DeviceCreateInfo>{ enum { value = true }; };
4288 template <> struct StructExtends<CommandPoolMemoryReservationCreateInfo, CommandPoolCreateInfo>{ enum { value = true }; };
4289 template <> struct StructExtends<FaultCallbackInfo, DeviceCreateInfo>{ enum { value = true }; };
4290 template <> struct StructExtends<PipelineOfflineCreateInfo, GraphicsPipelineCreateInfo>{ enum { value = true }; };
4291 template <> struct StructExtends<PipelineOfflineCreateInfo, ComputePipelineCreateInfo>{ enum { value = true }; };
4292 template <> struct StructExtends<PipelineOfflineCreateInfo, RayTracingPipelineCreateInfoKHR>{ enum { value = true }; };
4293 template <> struct StructExtends<PipelineOfflineCreateInfo, RayTracingPipelineCreateInfoNV>{ enum { value = true }; };
4294
4295 //=== VK_KHR_swapchain ===
4296 template <> struct StructExtends<ImageSwapchainCreateInfoKHR, ImageCreateInfo>{ enum { value = true }; };
4297 template <> struct StructExtends<BindImageMemorySwapchainInfoKHR, BindImageMemoryInfo>{ enum { value = true }; };
4298 template <> struct StructExtends<DeviceGroupPresentInfoKHR, PresentInfoKHR>{ enum { value = true }; };
4299 template <> struct StructExtends<DeviceGroupSwapchainCreateInfoKHR, SwapchainCreateInfoKHR>{ enum { value = true }; };
4300
4301 //=== VK_KHR_display_swapchain ===
4302 template <> struct StructExtends<DisplayPresentInfoKHR, PresentInfoKHR>{ enum { value = true }; };
4303
4304 //=== VK_EXT_astc_decode_mode ===
4305 template <> struct StructExtends<ImageViewASTCDecodeModeEXT, ImageViewCreateInfo>{ enum { value = true }; };
4306 template <> struct StructExtends<PhysicalDeviceASTCDecodeFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
4307 template <> struct StructExtends<PhysicalDeviceASTCDecodeFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
4308
4309 //=== VK_KHR_external_memory_fd ===
4310 template <> struct StructExtends<ImportMemoryFdInfoKHR, MemoryAllocateInfo>{ enum { value = true }; };
4311
4312 //=== VK_KHR_incremental_present ===
4313 template <> struct StructExtends<PresentRegionsKHR, PresentInfoKHR>{ enum { value = true }; };
4314
4315 //=== VK_EXT_display_control ===
4316 template <> struct StructExtends<SwapchainCounterCreateInfoEXT, SwapchainCreateInfoKHR>{ enum { value = true }; };
4317
4318 //=== VK_EXT_discard_rectangles ===
4319 template <> struct StructExtends<PhysicalDeviceDiscardRectanglePropertiesEXT, PhysicalDeviceProperties2>{ enum { value = true }; };
4320 template <> struct StructExtends<PipelineDiscardRectangleStateCreateInfoEXT, GraphicsPipelineCreateInfo>{ enum { value = true }; };
4321
4322 //=== VK_EXT_conservative_rasterization ===
4323 template <> struct StructExtends<PhysicalDeviceConservativeRasterizationPropertiesEXT, PhysicalDeviceProperties2>{ enum { value = true }; };
4324 template <> struct StructExtends<PipelineRasterizationConservativeStateCreateInfoEXT, PipelineRasterizationStateCreateInfo>{ enum { value = true }; };
4325
4326 //=== VK_EXT_depth_clip_enable ===
4327 template <> struct StructExtends<PhysicalDeviceDepthClipEnableFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
4328 template <> struct StructExtends<PhysicalDeviceDepthClipEnableFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
4329 template <> struct StructExtends<PipelineRasterizationDepthClipStateCreateInfoEXT, PipelineRasterizationStateCreateInfo>{ enum { value = true }; };
4330
4331 //=== VK_KHR_shared_presentable_image ===
4332 template <> struct StructExtends<SharedPresentSurfaceCapabilitiesKHR, SurfaceCapabilities2KHR>{ enum { value = true }; };
4333
4334 //=== VK_KHR_performance_query ===
4335 template <> struct StructExtends<PhysicalDevicePerformanceQueryFeaturesKHR, PhysicalDeviceFeatures2>{ enum { value = true }; };
4336 template <> struct StructExtends<PhysicalDevicePerformanceQueryFeaturesKHR, DeviceCreateInfo>{ enum { value = true }; };
4337 template <> struct StructExtends<PhysicalDevicePerformanceQueryPropertiesKHR, PhysicalDeviceProperties2>{ enum { value = true }; };
4338 template <> struct StructExtends<QueryPoolPerformanceCreateInfoKHR, QueryPoolCreateInfo>{ enum { value = true }; };
4339 template <> struct StructExtends<PerformanceQuerySubmitInfoKHR, SubmitInfo>{ enum { value = true }; };
4340 template <> struct StructExtends<PerformanceQuerySubmitInfoKHR, SubmitInfo2>{ enum { value = true }; };
4341 template <> struct StructExtends<PerformanceQueryReservationInfoKHR, DeviceCreateInfo>{ enum { value = true }; };
4342
4343 //=== VK_EXT_debug_utils ===
4344 template <> struct StructExtends<DebugUtilsMessengerCreateInfoEXT, InstanceCreateInfo>{ enum { value = true }; };
4345 template <> struct StructExtends<DebugUtilsObjectNameInfoEXT, PipelineShaderStageCreateInfo>{ enum { value = true }; };
4346
4347 //=== VK_EXT_sample_locations ===
4348 template <> struct StructExtends<SampleLocationsInfoEXT, ImageMemoryBarrier>{ enum { value = true }; };
4349 template <> struct StructExtends<SampleLocationsInfoEXT, ImageMemoryBarrier2>{ enum { value = true }; };
4350 template <> struct StructExtends<RenderPassSampleLocationsBeginInfoEXT, RenderPassBeginInfo>{ enum { value = true }; };
4351 template <> struct StructExtends<PipelineSampleLocationsStateCreateInfoEXT, PipelineMultisampleStateCreateInfo>{ enum { value = true }; };
4352 template <> struct StructExtends<PhysicalDeviceSampleLocationsPropertiesEXT, PhysicalDeviceProperties2>{ enum { value = true }; };
4353
4354 //=== VK_EXT_blend_operation_advanced ===
4355 template <> struct StructExtends<PhysicalDeviceBlendOperationAdvancedFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
4356 template <> struct StructExtends<PhysicalDeviceBlendOperationAdvancedFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
4357 template <> struct StructExtends<PhysicalDeviceBlendOperationAdvancedPropertiesEXT, PhysicalDeviceProperties2>{ enum { value = true }; };
4358 template <> struct StructExtends<PipelineColorBlendAdvancedStateCreateInfoEXT, PipelineColorBlendStateCreateInfo>{ enum { value = true }; };
4359
4360 //=== VK_EXT_image_drm_format_modifier ===
4361 template <> struct StructExtends<DrmFormatModifierPropertiesListEXT, FormatProperties2>{ enum { value = true }; };
4362 template <> struct StructExtends<PhysicalDeviceImageDrmFormatModifierInfoEXT, PhysicalDeviceImageFormatInfo2>{ enum { value = true }; };
4363 template <> struct StructExtends<ImageDrmFormatModifierListCreateInfoEXT, ImageCreateInfo>{ enum { value = true }; };
4364 template <> struct StructExtends<ImageDrmFormatModifierExplicitCreateInfoEXT, ImageCreateInfo>{ enum { value = true }; };
4365 template <> struct StructExtends<DrmFormatModifierPropertiesList2EXT, FormatProperties2>{ enum { value = true }; };
4366
4367 //=== VK_EXT_filter_cubic ===
4368 template <> struct StructExtends<PhysicalDeviceImageViewImageFormatInfoEXT, PhysicalDeviceImageFormatInfo2>{ enum { value = true }; };
4369 template <> struct StructExtends<FilterCubicImageViewImageFormatPropertiesEXT, ImageFormatProperties2>{ enum { value = true }; };
4370
4371 //=== VK_EXT_external_memory_host ===
4372 template <> struct StructExtends<ImportMemoryHostPointerInfoEXT, MemoryAllocateInfo>{ enum { value = true }; };
4373 template <> struct StructExtends<PhysicalDeviceExternalMemoryHostPropertiesEXT, PhysicalDeviceProperties2>{ enum { value = true }; };
4374
4375 //=== VK_KHR_shader_clock ===
4376 template <> struct StructExtends<PhysicalDeviceShaderClockFeaturesKHR, PhysicalDeviceFeatures2>{ enum { value = true }; };
4377 template <> struct StructExtends<PhysicalDeviceShaderClockFeaturesKHR, DeviceCreateInfo>{ enum { value = true }; };
4378
4379 //=== VK_EXT_vertex_attribute_divisor ===
4380 template <> struct StructExtends<PhysicalDeviceVertexAttributeDivisorPropertiesEXT, PhysicalDeviceProperties2>{ enum { value = true }; };
4381 template <> struct StructExtends<PipelineVertexInputDivisorStateCreateInfoEXT, PipelineVertexInputStateCreateInfo>{ enum { value = true }; };
4382 template <> struct StructExtends<PhysicalDeviceVertexAttributeDivisorFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
4383 template <> struct StructExtends<PhysicalDeviceVertexAttributeDivisorFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
4384
4385 //=== VK_EXT_pci_bus_info ===
4386 template <> struct StructExtends<PhysicalDevicePCIBusInfoPropertiesEXT, PhysicalDeviceProperties2>{ enum { value = true }; };
4387
4388 //=== VK_KHR_fragment_shading_rate ===
4389 template <> struct StructExtends<FragmentShadingRateAttachmentInfoKHR, SubpassDescription2>{ enum { value = true }; };
4390 template <> struct StructExtends<PipelineFragmentShadingRateStateCreateInfoKHR, GraphicsPipelineCreateInfo>{ enum { value = true }; };
4391 template <> struct StructExtends<PhysicalDeviceFragmentShadingRateFeaturesKHR, PhysicalDeviceFeatures2>{ enum { value = true }; };
4392 template <> struct StructExtends<PhysicalDeviceFragmentShadingRateFeaturesKHR, DeviceCreateInfo>{ enum { value = true }; };
4393 template <> struct StructExtends<PhysicalDeviceFragmentShadingRatePropertiesKHR, PhysicalDeviceProperties2>{ enum { value = true }; };
4394
4395 //=== VK_EXT_shader_image_atomic_int64 ===
4396 template <> struct StructExtends<PhysicalDeviceShaderImageAtomicInt64FeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
4397 template <> struct StructExtends<PhysicalDeviceShaderImageAtomicInt64FeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
4398
4399 //=== VK_EXT_memory_budget ===
4400 template <> struct StructExtends<PhysicalDeviceMemoryBudgetPropertiesEXT, PhysicalDeviceMemoryProperties2>{ enum { value = true }; };
4401
4402 //=== VK_EXT_validation_features ===
4403 template <> struct StructExtends<ValidationFeaturesEXT, InstanceCreateInfo>{ enum { value = true }; };
4404
4405 //=== VK_EXT_fragment_shader_interlock ===
4406 template <> struct StructExtends<PhysicalDeviceFragmentShaderInterlockFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
4407 template <> struct StructExtends<PhysicalDeviceFragmentShaderInterlockFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
4408
4409 //=== VK_EXT_ycbcr_image_arrays ===
4410 template <> struct StructExtends<PhysicalDeviceYcbcrImageArraysFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
4411 template <> struct StructExtends<PhysicalDeviceYcbcrImageArraysFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
4412
4413 //=== VK_EXT_line_rasterization ===
4414 template <> struct StructExtends<PhysicalDeviceLineRasterizationFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
4415 template <> struct StructExtends<PhysicalDeviceLineRasterizationFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
4416 template <> struct StructExtends<PhysicalDeviceLineRasterizationPropertiesEXT, PhysicalDeviceProperties2>{ enum { value = true }; };
4417 template <> struct StructExtends<PipelineRasterizationLineStateCreateInfoEXT, PipelineRasterizationStateCreateInfo>{ enum { value = true }; };
4418
4419 //=== VK_EXT_shader_atomic_float ===
4420 template <> struct StructExtends<PhysicalDeviceShaderAtomicFloatFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
4421 template <> struct StructExtends<PhysicalDeviceShaderAtomicFloatFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
4422
4423 //=== VK_EXT_index_type_uint8 ===
4424 template <> struct StructExtends<PhysicalDeviceIndexTypeUint8FeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
4425 template <> struct StructExtends<PhysicalDeviceIndexTypeUint8FeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
4426
4427 //=== VK_EXT_extended_dynamic_state ===
4428 template <> struct StructExtends<PhysicalDeviceExtendedDynamicStateFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
4429 template <> struct StructExtends<PhysicalDeviceExtendedDynamicStateFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
4430
4431 //=== VK_EXT_texel_buffer_alignment ===
4432 template <> struct StructExtends<PhysicalDeviceTexelBufferAlignmentFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
4433 template <> struct StructExtends<PhysicalDeviceTexelBufferAlignmentFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
4434
4435 //=== VK_EXT_robustness2 ===
4436 template <> struct StructExtends<PhysicalDeviceRobustness2FeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
4437 template <> struct StructExtends<PhysicalDeviceRobustness2FeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
4438 template <> struct StructExtends<PhysicalDeviceRobustness2PropertiesEXT, PhysicalDeviceProperties2>{ enum { value = true }; };
4439
4440 //=== VK_EXT_custom_border_color ===
4441 template <> struct StructExtends<SamplerCustomBorderColorCreateInfoEXT, SamplerCreateInfo>{ enum { value = true }; };
4442 template <> struct StructExtends<PhysicalDeviceCustomBorderColorPropertiesEXT, PhysicalDeviceProperties2>{ enum { value = true }; };
4443 template <> struct StructExtends<PhysicalDeviceCustomBorderColorFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
4444 template <> struct StructExtends<PhysicalDeviceCustomBorderColorFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
4445
4446 //=== VK_KHR_synchronization2 ===
4447 template <> struct StructExtends<QueueFamilyCheckpointProperties2NV, QueueFamilyProperties2>{ enum { value = true }; };
4448
4449 //=== VK_EXT_ycbcr_2plane_444_formats ===
4450 template <> struct StructExtends<PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
4451 template <> struct StructExtends<PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
4452
4453 //=== VK_EXT_4444_formats ===
4454 template <> struct StructExtends<PhysicalDevice4444FormatsFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
4455 template <> struct StructExtends<PhysicalDevice4444FormatsFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
4456
4457 //=== VK_EXT_vertex_input_dynamic_state ===
4458 template <> struct StructExtends<PhysicalDeviceVertexInputDynamicStateFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
4459 template <> struct StructExtends<PhysicalDeviceVertexInputDynamicStateFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
4460
4461 #if defined( VK_USE_PLATFORM_SCI )
4462 //=== VK_NV_external_sci_sync ===
4463 template <> struct StructExtends<ExportFenceSciSyncInfoNV, FenceCreateInfo>{ enum { value = true }; };
4464 template <> struct StructExtends<ExportSemaphoreSciSyncInfoNV, SemaphoreCreateInfo>{ enum { value = true }; };
4465 template <> struct StructExtends<PhysicalDeviceExternalSciSyncFeaturesNV, PhysicalDeviceFeatures2>{ enum { value = true }; };
4466 template <> struct StructExtends<PhysicalDeviceExternalSciSyncFeaturesNV, DeviceCreateInfo>{ enum { value = true }; };
4467 #endif /*VK_USE_PLATFORM_SCI*/
4468
4469 #if defined( VK_USE_PLATFORM_SCI )
4470 //=== VK_NV_external_memory_sci_buf ===
4471 template <> struct StructExtends<ExportMemorySciBufInfoNV, MemoryAllocateInfo>{ enum { value = true }; };
4472 template <> struct StructExtends<ImportMemorySciBufInfoNV, MemoryAllocateInfo>{ enum { value = true }; };
4473 template <> struct StructExtends<PhysicalDeviceExternalMemorySciBufFeaturesNV, PhysicalDeviceFeatures2>{ enum { value = true }; };
4474 template <> struct StructExtends<PhysicalDeviceExternalMemorySciBufFeaturesNV, DeviceCreateInfo>{ enum { value = true }; };
4475 #endif /*VK_USE_PLATFORM_SCI*/
4476
4477 //=== VK_EXT_extended_dynamic_state2 ===
4478 template <> struct StructExtends<PhysicalDeviceExtendedDynamicState2FeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
4479 template <> struct StructExtends<PhysicalDeviceExtendedDynamicState2FeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
4480
4481 //=== VK_EXT_color_write_enable ===
4482 template <> struct StructExtends<PhysicalDeviceColorWriteEnableFeaturesEXT, PhysicalDeviceFeatures2>{ enum { value = true }; };
4483 template <> struct StructExtends<PhysicalDeviceColorWriteEnableFeaturesEXT, DeviceCreateInfo>{ enum { value = true }; };
4484 template <> struct StructExtends<PipelineColorWriteCreateInfoEXT, PipelineColorBlendStateCreateInfo>{ enum { value = true }; };
4485
4486 //=== VK_EXT_application_parameters ===
4487 template <> struct StructExtends<ApplicationParametersEXT, ApplicationInfo>{ enum { value = true }; };
4488 template <> struct StructExtends<ApplicationParametersEXT, DeviceCreateInfo>{ enum { value = true }; };
4489
4490 #if defined( VK_USE_PLATFORM_SCI )
4491 //=== VK_NV_external_sci_sync2 ===
4492 template <> struct StructExtends<PhysicalDeviceExternalSciSync2FeaturesNV, PhysicalDeviceFeatures2>{ enum { value = true }; };
4493 template <> struct StructExtends<PhysicalDeviceExternalSciSync2FeaturesNV, DeviceCreateInfo>{ enum { value = true }; };
4494 template <> struct StructExtends<SemaphoreSciSyncCreateInfoNV, SemaphoreCreateInfo>{ enum { value = true }; };
4495 template <> struct StructExtends<DeviceSemaphoreSciSyncPoolReservationCreateInfoNV, DeviceCreateInfo>{ enum { value = true }; };
4496 #endif /*VK_USE_PLATFORM_SCI*/
4497
4498 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
4499 //=== VK_QNX_external_memory_screen_buffer ===
4500 template <> struct StructExtends<ScreenBufferFormatPropertiesQNX, ScreenBufferPropertiesQNX>{ enum { value = true }; };
4501 template <> struct StructExtends<ImportScreenBufferInfoQNX, MemoryAllocateInfo>{ enum { value = true }; };
4502 template <> struct StructExtends<ExternalFormatQNX, ImageCreateInfo>{ enum { value = true }; };
4503 template <> struct StructExtends<ExternalFormatQNX, SamplerYcbcrConversionCreateInfo>{ enum { value = true }; };
4504 template <> struct StructExtends<PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX, PhysicalDeviceFeatures2>{ enum { value = true }; };
4505 template <> struct StructExtends<PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX, DeviceCreateInfo>{ enum { value = true }; };
4506 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
4507
4508 #endif // VULKAN_HPP_DISABLE_ENHANCED_MODE
4509
4510 #if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
4511 class DynamicLoader
4512 {
4513 public:
4514 # ifdef VULKAN_HPP_NO_EXCEPTIONS
DynamicLoader(std::string const & vulkanLibraryName={} )4515 DynamicLoader( std::string const & vulkanLibraryName = {} ) VULKAN_HPP_NOEXCEPT
4516 # else
4517 DynamicLoader( std::string const & vulkanLibraryName = {} )
4518 # endif
4519 {
4520 if ( !vulkanLibraryName.empty() )
4521 {
4522 # if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNX__ ) || defined(__Fuchsia__)
4523 m_library = dlopen( vulkanLibraryName.c_str(), RTLD_NOW | RTLD_LOCAL );
4524 # elif defined( _WIN32 )
4525 m_library = ::LoadLibraryA( vulkanLibraryName.c_str() );
4526 # else
4527 # error unsupported platform
4528 # endif
4529 }
4530 else
4531 {
4532 # if defined( __unix__ ) || defined( __QNX__ ) || defined(__Fuchsia__)
4533 m_library = dlopen( "libvulkan.so", RTLD_NOW | RTLD_LOCAL );
4534 if ( m_library == nullptr )
4535 {
4536 m_library = dlopen( "libvulkan.so.1", RTLD_NOW | RTLD_LOCAL );
4537 }
4538 # elif defined( __APPLE__ )
4539 m_library = dlopen( "libvulkan.dylib", RTLD_NOW | RTLD_LOCAL );
4540 # elif defined( _WIN32 )
4541 m_library = ::LoadLibraryA( "vulkan-1.dll" );
4542 # else
4543 # error unsupported platform
4544 # endif
4545 }
4546
4547 #ifndef VULKAN_HPP_NO_EXCEPTIONS
4548 if ( m_library == nullptr )
4549 {
4550 // NOTE there should be an InitializationFailedError, but msvc insists on the symbol does not exist within the scope of this function.
4551 throw std::runtime_error( "Failed to load vulkan library!" );
4552 }
4553 #endif
4554 }
4555
4556 DynamicLoader( DynamicLoader const & ) = delete;
4557
DynamicLoader(DynamicLoader && other)4558 DynamicLoader( DynamicLoader && other ) VULKAN_HPP_NOEXCEPT : m_library(other.m_library)
4559 {
4560 other.m_library = nullptr;
4561 }
4562
4563 DynamicLoader &operator=( DynamicLoader const & ) = delete;
4564
operator =(DynamicLoader && other)4565 DynamicLoader &operator=( DynamicLoader && other ) VULKAN_HPP_NOEXCEPT
4566 {
4567 std::swap(m_library, other.m_library);
4568 return *this;
4569 }
4570
~DynamicLoader()4571 ~DynamicLoader() VULKAN_HPP_NOEXCEPT
4572 {
4573 if ( m_library )
4574 {
4575 # if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNX__ ) || defined(__Fuchsia__)
4576 dlclose( m_library );
4577 # elif defined( _WIN32 )
4578 ::FreeLibrary( m_library );
4579 # else
4580 # error unsupported platform
4581 # endif
4582 }
4583 }
4584
4585 template <typename T>
getProcAddress(const char * function) const4586 T getProcAddress( const char* function ) const VULKAN_HPP_NOEXCEPT
4587 {
4588 # if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNX__ ) || defined(__Fuchsia__)
4589 return (T)dlsym( m_library, function );
4590 # elif defined( _WIN32 )
4591 return (T)::GetProcAddress( m_library, function );
4592 # else
4593 # error unsupported platform
4594 # endif
4595 }
4596
success() const4597 bool success() const VULKAN_HPP_NOEXCEPT { return m_library != nullptr; }
4598
4599 private:
4600 # if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNX__ ) || defined(__Fuchsia__)
4601 void * m_library;
4602 # elif defined( _WIN32 )
4603 ::HINSTANCE m_library;
4604 # else
4605 # error unsupported platform
4606 # endif
4607 };
4608 #endif
4609
4610
4611 using PFN_dummy = void ( * )();
4612
4613 class DispatchLoaderDynamic : public DispatchLoaderBase
4614 {
4615 public:
4616
4617 //=== VK_VERSION_1_0 ===
4618 PFN_vkCreateInstance vkCreateInstance = 0;
4619 PFN_vkDestroyInstance vkDestroyInstance = 0;
4620 PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices = 0;
4621 PFN_vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures = 0;
4622 PFN_vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties = 0;
4623 PFN_vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceImageFormatProperties = 0;
4624 PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties = 0;
4625 PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties = 0;
4626 PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties = 0;
4627 PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = 0;
4628 PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr = 0;
4629 PFN_vkCreateDevice vkCreateDevice = 0;
4630 PFN_vkDestroyDevice vkDestroyDevice = 0;
4631 PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties = 0;
4632 PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties = 0;
4633 PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties = 0;
4634 PFN_vkEnumerateDeviceLayerProperties vkEnumerateDeviceLayerProperties = 0;
4635 PFN_vkGetDeviceQueue vkGetDeviceQueue = 0;
4636 PFN_vkQueueSubmit vkQueueSubmit = 0;
4637 PFN_vkQueueWaitIdle vkQueueWaitIdle = 0;
4638 PFN_vkDeviceWaitIdle vkDeviceWaitIdle = 0;
4639 PFN_vkAllocateMemory vkAllocateMemory = 0;
4640 PFN_vkMapMemory vkMapMemory = 0;
4641 PFN_vkUnmapMemory vkUnmapMemory = 0;
4642 PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges = 0;
4643 PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges = 0;
4644 PFN_vkGetDeviceMemoryCommitment vkGetDeviceMemoryCommitment = 0;
4645 PFN_vkBindBufferMemory vkBindBufferMemory = 0;
4646 PFN_vkBindImageMemory vkBindImageMemory = 0;
4647 PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements = 0;
4648 PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements = 0;
4649 PFN_vkCreateFence vkCreateFence = 0;
4650 PFN_vkDestroyFence vkDestroyFence = 0;
4651 PFN_vkResetFences vkResetFences = 0;
4652 PFN_vkGetFenceStatus vkGetFenceStatus = 0;
4653 PFN_vkWaitForFences vkWaitForFences = 0;
4654 PFN_vkCreateSemaphore vkCreateSemaphore = 0;
4655 PFN_vkDestroySemaphore vkDestroySemaphore = 0;
4656 PFN_vkCreateEvent vkCreateEvent = 0;
4657 PFN_vkDestroyEvent vkDestroyEvent = 0;
4658 PFN_vkGetEventStatus vkGetEventStatus = 0;
4659 PFN_vkSetEvent vkSetEvent = 0;
4660 PFN_vkResetEvent vkResetEvent = 0;
4661 PFN_vkCreateQueryPool vkCreateQueryPool = 0;
4662 PFN_vkGetQueryPoolResults vkGetQueryPoolResults = 0;
4663 PFN_vkCreateBuffer vkCreateBuffer = 0;
4664 PFN_vkDestroyBuffer vkDestroyBuffer = 0;
4665 PFN_vkCreateBufferView vkCreateBufferView = 0;
4666 PFN_vkDestroyBufferView vkDestroyBufferView = 0;
4667 PFN_vkCreateImage vkCreateImage = 0;
4668 PFN_vkDestroyImage vkDestroyImage = 0;
4669 PFN_vkGetImageSubresourceLayout vkGetImageSubresourceLayout = 0;
4670 PFN_vkCreateImageView vkCreateImageView = 0;
4671 PFN_vkDestroyImageView vkDestroyImageView = 0;
4672 PFN_vkCreatePipelineCache vkCreatePipelineCache = 0;
4673 PFN_vkDestroyPipelineCache vkDestroyPipelineCache = 0;
4674 PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines = 0;
4675 PFN_vkCreateComputePipelines vkCreateComputePipelines = 0;
4676 PFN_vkDestroyPipeline vkDestroyPipeline = 0;
4677 PFN_vkCreatePipelineLayout vkCreatePipelineLayout = 0;
4678 PFN_vkDestroyPipelineLayout vkDestroyPipelineLayout = 0;
4679 PFN_vkCreateSampler vkCreateSampler = 0;
4680 PFN_vkDestroySampler vkDestroySampler = 0;
4681 PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout = 0;
4682 PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout = 0;
4683 PFN_vkCreateDescriptorPool vkCreateDescriptorPool = 0;
4684 PFN_vkResetDescriptorPool vkResetDescriptorPool = 0;
4685 PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets = 0;
4686 PFN_vkFreeDescriptorSets vkFreeDescriptorSets = 0;
4687 PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets = 0;
4688 PFN_vkCreateFramebuffer vkCreateFramebuffer = 0;
4689 PFN_vkDestroyFramebuffer vkDestroyFramebuffer = 0;
4690 PFN_vkCreateRenderPass vkCreateRenderPass = 0;
4691 PFN_vkDestroyRenderPass vkDestroyRenderPass = 0;
4692 PFN_vkGetRenderAreaGranularity vkGetRenderAreaGranularity = 0;
4693 PFN_vkCreateCommandPool vkCreateCommandPool = 0;
4694 PFN_vkResetCommandPool vkResetCommandPool = 0;
4695 PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers = 0;
4696 PFN_vkFreeCommandBuffers vkFreeCommandBuffers = 0;
4697 PFN_vkBeginCommandBuffer vkBeginCommandBuffer = 0;
4698 PFN_vkEndCommandBuffer vkEndCommandBuffer = 0;
4699 PFN_vkResetCommandBuffer vkResetCommandBuffer = 0;
4700 PFN_vkCmdBindPipeline vkCmdBindPipeline = 0;
4701 PFN_vkCmdSetViewport vkCmdSetViewport = 0;
4702 PFN_vkCmdSetScissor vkCmdSetScissor = 0;
4703 PFN_vkCmdSetLineWidth vkCmdSetLineWidth = 0;
4704 PFN_vkCmdSetDepthBias vkCmdSetDepthBias = 0;
4705 PFN_vkCmdSetBlendConstants vkCmdSetBlendConstants = 0;
4706 PFN_vkCmdSetDepthBounds vkCmdSetDepthBounds = 0;
4707 PFN_vkCmdSetStencilCompareMask vkCmdSetStencilCompareMask = 0;
4708 PFN_vkCmdSetStencilWriteMask vkCmdSetStencilWriteMask = 0;
4709 PFN_vkCmdSetStencilReference vkCmdSetStencilReference = 0;
4710 PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets = 0;
4711 PFN_vkCmdBindIndexBuffer vkCmdBindIndexBuffer = 0;
4712 PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers = 0;
4713 PFN_vkCmdDraw vkCmdDraw = 0;
4714 PFN_vkCmdDrawIndexed vkCmdDrawIndexed = 0;
4715 PFN_vkCmdDrawIndirect vkCmdDrawIndirect = 0;
4716 PFN_vkCmdDrawIndexedIndirect vkCmdDrawIndexedIndirect = 0;
4717 PFN_vkCmdDispatch vkCmdDispatch = 0;
4718 PFN_vkCmdDispatchIndirect vkCmdDispatchIndirect = 0;
4719 PFN_vkCmdCopyBuffer vkCmdCopyBuffer = 0;
4720 PFN_vkCmdCopyImage vkCmdCopyImage = 0;
4721 PFN_vkCmdBlitImage vkCmdBlitImage = 0;
4722 PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage = 0;
4723 PFN_vkCmdCopyImageToBuffer vkCmdCopyImageToBuffer = 0;
4724 PFN_vkCmdUpdateBuffer vkCmdUpdateBuffer = 0;
4725 PFN_vkCmdFillBuffer vkCmdFillBuffer = 0;
4726 PFN_vkCmdClearColorImage vkCmdClearColorImage = 0;
4727 PFN_vkCmdClearDepthStencilImage vkCmdClearDepthStencilImage = 0;
4728 PFN_vkCmdClearAttachments vkCmdClearAttachments = 0;
4729 PFN_vkCmdResolveImage vkCmdResolveImage = 0;
4730 PFN_vkCmdSetEvent vkCmdSetEvent = 0;
4731 PFN_vkCmdResetEvent vkCmdResetEvent = 0;
4732 PFN_vkCmdWaitEvents vkCmdWaitEvents = 0;
4733 PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier = 0;
4734 PFN_vkCmdBeginQuery vkCmdBeginQuery = 0;
4735 PFN_vkCmdEndQuery vkCmdEndQuery = 0;
4736 PFN_vkCmdResetQueryPool vkCmdResetQueryPool = 0;
4737 PFN_vkCmdWriteTimestamp vkCmdWriteTimestamp = 0;
4738 PFN_vkCmdCopyQueryPoolResults vkCmdCopyQueryPoolResults = 0;
4739 PFN_vkCmdPushConstants vkCmdPushConstants = 0;
4740 PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass = 0;
4741 PFN_vkCmdNextSubpass vkCmdNextSubpass = 0;
4742 PFN_vkCmdEndRenderPass vkCmdEndRenderPass = 0;
4743 PFN_vkCmdExecuteCommands vkCmdExecuteCommands = 0;
4744
4745 //=== VK_VERSION_1_1 ===
4746 PFN_vkEnumerateInstanceVersion vkEnumerateInstanceVersion = 0;
4747 PFN_vkBindBufferMemory2 vkBindBufferMemory2 = 0;
4748 PFN_vkBindImageMemory2 vkBindImageMemory2 = 0;
4749 PFN_vkGetDeviceGroupPeerMemoryFeatures vkGetDeviceGroupPeerMemoryFeatures = 0;
4750 PFN_vkCmdSetDeviceMask vkCmdSetDeviceMask = 0;
4751 PFN_vkCmdDispatchBase vkCmdDispatchBase = 0;
4752 PFN_vkEnumeratePhysicalDeviceGroups vkEnumeratePhysicalDeviceGroups = 0;
4753 PFN_vkGetImageMemoryRequirements2 vkGetImageMemoryRequirements2 = 0;
4754 PFN_vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2 = 0;
4755 PFN_vkGetPhysicalDeviceFeatures2 vkGetPhysicalDeviceFeatures2 = 0;
4756 PFN_vkGetPhysicalDeviceProperties2 vkGetPhysicalDeviceProperties2 = 0;
4757 PFN_vkGetPhysicalDeviceFormatProperties2 vkGetPhysicalDeviceFormatProperties2 = 0;
4758 PFN_vkGetPhysicalDeviceImageFormatProperties2 vkGetPhysicalDeviceImageFormatProperties2 = 0;
4759 PFN_vkGetPhysicalDeviceQueueFamilyProperties2 vkGetPhysicalDeviceQueueFamilyProperties2 = 0;
4760 PFN_vkGetPhysicalDeviceMemoryProperties2 vkGetPhysicalDeviceMemoryProperties2 = 0;
4761 PFN_vkGetDeviceQueue2 vkGetDeviceQueue2 = 0;
4762 PFN_vkCreateSamplerYcbcrConversion vkCreateSamplerYcbcrConversion = 0;
4763 PFN_vkDestroySamplerYcbcrConversion vkDestroySamplerYcbcrConversion = 0;
4764 PFN_vkGetPhysicalDeviceExternalBufferProperties vkGetPhysicalDeviceExternalBufferProperties = 0;
4765 PFN_vkGetPhysicalDeviceExternalFenceProperties vkGetPhysicalDeviceExternalFenceProperties = 0;
4766 PFN_vkGetPhysicalDeviceExternalSemaphoreProperties vkGetPhysicalDeviceExternalSemaphoreProperties = 0;
4767 PFN_vkGetDescriptorSetLayoutSupport vkGetDescriptorSetLayoutSupport = 0;
4768
4769 //=== VK_VERSION_1_2 ===
4770 PFN_vkCmdDrawIndirectCount vkCmdDrawIndirectCount = 0;
4771 PFN_vkCmdDrawIndexedIndirectCount vkCmdDrawIndexedIndirectCount = 0;
4772 PFN_vkCreateRenderPass2 vkCreateRenderPass2 = 0;
4773 PFN_vkCmdBeginRenderPass2 vkCmdBeginRenderPass2 = 0;
4774 PFN_vkCmdNextSubpass2 vkCmdNextSubpass2 = 0;
4775 PFN_vkCmdEndRenderPass2 vkCmdEndRenderPass2 = 0;
4776 PFN_vkResetQueryPool vkResetQueryPool = 0;
4777 PFN_vkGetSemaphoreCounterValue vkGetSemaphoreCounterValue = 0;
4778 PFN_vkWaitSemaphores vkWaitSemaphores = 0;
4779 PFN_vkSignalSemaphore vkSignalSemaphore = 0;
4780 PFN_vkGetBufferDeviceAddress vkGetBufferDeviceAddress = 0;
4781 PFN_vkGetBufferOpaqueCaptureAddress vkGetBufferOpaqueCaptureAddress = 0;
4782 PFN_vkGetDeviceMemoryOpaqueCaptureAddress vkGetDeviceMemoryOpaqueCaptureAddress = 0;
4783
4784 //=== VK_VERSION_1_3 ===
4785 PFN_vkGetPhysicalDeviceToolProperties vkGetPhysicalDeviceToolProperties = 0;
4786 PFN_vkCreatePrivateDataSlot vkCreatePrivateDataSlot = 0;
4787 PFN_vkDestroyPrivateDataSlot vkDestroyPrivateDataSlot = 0;
4788 PFN_vkSetPrivateData vkSetPrivateData = 0;
4789 PFN_vkGetPrivateData vkGetPrivateData = 0;
4790 PFN_vkCmdSetEvent2 vkCmdSetEvent2 = 0;
4791 PFN_vkCmdResetEvent2 vkCmdResetEvent2 = 0;
4792 PFN_vkCmdWaitEvents2 vkCmdWaitEvents2 = 0;
4793 PFN_vkCmdPipelineBarrier2 vkCmdPipelineBarrier2 = 0;
4794 PFN_vkCmdWriteTimestamp2 vkCmdWriteTimestamp2 = 0;
4795 PFN_vkQueueSubmit2 vkQueueSubmit2 = 0;
4796 PFN_vkCmdCopyBuffer2 vkCmdCopyBuffer2 = 0;
4797 PFN_vkCmdCopyImage2 vkCmdCopyImage2 = 0;
4798 PFN_vkCmdCopyBufferToImage2 vkCmdCopyBufferToImage2 = 0;
4799 PFN_vkCmdCopyImageToBuffer2 vkCmdCopyImageToBuffer2 = 0;
4800 PFN_vkCmdBlitImage2 vkCmdBlitImage2 = 0;
4801 PFN_vkCmdResolveImage2 vkCmdResolveImage2 = 0;
4802 PFN_vkCmdBeginRendering vkCmdBeginRendering = 0;
4803 PFN_vkCmdEndRendering vkCmdEndRendering = 0;
4804 PFN_vkCmdSetCullMode vkCmdSetCullMode = 0;
4805 PFN_vkCmdSetFrontFace vkCmdSetFrontFace = 0;
4806 PFN_vkCmdSetPrimitiveTopology vkCmdSetPrimitiveTopology = 0;
4807 PFN_vkCmdSetViewportWithCount vkCmdSetViewportWithCount = 0;
4808 PFN_vkCmdSetScissorWithCount vkCmdSetScissorWithCount = 0;
4809 PFN_vkCmdBindVertexBuffers2 vkCmdBindVertexBuffers2 = 0;
4810 PFN_vkCmdSetDepthTestEnable vkCmdSetDepthTestEnable = 0;
4811 PFN_vkCmdSetDepthWriteEnable vkCmdSetDepthWriteEnable = 0;
4812 PFN_vkCmdSetDepthCompareOp vkCmdSetDepthCompareOp = 0;
4813 PFN_vkCmdSetDepthBoundsTestEnable vkCmdSetDepthBoundsTestEnable = 0;
4814 PFN_vkCmdSetStencilTestEnable vkCmdSetStencilTestEnable = 0;
4815 PFN_vkCmdSetStencilOp vkCmdSetStencilOp = 0;
4816 PFN_vkCmdSetRasterizerDiscardEnable vkCmdSetRasterizerDiscardEnable = 0;
4817 PFN_vkCmdSetDepthBiasEnable vkCmdSetDepthBiasEnable = 0;
4818 PFN_vkCmdSetPrimitiveRestartEnable vkCmdSetPrimitiveRestartEnable = 0;
4819 PFN_vkGetDeviceBufferMemoryRequirements vkGetDeviceBufferMemoryRequirements = 0;
4820 PFN_vkGetDeviceImageMemoryRequirements vkGetDeviceImageMemoryRequirements = 0;
4821 PFN_vkGetDeviceImageSparseMemoryRequirements vkGetDeviceImageSparseMemoryRequirements = 0;
4822
4823 //=== VKSC_VERSION_1_0 ===
4824 PFN_vkGetCommandPoolMemoryConsumption vkGetCommandPoolMemoryConsumption = 0;
4825 PFN_vkGetFaultData vkGetFaultData = 0;
4826
4827 //=== VK_KHR_surface ===
4828 PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR = 0;
4829 PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR = 0;
4830 PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceCapabilitiesKHR = 0;
4831 PFN_vkGetPhysicalDeviceSurfaceFormatsKHR vkGetPhysicalDeviceSurfaceFormatsKHR = 0;
4832 PFN_vkGetPhysicalDeviceSurfacePresentModesKHR vkGetPhysicalDeviceSurfacePresentModesKHR = 0;
4833
4834 //=== VK_KHR_swapchain ===
4835 PFN_vkCreateSwapchainKHR vkCreateSwapchainKHR = 0;
4836 PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR = 0;
4837 PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR = 0;
4838 PFN_vkQueuePresentKHR vkQueuePresentKHR = 0;
4839 PFN_vkGetDeviceGroupPresentCapabilitiesKHR vkGetDeviceGroupPresentCapabilitiesKHR = 0;
4840 PFN_vkGetDeviceGroupSurfacePresentModesKHR vkGetDeviceGroupSurfacePresentModesKHR = 0;
4841 PFN_vkGetPhysicalDevicePresentRectanglesKHR vkGetPhysicalDevicePresentRectanglesKHR = 0;
4842 PFN_vkAcquireNextImage2KHR vkAcquireNextImage2KHR = 0;
4843
4844 //=== VK_KHR_display ===
4845 PFN_vkGetPhysicalDeviceDisplayPropertiesKHR vkGetPhysicalDeviceDisplayPropertiesKHR = 0;
4846 PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR vkGetPhysicalDeviceDisplayPlanePropertiesKHR = 0;
4847 PFN_vkGetDisplayPlaneSupportedDisplaysKHR vkGetDisplayPlaneSupportedDisplaysKHR = 0;
4848 PFN_vkGetDisplayModePropertiesKHR vkGetDisplayModePropertiesKHR = 0;
4849 PFN_vkCreateDisplayModeKHR vkCreateDisplayModeKHR = 0;
4850 PFN_vkGetDisplayPlaneCapabilitiesKHR vkGetDisplayPlaneCapabilitiesKHR = 0;
4851 PFN_vkCreateDisplayPlaneSurfaceKHR vkCreateDisplayPlaneSurfaceKHR = 0;
4852
4853 //=== VK_KHR_display_swapchain ===
4854 PFN_vkCreateSharedSwapchainsKHR vkCreateSharedSwapchainsKHR = 0;
4855
4856 //=== VK_KHR_external_memory_fd ===
4857 PFN_vkGetMemoryFdKHR vkGetMemoryFdKHR = 0;
4858 PFN_vkGetMemoryFdPropertiesKHR vkGetMemoryFdPropertiesKHR = 0;
4859
4860 //=== VK_KHR_external_semaphore_fd ===
4861 PFN_vkImportSemaphoreFdKHR vkImportSemaphoreFdKHR = 0;
4862 PFN_vkGetSemaphoreFdKHR vkGetSemaphoreFdKHR = 0;
4863
4864 //=== VK_EXT_direct_mode_display ===
4865 PFN_vkReleaseDisplayEXT vkReleaseDisplayEXT = 0;
4866
4867 //=== VK_EXT_display_surface_counter ===
4868 PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT vkGetPhysicalDeviceSurfaceCapabilities2EXT = 0;
4869
4870 //=== VK_EXT_display_control ===
4871 PFN_vkDisplayPowerControlEXT vkDisplayPowerControlEXT = 0;
4872 PFN_vkRegisterDeviceEventEXT vkRegisterDeviceEventEXT = 0;
4873 PFN_vkRegisterDisplayEventEXT vkRegisterDisplayEventEXT = 0;
4874 PFN_vkGetSwapchainCounterEXT vkGetSwapchainCounterEXT = 0;
4875
4876 //=== VK_EXT_discard_rectangles ===
4877 PFN_vkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXT = 0;
4878 PFN_vkCmdSetDiscardRectangleEnableEXT vkCmdSetDiscardRectangleEnableEXT = 0;
4879 PFN_vkCmdSetDiscardRectangleModeEXT vkCmdSetDiscardRectangleModeEXT = 0;
4880
4881 //=== VK_EXT_hdr_metadata ===
4882 PFN_vkSetHdrMetadataEXT vkSetHdrMetadataEXT = 0;
4883
4884 //=== VK_KHR_shared_presentable_image ===
4885 PFN_vkGetSwapchainStatusKHR vkGetSwapchainStatusKHR = 0;
4886
4887 //=== VK_KHR_external_fence_fd ===
4888 PFN_vkImportFenceFdKHR vkImportFenceFdKHR = 0;
4889 PFN_vkGetFenceFdKHR vkGetFenceFdKHR = 0;
4890
4891 //=== VK_KHR_performance_query ===
4892 PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = 0;
4893 PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = 0;
4894 PFN_vkAcquireProfilingLockKHR vkAcquireProfilingLockKHR = 0;
4895 PFN_vkReleaseProfilingLockKHR vkReleaseProfilingLockKHR = 0;
4896
4897 //=== VK_KHR_get_surface_capabilities2 ===
4898 PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR vkGetPhysicalDeviceSurfaceCapabilities2KHR = 0;
4899 PFN_vkGetPhysicalDeviceSurfaceFormats2KHR vkGetPhysicalDeviceSurfaceFormats2KHR = 0;
4900
4901 //=== VK_KHR_get_display_properties2 ===
4902 PFN_vkGetPhysicalDeviceDisplayProperties2KHR vkGetPhysicalDeviceDisplayProperties2KHR = 0;
4903 PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR vkGetPhysicalDeviceDisplayPlaneProperties2KHR = 0;
4904 PFN_vkGetDisplayModeProperties2KHR vkGetDisplayModeProperties2KHR = 0;
4905 PFN_vkGetDisplayPlaneCapabilities2KHR vkGetDisplayPlaneCapabilities2KHR = 0;
4906
4907 //=== VK_EXT_debug_utils ===
4908 PFN_vkSetDebugUtilsObjectNameEXT vkSetDebugUtilsObjectNameEXT = 0;
4909 PFN_vkSetDebugUtilsObjectTagEXT vkSetDebugUtilsObjectTagEXT = 0;
4910 PFN_vkQueueBeginDebugUtilsLabelEXT vkQueueBeginDebugUtilsLabelEXT = 0;
4911 PFN_vkQueueEndDebugUtilsLabelEXT vkQueueEndDebugUtilsLabelEXT = 0;
4912 PFN_vkQueueInsertDebugUtilsLabelEXT vkQueueInsertDebugUtilsLabelEXT = 0;
4913 PFN_vkCmdBeginDebugUtilsLabelEXT vkCmdBeginDebugUtilsLabelEXT = 0;
4914 PFN_vkCmdEndDebugUtilsLabelEXT vkCmdEndDebugUtilsLabelEXT = 0;
4915 PFN_vkCmdInsertDebugUtilsLabelEXT vkCmdInsertDebugUtilsLabelEXT = 0;
4916 PFN_vkCreateDebugUtilsMessengerEXT vkCreateDebugUtilsMessengerEXT = 0;
4917 PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT = 0;
4918 PFN_vkSubmitDebugUtilsMessageEXT vkSubmitDebugUtilsMessageEXT = 0;
4919
4920 //=== VK_EXT_sample_locations ===
4921 PFN_vkCmdSetSampleLocationsEXT vkCmdSetSampleLocationsEXT = 0;
4922 PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT vkGetPhysicalDeviceMultisamplePropertiesEXT = 0;
4923
4924 //=== VK_EXT_image_drm_format_modifier ===
4925 PFN_vkGetImageDrmFormatModifierPropertiesEXT vkGetImageDrmFormatModifierPropertiesEXT = 0;
4926
4927 //=== VK_EXT_external_memory_host ===
4928 PFN_vkGetMemoryHostPointerPropertiesEXT vkGetMemoryHostPointerPropertiesEXT = 0;
4929
4930 //=== VK_EXT_calibrated_timestamps ===
4931 PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = 0;
4932 PFN_vkGetCalibratedTimestampsEXT vkGetCalibratedTimestampsEXT = 0;
4933
4934 //=== VK_KHR_fragment_shading_rate ===
4935 PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR vkGetPhysicalDeviceFragmentShadingRatesKHR = 0;
4936 PFN_vkCmdSetFragmentShadingRateKHR vkCmdSetFragmentShadingRateKHR = 0;
4937
4938 //=== VK_EXT_headless_surface ===
4939 PFN_vkCreateHeadlessSurfaceEXT vkCreateHeadlessSurfaceEXT = 0;
4940
4941 //=== VK_EXT_line_rasterization ===
4942 PFN_vkCmdSetLineStippleEXT vkCmdSetLineStippleEXT = 0;
4943
4944 //=== VK_EXT_extended_dynamic_state ===
4945 PFN_vkCmdSetCullModeEXT vkCmdSetCullModeEXT = 0;
4946 PFN_vkCmdSetFrontFaceEXT vkCmdSetFrontFaceEXT = 0;
4947 PFN_vkCmdSetPrimitiveTopologyEXT vkCmdSetPrimitiveTopologyEXT = 0;
4948 PFN_vkCmdSetViewportWithCountEXT vkCmdSetViewportWithCountEXT = 0;
4949 PFN_vkCmdSetScissorWithCountEXT vkCmdSetScissorWithCountEXT = 0;
4950 PFN_vkCmdBindVertexBuffers2EXT vkCmdBindVertexBuffers2EXT = 0;
4951 PFN_vkCmdSetDepthTestEnableEXT vkCmdSetDepthTestEnableEXT = 0;
4952 PFN_vkCmdSetDepthWriteEnableEXT vkCmdSetDepthWriteEnableEXT = 0;
4953 PFN_vkCmdSetDepthCompareOpEXT vkCmdSetDepthCompareOpEXT = 0;
4954 PFN_vkCmdSetDepthBoundsTestEnableEXT vkCmdSetDepthBoundsTestEnableEXT = 0;
4955 PFN_vkCmdSetStencilTestEnableEXT vkCmdSetStencilTestEnableEXT = 0;
4956 PFN_vkCmdSetStencilOpEXT vkCmdSetStencilOpEXT = 0;
4957
4958 //=== VK_KHR_object_refresh ===
4959 PFN_vkCmdRefreshObjectsKHR vkCmdRefreshObjectsKHR = 0;
4960 PFN_vkGetPhysicalDeviceRefreshableObjectTypesKHR vkGetPhysicalDeviceRefreshableObjectTypesKHR = 0;
4961
4962 //=== VK_KHR_synchronization2 ===
4963 PFN_vkCmdSetEvent2KHR vkCmdSetEvent2KHR = 0;
4964 PFN_vkCmdResetEvent2KHR vkCmdResetEvent2KHR = 0;
4965 PFN_vkCmdWaitEvents2KHR vkCmdWaitEvents2KHR = 0;
4966 PFN_vkCmdPipelineBarrier2KHR vkCmdPipelineBarrier2KHR = 0;
4967 PFN_vkCmdWriteTimestamp2KHR vkCmdWriteTimestamp2KHR = 0;
4968 PFN_vkQueueSubmit2KHR vkQueueSubmit2KHR = 0;
4969 PFN_vkCmdWriteBufferMarker2AMD vkCmdWriteBufferMarker2AMD = 0;
4970 PFN_vkGetQueueCheckpointData2NV vkGetQueueCheckpointData2NV = 0;
4971
4972 //=== VK_KHR_copy_commands2 ===
4973 PFN_vkCmdCopyBuffer2KHR vkCmdCopyBuffer2KHR = 0;
4974 PFN_vkCmdCopyImage2KHR vkCmdCopyImage2KHR = 0;
4975 PFN_vkCmdCopyBufferToImage2KHR vkCmdCopyBufferToImage2KHR = 0;
4976 PFN_vkCmdCopyImageToBuffer2KHR vkCmdCopyImageToBuffer2KHR = 0;
4977 PFN_vkCmdBlitImage2KHR vkCmdBlitImage2KHR = 0;
4978 PFN_vkCmdResolveImage2KHR vkCmdResolveImage2KHR = 0;
4979
4980 //=== VK_EXT_vertex_input_dynamic_state ===
4981 PFN_vkCmdSetVertexInputEXT vkCmdSetVertexInputEXT = 0;
4982
4983 #if defined( VK_USE_PLATFORM_SCI )
4984 //=== VK_NV_external_sci_sync ===
4985 PFN_vkGetFenceSciSyncFenceNV vkGetFenceSciSyncFenceNV = 0;
4986 PFN_vkGetFenceSciSyncObjNV vkGetFenceSciSyncObjNV = 0;
4987 PFN_vkImportFenceSciSyncFenceNV vkImportFenceSciSyncFenceNV = 0;
4988 PFN_vkImportFenceSciSyncObjNV vkImportFenceSciSyncObjNV = 0;
4989 PFN_vkGetPhysicalDeviceSciSyncAttributesNV vkGetPhysicalDeviceSciSyncAttributesNV = 0;
4990 PFN_vkGetSemaphoreSciSyncObjNV vkGetSemaphoreSciSyncObjNV = 0;
4991 PFN_vkImportSemaphoreSciSyncObjNV vkImportSemaphoreSciSyncObjNV = 0;
4992 #else
4993 PFN_dummy vkGetFenceSciSyncFenceNV_placeholder = 0;
4994 PFN_dummy vkGetFenceSciSyncObjNV_placeholder = 0;
4995 PFN_dummy vkImportFenceSciSyncFenceNV_placeholder = 0;
4996 PFN_dummy vkImportFenceSciSyncObjNV_placeholder = 0;
4997 PFN_dummy vkGetPhysicalDeviceSciSyncAttributesNV_placeholder = 0;
4998 PFN_dummy vkGetSemaphoreSciSyncObjNV_placeholder = 0;
4999 PFN_dummy vkImportSemaphoreSciSyncObjNV_placeholder = 0;
5000 #endif /*VK_USE_PLATFORM_SCI*/
5001
5002 #if defined( VK_USE_PLATFORM_SCI )
5003 //=== VK_NV_external_memory_sci_buf ===
5004 PFN_vkGetMemorySciBufNV vkGetMemorySciBufNV = 0;
5005 PFN_vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV = 0;
5006 PFN_vkGetPhysicalDeviceSciBufAttributesNV vkGetPhysicalDeviceSciBufAttributesNV = 0;
5007 #else
5008 PFN_dummy vkGetMemorySciBufNV_placeholder = 0;
5009 PFN_dummy vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV_placeholder = 0;
5010 PFN_dummy vkGetPhysicalDeviceSciBufAttributesNV_placeholder = 0;
5011 #endif /*VK_USE_PLATFORM_SCI*/
5012
5013 //=== VK_EXT_extended_dynamic_state2 ===
5014 PFN_vkCmdSetPatchControlPointsEXT vkCmdSetPatchControlPointsEXT = 0;
5015 PFN_vkCmdSetRasterizerDiscardEnableEXT vkCmdSetRasterizerDiscardEnableEXT = 0;
5016 PFN_vkCmdSetDepthBiasEnableEXT vkCmdSetDepthBiasEnableEXT = 0;
5017 PFN_vkCmdSetLogicOpEXT vkCmdSetLogicOpEXT = 0;
5018 PFN_vkCmdSetPrimitiveRestartEnableEXT vkCmdSetPrimitiveRestartEnableEXT = 0;
5019
5020 //=== VK_EXT_color_write_enable ===
5021 PFN_vkCmdSetColorWriteEnableEXT vkCmdSetColorWriteEnableEXT = 0;
5022
5023 #if defined( VK_USE_PLATFORM_SCI )
5024 //=== VK_NV_external_sci_sync2 ===
5025 PFN_vkCreateSemaphoreSciSyncPoolNV vkCreateSemaphoreSciSyncPoolNV = 0;
5026 #else
5027 PFN_dummy vkCreateSemaphoreSciSyncPoolNV_placeholder = 0;
5028 #endif /*VK_USE_PLATFORM_SCI*/
5029
5030 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
5031 //=== VK_QNX_external_memory_screen_buffer ===
5032 PFN_vkGetScreenBufferPropertiesQNX vkGetScreenBufferPropertiesQNX = 0;
5033 #else
5034 PFN_dummy vkGetScreenBufferPropertiesQNX_placeholder = 0;
5035 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
5036
5037
5038 public:
5039 DispatchLoaderDynamic() VULKAN_HPP_NOEXCEPT = default;
5040 DispatchLoaderDynamic( DispatchLoaderDynamic const & rhs ) VULKAN_HPP_NOEXCEPT = default;
5041
DispatchLoaderDynamic(PFN_vkGetInstanceProcAddr getInstanceProcAddr)5042 DispatchLoaderDynamic(PFN_vkGetInstanceProcAddr getInstanceProcAddr) VULKAN_HPP_NOEXCEPT
5043 {
5044 init(getInstanceProcAddr);
5045 }
5046
5047 // This interface does not require a linked vulkan library.
DispatchLoaderDynamic(VkInstance instance,PFN_vkGetInstanceProcAddr getInstanceProcAddr,VkDevice device={},PFN_vkGetDeviceProcAddr getDeviceProcAddr=nullptr)5048 DispatchLoaderDynamic( VkInstance instance,
5049 PFN_vkGetInstanceProcAddr getInstanceProcAddr,
5050 VkDevice device = {},
5051 PFN_vkGetDeviceProcAddr getDeviceProcAddr = nullptr ) VULKAN_HPP_NOEXCEPT
5052 {
5053 init( instance, getInstanceProcAddr, device, getDeviceProcAddr );
5054 }
5055
5056 template <typename DynamicLoader
5057 #if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
5058 = VULKAN_HPP_NAMESPACE::DynamicLoader
5059 #endif
5060 >
init()5061 void init()
5062 {
5063 static DynamicLoader dl;
5064 init( dl );
5065 }
5066
5067 template <typename DynamicLoader>
init(DynamicLoader const & dl)5068 void init( DynamicLoader const & dl ) VULKAN_HPP_NOEXCEPT
5069 {
5070 PFN_vkGetInstanceProcAddr getInstanceProcAddr = dl.template getProcAddress<PFN_vkGetInstanceProcAddr>( "vkGetInstanceProcAddr" );
5071 init( getInstanceProcAddr );
5072 }
5073
init(PFN_vkGetInstanceProcAddr getInstanceProcAddr)5074 void init( PFN_vkGetInstanceProcAddr getInstanceProcAddr ) VULKAN_HPP_NOEXCEPT
5075 {
5076 VULKAN_HPP_ASSERT(getInstanceProcAddr);
5077
5078 vkGetInstanceProcAddr = getInstanceProcAddr;
5079
5080
5081 //=== VK_VERSION_1_0 ===
5082 vkCreateInstance = PFN_vkCreateInstance( vkGetInstanceProcAddr( NULL, "vkCreateInstance" ) );
5083 vkEnumerateInstanceExtensionProperties = PFN_vkEnumerateInstanceExtensionProperties( vkGetInstanceProcAddr( NULL, "vkEnumerateInstanceExtensionProperties" ) );
5084 vkEnumerateInstanceLayerProperties = PFN_vkEnumerateInstanceLayerProperties( vkGetInstanceProcAddr( NULL, "vkEnumerateInstanceLayerProperties" ) );
5085
5086 //=== VK_VERSION_1_1 ===
5087 vkEnumerateInstanceVersion = PFN_vkEnumerateInstanceVersion( vkGetInstanceProcAddr( NULL, "vkEnumerateInstanceVersion" ) );
5088
5089 }
5090
5091 // This interface does not require a linked vulkan library.
init(VkInstance instance,PFN_vkGetInstanceProcAddr getInstanceProcAddr,VkDevice device={},PFN_vkGetDeviceProcAddr=nullptr)5092 void init( VkInstance instance,
5093 PFN_vkGetInstanceProcAddr getInstanceProcAddr,
5094 VkDevice device = {},
5095 PFN_vkGetDeviceProcAddr /*getDeviceProcAddr*/ = nullptr ) VULKAN_HPP_NOEXCEPT
5096 {
5097 VULKAN_HPP_ASSERT(instance && getInstanceProcAddr);
5098 vkGetInstanceProcAddr = getInstanceProcAddr;
5099 init( VULKAN_HPP_NAMESPACE::Instance(instance) );
5100 if (device)
5101 {
5102 init( VULKAN_HPP_NAMESPACE::Device(device) );
5103 }
5104 }
5105
init(VULKAN_HPP_NAMESPACE::Instance instanceCpp)5106 void init( VULKAN_HPP_NAMESPACE::Instance instanceCpp ) VULKAN_HPP_NOEXCEPT
5107 {
5108 VkInstance instance = static_cast<VkInstance>(instanceCpp);
5109
5110
5111 //=== VK_VERSION_1_0 ===
5112 vkDestroyInstance = PFN_vkDestroyInstance( vkGetInstanceProcAddr( instance, "vkDestroyInstance" ) );
5113 vkEnumeratePhysicalDevices = PFN_vkEnumeratePhysicalDevices( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDevices" ) );
5114 vkGetPhysicalDeviceFeatures = PFN_vkGetPhysicalDeviceFeatures( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures" ) );
5115 vkGetPhysicalDeviceFormatProperties = PFN_vkGetPhysicalDeviceFormatProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties" ) );
5116 vkGetPhysicalDeviceImageFormatProperties = PFN_vkGetPhysicalDeviceImageFormatProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties" ) );
5117 vkGetPhysicalDeviceProperties = PFN_vkGetPhysicalDeviceProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties" ) );
5118 vkGetPhysicalDeviceQueueFamilyProperties = PFN_vkGetPhysicalDeviceQueueFamilyProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties" ) );
5119 vkGetPhysicalDeviceMemoryProperties = PFN_vkGetPhysicalDeviceMemoryProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties" ) );
5120 vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr( vkGetInstanceProcAddr( instance, "vkGetDeviceProcAddr" ) );
5121 vkCreateDevice = PFN_vkCreateDevice( vkGetInstanceProcAddr( instance, "vkCreateDevice" ) );
5122 vkDestroyDevice = PFN_vkDestroyDevice( vkGetInstanceProcAddr( instance, "vkDestroyDevice" ) );
5123 vkEnumerateDeviceExtensionProperties = PFN_vkEnumerateDeviceExtensionProperties( vkGetInstanceProcAddr( instance, "vkEnumerateDeviceExtensionProperties" ) );
5124 vkEnumerateDeviceLayerProperties = PFN_vkEnumerateDeviceLayerProperties( vkGetInstanceProcAddr( instance, "vkEnumerateDeviceLayerProperties" ) );
5125 vkGetDeviceQueue = PFN_vkGetDeviceQueue( vkGetInstanceProcAddr( instance, "vkGetDeviceQueue" ) );
5126 vkQueueSubmit = PFN_vkQueueSubmit( vkGetInstanceProcAddr( instance, "vkQueueSubmit" ) );
5127 vkQueueWaitIdle = PFN_vkQueueWaitIdle( vkGetInstanceProcAddr( instance, "vkQueueWaitIdle" ) );
5128 vkDeviceWaitIdle = PFN_vkDeviceWaitIdle( vkGetInstanceProcAddr( instance, "vkDeviceWaitIdle" ) );
5129 vkAllocateMemory = PFN_vkAllocateMemory( vkGetInstanceProcAddr( instance, "vkAllocateMemory" ) );
5130 vkMapMemory = PFN_vkMapMemory( vkGetInstanceProcAddr( instance, "vkMapMemory" ) );
5131 vkUnmapMemory = PFN_vkUnmapMemory( vkGetInstanceProcAddr( instance, "vkUnmapMemory" ) );
5132 vkFlushMappedMemoryRanges = PFN_vkFlushMappedMemoryRanges( vkGetInstanceProcAddr( instance, "vkFlushMappedMemoryRanges" ) );
5133 vkInvalidateMappedMemoryRanges = PFN_vkInvalidateMappedMemoryRanges( vkGetInstanceProcAddr( instance, "vkInvalidateMappedMemoryRanges" ) );
5134 vkGetDeviceMemoryCommitment = PFN_vkGetDeviceMemoryCommitment( vkGetInstanceProcAddr( instance, "vkGetDeviceMemoryCommitment" ) );
5135 vkBindBufferMemory = PFN_vkBindBufferMemory( vkGetInstanceProcAddr( instance, "vkBindBufferMemory" ) );
5136 vkBindImageMemory = PFN_vkBindImageMemory( vkGetInstanceProcAddr( instance, "vkBindImageMemory" ) );
5137 vkGetBufferMemoryRequirements = PFN_vkGetBufferMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetBufferMemoryRequirements" ) );
5138 vkGetImageMemoryRequirements = PFN_vkGetImageMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetImageMemoryRequirements" ) );
5139 vkCreateFence = PFN_vkCreateFence( vkGetInstanceProcAddr( instance, "vkCreateFence" ) );
5140 vkDestroyFence = PFN_vkDestroyFence( vkGetInstanceProcAddr( instance, "vkDestroyFence" ) );
5141 vkResetFences = PFN_vkResetFences( vkGetInstanceProcAddr( instance, "vkResetFences" ) );
5142 vkGetFenceStatus = PFN_vkGetFenceStatus( vkGetInstanceProcAddr( instance, "vkGetFenceStatus" ) );
5143 vkWaitForFences = PFN_vkWaitForFences( vkGetInstanceProcAddr( instance, "vkWaitForFences" ) );
5144 vkCreateSemaphore = PFN_vkCreateSemaphore( vkGetInstanceProcAddr( instance, "vkCreateSemaphore" ) );
5145 vkDestroySemaphore = PFN_vkDestroySemaphore( vkGetInstanceProcAddr( instance, "vkDestroySemaphore" ) );
5146 vkCreateEvent = PFN_vkCreateEvent( vkGetInstanceProcAddr( instance, "vkCreateEvent" ) );
5147 vkDestroyEvent = PFN_vkDestroyEvent( vkGetInstanceProcAddr( instance, "vkDestroyEvent" ) );
5148 vkGetEventStatus = PFN_vkGetEventStatus( vkGetInstanceProcAddr( instance, "vkGetEventStatus" ) );
5149 vkSetEvent = PFN_vkSetEvent( vkGetInstanceProcAddr( instance, "vkSetEvent" ) );
5150 vkResetEvent = PFN_vkResetEvent( vkGetInstanceProcAddr( instance, "vkResetEvent" ) );
5151 vkCreateQueryPool = PFN_vkCreateQueryPool( vkGetInstanceProcAddr( instance, "vkCreateQueryPool" ) );
5152 vkGetQueryPoolResults = PFN_vkGetQueryPoolResults( vkGetInstanceProcAddr( instance, "vkGetQueryPoolResults" ) );
5153 vkCreateBuffer = PFN_vkCreateBuffer( vkGetInstanceProcAddr( instance, "vkCreateBuffer" ) );
5154 vkDestroyBuffer = PFN_vkDestroyBuffer( vkGetInstanceProcAddr( instance, "vkDestroyBuffer" ) );
5155 vkCreateBufferView = PFN_vkCreateBufferView( vkGetInstanceProcAddr( instance, "vkCreateBufferView" ) );
5156 vkDestroyBufferView = PFN_vkDestroyBufferView( vkGetInstanceProcAddr( instance, "vkDestroyBufferView" ) );
5157 vkCreateImage = PFN_vkCreateImage( vkGetInstanceProcAddr( instance, "vkCreateImage" ) );
5158 vkDestroyImage = PFN_vkDestroyImage( vkGetInstanceProcAddr( instance, "vkDestroyImage" ) );
5159 vkGetImageSubresourceLayout = PFN_vkGetImageSubresourceLayout( vkGetInstanceProcAddr( instance, "vkGetImageSubresourceLayout" ) );
5160 vkCreateImageView = PFN_vkCreateImageView( vkGetInstanceProcAddr( instance, "vkCreateImageView" ) );
5161 vkDestroyImageView = PFN_vkDestroyImageView( vkGetInstanceProcAddr( instance, "vkDestroyImageView" ) );
5162 vkCreatePipelineCache = PFN_vkCreatePipelineCache( vkGetInstanceProcAddr( instance, "vkCreatePipelineCache" ) );
5163 vkDestroyPipelineCache = PFN_vkDestroyPipelineCache( vkGetInstanceProcAddr( instance, "vkDestroyPipelineCache" ) );
5164 vkCreateGraphicsPipelines = PFN_vkCreateGraphicsPipelines( vkGetInstanceProcAddr( instance, "vkCreateGraphicsPipelines" ) );
5165 vkCreateComputePipelines = PFN_vkCreateComputePipelines( vkGetInstanceProcAddr( instance, "vkCreateComputePipelines" ) );
5166 vkDestroyPipeline = PFN_vkDestroyPipeline( vkGetInstanceProcAddr( instance, "vkDestroyPipeline" ) );
5167 vkCreatePipelineLayout = PFN_vkCreatePipelineLayout( vkGetInstanceProcAddr( instance, "vkCreatePipelineLayout" ) );
5168 vkDestroyPipelineLayout = PFN_vkDestroyPipelineLayout( vkGetInstanceProcAddr( instance, "vkDestroyPipelineLayout" ) );
5169 vkCreateSampler = PFN_vkCreateSampler( vkGetInstanceProcAddr( instance, "vkCreateSampler" ) );
5170 vkDestroySampler = PFN_vkDestroySampler( vkGetInstanceProcAddr( instance, "vkDestroySampler" ) );
5171 vkCreateDescriptorSetLayout = PFN_vkCreateDescriptorSetLayout( vkGetInstanceProcAddr( instance, "vkCreateDescriptorSetLayout" ) );
5172 vkDestroyDescriptorSetLayout = PFN_vkDestroyDescriptorSetLayout( vkGetInstanceProcAddr( instance, "vkDestroyDescriptorSetLayout" ) );
5173 vkCreateDescriptorPool = PFN_vkCreateDescriptorPool( vkGetInstanceProcAddr( instance, "vkCreateDescriptorPool" ) );
5174 vkResetDescriptorPool = PFN_vkResetDescriptorPool( vkGetInstanceProcAddr( instance, "vkResetDescriptorPool" ) );
5175 vkAllocateDescriptorSets = PFN_vkAllocateDescriptorSets( vkGetInstanceProcAddr( instance, "vkAllocateDescriptorSets" ) );
5176 vkFreeDescriptorSets = PFN_vkFreeDescriptorSets( vkGetInstanceProcAddr( instance, "vkFreeDescriptorSets" ) );
5177 vkUpdateDescriptorSets = PFN_vkUpdateDescriptorSets( vkGetInstanceProcAddr( instance, "vkUpdateDescriptorSets" ) );
5178 vkCreateFramebuffer = PFN_vkCreateFramebuffer( vkGetInstanceProcAddr( instance, "vkCreateFramebuffer" ) );
5179 vkDestroyFramebuffer = PFN_vkDestroyFramebuffer( vkGetInstanceProcAddr( instance, "vkDestroyFramebuffer" ) );
5180 vkCreateRenderPass = PFN_vkCreateRenderPass( vkGetInstanceProcAddr( instance, "vkCreateRenderPass" ) );
5181 vkDestroyRenderPass = PFN_vkDestroyRenderPass( vkGetInstanceProcAddr( instance, "vkDestroyRenderPass" ) );
5182 vkGetRenderAreaGranularity = PFN_vkGetRenderAreaGranularity( vkGetInstanceProcAddr( instance, "vkGetRenderAreaGranularity" ) );
5183 vkCreateCommandPool = PFN_vkCreateCommandPool( vkGetInstanceProcAddr( instance, "vkCreateCommandPool" ) );
5184 vkResetCommandPool = PFN_vkResetCommandPool( vkGetInstanceProcAddr( instance, "vkResetCommandPool" ) );
5185 vkAllocateCommandBuffers = PFN_vkAllocateCommandBuffers( vkGetInstanceProcAddr( instance, "vkAllocateCommandBuffers" ) );
5186 vkFreeCommandBuffers = PFN_vkFreeCommandBuffers( vkGetInstanceProcAddr( instance, "vkFreeCommandBuffers" ) );
5187 vkBeginCommandBuffer = PFN_vkBeginCommandBuffer( vkGetInstanceProcAddr( instance, "vkBeginCommandBuffer" ) );
5188 vkEndCommandBuffer = PFN_vkEndCommandBuffer( vkGetInstanceProcAddr( instance, "vkEndCommandBuffer" ) );
5189 vkResetCommandBuffer = PFN_vkResetCommandBuffer( vkGetInstanceProcAddr( instance, "vkResetCommandBuffer" ) );
5190 vkCmdBindPipeline = PFN_vkCmdBindPipeline( vkGetInstanceProcAddr( instance, "vkCmdBindPipeline" ) );
5191 vkCmdSetViewport = PFN_vkCmdSetViewport( vkGetInstanceProcAddr( instance, "vkCmdSetViewport" ) );
5192 vkCmdSetScissor = PFN_vkCmdSetScissor( vkGetInstanceProcAddr( instance, "vkCmdSetScissor" ) );
5193 vkCmdSetLineWidth = PFN_vkCmdSetLineWidth( vkGetInstanceProcAddr( instance, "vkCmdSetLineWidth" ) );
5194 vkCmdSetDepthBias = PFN_vkCmdSetDepthBias( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBias" ) );
5195 vkCmdSetBlendConstants = PFN_vkCmdSetBlendConstants( vkGetInstanceProcAddr( instance, "vkCmdSetBlendConstants" ) );
5196 vkCmdSetDepthBounds = PFN_vkCmdSetDepthBounds( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBounds" ) );
5197 vkCmdSetStencilCompareMask = PFN_vkCmdSetStencilCompareMask( vkGetInstanceProcAddr( instance, "vkCmdSetStencilCompareMask" ) );
5198 vkCmdSetStencilWriteMask = PFN_vkCmdSetStencilWriteMask( vkGetInstanceProcAddr( instance, "vkCmdSetStencilWriteMask" ) );
5199 vkCmdSetStencilReference = PFN_vkCmdSetStencilReference( vkGetInstanceProcAddr( instance, "vkCmdSetStencilReference" ) );
5200 vkCmdBindDescriptorSets = PFN_vkCmdBindDescriptorSets( vkGetInstanceProcAddr( instance, "vkCmdBindDescriptorSets" ) );
5201 vkCmdBindIndexBuffer = PFN_vkCmdBindIndexBuffer( vkGetInstanceProcAddr( instance, "vkCmdBindIndexBuffer" ) );
5202 vkCmdBindVertexBuffers = PFN_vkCmdBindVertexBuffers( vkGetInstanceProcAddr( instance, "vkCmdBindVertexBuffers" ) );
5203 vkCmdDraw = PFN_vkCmdDraw( vkGetInstanceProcAddr( instance, "vkCmdDraw" ) );
5204 vkCmdDrawIndexed = PFN_vkCmdDrawIndexed( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexed" ) );
5205 vkCmdDrawIndirect = PFN_vkCmdDrawIndirect( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirect" ) );
5206 vkCmdDrawIndexedIndirect = PFN_vkCmdDrawIndexedIndirect( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirect" ) );
5207 vkCmdDispatch = PFN_vkCmdDispatch( vkGetInstanceProcAddr( instance, "vkCmdDispatch" ) );
5208 vkCmdDispatchIndirect = PFN_vkCmdDispatchIndirect( vkGetInstanceProcAddr( instance, "vkCmdDispatchIndirect" ) );
5209 vkCmdCopyBuffer = PFN_vkCmdCopyBuffer( vkGetInstanceProcAddr( instance, "vkCmdCopyBuffer" ) );
5210 vkCmdCopyImage = PFN_vkCmdCopyImage( vkGetInstanceProcAddr( instance, "vkCmdCopyImage" ) );
5211 vkCmdBlitImage = PFN_vkCmdBlitImage( vkGetInstanceProcAddr( instance, "vkCmdBlitImage" ) );
5212 vkCmdCopyBufferToImage = PFN_vkCmdCopyBufferToImage( vkGetInstanceProcAddr( instance, "vkCmdCopyBufferToImage" ) );
5213 vkCmdCopyImageToBuffer = PFN_vkCmdCopyImageToBuffer( vkGetInstanceProcAddr( instance, "vkCmdCopyImageToBuffer" ) );
5214 vkCmdUpdateBuffer = PFN_vkCmdUpdateBuffer( vkGetInstanceProcAddr( instance, "vkCmdUpdateBuffer" ) );
5215 vkCmdFillBuffer = PFN_vkCmdFillBuffer( vkGetInstanceProcAddr( instance, "vkCmdFillBuffer" ) );
5216 vkCmdClearColorImage = PFN_vkCmdClearColorImage( vkGetInstanceProcAddr( instance, "vkCmdClearColorImage" ) );
5217 vkCmdClearDepthStencilImage = PFN_vkCmdClearDepthStencilImage( vkGetInstanceProcAddr( instance, "vkCmdClearDepthStencilImage" ) );
5218 vkCmdClearAttachments = PFN_vkCmdClearAttachments( vkGetInstanceProcAddr( instance, "vkCmdClearAttachments" ) );
5219 vkCmdResolveImage = PFN_vkCmdResolveImage( vkGetInstanceProcAddr( instance, "vkCmdResolveImage" ) );
5220 vkCmdSetEvent = PFN_vkCmdSetEvent( vkGetInstanceProcAddr( instance, "vkCmdSetEvent" ) );
5221 vkCmdResetEvent = PFN_vkCmdResetEvent( vkGetInstanceProcAddr( instance, "vkCmdResetEvent" ) );
5222 vkCmdWaitEvents = PFN_vkCmdWaitEvents( vkGetInstanceProcAddr( instance, "vkCmdWaitEvents" ) );
5223 vkCmdPipelineBarrier = PFN_vkCmdPipelineBarrier( vkGetInstanceProcAddr( instance, "vkCmdPipelineBarrier" ) );
5224 vkCmdBeginQuery = PFN_vkCmdBeginQuery( vkGetInstanceProcAddr( instance, "vkCmdBeginQuery" ) );
5225 vkCmdEndQuery = PFN_vkCmdEndQuery( vkGetInstanceProcAddr( instance, "vkCmdEndQuery" ) );
5226 vkCmdResetQueryPool = PFN_vkCmdResetQueryPool( vkGetInstanceProcAddr( instance, "vkCmdResetQueryPool" ) );
5227 vkCmdWriteTimestamp = PFN_vkCmdWriteTimestamp( vkGetInstanceProcAddr( instance, "vkCmdWriteTimestamp" ) );
5228 vkCmdCopyQueryPoolResults = PFN_vkCmdCopyQueryPoolResults( vkGetInstanceProcAddr( instance, "vkCmdCopyQueryPoolResults" ) );
5229 vkCmdPushConstants = PFN_vkCmdPushConstants( vkGetInstanceProcAddr( instance, "vkCmdPushConstants" ) );
5230 vkCmdBeginRenderPass = PFN_vkCmdBeginRenderPass( vkGetInstanceProcAddr( instance, "vkCmdBeginRenderPass" ) );
5231 vkCmdNextSubpass = PFN_vkCmdNextSubpass( vkGetInstanceProcAddr( instance, "vkCmdNextSubpass" ) );
5232 vkCmdEndRenderPass = PFN_vkCmdEndRenderPass( vkGetInstanceProcAddr( instance, "vkCmdEndRenderPass" ) );
5233 vkCmdExecuteCommands = PFN_vkCmdExecuteCommands( vkGetInstanceProcAddr( instance, "vkCmdExecuteCommands" ) );
5234
5235 //=== VK_VERSION_1_1 ===
5236 vkBindBufferMemory2 = PFN_vkBindBufferMemory2( vkGetInstanceProcAddr( instance, "vkBindBufferMemory2" ) );
5237 vkBindImageMemory2 = PFN_vkBindImageMemory2( vkGetInstanceProcAddr( instance, "vkBindImageMemory2" ) );
5238 vkGetDeviceGroupPeerMemoryFeatures = PFN_vkGetDeviceGroupPeerMemoryFeatures( vkGetInstanceProcAddr( instance, "vkGetDeviceGroupPeerMemoryFeatures" ) );
5239 vkCmdSetDeviceMask = PFN_vkCmdSetDeviceMask( vkGetInstanceProcAddr( instance, "vkCmdSetDeviceMask" ) );
5240 vkCmdDispatchBase = PFN_vkCmdDispatchBase( vkGetInstanceProcAddr( instance, "vkCmdDispatchBase" ) );
5241 vkEnumeratePhysicalDeviceGroups = PFN_vkEnumeratePhysicalDeviceGroups( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceGroups" ) );
5242 vkGetImageMemoryRequirements2 = PFN_vkGetImageMemoryRequirements2( vkGetInstanceProcAddr( instance, "vkGetImageMemoryRequirements2" ) );
5243 vkGetBufferMemoryRequirements2 = PFN_vkGetBufferMemoryRequirements2( vkGetInstanceProcAddr( instance, "vkGetBufferMemoryRequirements2" ) );
5244 vkGetPhysicalDeviceFeatures2 = PFN_vkGetPhysicalDeviceFeatures2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures2" ) );
5245 vkGetPhysicalDeviceProperties2 = PFN_vkGetPhysicalDeviceProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties2" ) );
5246 vkGetPhysicalDeviceFormatProperties2 = PFN_vkGetPhysicalDeviceFormatProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties2" ) );
5247 vkGetPhysicalDeviceImageFormatProperties2 = PFN_vkGetPhysicalDeviceImageFormatProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties2" ) );
5248 vkGetPhysicalDeviceQueueFamilyProperties2 = PFN_vkGetPhysicalDeviceQueueFamilyProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties2" ) );
5249 vkGetPhysicalDeviceMemoryProperties2 = PFN_vkGetPhysicalDeviceMemoryProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties2" ) );
5250 vkGetDeviceQueue2 = PFN_vkGetDeviceQueue2( vkGetInstanceProcAddr( instance, "vkGetDeviceQueue2" ) );
5251 vkCreateSamplerYcbcrConversion = PFN_vkCreateSamplerYcbcrConversion( vkGetInstanceProcAddr( instance, "vkCreateSamplerYcbcrConversion" ) );
5252 vkDestroySamplerYcbcrConversion = PFN_vkDestroySamplerYcbcrConversion( vkGetInstanceProcAddr( instance, "vkDestroySamplerYcbcrConversion" ) );
5253 vkGetPhysicalDeviceExternalBufferProperties = PFN_vkGetPhysicalDeviceExternalBufferProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalBufferProperties" ) );
5254 vkGetPhysicalDeviceExternalFenceProperties = PFN_vkGetPhysicalDeviceExternalFenceProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalFenceProperties" ) );
5255 vkGetPhysicalDeviceExternalSemaphoreProperties = PFN_vkGetPhysicalDeviceExternalSemaphoreProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalSemaphoreProperties" ) );
5256 vkGetDescriptorSetLayoutSupport = PFN_vkGetDescriptorSetLayoutSupport( vkGetInstanceProcAddr( instance, "vkGetDescriptorSetLayoutSupport" ) );
5257
5258 //=== VK_VERSION_1_2 ===
5259 vkCmdDrawIndirectCount = PFN_vkCmdDrawIndirectCount( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectCount" ) );
5260 vkCmdDrawIndexedIndirectCount = PFN_vkCmdDrawIndexedIndirectCount( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirectCount" ) );
5261 vkCreateRenderPass2 = PFN_vkCreateRenderPass2( vkGetInstanceProcAddr( instance, "vkCreateRenderPass2" ) );
5262 vkCmdBeginRenderPass2 = PFN_vkCmdBeginRenderPass2( vkGetInstanceProcAddr( instance, "vkCmdBeginRenderPass2" ) );
5263 vkCmdNextSubpass2 = PFN_vkCmdNextSubpass2( vkGetInstanceProcAddr( instance, "vkCmdNextSubpass2" ) );
5264 vkCmdEndRenderPass2 = PFN_vkCmdEndRenderPass2( vkGetInstanceProcAddr( instance, "vkCmdEndRenderPass2" ) );
5265 vkResetQueryPool = PFN_vkResetQueryPool( vkGetInstanceProcAddr( instance, "vkResetQueryPool" ) );
5266 vkGetSemaphoreCounterValue = PFN_vkGetSemaphoreCounterValue( vkGetInstanceProcAddr( instance, "vkGetSemaphoreCounterValue" ) );
5267 vkWaitSemaphores = PFN_vkWaitSemaphores( vkGetInstanceProcAddr( instance, "vkWaitSemaphores" ) );
5268 vkSignalSemaphore = PFN_vkSignalSemaphore( vkGetInstanceProcAddr( instance, "vkSignalSemaphore" ) );
5269 vkGetBufferDeviceAddress = PFN_vkGetBufferDeviceAddress( vkGetInstanceProcAddr( instance, "vkGetBufferDeviceAddress" ) );
5270 vkGetBufferOpaqueCaptureAddress = PFN_vkGetBufferOpaqueCaptureAddress( vkGetInstanceProcAddr( instance, "vkGetBufferOpaqueCaptureAddress" ) );
5271 vkGetDeviceMemoryOpaqueCaptureAddress = PFN_vkGetDeviceMemoryOpaqueCaptureAddress( vkGetInstanceProcAddr( instance, "vkGetDeviceMemoryOpaqueCaptureAddress" ) );
5272
5273 //=== VK_VERSION_1_3 ===
5274 vkGetPhysicalDeviceToolProperties = PFN_vkGetPhysicalDeviceToolProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceToolProperties" ) );
5275 vkCreatePrivateDataSlot = PFN_vkCreatePrivateDataSlot( vkGetInstanceProcAddr( instance, "vkCreatePrivateDataSlot" ) );
5276 vkDestroyPrivateDataSlot = PFN_vkDestroyPrivateDataSlot( vkGetInstanceProcAddr( instance, "vkDestroyPrivateDataSlot" ) );
5277 vkSetPrivateData = PFN_vkSetPrivateData( vkGetInstanceProcAddr( instance, "vkSetPrivateData" ) );
5278 vkGetPrivateData = PFN_vkGetPrivateData( vkGetInstanceProcAddr( instance, "vkGetPrivateData" ) );
5279 vkCmdSetEvent2 = PFN_vkCmdSetEvent2( vkGetInstanceProcAddr( instance, "vkCmdSetEvent2" ) );
5280 vkCmdResetEvent2 = PFN_vkCmdResetEvent2( vkGetInstanceProcAddr( instance, "vkCmdResetEvent2" ) );
5281 vkCmdWaitEvents2 = PFN_vkCmdWaitEvents2( vkGetInstanceProcAddr( instance, "vkCmdWaitEvents2" ) );
5282 vkCmdPipelineBarrier2 = PFN_vkCmdPipelineBarrier2( vkGetInstanceProcAddr( instance, "vkCmdPipelineBarrier2" ) );
5283 vkCmdWriteTimestamp2 = PFN_vkCmdWriteTimestamp2( vkGetInstanceProcAddr( instance, "vkCmdWriteTimestamp2" ) );
5284 vkQueueSubmit2 = PFN_vkQueueSubmit2( vkGetInstanceProcAddr( instance, "vkQueueSubmit2" ) );
5285 vkCmdCopyBuffer2 = PFN_vkCmdCopyBuffer2( vkGetInstanceProcAddr( instance, "vkCmdCopyBuffer2" ) );
5286 vkCmdCopyImage2 = PFN_vkCmdCopyImage2( vkGetInstanceProcAddr( instance, "vkCmdCopyImage2" ) );
5287 vkCmdCopyBufferToImage2 = PFN_vkCmdCopyBufferToImage2( vkGetInstanceProcAddr( instance, "vkCmdCopyBufferToImage2" ) );
5288 vkCmdCopyImageToBuffer2 = PFN_vkCmdCopyImageToBuffer2( vkGetInstanceProcAddr( instance, "vkCmdCopyImageToBuffer2" ) );
5289 vkCmdBlitImage2 = PFN_vkCmdBlitImage2( vkGetInstanceProcAddr( instance, "vkCmdBlitImage2" ) );
5290 vkCmdResolveImage2 = PFN_vkCmdResolveImage2( vkGetInstanceProcAddr( instance, "vkCmdResolveImage2" ) );
5291 vkCmdBeginRendering = PFN_vkCmdBeginRendering( vkGetInstanceProcAddr( instance, "vkCmdBeginRendering" ) );
5292 vkCmdEndRendering = PFN_vkCmdEndRendering( vkGetInstanceProcAddr( instance, "vkCmdEndRendering" ) );
5293 vkCmdSetCullMode = PFN_vkCmdSetCullMode( vkGetInstanceProcAddr( instance, "vkCmdSetCullMode" ) );
5294 vkCmdSetFrontFace = PFN_vkCmdSetFrontFace( vkGetInstanceProcAddr( instance, "vkCmdSetFrontFace" ) );
5295 vkCmdSetPrimitiveTopology = PFN_vkCmdSetPrimitiveTopology( vkGetInstanceProcAddr( instance, "vkCmdSetPrimitiveTopology" ) );
5296 vkCmdSetViewportWithCount = PFN_vkCmdSetViewportWithCount( vkGetInstanceProcAddr( instance, "vkCmdSetViewportWithCount" ) );
5297 vkCmdSetScissorWithCount = PFN_vkCmdSetScissorWithCount( vkGetInstanceProcAddr( instance, "vkCmdSetScissorWithCount" ) );
5298 vkCmdBindVertexBuffers2 = PFN_vkCmdBindVertexBuffers2( vkGetInstanceProcAddr( instance, "vkCmdBindVertexBuffers2" ) );
5299 vkCmdSetDepthTestEnable = PFN_vkCmdSetDepthTestEnable( vkGetInstanceProcAddr( instance, "vkCmdSetDepthTestEnable" ) );
5300 vkCmdSetDepthWriteEnable = PFN_vkCmdSetDepthWriteEnable( vkGetInstanceProcAddr( instance, "vkCmdSetDepthWriteEnable" ) );
5301 vkCmdSetDepthCompareOp = PFN_vkCmdSetDepthCompareOp( vkGetInstanceProcAddr( instance, "vkCmdSetDepthCompareOp" ) );
5302 vkCmdSetDepthBoundsTestEnable = PFN_vkCmdSetDepthBoundsTestEnable( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBoundsTestEnable" ) );
5303 vkCmdSetStencilTestEnable = PFN_vkCmdSetStencilTestEnable( vkGetInstanceProcAddr( instance, "vkCmdSetStencilTestEnable" ) );
5304 vkCmdSetStencilOp = PFN_vkCmdSetStencilOp( vkGetInstanceProcAddr( instance, "vkCmdSetStencilOp" ) );
5305 vkCmdSetRasterizerDiscardEnable = PFN_vkCmdSetRasterizerDiscardEnable( vkGetInstanceProcAddr( instance, "vkCmdSetRasterizerDiscardEnable" ) );
5306 vkCmdSetDepthBiasEnable = PFN_vkCmdSetDepthBiasEnable( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBiasEnable" ) );
5307 vkCmdSetPrimitiveRestartEnable = PFN_vkCmdSetPrimitiveRestartEnable( vkGetInstanceProcAddr( instance, "vkCmdSetPrimitiveRestartEnable" ) );
5308 vkGetDeviceBufferMemoryRequirements = PFN_vkGetDeviceBufferMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetDeviceBufferMemoryRequirements" ) );
5309 vkGetDeviceImageMemoryRequirements = PFN_vkGetDeviceImageMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetDeviceImageMemoryRequirements" ) );
5310 vkGetDeviceImageSparseMemoryRequirements = PFN_vkGetDeviceImageSparseMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetDeviceImageSparseMemoryRequirements" ) );
5311
5312 //=== VKSC_VERSION_1_0 ===
5313 vkGetCommandPoolMemoryConsumption = PFN_vkGetCommandPoolMemoryConsumption( vkGetInstanceProcAddr( instance, "vkGetCommandPoolMemoryConsumption" ) );
5314 vkGetFaultData = PFN_vkGetFaultData( vkGetInstanceProcAddr( instance, "vkGetFaultData" ) );
5315
5316 //=== VK_KHR_surface ===
5317 vkDestroySurfaceKHR = PFN_vkDestroySurfaceKHR( vkGetInstanceProcAddr( instance, "vkDestroySurfaceKHR" ) );
5318 vkGetPhysicalDeviceSurfaceSupportKHR = PFN_vkGetPhysicalDeviceSurfaceSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceSupportKHR" ) );
5319 vkGetPhysicalDeviceSurfaceCapabilitiesKHR = PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR" ) );
5320 vkGetPhysicalDeviceSurfaceFormatsKHR = PFN_vkGetPhysicalDeviceSurfaceFormatsKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceFormatsKHR" ) );
5321 vkGetPhysicalDeviceSurfacePresentModesKHR = PFN_vkGetPhysicalDeviceSurfacePresentModesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfacePresentModesKHR" ) );
5322
5323 //=== VK_KHR_swapchain ===
5324 vkCreateSwapchainKHR = PFN_vkCreateSwapchainKHR( vkGetInstanceProcAddr( instance, "vkCreateSwapchainKHR" ) );
5325 vkGetSwapchainImagesKHR = PFN_vkGetSwapchainImagesKHR( vkGetInstanceProcAddr( instance, "vkGetSwapchainImagesKHR" ) );
5326 vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR( vkGetInstanceProcAddr( instance, "vkAcquireNextImageKHR" ) );
5327 vkQueuePresentKHR = PFN_vkQueuePresentKHR( vkGetInstanceProcAddr( instance, "vkQueuePresentKHR" ) );
5328 vkGetDeviceGroupPresentCapabilitiesKHR = PFN_vkGetDeviceGroupPresentCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceGroupPresentCapabilitiesKHR" ) );
5329 vkGetDeviceGroupSurfacePresentModesKHR = PFN_vkGetDeviceGroupSurfacePresentModesKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceGroupSurfacePresentModesKHR" ) );
5330 vkGetPhysicalDevicePresentRectanglesKHR = PFN_vkGetPhysicalDevicePresentRectanglesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDevicePresentRectanglesKHR" ) );
5331 vkAcquireNextImage2KHR = PFN_vkAcquireNextImage2KHR( vkGetInstanceProcAddr( instance, "vkAcquireNextImage2KHR" ) );
5332
5333 //=== VK_KHR_display ===
5334 vkGetPhysicalDeviceDisplayPropertiesKHR = PFN_vkGetPhysicalDeviceDisplayPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPropertiesKHR" ) );
5335 vkGetPhysicalDeviceDisplayPlanePropertiesKHR = PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR" ) );
5336 vkGetDisplayPlaneSupportedDisplaysKHR = PFN_vkGetDisplayPlaneSupportedDisplaysKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneSupportedDisplaysKHR" ) );
5337 vkGetDisplayModePropertiesKHR = PFN_vkGetDisplayModePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayModePropertiesKHR" ) );
5338 vkCreateDisplayModeKHR = PFN_vkCreateDisplayModeKHR( vkGetInstanceProcAddr( instance, "vkCreateDisplayModeKHR" ) );
5339 vkGetDisplayPlaneCapabilitiesKHR = PFN_vkGetDisplayPlaneCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneCapabilitiesKHR" ) );
5340 vkCreateDisplayPlaneSurfaceKHR = PFN_vkCreateDisplayPlaneSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateDisplayPlaneSurfaceKHR" ) );
5341
5342 //=== VK_KHR_display_swapchain ===
5343 vkCreateSharedSwapchainsKHR = PFN_vkCreateSharedSwapchainsKHR( vkGetInstanceProcAddr( instance, "vkCreateSharedSwapchainsKHR" ) );
5344
5345 //=== VK_KHR_external_memory_fd ===
5346 vkGetMemoryFdKHR = PFN_vkGetMemoryFdKHR( vkGetInstanceProcAddr( instance, "vkGetMemoryFdKHR" ) );
5347 vkGetMemoryFdPropertiesKHR = PFN_vkGetMemoryFdPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetMemoryFdPropertiesKHR" ) );
5348
5349 //=== VK_KHR_external_semaphore_fd ===
5350 vkImportSemaphoreFdKHR = PFN_vkImportSemaphoreFdKHR( vkGetInstanceProcAddr( instance, "vkImportSemaphoreFdKHR" ) );
5351 vkGetSemaphoreFdKHR = PFN_vkGetSemaphoreFdKHR( vkGetInstanceProcAddr( instance, "vkGetSemaphoreFdKHR" ) );
5352
5353 //=== VK_EXT_direct_mode_display ===
5354 vkReleaseDisplayEXT = PFN_vkReleaseDisplayEXT( vkGetInstanceProcAddr( instance, "vkReleaseDisplayEXT" ) );
5355
5356 //=== VK_EXT_display_surface_counter ===
5357 vkGetPhysicalDeviceSurfaceCapabilities2EXT = PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilities2EXT" ) );
5358
5359 //=== VK_EXT_display_control ===
5360 vkDisplayPowerControlEXT = PFN_vkDisplayPowerControlEXT( vkGetInstanceProcAddr( instance, "vkDisplayPowerControlEXT" ) );
5361 vkRegisterDeviceEventEXT = PFN_vkRegisterDeviceEventEXT( vkGetInstanceProcAddr( instance, "vkRegisterDeviceEventEXT" ) );
5362 vkRegisterDisplayEventEXT = PFN_vkRegisterDisplayEventEXT( vkGetInstanceProcAddr( instance, "vkRegisterDisplayEventEXT" ) );
5363 vkGetSwapchainCounterEXT = PFN_vkGetSwapchainCounterEXT( vkGetInstanceProcAddr( instance, "vkGetSwapchainCounterEXT" ) );
5364
5365 //=== VK_EXT_discard_rectangles ===
5366 vkCmdSetDiscardRectangleEXT = PFN_vkCmdSetDiscardRectangleEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDiscardRectangleEXT" ) );
5367 vkCmdSetDiscardRectangleEnableEXT = PFN_vkCmdSetDiscardRectangleEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDiscardRectangleEnableEXT" ) );
5368 vkCmdSetDiscardRectangleModeEXT = PFN_vkCmdSetDiscardRectangleModeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDiscardRectangleModeEXT" ) );
5369
5370 //=== VK_EXT_hdr_metadata ===
5371 vkSetHdrMetadataEXT = PFN_vkSetHdrMetadataEXT( vkGetInstanceProcAddr( instance, "vkSetHdrMetadataEXT" ) );
5372
5373 //=== VK_KHR_shared_presentable_image ===
5374 vkGetSwapchainStatusKHR = PFN_vkGetSwapchainStatusKHR( vkGetInstanceProcAddr( instance, "vkGetSwapchainStatusKHR" ) );
5375
5376 //=== VK_KHR_external_fence_fd ===
5377 vkImportFenceFdKHR = PFN_vkImportFenceFdKHR( vkGetInstanceProcAddr( instance, "vkImportFenceFdKHR" ) );
5378 vkGetFenceFdKHR = PFN_vkGetFenceFdKHR( vkGetInstanceProcAddr( instance, "vkGetFenceFdKHR" ) );
5379
5380 //=== VK_KHR_performance_query ===
5381 vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR" ) );
5382 vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR" ) );
5383 vkAcquireProfilingLockKHR = PFN_vkAcquireProfilingLockKHR( vkGetInstanceProcAddr( instance, "vkAcquireProfilingLockKHR" ) );
5384 vkReleaseProfilingLockKHR = PFN_vkReleaseProfilingLockKHR( vkGetInstanceProcAddr( instance, "vkReleaseProfilingLockKHR" ) );
5385
5386 //=== VK_KHR_get_surface_capabilities2 ===
5387 vkGetPhysicalDeviceSurfaceCapabilities2KHR = PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilities2KHR" ) );
5388 vkGetPhysicalDeviceSurfaceFormats2KHR = PFN_vkGetPhysicalDeviceSurfaceFormats2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceFormats2KHR" ) );
5389
5390 //=== VK_KHR_get_display_properties2 ===
5391 vkGetPhysicalDeviceDisplayProperties2KHR = PFN_vkGetPhysicalDeviceDisplayProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayProperties2KHR" ) );
5392 vkGetPhysicalDeviceDisplayPlaneProperties2KHR = PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPlaneProperties2KHR" ) );
5393 vkGetDisplayModeProperties2KHR = PFN_vkGetDisplayModeProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetDisplayModeProperties2KHR" ) );
5394 vkGetDisplayPlaneCapabilities2KHR = PFN_vkGetDisplayPlaneCapabilities2KHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneCapabilities2KHR" ) );
5395
5396 //=== VK_EXT_debug_utils ===
5397 vkSetDebugUtilsObjectNameEXT = PFN_vkSetDebugUtilsObjectNameEXT( vkGetInstanceProcAddr( instance, "vkSetDebugUtilsObjectNameEXT" ) );
5398 vkSetDebugUtilsObjectTagEXT = PFN_vkSetDebugUtilsObjectTagEXT( vkGetInstanceProcAddr( instance, "vkSetDebugUtilsObjectTagEXT" ) );
5399 vkQueueBeginDebugUtilsLabelEXT = PFN_vkQueueBeginDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkQueueBeginDebugUtilsLabelEXT" ) );
5400 vkQueueEndDebugUtilsLabelEXT = PFN_vkQueueEndDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkQueueEndDebugUtilsLabelEXT" ) );
5401 vkQueueInsertDebugUtilsLabelEXT = PFN_vkQueueInsertDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkQueueInsertDebugUtilsLabelEXT" ) );
5402 vkCmdBeginDebugUtilsLabelEXT = PFN_vkCmdBeginDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkCmdBeginDebugUtilsLabelEXT" ) );
5403 vkCmdEndDebugUtilsLabelEXT = PFN_vkCmdEndDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkCmdEndDebugUtilsLabelEXT" ) );
5404 vkCmdInsertDebugUtilsLabelEXT = PFN_vkCmdInsertDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkCmdInsertDebugUtilsLabelEXT" ) );
5405 vkCreateDebugUtilsMessengerEXT = PFN_vkCreateDebugUtilsMessengerEXT( vkGetInstanceProcAddr( instance, "vkCreateDebugUtilsMessengerEXT" ) );
5406 vkDestroyDebugUtilsMessengerEXT = PFN_vkDestroyDebugUtilsMessengerEXT( vkGetInstanceProcAddr( instance, "vkDestroyDebugUtilsMessengerEXT" ) );
5407 vkSubmitDebugUtilsMessageEXT = PFN_vkSubmitDebugUtilsMessageEXT( vkGetInstanceProcAddr( instance, "vkSubmitDebugUtilsMessageEXT" ) );
5408
5409 //=== VK_EXT_sample_locations ===
5410 vkCmdSetSampleLocationsEXT = PFN_vkCmdSetSampleLocationsEXT( vkGetInstanceProcAddr( instance, "vkCmdSetSampleLocationsEXT" ) );
5411 vkGetPhysicalDeviceMultisamplePropertiesEXT = PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMultisamplePropertiesEXT" ) );
5412
5413 //=== VK_EXT_image_drm_format_modifier ===
5414 vkGetImageDrmFormatModifierPropertiesEXT = PFN_vkGetImageDrmFormatModifierPropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetImageDrmFormatModifierPropertiesEXT" ) );
5415
5416 //=== VK_EXT_external_memory_host ===
5417 vkGetMemoryHostPointerPropertiesEXT = PFN_vkGetMemoryHostPointerPropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetMemoryHostPointerPropertiesEXT" ) );
5418
5419 //=== VK_EXT_calibrated_timestamps ===
5420 vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT" ) );
5421 vkGetCalibratedTimestampsEXT = PFN_vkGetCalibratedTimestampsEXT( vkGetInstanceProcAddr( instance, "vkGetCalibratedTimestampsEXT" ) );
5422
5423 //=== VK_KHR_fragment_shading_rate ===
5424 vkGetPhysicalDeviceFragmentShadingRatesKHR = PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFragmentShadingRatesKHR" ) );
5425 vkCmdSetFragmentShadingRateKHR = PFN_vkCmdSetFragmentShadingRateKHR( vkGetInstanceProcAddr( instance, "vkCmdSetFragmentShadingRateKHR" ) );
5426
5427 //=== VK_EXT_headless_surface ===
5428 vkCreateHeadlessSurfaceEXT = PFN_vkCreateHeadlessSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateHeadlessSurfaceEXT" ) );
5429
5430 //=== VK_EXT_line_rasterization ===
5431 vkCmdSetLineStippleEXT = PFN_vkCmdSetLineStippleEXT( vkGetInstanceProcAddr( instance, "vkCmdSetLineStippleEXT" ) );
5432
5433 //=== VK_EXT_extended_dynamic_state ===
5434 vkCmdSetCullModeEXT = PFN_vkCmdSetCullModeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetCullModeEXT" ) );
5435 if ( !vkCmdSetCullMode ) vkCmdSetCullMode = vkCmdSetCullModeEXT;
5436 vkCmdSetFrontFaceEXT = PFN_vkCmdSetFrontFaceEXT( vkGetInstanceProcAddr( instance, "vkCmdSetFrontFaceEXT" ) );
5437 if ( !vkCmdSetFrontFace ) vkCmdSetFrontFace = vkCmdSetFrontFaceEXT;
5438 vkCmdSetPrimitiveTopologyEXT = PFN_vkCmdSetPrimitiveTopologyEXT( vkGetInstanceProcAddr( instance, "vkCmdSetPrimitiveTopologyEXT" ) );
5439 if ( !vkCmdSetPrimitiveTopology ) vkCmdSetPrimitiveTopology = vkCmdSetPrimitiveTopologyEXT;
5440 vkCmdSetViewportWithCountEXT = PFN_vkCmdSetViewportWithCountEXT( vkGetInstanceProcAddr( instance, "vkCmdSetViewportWithCountEXT" ) );
5441 if ( !vkCmdSetViewportWithCount ) vkCmdSetViewportWithCount = vkCmdSetViewportWithCountEXT;
5442 vkCmdSetScissorWithCountEXT = PFN_vkCmdSetScissorWithCountEXT( vkGetInstanceProcAddr( instance, "vkCmdSetScissorWithCountEXT" ) );
5443 if ( !vkCmdSetScissorWithCount ) vkCmdSetScissorWithCount = vkCmdSetScissorWithCountEXT;
5444 vkCmdBindVertexBuffers2EXT = PFN_vkCmdBindVertexBuffers2EXT( vkGetInstanceProcAddr( instance, "vkCmdBindVertexBuffers2EXT" ) );
5445 if ( !vkCmdBindVertexBuffers2 ) vkCmdBindVertexBuffers2 = vkCmdBindVertexBuffers2EXT;
5446 vkCmdSetDepthTestEnableEXT = PFN_vkCmdSetDepthTestEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthTestEnableEXT" ) );
5447 if ( !vkCmdSetDepthTestEnable ) vkCmdSetDepthTestEnable = vkCmdSetDepthTestEnableEXT;
5448 vkCmdSetDepthWriteEnableEXT = PFN_vkCmdSetDepthWriteEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthWriteEnableEXT" ) );
5449 if ( !vkCmdSetDepthWriteEnable ) vkCmdSetDepthWriteEnable = vkCmdSetDepthWriteEnableEXT;
5450 vkCmdSetDepthCompareOpEXT = PFN_vkCmdSetDepthCompareOpEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthCompareOpEXT" ) );
5451 if ( !vkCmdSetDepthCompareOp ) vkCmdSetDepthCompareOp = vkCmdSetDepthCompareOpEXT;
5452 vkCmdSetDepthBoundsTestEnableEXT = PFN_vkCmdSetDepthBoundsTestEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBoundsTestEnableEXT" ) );
5453 if ( !vkCmdSetDepthBoundsTestEnable ) vkCmdSetDepthBoundsTestEnable = vkCmdSetDepthBoundsTestEnableEXT;
5454 vkCmdSetStencilTestEnableEXT = PFN_vkCmdSetStencilTestEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetStencilTestEnableEXT" ) );
5455 if ( !vkCmdSetStencilTestEnable ) vkCmdSetStencilTestEnable = vkCmdSetStencilTestEnableEXT;
5456 vkCmdSetStencilOpEXT = PFN_vkCmdSetStencilOpEXT( vkGetInstanceProcAddr( instance, "vkCmdSetStencilOpEXT" ) );
5457 if ( !vkCmdSetStencilOp ) vkCmdSetStencilOp = vkCmdSetStencilOpEXT;
5458
5459 //=== VK_KHR_object_refresh ===
5460 vkCmdRefreshObjectsKHR = PFN_vkCmdRefreshObjectsKHR( vkGetInstanceProcAddr( instance, "vkCmdRefreshObjectsKHR" ) );
5461 vkGetPhysicalDeviceRefreshableObjectTypesKHR = PFN_vkGetPhysicalDeviceRefreshableObjectTypesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceRefreshableObjectTypesKHR" ) );
5462
5463 //=== VK_KHR_synchronization2 ===
5464 vkCmdSetEvent2KHR = PFN_vkCmdSetEvent2KHR( vkGetInstanceProcAddr( instance, "vkCmdSetEvent2KHR" ) );
5465 if ( !vkCmdSetEvent2 ) vkCmdSetEvent2 = vkCmdSetEvent2KHR;
5466 vkCmdResetEvent2KHR = PFN_vkCmdResetEvent2KHR( vkGetInstanceProcAddr( instance, "vkCmdResetEvent2KHR" ) );
5467 if ( !vkCmdResetEvent2 ) vkCmdResetEvent2 = vkCmdResetEvent2KHR;
5468 vkCmdWaitEvents2KHR = PFN_vkCmdWaitEvents2KHR( vkGetInstanceProcAddr( instance, "vkCmdWaitEvents2KHR" ) );
5469 if ( !vkCmdWaitEvents2 ) vkCmdWaitEvents2 = vkCmdWaitEvents2KHR;
5470 vkCmdPipelineBarrier2KHR = PFN_vkCmdPipelineBarrier2KHR( vkGetInstanceProcAddr( instance, "vkCmdPipelineBarrier2KHR" ) );
5471 if ( !vkCmdPipelineBarrier2 ) vkCmdPipelineBarrier2 = vkCmdPipelineBarrier2KHR;
5472 vkCmdWriteTimestamp2KHR = PFN_vkCmdWriteTimestamp2KHR( vkGetInstanceProcAddr( instance, "vkCmdWriteTimestamp2KHR" ) );
5473 if ( !vkCmdWriteTimestamp2 ) vkCmdWriteTimestamp2 = vkCmdWriteTimestamp2KHR;
5474 vkQueueSubmit2KHR = PFN_vkQueueSubmit2KHR( vkGetInstanceProcAddr( instance, "vkQueueSubmit2KHR" ) );
5475 if ( !vkQueueSubmit2 ) vkQueueSubmit2 = vkQueueSubmit2KHR;
5476 vkCmdWriteBufferMarker2AMD = PFN_vkCmdWriteBufferMarker2AMD( vkGetInstanceProcAddr( instance, "vkCmdWriteBufferMarker2AMD" ) );
5477 vkGetQueueCheckpointData2NV = PFN_vkGetQueueCheckpointData2NV( vkGetInstanceProcAddr( instance, "vkGetQueueCheckpointData2NV" ) );
5478
5479 //=== VK_KHR_copy_commands2 ===
5480 vkCmdCopyBuffer2KHR = PFN_vkCmdCopyBuffer2KHR( vkGetInstanceProcAddr( instance, "vkCmdCopyBuffer2KHR" ) );
5481 if ( !vkCmdCopyBuffer2 ) vkCmdCopyBuffer2 = vkCmdCopyBuffer2KHR;
5482 vkCmdCopyImage2KHR = PFN_vkCmdCopyImage2KHR( vkGetInstanceProcAddr( instance, "vkCmdCopyImage2KHR" ) );
5483 if ( !vkCmdCopyImage2 ) vkCmdCopyImage2 = vkCmdCopyImage2KHR;
5484 vkCmdCopyBufferToImage2KHR = PFN_vkCmdCopyBufferToImage2KHR( vkGetInstanceProcAddr( instance, "vkCmdCopyBufferToImage2KHR" ) );
5485 if ( !vkCmdCopyBufferToImage2 ) vkCmdCopyBufferToImage2 = vkCmdCopyBufferToImage2KHR;
5486 vkCmdCopyImageToBuffer2KHR = PFN_vkCmdCopyImageToBuffer2KHR( vkGetInstanceProcAddr( instance, "vkCmdCopyImageToBuffer2KHR" ) );
5487 if ( !vkCmdCopyImageToBuffer2 ) vkCmdCopyImageToBuffer2 = vkCmdCopyImageToBuffer2KHR;
5488 vkCmdBlitImage2KHR = PFN_vkCmdBlitImage2KHR( vkGetInstanceProcAddr( instance, "vkCmdBlitImage2KHR" ) );
5489 if ( !vkCmdBlitImage2 ) vkCmdBlitImage2 = vkCmdBlitImage2KHR;
5490 vkCmdResolveImage2KHR = PFN_vkCmdResolveImage2KHR( vkGetInstanceProcAddr( instance, "vkCmdResolveImage2KHR" ) );
5491 if ( !vkCmdResolveImage2 ) vkCmdResolveImage2 = vkCmdResolveImage2KHR;
5492
5493 //=== VK_EXT_vertex_input_dynamic_state ===
5494 vkCmdSetVertexInputEXT = PFN_vkCmdSetVertexInputEXT( vkGetInstanceProcAddr( instance, "vkCmdSetVertexInputEXT" ) );
5495
5496 #if defined( VK_USE_PLATFORM_SCI )
5497 //=== VK_NV_external_sci_sync ===
5498 vkGetFenceSciSyncFenceNV = PFN_vkGetFenceSciSyncFenceNV( vkGetInstanceProcAddr( instance, "vkGetFenceSciSyncFenceNV" ) );
5499 vkGetFenceSciSyncObjNV = PFN_vkGetFenceSciSyncObjNV( vkGetInstanceProcAddr( instance, "vkGetFenceSciSyncObjNV" ) );
5500 vkImportFenceSciSyncFenceNV = PFN_vkImportFenceSciSyncFenceNV( vkGetInstanceProcAddr( instance, "vkImportFenceSciSyncFenceNV" ) );
5501 vkImportFenceSciSyncObjNV = PFN_vkImportFenceSciSyncObjNV( vkGetInstanceProcAddr( instance, "vkImportFenceSciSyncObjNV" ) );
5502 vkGetPhysicalDeviceSciSyncAttributesNV = PFN_vkGetPhysicalDeviceSciSyncAttributesNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSciSyncAttributesNV" ) );
5503 vkGetSemaphoreSciSyncObjNV = PFN_vkGetSemaphoreSciSyncObjNV( vkGetInstanceProcAddr( instance, "vkGetSemaphoreSciSyncObjNV" ) );
5504 vkImportSemaphoreSciSyncObjNV = PFN_vkImportSemaphoreSciSyncObjNV( vkGetInstanceProcAddr( instance, "vkImportSemaphoreSciSyncObjNV" ) );
5505 #endif /*VK_USE_PLATFORM_SCI*/
5506
5507 #if defined( VK_USE_PLATFORM_SCI )
5508 //=== VK_NV_external_memory_sci_buf ===
5509 vkGetMemorySciBufNV = PFN_vkGetMemorySciBufNV( vkGetInstanceProcAddr( instance, "vkGetMemorySciBufNV" ) );
5510 vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV = PFN_vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV" ) );
5511 vkGetPhysicalDeviceSciBufAttributesNV = PFN_vkGetPhysicalDeviceSciBufAttributesNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSciBufAttributesNV" ) );
5512 #endif /*VK_USE_PLATFORM_SCI*/
5513
5514 //=== VK_EXT_extended_dynamic_state2 ===
5515 vkCmdSetPatchControlPointsEXT = PFN_vkCmdSetPatchControlPointsEXT( vkGetInstanceProcAddr( instance, "vkCmdSetPatchControlPointsEXT" ) );
5516 vkCmdSetRasterizerDiscardEnableEXT = PFN_vkCmdSetRasterizerDiscardEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetRasterizerDiscardEnableEXT" ) );
5517 if ( !vkCmdSetRasterizerDiscardEnable ) vkCmdSetRasterizerDiscardEnable = vkCmdSetRasterizerDiscardEnableEXT;
5518 vkCmdSetDepthBiasEnableEXT = PFN_vkCmdSetDepthBiasEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBiasEnableEXT" ) );
5519 if ( !vkCmdSetDepthBiasEnable ) vkCmdSetDepthBiasEnable = vkCmdSetDepthBiasEnableEXT;
5520 vkCmdSetLogicOpEXT = PFN_vkCmdSetLogicOpEXT( vkGetInstanceProcAddr( instance, "vkCmdSetLogicOpEXT" ) );
5521 vkCmdSetPrimitiveRestartEnableEXT = PFN_vkCmdSetPrimitiveRestartEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetPrimitiveRestartEnableEXT" ) );
5522 if ( !vkCmdSetPrimitiveRestartEnable ) vkCmdSetPrimitiveRestartEnable = vkCmdSetPrimitiveRestartEnableEXT;
5523
5524 //=== VK_EXT_color_write_enable ===
5525 vkCmdSetColorWriteEnableEXT = PFN_vkCmdSetColorWriteEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetColorWriteEnableEXT" ) );
5526
5527 #if defined( VK_USE_PLATFORM_SCI )
5528 //=== VK_NV_external_sci_sync2 ===
5529 vkCreateSemaphoreSciSyncPoolNV = PFN_vkCreateSemaphoreSciSyncPoolNV( vkGetInstanceProcAddr( instance, "vkCreateSemaphoreSciSyncPoolNV" ) );
5530 #endif /*VK_USE_PLATFORM_SCI*/
5531
5532 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
5533 //=== VK_QNX_external_memory_screen_buffer ===
5534 vkGetScreenBufferPropertiesQNX = PFN_vkGetScreenBufferPropertiesQNX( vkGetInstanceProcAddr( instance, "vkGetScreenBufferPropertiesQNX" ) );
5535 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
5536
5537 }
5538
init(VULKAN_HPP_NAMESPACE::Device deviceCpp)5539 void init( VULKAN_HPP_NAMESPACE::Device deviceCpp ) VULKAN_HPP_NOEXCEPT
5540 {
5541 VkDevice device = static_cast<VkDevice>(deviceCpp);
5542
5543
5544 //=== VK_VERSION_1_0 ===
5545 vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr( vkGetDeviceProcAddr( device, "vkGetDeviceProcAddr" ) );
5546 vkDestroyDevice = PFN_vkDestroyDevice( vkGetDeviceProcAddr( device, "vkDestroyDevice" ) );
5547 vkGetDeviceQueue = PFN_vkGetDeviceQueue( vkGetDeviceProcAddr( device, "vkGetDeviceQueue" ) );
5548 vkQueueSubmit = PFN_vkQueueSubmit( vkGetDeviceProcAddr( device, "vkQueueSubmit" ) );
5549 vkQueueWaitIdle = PFN_vkQueueWaitIdle( vkGetDeviceProcAddr( device, "vkQueueWaitIdle" ) );
5550 vkDeviceWaitIdle = PFN_vkDeviceWaitIdle( vkGetDeviceProcAddr( device, "vkDeviceWaitIdle" ) );
5551 vkAllocateMemory = PFN_vkAllocateMemory( vkGetDeviceProcAddr( device, "vkAllocateMemory" ) );
5552 vkMapMemory = PFN_vkMapMemory( vkGetDeviceProcAddr( device, "vkMapMemory" ) );
5553 vkUnmapMemory = PFN_vkUnmapMemory( vkGetDeviceProcAddr( device, "vkUnmapMemory" ) );
5554 vkFlushMappedMemoryRanges = PFN_vkFlushMappedMemoryRanges( vkGetDeviceProcAddr( device, "vkFlushMappedMemoryRanges" ) );
5555 vkInvalidateMappedMemoryRanges = PFN_vkInvalidateMappedMemoryRanges( vkGetDeviceProcAddr( device, "vkInvalidateMappedMemoryRanges" ) );
5556 vkGetDeviceMemoryCommitment = PFN_vkGetDeviceMemoryCommitment( vkGetDeviceProcAddr( device, "vkGetDeviceMemoryCommitment" ) );
5557 vkBindBufferMemory = PFN_vkBindBufferMemory( vkGetDeviceProcAddr( device, "vkBindBufferMemory" ) );
5558 vkBindImageMemory = PFN_vkBindImageMemory( vkGetDeviceProcAddr( device, "vkBindImageMemory" ) );
5559 vkGetBufferMemoryRequirements = PFN_vkGetBufferMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements" ) );
5560 vkGetImageMemoryRequirements = PFN_vkGetImageMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements" ) );
5561 vkCreateFence = PFN_vkCreateFence( vkGetDeviceProcAddr( device, "vkCreateFence" ) );
5562 vkDestroyFence = PFN_vkDestroyFence( vkGetDeviceProcAddr( device, "vkDestroyFence" ) );
5563 vkResetFences = PFN_vkResetFences( vkGetDeviceProcAddr( device, "vkResetFences" ) );
5564 vkGetFenceStatus = PFN_vkGetFenceStatus( vkGetDeviceProcAddr( device, "vkGetFenceStatus" ) );
5565 vkWaitForFences = PFN_vkWaitForFences( vkGetDeviceProcAddr( device, "vkWaitForFences" ) );
5566 vkCreateSemaphore = PFN_vkCreateSemaphore( vkGetDeviceProcAddr( device, "vkCreateSemaphore" ) );
5567 vkDestroySemaphore = PFN_vkDestroySemaphore( vkGetDeviceProcAddr( device, "vkDestroySemaphore" ) );
5568 vkCreateEvent = PFN_vkCreateEvent( vkGetDeviceProcAddr( device, "vkCreateEvent" ) );
5569 vkDestroyEvent = PFN_vkDestroyEvent( vkGetDeviceProcAddr( device, "vkDestroyEvent" ) );
5570 vkGetEventStatus = PFN_vkGetEventStatus( vkGetDeviceProcAddr( device, "vkGetEventStatus" ) );
5571 vkSetEvent = PFN_vkSetEvent( vkGetDeviceProcAddr( device, "vkSetEvent" ) );
5572 vkResetEvent = PFN_vkResetEvent( vkGetDeviceProcAddr( device, "vkResetEvent" ) );
5573 vkCreateQueryPool = PFN_vkCreateQueryPool( vkGetDeviceProcAddr( device, "vkCreateQueryPool" ) );
5574 vkGetQueryPoolResults = PFN_vkGetQueryPoolResults( vkGetDeviceProcAddr( device, "vkGetQueryPoolResults" ) );
5575 vkCreateBuffer = PFN_vkCreateBuffer( vkGetDeviceProcAddr( device, "vkCreateBuffer" ) );
5576 vkDestroyBuffer = PFN_vkDestroyBuffer( vkGetDeviceProcAddr( device, "vkDestroyBuffer" ) );
5577 vkCreateBufferView = PFN_vkCreateBufferView( vkGetDeviceProcAddr( device, "vkCreateBufferView" ) );
5578 vkDestroyBufferView = PFN_vkDestroyBufferView( vkGetDeviceProcAddr( device, "vkDestroyBufferView" ) );
5579 vkCreateImage = PFN_vkCreateImage( vkGetDeviceProcAddr( device, "vkCreateImage" ) );
5580 vkDestroyImage = PFN_vkDestroyImage( vkGetDeviceProcAddr( device, "vkDestroyImage" ) );
5581 vkGetImageSubresourceLayout = PFN_vkGetImageSubresourceLayout( vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout" ) );
5582 vkCreateImageView = PFN_vkCreateImageView( vkGetDeviceProcAddr( device, "vkCreateImageView" ) );
5583 vkDestroyImageView = PFN_vkDestroyImageView( vkGetDeviceProcAddr( device, "vkDestroyImageView" ) );
5584 vkCreatePipelineCache = PFN_vkCreatePipelineCache( vkGetDeviceProcAddr( device, "vkCreatePipelineCache" ) );
5585 vkDestroyPipelineCache = PFN_vkDestroyPipelineCache( vkGetDeviceProcAddr( device, "vkDestroyPipelineCache" ) );
5586 vkCreateGraphicsPipelines = PFN_vkCreateGraphicsPipelines( vkGetDeviceProcAddr( device, "vkCreateGraphicsPipelines" ) );
5587 vkCreateComputePipelines = PFN_vkCreateComputePipelines( vkGetDeviceProcAddr( device, "vkCreateComputePipelines" ) );
5588 vkDestroyPipeline = PFN_vkDestroyPipeline( vkGetDeviceProcAddr( device, "vkDestroyPipeline" ) );
5589 vkCreatePipelineLayout = PFN_vkCreatePipelineLayout( vkGetDeviceProcAddr( device, "vkCreatePipelineLayout" ) );
5590 vkDestroyPipelineLayout = PFN_vkDestroyPipelineLayout( vkGetDeviceProcAddr( device, "vkDestroyPipelineLayout" ) );
5591 vkCreateSampler = PFN_vkCreateSampler( vkGetDeviceProcAddr( device, "vkCreateSampler" ) );
5592 vkDestroySampler = PFN_vkDestroySampler( vkGetDeviceProcAddr( device, "vkDestroySampler" ) );
5593 vkCreateDescriptorSetLayout = PFN_vkCreateDescriptorSetLayout( vkGetDeviceProcAddr( device, "vkCreateDescriptorSetLayout" ) );
5594 vkDestroyDescriptorSetLayout = PFN_vkDestroyDescriptorSetLayout( vkGetDeviceProcAddr( device, "vkDestroyDescriptorSetLayout" ) );
5595 vkCreateDescriptorPool = PFN_vkCreateDescriptorPool( vkGetDeviceProcAddr( device, "vkCreateDescriptorPool" ) );
5596 vkResetDescriptorPool = PFN_vkResetDescriptorPool( vkGetDeviceProcAddr( device, "vkResetDescriptorPool" ) );
5597 vkAllocateDescriptorSets = PFN_vkAllocateDescriptorSets( vkGetDeviceProcAddr( device, "vkAllocateDescriptorSets" ) );
5598 vkFreeDescriptorSets = PFN_vkFreeDescriptorSets( vkGetDeviceProcAddr( device, "vkFreeDescriptorSets" ) );
5599 vkUpdateDescriptorSets = PFN_vkUpdateDescriptorSets( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSets" ) );
5600 vkCreateFramebuffer = PFN_vkCreateFramebuffer( vkGetDeviceProcAddr( device, "vkCreateFramebuffer" ) );
5601 vkDestroyFramebuffer = PFN_vkDestroyFramebuffer( vkGetDeviceProcAddr( device, "vkDestroyFramebuffer" ) );
5602 vkCreateRenderPass = PFN_vkCreateRenderPass( vkGetDeviceProcAddr( device, "vkCreateRenderPass" ) );
5603 vkDestroyRenderPass = PFN_vkDestroyRenderPass( vkGetDeviceProcAddr( device, "vkDestroyRenderPass" ) );
5604 vkGetRenderAreaGranularity = PFN_vkGetRenderAreaGranularity( vkGetDeviceProcAddr( device, "vkGetRenderAreaGranularity" ) );
5605 vkCreateCommandPool = PFN_vkCreateCommandPool( vkGetDeviceProcAddr( device, "vkCreateCommandPool" ) );
5606 vkResetCommandPool = PFN_vkResetCommandPool( vkGetDeviceProcAddr( device, "vkResetCommandPool" ) );
5607 vkAllocateCommandBuffers = PFN_vkAllocateCommandBuffers( vkGetDeviceProcAddr( device, "vkAllocateCommandBuffers" ) );
5608 vkFreeCommandBuffers = PFN_vkFreeCommandBuffers( vkGetDeviceProcAddr( device, "vkFreeCommandBuffers" ) );
5609 vkBeginCommandBuffer = PFN_vkBeginCommandBuffer( vkGetDeviceProcAddr( device, "vkBeginCommandBuffer" ) );
5610 vkEndCommandBuffer = PFN_vkEndCommandBuffer( vkGetDeviceProcAddr( device, "vkEndCommandBuffer" ) );
5611 vkResetCommandBuffer = PFN_vkResetCommandBuffer( vkGetDeviceProcAddr( device, "vkResetCommandBuffer" ) );
5612 vkCmdBindPipeline = PFN_vkCmdBindPipeline( vkGetDeviceProcAddr( device, "vkCmdBindPipeline" ) );
5613 vkCmdSetViewport = PFN_vkCmdSetViewport( vkGetDeviceProcAddr( device, "vkCmdSetViewport" ) );
5614 vkCmdSetScissor = PFN_vkCmdSetScissor( vkGetDeviceProcAddr( device, "vkCmdSetScissor" ) );
5615 vkCmdSetLineWidth = PFN_vkCmdSetLineWidth( vkGetDeviceProcAddr( device, "vkCmdSetLineWidth" ) );
5616 vkCmdSetDepthBias = PFN_vkCmdSetDepthBias( vkGetDeviceProcAddr( device, "vkCmdSetDepthBias" ) );
5617 vkCmdSetBlendConstants = PFN_vkCmdSetBlendConstants( vkGetDeviceProcAddr( device, "vkCmdSetBlendConstants" ) );
5618 vkCmdSetDepthBounds = PFN_vkCmdSetDepthBounds( vkGetDeviceProcAddr( device, "vkCmdSetDepthBounds" ) );
5619 vkCmdSetStencilCompareMask = PFN_vkCmdSetStencilCompareMask( vkGetDeviceProcAddr( device, "vkCmdSetStencilCompareMask" ) );
5620 vkCmdSetStencilWriteMask = PFN_vkCmdSetStencilWriteMask( vkGetDeviceProcAddr( device, "vkCmdSetStencilWriteMask" ) );
5621 vkCmdSetStencilReference = PFN_vkCmdSetStencilReference( vkGetDeviceProcAddr( device, "vkCmdSetStencilReference" ) );
5622 vkCmdBindDescriptorSets = PFN_vkCmdBindDescriptorSets( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorSets" ) );
5623 vkCmdBindIndexBuffer = PFN_vkCmdBindIndexBuffer( vkGetDeviceProcAddr( device, "vkCmdBindIndexBuffer" ) );
5624 vkCmdBindVertexBuffers = PFN_vkCmdBindVertexBuffers( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers" ) );
5625 vkCmdDraw = PFN_vkCmdDraw( vkGetDeviceProcAddr( device, "vkCmdDraw" ) );
5626 vkCmdDrawIndexed = PFN_vkCmdDrawIndexed( vkGetDeviceProcAddr( device, "vkCmdDrawIndexed" ) );
5627 vkCmdDrawIndirect = PFN_vkCmdDrawIndirect( vkGetDeviceProcAddr( device, "vkCmdDrawIndirect" ) );
5628 vkCmdDrawIndexedIndirect = PFN_vkCmdDrawIndexedIndirect( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirect" ) );
5629 vkCmdDispatch = PFN_vkCmdDispatch( vkGetDeviceProcAddr( device, "vkCmdDispatch" ) );
5630 vkCmdDispatchIndirect = PFN_vkCmdDispatchIndirect( vkGetDeviceProcAddr( device, "vkCmdDispatchIndirect" ) );
5631 vkCmdCopyBuffer = PFN_vkCmdCopyBuffer( vkGetDeviceProcAddr( device, "vkCmdCopyBuffer" ) );
5632 vkCmdCopyImage = PFN_vkCmdCopyImage( vkGetDeviceProcAddr( device, "vkCmdCopyImage" ) );
5633 vkCmdBlitImage = PFN_vkCmdBlitImage( vkGetDeviceProcAddr( device, "vkCmdBlitImage" ) );
5634 vkCmdCopyBufferToImage = PFN_vkCmdCopyBufferToImage( vkGetDeviceProcAddr( device, "vkCmdCopyBufferToImage" ) );
5635 vkCmdCopyImageToBuffer = PFN_vkCmdCopyImageToBuffer( vkGetDeviceProcAddr( device, "vkCmdCopyImageToBuffer" ) );
5636 vkCmdUpdateBuffer = PFN_vkCmdUpdateBuffer( vkGetDeviceProcAddr( device, "vkCmdUpdateBuffer" ) );
5637 vkCmdFillBuffer = PFN_vkCmdFillBuffer( vkGetDeviceProcAddr( device, "vkCmdFillBuffer" ) );
5638 vkCmdClearColorImage = PFN_vkCmdClearColorImage( vkGetDeviceProcAddr( device, "vkCmdClearColorImage" ) );
5639 vkCmdClearDepthStencilImage = PFN_vkCmdClearDepthStencilImage( vkGetDeviceProcAddr( device, "vkCmdClearDepthStencilImage" ) );
5640 vkCmdClearAttachments = PFN_vkCmdClearAttachments( vkGetDeviceProcAddr( device, "vkCmdClearAttachments" ) );
5641 vkCmdResolveImage = PFN_vkCmdResolveImage( vkGetDeviceProcAddr( device, "vkCmdResolveImage" ) );
5642 vkCmdSetEvent = PFN_vkCmdSetEvent( vkGetDeviceProcAddr( device, "vkCmdSetEvent" ) );
5643 vkCmdResetEvent = PFN_vkCmdResetEvent( vkGetDeviceProcAddr( device, "vkCmdResetEvent" ) );
5644 vkCmdWaitEvents = PFN_vkCmdWaitEvents( vkGetDeviceProcAddr( device, "vkCmdWaitEvents" ) );
5645 vkCmdPipelineBarrier = PFN_vkCmdPipelineBarrier( vkGetDeviceProcAddr( device, "vkCmdPipelineBarrier" ) );
5646 vkCmdBeginQuery = PFN_vkCmdBeginQuery( vkGetDeviceProcAddr( device, "vkCmdBeginQuery" ) );
5647 vkCmdEndQuery = PFN_vkCmdEndQuery( vkGetDeviceProcAddr( device, "vkCmdEndQuery" ) );
5648 vkCmdResetQueryPool = PFN_vkCmdResetQueryPool( vkGetDeviceProcAddr( device, "vkCmdResetQueryPool" ) );
5649 vkCmdWriteTimestamp = PFN_vkCmdWriteTimestamp( vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp" ) );
5650 vkCmdCopyQueryPoolResults = PFN_vkCmdCopyQueryPoolResults( vkGetDeviceProcAddr( device, "vkCmdCopyQueryPoolResults" ) );
5651 vkCmdPushConstants = PFN_vkCmdPushConstants( vkGetDeviceProcAddr( device, "vkCmdPushConstants" ) );
5652 vkCmdBeginRenderPass = PFN_vkCmdBeginRenderPass( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass" ) );
5653 vkCmdNextSubpass = PFN_vkCmdNextSubpass( vkGetDeviceProcAddr( device, "vkCmdNextSubpass" ) );
5654 vkCmdEndRenderPass = PFN_vkCmdEndRenderPass( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass" ) );
5655 vkCmdExecuteCommands = PFN_vkCmdExecuteCommands( vkGetDeviceProcAddr( device, "vkCmdExecuteCommands" ) );
5656
5657 //=== VK_VERSION_1_1 ===
5658 vkBindBufferMemory2 = PFN_vkBindBufferMemory2( vkGetDeviceProcAddr( device, "vkBindBufferMemory2" ) );
5659 vkBindImageMemory2 = PFN_vkBindImageMemory2( vkGetDeviceProcAddr( device, "vkBindImageMemory2" ) );
5660 vkGetDeviceGroupPeerMemoryFeatures = PFN_vkGetDeviceGroupPeerMemoryFeatures( vkGetDeviceProcAddr( device, "vkGetDeviceGroupPeerMemoryFeatures" ) );
5661 vkCmdSetDeviceMask = PFN_vkCmdSetDeviceMask( vkGetDeviceProcAddr( device, "vkCmdSetDeviceMask" ) );
5662 vkCmdDispatchBase = PFN_vkCmdDispatchBase( vkGetDeviceProcAddr( device, "vkCmdDispatchBase" ) );
5663 vkGetImageMemoryRequirements2 = PFN_vkGetImageMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements2" ) );
5664 vkGetBufferMemoryRequirements2 = PFN_vkGetBufferMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements2" ) );
5665 vkGetDeviceQueue2 = PFN_vkGetDeviceQueue2( vkGetDeviceProcAddr( device, "vkGetDeviceQueue2" ) );
5666 vkCreateSamplerYcbcrConversion = PFN_vkCreateSamplerYcbcrConversion( vkGetDeviceProcAddr( device, "vkCreateSamplerYcbcrConversion" ) );
5667 vkDestroySamplerYcbcrConversion = PFN_vkDestroySamplerYcbcrConversion( vkGetDeviceProcAddr( device, "vkDestroySamplerYcbcrConversion" ) );
5668 vkGetDescriptorSetLayoutSupport = PFN_vkGetDescriptorSetLayoutSupport( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSupport" ) );
5669
5670 //=== VK_VERSION_1_2 ===
5671 vkCmdDrawIndirectCount = PFN_vkCmdDrawIndirectCount( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCount" ) );
5672 vkCmdDrawIndexedIndirectCount = PFN_vkCmdDrawIndexedIndirectCount( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCount" ) );
5673 vkCreateRenderPass2 = PFN_vkCreateRenderPass2( vkGetDeviceProcAddr( device, "vkCreateRenderPass2" ) );
5674 vkCmdBeginRenderPass2 = PFN_vkCmdBeginRenderPass2( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass2" ) );
5675 vkCmdNextSubpass2 = PFN_vkCmdNextSubpass2( vkGetDeviceProcAddr( device, "vkCmdNextSubpass2" ) );
5676 vkCmdEndRenderPass2 = PFN_vkCmdEndRenderPass2( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass2" ) );
5677 vkResetQueryPool = PFN_vkResetQueryPool( vkGetDeviceProcAddr( device, "vkResetQueryPool" ) );
5678 vkGetSemaphoreCounterValue = PFN_vkGetSemaphoreCounterValue( vkGetDeviceProcAddr( device, "vkGetSemaphoreCounterValue" ) );
5679 vkWaitSemaphores = PFN_vkWaitSemaphores( vkGetDeviceProcAddr( device, "vkWaitSemaphores" ) );
5680 vkSignalSemaphore = PFN_vkSignalSemaphore( vkGetDeviceProcAddr( device, "vkSignalSemaphore" ) );
5681 vkGetBufferDeviceAddress = PFN_vkGetBufferDeviceAddress( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddress" ) );
5682 vkGetBufferOpaqueCaptureAddress = PFN_vkGetBufferOpaqueCaptureAddress( vkGetDeviceProcAddr( device, "vkGetBufferOpaqueCaptureAddress" ) );
5683 vkGetDeviceMemoryOpaqueCaptureAddress = PFN_vkGetDeviceMemoryOpaqueCaptureAddress( vkGetDeviceProcAddr( device, "vkGetDeviceMemoryOpaqueCaptureAddress" ) );
5684
5685 //=== VK_VERSION_1_3 ===
5686 vkCreatePrivateDataSlot = PFN_vkCreatePrivateDataSlot( vkGetDeviceProcAddr( device, "vkCreatePrivateDataSlot" ) );
5687 vkDestroyPrivateDataSlot = PFN_vkDestroyPrivateDataSlot( vkGetDeviceProcAddr( device, "vkDestroyPrivateDataSlot" ) );
5688 vkSetPrivateData = PFN_vkSetPrivateData( vkGetDeviceProcAddr( device, "vkSetPrivateData" ) );
5689 vkGetPrivateData = PFN_vkGetPrivateData( vkGetDeviceProcAddr( device, "vkGetPrivateData" ) );
5690 vkCmdSetEvent2 = PFN_vkCmdSetEvent2( vkGetDeviceProcAddr( device, "vkCmdSetEvent2" ) );
5691 vkCmdResetEvent2 = PFN_vkCmdResetEvent2( vkGetDeviceProcAddr( device, "vkCmdResetEvent2" ) );
5692 vkCmdWaitEvents2 = PFN_vkCmdWaitEvents2( vkGetDeviceProcAddr( device, "vkCmdWaitEvents2" ) );
5693 vkCmdPipelineBarrier2 = PFN_vkCmdPipelineBarrier2( vkGetDeviceProcAddr( device, "vkCmdPipelineBarrier2" ) );
5694 vkCmdWriteTimestamp2 = PFN_vkCmdWriteTimestamp2( vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp2" ) );
5695 vkQueueSubmit2 = PFN_vkQueueSubmit2( vkGetDeviceProcAddr( device, "vkQueueSubmit2" ) );
5696 vkCmdCopyBuffer2 = PFN_vkCmdCopyBuffer2( vkGetDeviceProcAddr( device, "vkCmdCopyBuffer2" ) );
5697 vkCmdCopyImage2 = PFN_vkCmdCopyImage2( vkGetDeviceProcAddr( device, "vkCmdCopyImage2" ) );
5698 vkCmdCopyBufferToImage2 = PFN_vkCmdCopyBufferToImage2( vkGetDeviceProcAddr( device, "vkCmdCopyBufferToImage2" ) );
5699 vkCmdCopyImageToBuffer2 = PFN_vkCmdCopyImageToBuffer2( vkGetDeviceProcAddr( device, "vkCmdCopyImageToBuffer2" ) );
5700 vkCmdBlitImage2 = PFN_vkCmdBlitImage2( vkGetDeviceProcAddr( device, "vkCmdBlitImage2" ) );
5701 vkCmdResolveImage2 = PFN_vkCmdResolveImage2( vkGetDeviceProcAddr( device, "vkCmdResolveImage2" ) );
5702 vkCmdBeginRendering = PFN_vkCmdBeginRendering( vkGetDeviceProcAddr( device, "vkCmdBeginRendering" ) );
5703 vkCmdEndRendering = PFN_vkCmdEndRendering( vkGetDeviceProcAddr( device, "vkCmdEndRendering" ) );
5704 vkCmdSetCullMode = PFN_vkCmdSetCullMode( vkGetDeviceProcAddr( device, "vkCmdSetCullMode" ) );
5705 vkCmdSetFrontFace = PFN_vkCmdSetFrontFace( vkGetDeviceProcAddr( device, "vkCmdSetFrontFace" ) );
5706 vkCmdSetPrimitiveTopology = PFN_vkCmdSetPrimitiveTopology( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveTopology" ) );
5707 vkCmdSetViewportWithCount = PFN_vkCmdSetViewportWithCount( vkGetDeviceProcAddr( device, "vkCmdSetViewportWithCount" ) );
5708 vkCmdSetScissorWithCount = PFN_vkCmdSetScissorWithCount( vkGetDeviceProcAddr( device, "vkCmdSetScissorWithCount" ) );
5709 vkCmdBindVertexBuffers2 = PFN_vkCmdBindVertexBuffers2( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers2" ) );
5710 vkCmdSetDepthTestEnable = PFN_vkCmdSetDepthTestEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthTestEnable" ) );
5711 vkCmdSetDepthWriteEnable = PFN_vkCmdSetDepthWriteEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthWriteEnable" ) );
5712 vkCmdSetDepthCompareOp = PFN_vkCmdSetDepthCompareOp( vkGetDeviceProcAddr( device, "vkCmdSetDepthCompareOp" ) );
5713 vkCmdSetDepthBoundsTestEnable = PFN_vkCmdSetDepthBoundsTestEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthBoundsTestEnable" ) );
5714 vkCmdSetStencilTestEnable = PFN_vkCmdSetStencilTestEnable( vkGetDeviceProcAddr( device, "vkCmdSetStencilTestEnable" ) );
5715 vkCmdSetStencilOp = PFN_vkCmdSetStencilOp( vkGetDeviceProcAddr( device, "vkCmdSetStencilOp" ) );
5716 vkCmdSetRasterizerDiscardEnable = PFN_vkCmdSetRasterizerDiscardEnable( vkGetDeviceProcAddr( device, "vkCmdSetRasterizerDiscardEnable" ) );
5717 vkCmdSetDepthBiasEnable = PFN_vkCmdSetDepthBiasEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthBiasEnable" ) );
5718 vkCmdSetPrimitiveRestartEnable = PFN_vkCmdSetPrimitiveRestartEnable( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveRestartEnable" ) );
5719 vkGetDeviceBufferMemoryRequirements = PFN_vkGetDeviceBufferMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetDeviceBufferMemoryRequirements" ) );
5720 vkGetDeviceImageMemoryRequirements = PFN_vkGetDeviceImageMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetDeviceImageMemoryRequirements" ) );
5721 vkGetDeviceImageSparseMemoryRequirements = PFN_vkGetDeviceImageSparseMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetDeviceImageSparseMemoryRequirements" ) );
5722
5723 //=== VKSC_VERSION_1_0 ===
5724 vkGetCommandPoolMemoryConsumption = PFN_vkGetCommandPoolMemoryConsumption( vkGetDeviceProcAddr( device, "vkGetCommandPoolMemoryConsumption" ) );
5725 vkGetFaultData = PFN_vkGetFaultData( vkGetDeviceProcAddr( device, "vkGetFaultData" ) );
5726
5727 //=== VK_KHR_swapchain ===
5728 vkCreateSwapchainKHR = PFN_vkCreateSwapchainKHR( vkGetDeviceProcAddr( device, "vkCreateSwapchainKHR" ) );
5729 vkGetSwapchainImagesKHR = PFN_vkGetSwapchainImagesKHR( vkGetDeviceProcAddr( device, "vkGetSwapchainImagesKHR" ) );
5730 vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR( vkGetDeviceProcAddr( device, "vkAcquireNextImageKHR" ) );
5731 vkQueuePresentKHR = PFN_vkQueuePresentKHR( vkGetDeviceProcAddr( device, "vkQueuePresentKHR" ) );
5732 vkGetDeviceGroupPresentCapabilitiesKHR = PFN_vkGetDeviceGroupPresentCapabilitiesKHR( vkGetDeviceProcAddr( device, "vkGetDeviceGroupPresentCapabilitiesKHR" ) );
5733 vkGetDeviceGroupSurfacePresentModesKHR = PFN_vkGetDeviceGroupSurfacePresentModesKHR( vkGetDeviceProcAddr( device, "vkGetDeviceGroupSurfacePresentModesKHR" ) );
5734 vkAcquireNextImage2KHR = PFN_vkAcquireNextImage2KHR( vkGetDeviceProcAddr( device, "vkAcquireNextImage2KHR" ) );
5735
5736 //=== VK_KHR_display_swapchain ===
5737 vkCreateSharedSwapchainsKHR = PFN_vkCreateSharedSwapchainsKHR( vkGetDeviceProcAddr( device, "vkCreateSharedSwapchainsKHR" ) );
5738
5739 //=== VK_KHR_external_memory_fd ===
5740 vkGetMemoryFdKHR = PFN_vkGetMemoryFdKHR( vkGetDeviceProcAddr( device, "vkGetMemoryFdKHR" ) );
5741 vkGetMemoryFdPropertiesKHR = PFN_vkGetMemoryFdPropertiesKHR( vkGetDeviceProcAddr( device, "vkGetMemoryFdPropertiesKHR" ) );
5742
5743 //=== VK_KHR_external_semaphore_fd ===
5744 vkImportSemaphoreFdKHR = PFN_vkImportSemaphoreFdKHR( vkGetDeviceProcAddr( device, "vkImportSemaphoreFdKHR" ) );
5745 vkGetSemaphoreFdKHR = PFN_vkGetSemaphoreFdKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreFdKHR" ) );
5746
5747 //=== VK_EXT_display_control ===
5748 vkDisplayPowerControlEXT = PFN_vkDisplayPowerControlEXT( vkGetDeviceProcAddr( device, "vkDisplayPowerControlEXT" ) );
5749 vkRegisterDeviceEventEXT = PFN_vkRegisterDeviceEventEXT( vkGetDeviceProcAddr( device, "vkRegisterDeviceEventEXT" ) );
5750 vkRegisterDisplayEventEXT = PFN_vkRegisterDisplayEventEXT( vkGetDeviceProcAddr( device, "vkRegisterDisplayEventEXT" ) );
5751 vkGetSwapchainCounterEXT = PFN_vkGetSwapchainCounterEXT( vkGetDeviceProcAddr( device, "vkGetSwapchainCounterEXT" ) );
5752
5753 //=== VK_EXT_discard_rectangles ===
5754 vkCmdSetDiscardRectangleEXT = PFN_vkCmdSetDiscardRectangleEXT( vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleEXT" ) );
5755 vkCmdSetDiscardRectangleEnableEXT = PFN_vkCmdSetDiscardRectangleEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleEnableEXT" ) );
5756 vkCmdSetDiscardRectangleModeEXT = PFN_vkCmdSetDiscardRectangleModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleModeEXT" ) );
5757
5758 //=== VK_EXT_hdr_metadata ===
5759 vkSetHdrMetadataEXT = PFN_vkSetHdrMetadataEXT( vkGetDeviceProcAddr( device, "vkSetHdrMetadataEXT" ) );
5760
5761 //=== VK_KHR_shared_presentable_image ===
5762 vkGetSwapchainStatusKHR = PFN_vkGetSwapchainStatusKHR( vkGetDeviceProcAddr( device, "vkGetSwapchainStatusKHR" ) );
5763
5764 //=== VK_KHR_external_fence_fd ===
5765 vkImportFenceFdKHR = PFN_vkImportFenceFdKHR( vkGetDeviceProcAddr( device, "vkImportFenceFdKHR" ) );
5766 vkGetFenceFdKHR = PFN_vkGetFenceFdKHR( vkGetDeviceProcAddr( device, "vkGetFenceFdKHR" ) );
5767
5768 //=== VK_KHR_performance_query ===
5769 vkAcquireProfilingLockKHR = PFN_vkAcquireProfilingLockKHR( vkGetDeviceProcAddr( device, "vkAcquireProfilingLockKHR" ) );
5770 vkReleaseProfilingLockKHR = PFN_vkReleaseProfilingLockKHR( vkGetDeviceProcAddr( device, "vkReleaseProfilingLockKHR" ) );
5771
5772 //=== VK_EXT_debug_utils ===
5773 vkSetDebugUtilsObjectNameEXT = PFN_vkSetDebugUtilsObjectNameEXT( vkGetDeviceProcAddr( device, "vkSetDebugUtilsObjectNameEXT" ) );
5774 vkSetDebugUtilsObjectTagEXT = PFN_vkSetDebugUtilsObjectTagEXT( vkGetDeviceProcAddr( device, "vkSetDebugUtilsObjectTagEXT" ) );
5775 vkQueueBeginDebugUtilsLabelEXT = PFN_vkQueueBeginDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueBeginDebugUtilsLabelEXT" ) );
5776 vkQueueEndDebugUtilsLabelEXT = PFN_vkQueueEndDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueEndDebugUtilsLabelEXT" ) );
5777 vkQueueInsertDebugUtilsLabelEXT = PFN_vkQueueInsertDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueInsertDebugUtilsLabelEXT" ) );
5778 vkCmdBeginDebugUtilsLabelEXT = PFN_vkCmdBeginDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdBeginDebugUtilsLabelEXT" ) );
5779 vkCmdEndDebugUtilsLabelEXT = PFN_vkCmdEndDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdEndDebugUtilsLabelEXT" ) );
5780 vkCmdInsertDebugUtilsLabelEXT = PFN_vkCmdInsertDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdInsertDebugUtilsLabelEXT" ) );
5781
5782 //=== VK_EXT_sample_locations ===
5783 vkCmdSetSampleLocationsEXT = PFN_vkCmdSetSampleLocationsEXT( vkGetDeviceProcAddr( device, "vkCmdSetSampleLocationsEXT" ) );
5784
5785 //=== VK_EXT_image_drm_format_modifier ===
5786 vkGetImageDrmFormatModifierPropertiesEXT = PFN_vkGetImageDrmFormatModifierPropertiesEXT( vkGetDeviceProcAddr( device, "vkGetImageDrmFormatModifierPropertiesEXT" ) );
5787
5788 //=== VK_EXT_external_memory_host ===
5789 vkGetMemoryHostPointerPropertiesEXT = PFN_vkGetMemoryHostPointerPropertiesEXT( vkGetDeviceProcAddr( device, "vkGetMemoryHostPointerPropertiesEXT" ) );
5790
5791 //=== VK_EXT_calibrated_timestamps ===
5792 vkGetCalibratedTimestampsEXT = PFN_vkGetCalibratedTimestampsEXT( vkGetDeviceProcAddr( device, "vkGetCalibratedTimestampsEXT" ) );
5793
5794 //=== VK_KHR_fragment_shading_rate ===
5795 vkCmdSetFragmentShadingRateKHR = PFN_vkCmdSetFragmentShadingRateKHR( vkGetDeviceProcAddr( device, "vkCmdSetFragmentShadingRateKHR" ) );
5796
5797 //=== VK_EXT_line_rasterization ===
5798 vkCmdSetLineStippleEXT = PFN_vkCmdSetLineStippleEXT( vkGetDeviceProcAddr( device, "vkCmdSetLineStippleEXT" ) );
5799
5800 //=== VK_EXT_extended_dynamic_state ===
5801 vkCmdSetCullModeEXT = PFN_vkCmdSetCullModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetCullModeEXT" ) );
5802 if ( !vkCmdSetCullMode ) vkCmdSetCullMode = vkCmdSetCullModeEXT;
5803 vkCmdSetFrontFaceEXT = PFN_vkCmdSetFrontFaceEXT( vkGetDeviceProcAddr( device, "vkCmdSetFrontFaceEXT" ) );
5804 if ( !vkCmdSetFrontFace ) vkCmdSetFrontFace = vkCmdSetFrontFaceEXT;
5805 vkCmdSetPrimitiveTopologyEXT = PFN_vkCmdSetPrimitiveTopologyEXT( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveTopologyEXT" ) );
5806 if ( !vkCmdSetPrimitiveTopology ) vkCmdSetPrimitiveTopology = vkCmdSetPrimitiveTopologyEXT;
5807 vkCmdSetViewportWithCountEXT = PFN_vkCmdSetViewportWithCountEXT( vkGetDeviceProcAddr( device, "vkCmdSetViewportWithCountEXT" ) );
5808 if ( !vkCmdSetViewportWithCount ) vkCmdSetViewportWithCount = vkCmdSetViewportWithCountEXT;
5809 vkCmdSetScissorWithCountEXT = PFN_vkCmdSetScissorWithCountEXT( vkGetDeviceProcAddr( device, "vkCmdSetScissorWithCountEXT" ) );
5810 if ( !vkCmdSetScissorWithCount ) vkCmdSetScissorWithCount = vkCmdSetScissorWithCountEXT;
5811 vkCmdBindVertexBuffers2EXT = PFN_vkCmdBindVertexBuffers2EXT( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers2EXT" ) );
5812 if ( !vkCmdBindVertexBuffers2 ) vkCmdBindVertexBuffers2 = vkCmdBindVertexBuffers2EXT;
5813 vkCmdSetDepthTestEnableEXT = PFN_vkCmdSetDepthTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthTestEnableEXT" ) );
5814 if ( !vkCmdSetDepthTestEnable ) vkCmdSetDepthTestEnable = vkCmdSetDepthTestEnableEXT;
5815 vkCmdSetDepthWriteEnableEXT = PFN_vkCmdSetDepthWriteEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthWriteEnableEXT" ) );
5816 if ( !vkCmdSetDepthWriteEnable ) vkCmdSetDepthWriteEnable = vkCmdSetDepthWriteEnableEXT;
5817 vkCmdSetDepthCompareOpEXT = PFN_vkCmdSetDepthCompareOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthCompareOpEXT" ) );
5818 if ( !vkCmdSetDepthCompareOp ) vkCmdSetDepthCompareOp = vkCmdSetDepthCompareOpEXT;
5819 vkCmdSetDepthBoundsTestEnableEXT = PFN_vkCmdSetDepthBoundsTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthBoundsTestEnableEXT" ) );
5820 if ( !vkCmdSetDepthBoundsTestEnable ) vkCmdSetDepthBoundsTestEnable = vkCmdSetDepthBoundsTestEnableEXT;
5821 vkCmdSetStencilTestEnableEXT = PFN_vkCmdSetStencilTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetStencilTestEnableEXT" ) );
5822 if ( !vkCmdSetStencilTestEnable ) vkCmdSetStencilTestEnable = vkCmdSetStencilTestEnableEXT;
5823 vkCmdSetStencilOpEXT = PFN_vkCmdSetStencilOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetStencilOpEXT" ) );
5824 if ( !vkCmdSetStencilOp ) vkCmdSetStencilOp = vkCmdSetStencilOpEXT;
5825
5826 //=== VK_KHR_object_refresh ===
5827 vkCmdRefreshObjectsKHR = PFN_vkCmdRefreshObjectsKHR( vkGetDeviceProcAddr( device, "vkCmdRefreshObjectsKHR" ) );
5828
5829 //=== VK_KHR_synchronization2 ===
5830 vkCmdSetEvent2KHR = PFN_vkCmdSetEvent2KHR( vkGetDeviceProcAddr( device, "vkCmdSetEvent2KHR" ) );
5831 if ( !vkCmdSetEvent2 ) vkCmdSetEvent2 = vkCmdSetEvent2KHR;
5832 vkCmdResetEvent2KHR = PFN_vkCmdResetEvent2KHR( vkGetDeviceProcAddr( device, "vkCmdResetEvent2KHR" ) );
5833 if ( !vkCmdResetEvent2 ) vkCmdResetEvent2 = vkCmdResetEvent2KHR;
5834 vkCmdWaitEvents2KHR = PFN_vkCmdWaitEvents2KHR( vkGetDeviceProcAddr( device, "vkCmdWaitEvents2KHR" ) );
5835 if ( !vkCmdWaitEvents2 ) vkCmdWaitEvents2 = vkCmdWaitEvents2KHR;
5836 vkCmdPipelineBarrier2KHR = PFN_vkCmdPipelineBarrier2KHR( vkGetDeviceProcAddr( device, "vkCmdPipelineBarrier2KHR" ) );
5837 if ( !vkCmdPipelineBarrier2 ) vkCmdPipelineBarrier2 = vkCmdPipelineBarrier2KHR;
5838 vkCmdWriteTimestamp2KHR = PFN_vkCmdWriteTimestamp2KHR( vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp2KHR" ) );
5839 if ( !vkCmdWriteTimestamp2 ) vkCmdWriteTimestamp2 = vkCmdWriteTimestamp2KHR;
5840 vkQueueSubmit2KHR = PFN_vkQueueSubmit2KHR( vkGetDeviceProcAddr( device, "vkQueueSubmit2KHR" ) );
5841 if ( !vkQueueSubmit2 ) vkQueueSubmit2 = vkQueueSubmit2KHR;
5842 vkCmdWriteBufferMarker2AMD = PFN_vkCmdWriteBufferMarker2AMD( vkGetDeviceProcAddr( device, "vkCmdWriteBufferMarker2AMD" ) );
5843 vkGetQueueCheckpointData2NV = PFN_vkGetQueueCheckpointData2NV( vkGetDeviceProcAddr( device, "vkGetQueueCheckpointData2NV" ) );
5844
5845 //=== VK_KHR_copy_commands2 ===
5846 vkCmdCopyBuffer2KHR = PFN_vkCmdCopyBuffer2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyBuffer2KHR" ) );
5847 if ( !vkCmdCopyBuffer2 ) vkCmdCopyBuffer2 = vkCmdCopyBuffer2KHR;
5848 vkCmdCopyImage2KHR = PFN_vkCmdCopyImage2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyImage2KHR" ) );
5849 if ( !vkCmdCopyImage2 ) vkCmdCopyImage2 = vkCmdCopyImage2KHR;
5850 vkCmdCopyBufferToImage2KHR = PFN_vkCmdCopyBufferToImage2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyBufferToImage2KHR" ) );
5851 if ( !vkCmdCopyBufferToImage2 ) vkCmdCopyBufferToImage2 = vkCmdCopyBufferToImage2KHR;
5852 vkCmdCopyImageToBuffer2KHR = PFN_vkCmdCopyImageToBuffer2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyImageToBuffer2KHR" ) );
5853 if ( !vkCmdCopyImageToBuffer2 ) vkCmdCopyImageToBuffer2 = vkCmdCopyImageToBuffer2KHR;
5854 vkCmdBlitImage2KHR = PFN_vkCmdBlitImage2KHR( vkGetDeviceProcAddr( device, "vkCmdBlitImage2KHR" ) );
5855 if ( !vkCmdBlitImage2 ) vkCmdBlitImage2 = vkCmdBlitImage2KHR;
5856 vkCmdResolveImage2KHR = PFN_vkCmdResolveImage2KHR( vkGetDeviceProcAddr( device, "vkCmdResolveImage2KHR" ) );
5857 if ( !vkCmdResolveImage2 ) vkCmdResolveImage2 = vkCmdResolveImage2KHR;
5858
5859 //=== VK_EXT_vertex_input_dynamic_state ===
5860 vkCmdSetVertexInputEXT = PFN_vkCmdSetVertexInputEXT( vkGetDeviceProcAddr( device, "vkCmdSetVertexInputEXT" ) );
5861
5862 #if defined( VK_USE_PLATFORM_SCI )
5863 //=== VK_NV_external_sci_sync ===
5864 vkGetFenceSciSyncFenceNV = PFN_vkGetFenceSciSyncFenceNV( vkGetDeviceProcAddr( device, "vkGetFenceSciSyncFenceNV" ) );
5865 vkGetFenceSciSyncObjNV = PFN_vkGetFenceSciSyncObjNV( vkGetDeviceProcAddr( device, "vkGetFenceSciSyncObjNV" ) );
5866 vkImportFenceSciSyncFenceNV = PFN_vkImportFenceSciSyncFenceNV( vkGetDeviceProcAddr( device, "vkImportFenceSciSyncFenceNV" ) );
5867 vkImportFenceSciSyncObjNV = PFN_vkImportFenceSciSyncObjNV( vkGetDeviceProcAddr( device, "vkImportFenceSciSyncObjNV" ) );
5868 vkGetSemaphoreSciSyncObjNV = PFN_vkGetSemaphoreSciSyncObjNV( vkGetDeviceProcAddr( device, "vkGetSemaphoreSciSyncObjNV" ) );
5869 vkImportSemaphoreSciSyncObjNV = PFN_vkImportSemaphoreSciSyncObjNV( vkGetDeviceProcAddr( device, "vkImportSemaphoreSciSyncObjNV" ) );
5870 #endif /*VK_USE_PLATFORM_SCI*/
5871
5872 #if defined( VK_USE_PLATFORM_SCI )
5873 //=== VK_NV_external_memory_sci_buf ===
5874 vkGetMemorySciBufNV = PFN_vkGetMemorySciBufNV( vkGetDeviceProcAddr( device, "vkGetMemorySciBufNV" ) );
5875 #endif /*VK_USE_PLATFORM_SCI*/
5876
5877 //=== VK_EXT_extended_dynamic_state2 ===
5878 vkCmdSetPatchControlPointsEXT = PFN_vkCmdSetPatchControlPointsEXT( vkGetDeviceProcAddr( device, "vkCmdSetPatchControlPointsEXT" ) );
5879 vkCmdSetRasterizerDiscardEnableEXT = PFN_vkCmdSetRasterizerDiscardEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetRasterizerDiscardEnableEXT" ) );
5880 if ( !vkCmdSetRasterizerDiscardEnable ) vkCmdSetRasterizerDiscardEnable = vkCmdSetRasterizerDiscardEnableEXT;
5881 vkCmdSetDepthBiasEnableEXT = PFN_vkCmdSetDepthBiasEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthBiasEnableEXT" ) );
5882 if ( !vkCmdSetDepthBiasEnable ) vkCmdSetDepthBiasEnable = vkCmdSetDepthBiasEnableEXT;
5883 vkCmdSetLogicOpEXT = PFN_vkCmdSetLogicOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetLogicOpEXT" ) );
5884 vkCmdSetPrimitiveRestartEnableEXT = PFN_vkCmdSetPrimitiveRestartEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveRestartEnableEXT" ) );
5885 if ( !vkCmdSetPrimitiveRestartEnable ) vkCmdSetPrimitiveRestartEnable = vkCmdSetPrimitiveRestartEnableEXT;
5886
5887 //=== VK_EXT_color_write_enable ===
5888 vkCmdSetColorWriteEnableEXT = PFN_vkCmdSetColorWriteEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorWriteEnableEXT" ) );
5889
5890 #if defined( VK_USE_PLATFORM_SCI )
5891 //=== VK_NV_external_sci_sync2 ===
5892 vkCreateSemaphoreSciSyncPoolNV = PFN_vkCreateSemaphoreSciSyncPoolNV( vkGetDeviceProcAddr( device, "vkCreateSemaphoreSciSyncPoolNV" ) );
5893 #endif /*VK_USE_PLATFORM_SCI*/
5894
5895 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
5896 //=== VK_QNX_external_memory_screen_buffer ===
5897 vkGetScreenBufferPropertiesQNX = PFN_vkGetScreenBufferPropertiesQNX( vkGetDeviceProcAddr( device, "vkGetScreenBufferPropertiesQNX" ) );
5898 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
5899
5900 }
5901
5902 template <typename DynamicLoader>
init(VULKAN_HPP_NAMESPACE::Instance const & instance,VULKAN_HPP_NAMESPACE::Device const & device,DynamicLoader const & dl)5903 void init(VULKAN_HPP_NAMESPACE::Instance const & instance, VULKAN_HPP_NAMESPACE::Device const & device, DynamicLoader const & dl) VULKAN_HPP_NOEXCEPT
5904 {
5905 PFN_vkGetInstanceProcAddr getInstanceProcAddr = dl.template getProcAddress<PFN_vkGetInstanceProcAddr>("vkGetInstanceProcAddr");
5906 PFN_vkGetDeviceProcAddr getDeviceProcAddr = dl.template getProcAddress<PFN_vkGetDeviceProcAddr>("vkGetDeviceProcAddr");
5907 init(static_cast<VkInstance>(instance), getInstanceProcAddr, static_cast<VkDevice>(device), device ? getDeviceProcAddr : nullptr);
5908 }
5909
5910 template <typename DynamicLoader
5911 #if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
5912 = VULKAN_HPP_NAMESPACE::DynamicLoader
5913 #endif
5914 >
init(VULKAN_HPP_NAMESPACE::Instance const & instance,VULKAN_HPP_NAMESPACE::Device const & device)5915 void init(VULKAN_HPP_NAMESPACE::Instance const & instance, VULKAN_HPP_NAMESPACE::Device const & device) VULKAN_HPP_NOEXCEPT
5916 {
5917 static DynamicLoader dl;
5918 init(instance, device, dl);
5919 }
5920 };
5921 } // namespace VULKAN_HPP_NAMESPACE
5922 #endif
5923