1 // Copyright 2015-2021 The Khronos Group Inc. 2 // 3 // SPDX-License-Identifier: Apache-2.0 OR MIT 4 // 5 6 // This header is generated from the Khronos Vulkan XML API Registry. 7 8 #ifndef VULKAN_HPP 9 #define VULKAN_HPP 10 11 #if defined( _MSVC_LANG ) 12 # define VULKAN_HPP_CPLUSPLUS _MSVC_LANG 13 #else 14 # define VULKAN_HPP_CPLUSPLUS __cplusplus 15 #endif 16 17 #if 201703L < VULKAN_HPP_CPLUSPLUS 18 # define VULKAN_HPP_CPP_VERSION 20 19 #elif 201402L < VULKAN_HPP_CPLUSPLUS 20 # define VULKAN_HPP_CPP_VERSION 17 21 #elif 201103L < VULKAN_HPP_CPLUSPLUS 22 # define VULKAN_HPP_CPP_VERSION 14 23 #elif 199711L < VULKAN_HPP_CPLUSPLUS 24 # define VULKAN_HPP_CPP_VERSION 11 25 #else 26 # error "vulkan.hpp needs at least c++ standard version 11" 27 #endif 28 29 #include <algorithm> 30 #include <array> 31 #include <cstddef> 32 #include <cstdint> 33 #include <cstring> 34 #include <functional> 35 #include <initializer_list> 36 #include <sstream> 37 #include <string> 38 #include <system_error> 39 #include <tuple> 40 #include <type_traits> 41 #include <vulkan/vulkan.h> 42 #if 17 <= VULKAN_HPP_CPP_VERSION 43 # include <string_view> 44 #endif 45 46 #if defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) 47 # if !defined( VULKAN_HPP_NO_SMART_HANDLE ) 48 # define VULKAN_HPP_NO_SMART_HANDLE 49 # endif 50 #else 51 # include <memory> 52 # include <vector> 53 #endif 54 55 #if defined( VULKAN_HPP_NO_CONSTRUCTORS ) 56 # if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) 57 # define VULKAN_HPP_NO_STRUCT_CONSTRUCTORS 58 # endif 59 # if !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS ) 60 # define VULKAN_HPP_NO_UNION_CONSTRUCTORS 61 # endif 62 #endif 63 64 #if defined( VULKAN_HPP_NO_SETTERS ) 65 # if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) 66 # define VULKAN_HPP_NO_STRUCT_SETTERS 67 # endif 68 # if !defined( VULKAN_HPP_NO_UNION_SETTERS ) 69 # define VULKAN_HPP_NO_UNION_SETTERS 70 # endif 71 #endif 72 73 #if !defined( VULKAN_HPP_ASSERT ) 74 # include <cassert> 75 # define VULKAN_HPP_ASSERT assert 76 #endif 77 78 #if !defined( VULKAN_HPP_ASSERT_ON_RESULT ) 79 # define VULKAN_HPP_ASSERT_ON_RESULT VULKAN_HPP_ASSERT 80 #endif 81 82 #if !defined( VULKAN_HPP_STATIC_ASSERT ) 83 # define VULKAN_HPP_STATIC_ASSERT static_assert 84 #endif 85 86 #if !defined( VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL ) 87 # define VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL 1 88 #endif 89 90 #if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL == 1 91 # if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNXNTO__ ) || defined( __Fuchsia__ ) 92 # include <dlfcn.h> 93 # elif defined( _WIN32 ) 94 typedef struct HINSTANCE__ * HINSTANCE; 95 # if defined( _WIN64 ) 96 typedef int64_t( __stdcall * FARPROC )(); 97 # else 98 typedef int( __stdcall * FARPROC )(); 99 # endif 100 extern "C" __declspec( dllimport ) HINSTANCE __stdcall LoadLibraryA( char const * lpLibFileName ); 101 extern "C" __declspec( dllimport ) int __stdcall FreeLibrary( HINSTANCE hLibModule ); 102 extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE hModule, const char * lpProcName ); 103 # endif 104 #endif 105 106 #if !defined( __has_include ) 107 # define __has_include( x ) false 108 #endif 109 110 #if ( 201711 <= __cpp_impl_three_way_comparison ) && __has_include( <compare> ) && !defined( VULKAN_HPP_NO_SPACESHIP_OPERATOR ) 111 # define VULKAN_HPP_HAS_SPACESHIP_OPERATOR 112 #endif 113 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) 114 # include <compare> 115 #endif 116 117 #if ( 201803 <= __cpp_lib_span ) 118 # define VULKAN_HPP_SUPPORT_SPAN 119 # include <span> 120 #endif 121 122 static_assert( VK_HEADER_VERSION == 201, "Wrong VK_HEADER_VERSION!" ); 123 124 // 32-bit vulkan is not typesafe for handles, so don't allow copy constructors on this platform by default. 125 // To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION 126 #if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) 127 # if !defined( VULKAN_HPP_TYPESAFE_CONVERSION ) 128 # define VULKAN_HPP_TYPESAFE_CONVERSION 129 # endif 130 #endif 131 132 // <tuple> includes <sys/sysmacros.h> through some other header 133 // this results in major(x) being resolved to gnu_dev_major(x) 134 // which is an expression in a constructor initializer list. 135 #if defined( major ) 136 # undef major 137 #endif 138 #if defined( minor ) 139 # undef minor 140 #endif 141 142 // Windows defines MemoryBarrier which is deprecated and collides 143 // with the VULKAN_HPP_NAMESPACE::MemoryBarrier struct. 144 #if defined( MemoryBarrier ) 145 # undef MemoryBarrier 146 #endif 147 148 #if !defined( VULKAN_HPP_HAS_UNRESTRICTED_UNIONS ) 149 # if defined( __clang__ ) 150 # if __has_feature( cxx_unrestricted_unions ) 151 # define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS 152 # endif 153 # elif defined( __GNUC__ ) 154 # define GCC_VERSION ( __GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__ ) 155 # if 40600 <= GCC_VERSION 156 # define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS 157 # endif 158 # elif defined( _MSC_VER ) 159 # if 1900 <= _MSC_VER 160 # define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS 161 # endif 162 # endif 163 #endif 164 165 #if !defined( VULKAN_HPP_INLINE ) 166 # if defined( __clang__ ) 167 # if __has_attribute( always_inline ) 168 # define VULKAN_HPP_INLINE __attribute__( ( always_inline ) ) __inline__ 169 # else 170 # define VULKAN_HPP_INLINE inline 171 # endif 172 # elif defined( __GNUC__ ) 173 # define VULKAN_HPP_INLINE __attribute__( ( always_inline ) ) __inline__ 174 # elif defined( _MSC_VER ) 175 # define VULKAN_HPP_INLINE inline 176 # else 177 # define VULKAN_HPP_INLINE inline 178 # endif 179 #endif 180 181 #if defined( VULKAN_HPP_TYPESAFE_CONVERSION ) 182 # define VULKAN_HPP_TYPESAFE_EXPLICIT 183 #else 184 # define VULKAN_HPP_TYPESAFE_EXPLICIT explicit 185 #endif 186 187 #if defined( __cpp_constexpr ) 188 # define VULKAN_HPP_CONSTEXPR constexpr 189 # if __cpp_constexpr >= 201304 190 # define VULKAN_HPP_CONSTEXPR_14 constexpr 191 # else 192 # define VULKAN_HPP_CONSTEXPR_14 193 # endif 194 # define VULKAN_HPP_CONST_OR_CONSTEXPR constexpr 195 #else 196 # define VULKAN_HPP_CONSTEXPR 197 # define VULKAN_HPP_CONSTEXPR_14 198 # define VULKAN_HPP_CONST_OR_CONSTEXPR const 199 #endif 200 201 #if !defined( VULKAN_HPP_NOEXCEPT ) 202 # if defined( _MSC_VER ) && ( _MSC_VER <= 1800 ) 203 # define VULKAN_HPP_NOEXCEPT 204 # else 205 # define VULKAN_HPP_NOEXCEPT noexcept 206 # define VULKAN_HPP_HAS_NOEXCEPT 1 207 # if defined( VULKAN_HPP_NO_EXCEPTIONS ) 208 # define VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS noexcept 209 # else 210 # define VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS 211 # endif 212 # endif 213 #endif 214 215 #if 14 <= VULKAN_HPP_CPP_VERSION 216 # define VULKAN_HPP_DEPRECATED( msg ) [[deprecated( msg )]] 217 #else 218 # define VULKAN_HPP_DEPRECATED( msg ) 219 #endif 220 221 #if ( 17 <= VULKAN_HPP_CPP_VERSION ) && !defined( VULKAN_HPP_NO_NODISCARD_WARNINGS ) 222 # define VULKAN_HPP_NODISCARD [[nodiscard]] 223 # if defined( VULKAN_HPP_NO_EXCEPTIONS ) 224 # define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS [[nodiscard]] 225 # else 226 # define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS 227 # endif 228 #else 229 # define VULKAN_HPP_NODISCARD 230 # define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS 231 #endif 232 233 #if !defined( VULKAN_HPP_NAMESPACE ) 234 # define VULKAN_HPP_NAMESPACE vk 235 #endif 236 237 #define VULKAN_HPP_STRINGIFY2( text ) #text 238 #define VULKAN_HPP_STRINGIFY( text ) VULKAN_HPP_STRINGIFY2( text ) 239 #define VULKAN_HPP_NAMESPACE_STRING VULKAN_HPP_STRINGIFY( VULKAN_HPP_NAMESPACE ) 240 241 namespace VULKAN_HPP_NAMESPACE 242 { 243 #if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) 244 template <typename T> 245 class ArrayProxy 246 { 247 public: ArrayProxy()248 VULKAN_HPP_CONSTEXPR ArrayProxy() VULKAN_HPP_NOEXCEPT 249 : m_count( 0 ) 250 , m_ptr( nullptr ) 251 {} 252 ArrayProxy(std::nullptr_t)253 VULKAN_HPP_CONSTEXPR ArrayProxy( std::nullptr_t ) VULKAN_HPP_NOEXCEPT 254 : m_count( 0 ) 255 , m_ptr( nullptr ) 256 {} 257 ArrayProxy(T & value)258 ArrayProxy( T & value ) VULKAN_HPP_NOEXCEPT 259 : m_count( 1 ) 260 , m_ptr( &value ) 261 {} 262 263 template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0> ArrayProxy(typename std::remove_const<T>::type & value)264 ArrayProxy( typename std::remove_const<T>::type & value ) VULKAN_HPP_NOEXCEPT 265 : m_count( 1 ) 266 , m_ptr( &value ) 267 {} 268 ArrayProxy(uint32_t count,T * ptr)269 ArrayProxy( uint32_t count, T * ptr ) VULKAN_HPP_NOEXCEPT 270 : m_count( count ) 271 , m_ptr( ptr ) 272 {} 273 274 template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0> ArrayProxy(uint32_t count,typename std::remove_const<T>::type * ptr)275 ArrayProxy( uint32_t count, typename std::remove_const<T>::type * ptr ) VULKAN_HPP_NOEXCEPT 276 : m_count( count ) 277 , m_ptr( ptr ) 278 {} 279 280 # if __GNUC__ >= 9 281 # pragma GCC diagnostic push 282 # pragma GCC diagnostic ignored "-Winit-list-lifetime" 283 # endif 284 ArrayProxy(std::initializer_list<T> const & list)285 ArrayProxy( std::initializer_list<T> const & list ) VULKAN_HPP_NOEXCEPT 286 : m_count( static_cast<uint32_t>( list.size() ) ) 287 , m_ptr( list.begin() ) 288 {} 289 290 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)291 ArrayProxy( std::initializer_list<typename std::remove_const<T>::type> const & list ) VULKAN_HPP_NOEXCEPT 292 : m_count( static_cast<uint32_t>( list.size() ) ) 293 , m_ptr( list.begin() ) 294 {} 295 ArrayProxy(std::initializer_list<T> & list)296 ArrayProxy( std::initializer_list<T> & list ) VULKAN_HPP_NOEXCEPT 297 : m_count( static_cast<uint32_t>( list.size() ) ) 298 , m_ptr( list.begin() ) 299 {} 300 301 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> & list)302 ArrayProxy( std::initializer_list<typename std::remove_const<T>::type> & list ) VULKAN_HPP_NOEXCEPT 303 : m_count( static_cast<uint32_t>( list.size() ) ) 304 , m_ptr( list.begin() ) 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 322 template <typename V, 323 typename std::enable_if< 324 std::is_convertible<decltype( std::declval<V>().data() ), T *>::value && 325 std::is_convertible<decltype( std::declval<V>().size() ), std::size_t>::value>::type * = nullptr> ArrayProxy(V & v)326 ArrayProxy( V & v ) VULKAN_HPP_NOEXCEPT 327 : m_count( static_cast<uint32_t>( v.size() ) ) 328 , m_ptr( v.data() ) 329 {} 330 begin() const331 const T * begin() const VULKAN_HPP_NOEXCEPT 332 { 333 return m_ptr; 334 } 335 end() const336 const T * end() const VULKAN_HPP_NOEXCEPT 337 { 338 return m_ptr + m_count; 339 } 340 front() const341 const T & front() const VULKAN_HPP_NOEXCEPT 342 { 343 VULKAN_HPP_ASSERT( m_count && m_ptr ); 344 return *m_ptr; 345 } 346 back() const347 const T & back() const VULKAN_HPP_NOEXCEPT 348 { 349 VULKAN_HPP_ASSERT( m_count && m_ptr ); 350 return *( m_ptr + m_count - 1 ); 351 } 352 empty() const353 bool empty() const VULKAN_HPP_NOEXCEPT 354 { 355 return ( m_count == 0 ); 356 } 357 size() const358 uint32_t size() const VULKAN_HPP_NOEXCEPT 359 { 360 return m_count; 361 } 362 data() const363 T * data() const VULKAN_HPP_NOEXCEPT 364 { 365 return m_ptr; 366 } 367 368 private: 369 uint32_t m_count; 370 T * m_ptr; 371 }; 372 373 template <typename T> 374 class ArrayProxyNoTemporaries 375 { 376 public: ArrayProxyNoTemporaries()377 VULKAN_HPP_CONSTEXPR ArrayProxyNoTemporaries() VULKAN_HPP_NOEXCEPT 378 : m_count( 0 ) 379 , m_ptr( nullptr ) 380 {} 381 ArrayProxyNoTemporaries(std::nullptr_t)382 VULKAN_HPP_CONSTEXPR ArrayProxyNoTemporaries( std::nullptr_t ) VULKAN_HPP_NOEXCEPT 383 : m_count( 0 ) 384 , m_ptr( nullptr ) 385 {} 386 ArrayProxyNoTemporaries(T & value)387 ArrayProxyNoTemporaries( T & value ) VULKAN_HPP_NOEXCEPT 388 : m_count( 1 ) 389 , m_ptr( &value ) 390 {} 391 392 template <typename V> 393 ArrayProxyNoTemporaries( V && value ) = delete; 394 395 template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0> ArrayProxyNoTemporaries(typename std::remove_const<T>::type & value)396 ArrayProxyNoTemporaries( typename std::remove_const<T>::type & value ) VULKAN_HPP_NOEXCEPT 397 : m_count( 1 ) 398 , m_ptr( &value ) 399 {} 400 401 template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0> 402 ArrayProxyNoTemporaries( typename std::remove_const<T>::type && value ) = delete; 403 ArrayProxyNoTemporaries(uint32_t count,T * ptr)404 ArrayProxyNoTemporaries( uint32_t count, T * ptr ) VULKAN_HPP_NOEXCEPT 405 : m_count( count ) 406 , m_ptr( ptr ) 407 {} 408 409 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)410 ArrayProxyNoTemporaries( uint32_t count, typename std::remove_const<T>::type * ptr ) VULKAN_HPP_NOEXCEPT 411 : m_count( count ) 412 , m_ptr( ptr ) 413 {} 414 ArrayProxyNoTemporaries(std::initializer_list<T> const & list)415 ArrayProxyNoTemporaries( std::initializer_list<T> const & list ) VULKAN_HPP_NOEXCEPT 416 : m_count( static_cast<uint32_t>( list.size() ) ) 417 , m_ptr( list.begin() ) 418 {} 419 420 ArrayProxyNoTemporaries( std::initializer_list<T> const && list ) = delete; 421 422 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)423 ArrayProxyNoTemporaries( std::initializer_list<typename std::remove_const<T>::type> const & list ) 424 VULKAN_HPP_NOEXCEPT 425 : m_count( static_cast<uint32_t>( list.size() ) ) 426 , m_ptr( list.begin() ) 427 {} 428 429 template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0> 430 ArrayProxyNoTemporaries( std::initializer_list<typename std::remove_const<T>::type> const && list ) = delete; 431 ArrayProxyNoTemporaries(std::initializer_list<T> & list)432 ArrayProxyNoTemporaries( std::initializer_list<T> & list ) VULKAN_HPP_NOEXCEPT 433 : m_count( static_cast<uint32_t>( list.size() ) ) 434 , m_ptr( list.begin() ) 435 {} 436 437 ArrayProxyNoTemporaries( std::initializer_list<T> && list ) = delete; 438 439 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)440 ArrayProxyNoTemporaries( std::initializer_list<typename std::remove_const<T>::type> & list ) VULKAN_HPP_NOEXCEPT 441 : m_count( static_cast<uint32_t>( list.size() ) ) 442 , m_ptr( list.begin() ) 443 {} 444 445 template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0> 446 ArrayProxyNoTemporaries( std::initializer_list<typename std::remove_const<T>::type> && list ) = delete; 447 448 // Any type with a .data() return type implicitly convertible to T*, and a // .size() return type implicitly 449 // convertible to size_t. 450 template <typename V, 451 typename std::enable_if< 452 std::is_convertible<decltype( std::declval<V>().data() ), T *>::value && 453 std::is_convertible<decltype( std::declval<V>().size() ), std::size_t>::value>::type * = nullptr> ArrayProxyNoTemporaries(V & v)454 ArrayProxyNoTemporaries( V & v ) VULKAN_HPP_NOEXCEPT 455 : m_count( static_cast<uint32_t>( v.size() ) ) 456 , m_ptr( v.data() ) 457 {} 458 begin() const459 const T * begin() const VULKAN_HPP_NOEXCEPT 460 { 461 return m_ptr; 462 } 463 end() const464 const T * end() const VULKAN_HPP_NOEXCEPT 465 { 466 return m_ptr + m_count; 467 } 468 front() const469 const T & front() const VULKAN_HPP_NOEXCEPT 470 { 471 VULKAN_HPP_ASSERT( m_count && m_ptr ); 472 return *m_ptr; 473 } 474 back() const475 const T & back() const VULKAN_HPP_NOEXCEPT 476 { 477 VULKAN_HPP_ASSERT( m_count && m_ptr ); 478 return *( m_ptr + m_count - 1 ); 479 } 480 empty() const481 bool empty() const VULKAN_HPP_NOEXCEPT 482 { 483 return ( m_count == 0 ); 484 } 485 size() const486 uint32_t size() const VULKAN_HPP_NOEXCEPT 487 { 488 return m_count; 489 } 490 data() const491 T * data() const VULKAN_HPP_NOEXCEPT 492 { 493 return m_ptr; 494 } 495 496 private: 497 uint32_t m_count; 498 T * m_ptr; 499 }; 500 #endif 501 502 template <typename T, size_t N> 503 class ArrayWrapper1D : public std::array<T, N> 504 { 505 public: ArrayWrapper1D()506 VULKAN_HPP_CONSTEXPR ArrayWrapper1D() VULKAN_HPP_NOEXCEPT : std::array<T, N>() {} 507 ArrayWrapper1D(std::array<T,N> const & data)508 VULKAN_HPP_CONSTEXPR ArrayWrapper1D( std::array<T, N> const & data ) VULKAN_HPP_NOEXCEPT : std::array<T, N>( data ) 509 {} 510 511 #if ( VK_USE_64_BIT_PTR_DEFINES == 0 ) 512 // on 32 bit compiles, needs overloads on index type int to resolve ambiguities operator [](int index) const513 VULKAN_HPP_CONSTEXPR T const & operator[]( int index ) const VULKAN_HPP_NOEXCEPT 514 { 515 return std::array<T, N>::operator[]( index ); 516 } 517 operator [](int index)518 T & operator[]( int index ) VULKAN_HPP_NOEXCEPT 519 { 520 return std::array<T, N>::operator[]( index ); 521 } 522 #endif 523 operator T const*() const524 operator T const *() const VULKAN_HPP_NOEXCEPT 525 { 526 return this->data(); 527 } 528 operator T*()529 operator T *() VULKAN_HPP_NOEXCEPT 530 { 531 return this->data(); 532 } 533 534 template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0> operator std::string() const535 operator std::string() const 536 { 537 return std::string( this->data() ); 538 } 539 540 #if 17 <= VULKAN_HPP_CPP_VERSION 541 template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0> operator std::string_view() const542 operator std::string_view() const 543 { 544 return std::string_view( this->data() ); 545 } 546 #endif 547 548 template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0> operator <(ArrayWrapper1D<char,N> const & rhs) const549 bool operator<( ArrayWrapper1D<char, N> const & rhs ) const VULKAN_HPP_NOEXCEPT 550 { 551 return *static_cast<std::array<char, N> const *>( this ) < *static_cast<std::array<char, N> const *>( &rhs ); 552 } 553 554 template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0> operator <=(ArrayWrapper1D<char,N> const & rhs) const555 bool operator<=( ArrayWrapper1D<char, N> const & rhs ) const VULKAN_HPP_NOEXCEPT 556 { 557 return *static_cast<std::array<char, N> const *>( this ) <= *static_cast<std::array<char, N> const *>( &rhs ); 558 } 559 560 template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0> operator >(ArrayWrapper1D<char,N> const & rhs) const561 bool operator>( ArrayWrapper1D<char, N> const & rhs ) const VULKAN_HPP_NOEXCEPT 562 { 563 return *static_cast<std::array<char, N> const *>( this ) > *static_cast<std::array<char, N> const *>( &rhs ); 564 } 565 566 template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0> operator >=(ArrayWrapper1D<char,N> const & rhs) const567 bool operator>=( ArrayWrapper1D<char, N> const & rhs ) const VULKAN_HPP_NOEXCEPT 568 { 569 return *static_cast<std::array<char, N> const *>( this ) >= *static_cast<std::array<char, N> const *>( &rhs ); 570 } 571 572 template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0> operator ==(ArrayWrapper1D<char,N> const & rhs) const573 bool operator==( ArrayWrapper1D<char, N> const & rhs ) const VULKAN_HPP_NOEXCEPT 574 { 575 return *static_cast<std::array<char, N> const *>( this ) == *static_cast<std::array<char, N> const *>( &rhs ); 576 } 577 578 template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0> operator !=(ArrayWrapper1D<char,N> const & rhs) const579 bool operator!=( ArrayWrapper1D<char, N> const & rhs ) const VULKAN_HPP_NOEXCEPT 580 { 581 return *static_cast<std::array<char, N> const *>( this ) != *static_cast<std::array<char, N> const *>( &rhs ); 582 } 583 }; 584 585 // specialization of relational operators between std::string and arrays of chars 586 template <size_t N> operator <(std::string const & lhs,ArrayWrapper1D<char,N> const & rhs)587 bool operator<( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT 588 { 589 return lhs < rhs.data(); 590 } 591 592 template <size_t N> operator <=(std::string const & lhs,ArrayWrapper1D<char,N> const & rhs)593 bool operator<=( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT 594 { 595 return lhs <= rhs.data(); 596 } 597 598 template <size_t N> operator >(std::string const & lhs,ArrayWrapper1D<char,N> const & rhs)599 bool operator>( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT 600 { 601 return lhs > rhs.data(); 602 } 603 604 template <size_t N> operator >=(std::string const & lhs,ArrayWrapper1D<char,N> const & rhs)605 bool operator>=( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT 606 { 607 return lhs >= rhs.data(); 608 } 609 610 template <size_t N> operator ==(std::string const & lhs,ArrayWrapper1D<char,N> const & rhs)611 bool operator==( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT 612 { 613 return lhs == rhs.data(); 614 } 615 616 template <size_t N> operator !=(std::string const & lhs,ArrayWrapper1D<char,N> const & rhs)617 bool operator!=( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT 618 { 619 return lhs != rhs.data(); 620 } 621 622 template <typename T, size_t N, size_t M> 623 class ArrayWrapper2D : public std::array<ArrayWrapper1D<T, M>, N> 624 { 625 public: ArrayWrapper2D()626 VULKAN_HPP_CONSTEXPR ArrayWrapper2D() VULKAN_HPP_NOEXCEPT : std::array<ArrayWrapper1D<T, M>, N>() {} 627 ArrayWrapper2D(std::array<std::array<T,M>,N> const & data)628 VULKAN_HPP_CONSTEXPR ArrayWrapper2D( std::array<std::array<T, M>, N> const & data ) VULKAN_HPP_NOEXCEPT 629 : std::array<ArrayWrapper1D<T, M>, N>( *reinterpret_cast<std::array<ArrayWrapper1D<T, M>, N> const *>( &data ) ) 630 {} 631 }; 632 633 template <typename FlagBitsType> 634 struct FlagTraits 635 { 636 enum 637 { 638 allFlags = 0 639 }; 640 }; 641 642 template <typename BitType> 643 class Flags 644 { 645 public: 646 using MaskType = typename std::underlying_type<BitType>::type; 647 648 // constructors Flags()649 VULKAN_HPP_CONSTEXPR Flags() VULKAN_HPP_NOEXCEPT : m_mask( 0 ) {} 650 Flags(BitType bit)651 VULKAN_HPP_CONSTEXPR Flags( BitType bit ) VULKAN_HPP_NOEXCEPT : m_mask( static_cast<MaskType>( bit ) ) {} 652 653 VULKAN_HPP_CONSTEXPR Flags( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT = default; 654 Flags(MaskType flags)655 VULKAN_HPP_CONSTEXPR explicit Flags( MaskType flags ) VULKAN_HPP_NOEXCEPT : m_mask( flags ) {} 656 657 // relational operators 658 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) 659 auto operator<=>( Flags<BitType> const & ) const = default; 660 #else operator <(Flags<BitType> const & rhs) const661 VULKAN_HPP_CONSTEXPR bool operator<( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT 662 { 663 return m_mask < rhs.m_mask; 664 } 665 operator <=(Flags<BitType> const & rhs) const666 VULKAN_HPP_CONSTEXPR bool operator<=( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT 667 { 668 return m_mask <= rhs.m_mask; 669 } 670 operator >(Flags<BitType> const & rhs) const671 VULKAN_HPP_CONSTEXPR bool operator>( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT 672 { 673 return m_mask > rhs.m_mask; 674 } 675 operator >=(Flags<BitType> const & rhs) const676 VULKAN_HPP_CONSTEXPR bool operator>=( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT 677 { 678 return m_mask >= rhs.m_mask; 679 } 680 operator ==(Flags<BitType> const & rhs) const681 VULKAN_HPP_CONSTEXPR bool operator==( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT 682 { 683 return m_mask == rhs.m_mask; 684 } 685 operator !=(Flags<BitType> const & rhs) const686 VULKAN_HPP_CONSTEXPR bool operator!=( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT 687 { 688 return m_mask != rhs.m_mask; 689 } 690 #endif 691 692 // logical operator operator !() const693 VULKAN_HPP_CONSTEXPR bool operator!() const VULKAN_HPP_NOEXCEPT 694 { 695 return !m_mask; 696 } 697 698 // bitwise operators operator &(Flags<BitType> const & rhs) const699 VULKAN_HPP_CONSTEXPR Flags<BitType> operator&( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT 700 { 701 return Flags<BitType>( m_mask & rhs.m_mask ); 702 } 703 operator |(Flags<BitType> const & rhs) const704 VULKAN_HPP_CONSTEXPR Flags<BitType> operator|( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT 705 { 706 return Flags<BitType>( m_mask | rhs.m_mask ); 707 } 708 operator ^(Flags<BitType> const & rhs) const709 VULKAN_HPP_CONSTEXPR Flags<BitType> operator^( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT 710 { 711 return Flags<BitType>( m_mask ^ rhs.m_mask ); 712 } 713 operator ~() const714 VULKAN_HPP_CONSTEXPR Flags<BitType> operator~() const VULKAN_HPP_NOEXCEPT 715 { 716 return Flags<BitType>( m_mask ^ FlagTraits<BitType>::allFlags ); 717 } 718 719 // assignment operators 720 VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT = default; 721 operator |=(Flags<BitType> const & rhs)722 VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator|=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT 723 { 724 m_mask |= rhs.m_mask; 725 return *this; 726 } 727 operator &=(Flags<BitType> const & rhs)728 VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator&=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT 729 { 730 m_mask &= rhs.m_mask; 731 return *this; 732 } 733 operator ^=(Flags<BitType> const & rhs)734 VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator^=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT 735 { 736 m_mask ^= rhs.m_mask; 737 return *this; 738 } 739 740 // cast operators operator bool() const741 explicit VULKAN_HPP_CONSTEXPR operator bool() const VULKAN_HPP_NOEXCEPT 742 { 743 return !!m_mask; 744 } 745 operator MaskType() const746 explicit VULKAN_HPP_CONSTEXPR operator MaskType() const VULKAN_HPP_NOEXCEPT 747 { 748 return m_mask; 749 } 750 751 #if defined( VULKAN_HPP_FLAGS_MASK_TYPE_AS_PUBLIC ) 752 public: 753 #else 754 private: 755 #endif 756 MaskType m_mask; 757 }; 758 759 #if !defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) 760 // relational operators only needed for pre C++20 761 template <typename BitType> operator <(BitType bit,Flags<BitType> const & flags)762 VULKAN_HPP_CONSTEXPR bool operator<( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT 763 { 764 return flags.operator>( bit ); 765 } 766 767 template <typename BitType> operator <=(BitType bit,Flags<BitType> const & flags)768 VULKAN_HPP_CONSTEXPR bool operator<=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT 769 { 770 return flags.operator>=( bit ); 771 } 772 773 template <typename BitType> operator >(BitType bit,Flags<BitType> const & flags)774 VULKAN_HPP_CONSTEXPR bool operator>( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT 775 { 776 return flags.operator<( bit ); 777 } 778 779 template <typename BitType> operator >=(BitType bit,Flags<BitType> const & flags)780 VULKAN_HPP_CONSTEXPR bool operator>=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT 781 { 782 return flags.operator<=( bit ); 783 } 784 785 template <typename BitType> operator ==(BitType bit,Flags<BitType> const & flags)786 VULKAN_HPP_CONSTEXPR bool operator==( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT 787 { 788 return flags.operator==( bit ); 789 } 790 791 template <typename BitType> operator !=(BitType bit,Flags<BitType> const & flags)792 VULKAN_HPP_CONSTEXPR bool operator!=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT 793 { 794 return flags.operator!=( bit ); 795 } 796 #endif 797 798 // bitwise operators 799 template <typename BitType> operator &(BitType bit,Flags<BitType> const & flags)800 VULKAN_HPP_CONSTEXPR Flags<BitType> operator&( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT 801 { 802 return flags.operator&( bit ); 803 } 804 805 template <typename BitType> operator |(BitType bit,Flags<BitType> const & flags)806 VULKAN_HPP_CONSTEXPR Flags<BitType> operator|( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT 807 { 808 return flags.operator|( bit ); 809 } 810 811 template <typename BitType> operator ^(BitType bit,Flags<BitType> const & flags)812 VULKAN_HPP_CONSTEXPR Flags<BitType> operator^( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT 813 { 814 return flags.operator^( bit ); 815 } 816 817 template <typename RefType> 818 class Optional 819 { 820 public: Optional(RefType & reference)821 Optional( RefType & reference ) VULKAN_HPP_NOEXCEPT 822 { 823 m_ptr = &reference; 824 } Optional(RefType * ptr)825 Optional( RefType * ptr ) VULKAN_HPP_NOEXCEPT 826 { 827 m_ptr = ptr; 828 } Optional(std::nullptr_t)829 Optional( std::nullptr_t ) VULKAN_HPP_NOEXCEPT 830 { 831 m_ptr = nullptr; 832 } 833 operator RefType*() const834 operator RefType *() const VULKAN_HPP_NOEXCEPT 835 { 836 return m_ptr; 837 } operator ->() const838 RefType const * operator->() const VULKAN_HPP_NOEXCEPT 839 { 840 return m_ptr; 841 } operator bool() const842 explicit operator bool() const VULKAN_HPP_NOEXCEPT 843 { 844 return !!m_ptr; 845 } 846 847 private: 848 RefType * m_ptr; 849 }; 850 851 template <typename X, typename Y> 852 struct StructExtends 853 { 854 enum 855 { 856 value = false 857 }; 858 }; 859 860 template <typename Type, class...> 861 struct IsPartOfStructureChain 862 { 863 static const bool valid = false; 864 }; 865 866 template <typename Type, typename Head, typename... Tail> 867 struct IsPartOfStructureChain<Type, Head, Tail...> 868 { 869 static const bool valid = std::is_same<Type, Head>::value || IsPartOfStructureChain<Type, Tail...>::valid; 870 }; 871 872 template <size_t Index, typename T, typename... ChainElements> 873 struct StructureChainContains 874 { 875 static const bool value = 876 std::is_same<T, typename std::tuple_element<Index, std::tuple<ChainElements...>>::type>::value || 877 StructureChainContains<Index - 1, T, ChainElements...>::value; 878 }; 879 880 template <typename T, typename... ChainElements> 881 struct StructureChainContains<0, T, ChainElements...> 882 { 883 static const bool value = 884 std::is_same<T, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value; 885 }; 886 887 template <size_t Index, typename... ChainElements> 888 struct StructureChainValidation 889 { 890 using TestType = typename std::tuple_element<Index, std::tuple<ChainElements...>>::type; 891 static const bool valid = 892 StructExtends<TestType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value && 893 ( TestType::allowDuplicate || !StructureChainContains<Index - 1, TestType, ChainElements...>::value ) && 894 StructureChainValidation<Index - 1, ChainElements...>::valid; 895 }; 896 897 template <typename... ChainElements> 898 struct StructureChainValidation<0, ChainElements...> 899 { 900 static const bool valid = true; 901 }; 902 903 template <typename... ChainElements> 904 class StructureChain : public std::tuple<ChainElements...> 905 { 906 public: StructureChain()907 StructureChain() VULKAN_HPP_NOEXCEPT 908 { 909 static_assert( StructureChainValidation<sizeof...( ChainElements ) - 1, ChainElements...>::valid, 910 "The structure chain is not valid!" ); 911 link<sizeof...( ChainElements ) - 1>(); 912 } 913 StructureChain(StructureChain const & rhs)914 StructureChain( StructureChain const & rhs ) VULKAN_HPP_NOEXCEPT : std::tuple<ChainElements...>( rhs ) 915 { 916 static_assert( StructureChainValidation<sizeof...( ChainElements ) - 1, ChainElements...>::valid, 917 "The structure chain is not valid!" ); 918 link( &std::get<0>( *this ), 919 &std::get<0>( rhs ), 920 reinterpret_cast<VkBaseOutStructure *>( &std::get<0>( *this ) ), 921 reinterpret_cast<VkBaseInStructure const *>( &std::get<0>( rhs ) ) ); 922 } 923 StructureChain(StructureChain && rhs)924 StructureChain( StructureChain && rhs ) VULKAN_HPP_NOEXCEPT 925 : std::tuple<ChainElements...>( std::forward<std::tuple<ChainElements...>>( rhs ) ) 926 { 927 static_assert( StructureChainValidation<sizeof...( ChainElements ) - 1, ChainElements...>::valid, 928 "The structure chain is not valid!" ); 929 link( &std::get<0>( *this ), 930 &std::get<0>( rhs ), 931 reinterpret_cast<VkBaseOutStructure *>( &std::get<0>( *this ) ), 932 reinterpret_cast<VkBaseInStructure const *>( &std::get<0>( rhs ) ) ); 933 } 934 StructureChain(ChainElements const &...elems)935 StructureChain( ChainElements const &... elems ) VULKAN_HPP_NOEXCEPT : std::tuple<ChainElements...>( elems... ) 936 { 937 static_assert( StructureChainValidation<sizeof...( ChainElements ) - 1, ChainElements...>::valid, 938 "The structure chain is not valid!" ); 939 link<sizeof...( ChainElements ) - 1>(); 940 } 941 operator =(StructureChain const & rhs)942 StructureChain & operator=( StructureChain const & rhs ) VULKAN_HPP_NOEXCEPT 943 { 944 std::tuple<ChainElements...>::operator=( rhs ); 945 link( &std::get<0>( *this ), 946 &std::get<0>( rhs ), 947 reinterpret_cast<VkBaseOutStructure *>( &std::get<0>( *this ) ), 948 reinterpret_cast<VkBaseInStructure const *>( &std::get<0>( rhs ) ) ); 949 return *this; 950 } 951 952 StructureChain & operator=( StructureChain && rhs ) = delete; 953 954 template <typename T = typename std::tuple_element<0, std::tuple<ChainElements...>>::type, size_t Which = 0> get()955 T & get() VULKAN_HPP_NOEXCEPT 956 { 957 return std::get<ChainElementIndex<0, T, Which, void, ChainElements...>::value>( 958 static_cast<std::tuple<ChainElements...> &>( *this ) ); 959 } 960 961 template <typename T = typename std::tuple_element<0, std::tuple<ChainElements...>>::type, size_t Which = 0> get() const962 T const & get() const VULKAN_HPP_NOEXCEPT 963 { 964 return std::get<ChainElementIndex<0, T, Which, void, ChainElements...>::value>( 965 static_cast<std::tuple<ChainElements...> const &>( *this ) ); 966 } 967 968 template <typename T0, typename T1, typename... Ts> get()969 std::tuple<T0 &, T1 &, Ts &...> get() VULKAN_HPP_NOEXCEPT 970 { 971 return std::tie( get<T0>(), get<T1>(), get<Ts>()... ); 972 } 973 974 template <typename T0, typename T1, typename... Ts> get() const975 std::tuple<T0 const &, T1 const &, Ts const &...> get() const VULKAN_HPP_NOEXCEPT 976 { 977 return std::tie( get<T0>(), get<T1>(), get<Ts>()... ); 978 } 979 980 template <typename ClassType, size_t Which = 0> 981 typename std::enable_if< 982 std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value && 983 ( Which == 0 ), 984 bool>::type isLinked() const985 isLinked() const VULKAN_HPP_NOEXCEPT 986 { 987 return true; 988 } 989 990 template <typename ClassType, size_t Which = 0> 991 typename std::enable_if< 992 !std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value || 993 ( Which != 0 ), 994 bool>::type isLinked() const995 isLinked() const VULKAN_HPP_NOEXCEPT 996 { 997 static_assert( IsPartOfStructureChain<ClassType, ChainElements...>::valid, 998 "Can't unlink Structure that's not part of this StructureChain!" ); 999 return isLinked( reinterpret_cast<VkBaseInStructure const *>( &get<ClassType, Which>() ) ); 1000 } 1001 1002 template <typename ClassType, size_t Which = 0> 1003 typename std::enable_if< 1004 !std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value || 1005 ( Which != 0 ), 1006 void>::type relink()1007 relink() VULKAN_HPP_NOEXCEPT 1008 { 1009 static_assert( IsPartOfStructureChain<ClassType, ChainElements...>::valid, 1010 "Can't relink Structure that's not part of this StructureChain!" ); 1011 auto pNext = reinterpret_cast<VkBaseInStructure *>( &get<ClassType, Which>() ); 1012 VULKAN_HPP_ASSERT( !isLinked( pNext ) ); 1013 auto & headElement = std::get<0>( static_cast<std::tuple<ChainElements...> &>( *this ) ); 1014 pNext->pNext = reinterpret_cast<VkBaseInStructure const *>( headElement.pNext ); 1015 headElement.pNext = pNext; 1016 } 1017 1018 template <typename ClassType, size_t Which = 0> 1019 typename std::enable_if< 1020 !std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value || 1021 ( Which != 0 ), 1022 void>::type unlink()1023 unlink() VULKAN_HPP_NOEXCEPT 1024 { 1025 static_assert( IsPartOfStructureChain<ClassType, ChainElements...>::valid, 1026 "Can't unlink Structure that's not part of this StructureChain!" ); 1027 unlink( reinterpret_cast<VkBaseOutStructure const *>( &get<ClassType, Which>() ) ); 1028 } 1029 1030 private: 1031 template <int Index, typename T, int Which, typename, class First, class... Types> 1032 struct ChainElementIndex : ChainElementIndex<Index + 1, T, Which, void, Types...> 1033 {}; 1034 1035 template <int Index, typename T, int Which, class First, class... Types> 1036 struct ChainElementIndex<Index, 1037 T, 1038 Which, 1039 typename std::enable_if<!std::is_same<T, First>::value, void>::type, 1040 First, 1041 Types...> : ChainElementIndex<Index + 1, T, Which, void, Types...> 1042 {}; 1043 1044 template <int Index, typename T, int Which, class First, class... Types> 1045 struct ChainElementIndex<Index, 1046 T, 1047 Which, 1048 typename std::enable_if<std::is_same<T, First>::value, void>::type, 1049 First, 1050 Types...> : ChainElementIndex<Index + 1, T, Which - 1, void, Types...> 1051 {}; 1052 1053 template <int Index, typename T, class First, class... Types> 1054 struct ChainElementIndex<Index, 1055 T, 1056 0, 1057 typename std::enable_if<std::is_same<T, First>::value, void>::type, 1058 First, 1059 Types...> : std::integral_constant<int, Index> 1060 {}; 1061 isLinked(VkBaseInStructure const * pNext) const1062 bool isLinked( VkBaseInStructure const * pNext ) const VULKAN_HPP_NOEXCEPT 1063 { 1064 VkBaseInStructure const * elementPtr = reinterpret_cast<VkBaseInStructure const *>( 1065 &std::get<0>( static_cast<std::tuple<ChainElements...> const &>( *this ) ) ); 1066 while ( elementPtr ) 1067 { 1068 if ( elementPtr->pNext == pNext ) 1069 { 1070 return true; 1071 } 1072 elementPtr = elementPtr->pNext; 1073 } 1074 return false; 1075 } 1076 1077 template <size_t Index> link()1078 typename std::enable_if<Index != 0, void>::type link() VULKAN_HPP_NOEXCEPT 1079 { 1080 auto & x = std::get<Index - 1>( static_cast<std::tuple<ChainElements...> &>( *this ) ); 1081 x.pNext = &std::get<Index>( static_cast<std::tuple<ChainElements...> &>( *this ) ); 1082 link<Index - 1>(); 1083 } 1084 1085 template <size_t Index> link()1086 typename std::enable_if<Index == 0, void>::type link() VULKAN_HPP_NOEXCEPT 1087 {} 1088 link(void * dstBase,void const * srcBase,VkBaseOutStructure * dst,VkBaseInStructure const * src)1089 void link( void * dstBase, void const * srcBase, VkBaseOutStructure * dst, VkBaseInStructure const * src ) 1090 { 1091 while ( src->pNext ) 1092 { 1093 std::ptrdiff_t offset = 1094 reinterpret_cast<char const *>( src->pNext ) - reinterpret_cast<char const *>( srcBase ); 1095 dst->pNext = reinterpret_cast<VkBaseOutStructure *>( reinterpret_cast<char *>( dstBase ) + offset ); 1096 dst = dst->pNext; 1097 src = src->pNext; 1098 } 1099 dst->pNext = nullptr; 1100 } 1101 unlink(VkBaseOutStructure const * pNext)1102 void unlink( VkBaseOutStructure const * pNext ) VULKAN_HPP_NOEXCEPT 1103 { 1104 VkBaseOutStructure * elementPtr = 1105 reinterpret_cast<VkBaseOutStructure *>( &std::get<0>( static_cast<std::tuple<ChainElements...> &>( *this ) ) ); 1106 while ( elementPtr && ( elementPtr->pNext != pNext ) ) 1107 { 1108 elementPtr = elementPtr->pNext; 1109 } 1110 if ( elementPtr ) 1111 { 1112 elementPtr->pNext = pNext->pNext; 1113 } 1114 else 1115 { 1116 VULKAN_HPP_ASSERT( false ); // fires, if the ClassType member has already been unlinked ! 1117 } 1118 } 1119 }; 1120 1121 #if !defined( VULKAN_HPP_NO_SMART_HANDLE ) 1122 template <typename Type, typename Dispatch> 1123 class UniqueHandleTraits; 1124 1125 template <typename Type, typename Dispatch> 1126 class UniqueHandle : public UniqueHandleTraits<Type, Dispatch>::deleter 1127 { 1128 private: 1129 using Deleter = typename UniqueHandleTraits<Type, Dispatch>::deleter; 1130 1131 public: 1132 using element_type = Type; 1133 UniqueHandle()1134 UniqueHandle() : Deleter(), m_value() {} 1135 UniqueHandle(Type const & value,Deleter const & deleter=Deleter ())1136 explicit UniqueHandle( Type const & value, Deleter const & deleter = Deleter() ) VULKAN_HPP_NOEXCEPT 1137 : Deleter( deleter ) 1138 , m_value( value ) 1139 {} 1140 1141 UniqueHandle( UniqueHandle const & ) = delete; 1142 UniqueHandle(UniqueHandle && other)1143 UniqueHandle( UniqueHandle && other ) VULKAN_HPP_NOEXCEPT 1144 : Deleter( std::move( static_cast<Deleter &>( other ) ) ) 1145 , m_value( other.release() ) 1146 {} 1147 ~UniqueHandle()1148 ~UniqueHandle() VULKAN_HPP_NOEXCEPT 1149 { 1150 if ( m_value ) 1151 { 1152 this->destroy( m_value ); 1153 } 1154 } 1155 1156 UniqueHandle & operator=( UniqueHandle const & ) = delete; 1157 operator =(UniqueHandle && other)1158 UniqueHandle & operator=( UniqueHandle && other ) VULKAN_HPP_NOEXCEPT 1159 { 1160 reset( other.release() ); 1161 *static_cast<Deleter *>( this ) = std::move( static_cast<Deleter &>( other ) ); 1162 return *this; 1163 } 1164 operator bool() const1165 explicit operator bool() const VULKAN_HPP_NOEXCEPT 1166 { 1167 return m_value.operator bool(); 1168 } 1169 operator ->() const1170 Type const * operator->() const VULKAN_HPP_NOEXCEPT 1171 { 1172 return &m_value; 1173 } 1174 operator ->()1175 Type * operator->() VULKAN_HPP_NOEXCEPT 1176 { 1177 return &m_value; 1178 } 1179 operator *() const1180 Type const & operator*() const VULKAN_HPP_NOEXCEPT 1181 { 1182 return m_value; 1183 } 1184 operator *()1185 Type & operator*() VULKAN_HPP_NOEXCEPT 1186 { 1187 return m_value; 1188 } 1189 get() const1190 const Type & get() const VULKAN_HPP_NOEXCEPT 1191 { 1192 return m_value; 1193 } 1194 get()1195 Type & get() VULKAN_HPP_NOEXCEPT 1196 { 1197 return m_value; 1198 } 1199 reset(Type const & value=Type ())1200 void reset( Type const & value = Type() ) VULKAN_HPP_NOEXCEPT 1201 { 1202 if ( m_value != value ) 1203 { 1204 if ( m_value ) 1205 { 1206 this->destroy( m_value ); 1207 } 1208 m_value = value; 1209 } 1210 } 1211 release()1212 Type release() VULKAN_HPP_NOEXCEPT 1213 { 1214 Type value = m_value; 1215 m_value = nullptr; 1216 return value; 1217 } 1218 swap(UniqueHandle<Type,Dispatch> & rhs)1219 void swap( UniqueHandle<Type, Dispatch> & rhs ) VULKAN_HPP_NOEXCEPT 1220 { 1221 std::swap( m_value, rhs.m_value ); 1222 std::swap( static_cast<Deleter &>( *this ), static_cast<Deleter &>( rhs ) ); 1223 } 1224 1225 private: 1226 Type m_value; 1227 }; 1228 1229 template <typename UniqueType> 1230 VULKAN_HPP_INLINE std::vector<typename UniqueType::element_type> uniqueToRaw(std::vector<UniqueType> const & handles)1231 uniqueToRaw( std::vector<UniqueType> const & handles ) 1232 { 1233 std::vector<typename UniqueType::element_type> newBuffer( handles.size() ); 1234 std::transform( 1235 handles.begin(), handles.end(), newBuffer.begin(), []( UniqueType const & handle ) { return handle.get(); } ); 1236 return newBuffer; 1237 } 1238 1239 template <typename Type, typename Dispatch> swap(UniqueHandle<Type,Dispatch> & lhs,UniqueHandle<Type,Dispatch> & rhs)1240 VULKAN_HPP_INLINE void swap( UniqueHandle<Type, Dispatch> & lhs, 1241 UniqueHandle<Type, Dispatch> & rhs ) VULKAN_HPP_NOEXCEPT 1242 { 1243 lhs.swap( rhs ); 1244 } 1245 #endif 1246 1247 class DispatchLoaderBase 1248 { 1249 public: 1250 DispatchLoaderBase() = default; DispatchLoaderBase(std::nullptr_t)1251 DispatchLoaderBase( std::nullptr_t ) 1252 #if !defined( NDEBUG ) 1253 : m_valid( false ) 1254 #endif 1255 {} 1256 1257 #if !defined( NDEBUG ) getVkHeaderVersion() const1258 size_t getVkHeaderVersion() const 1259 { 1260 VULKAN_HPP_ASSERT( m_valid ); 1261 return vkHeaderVersion; 1262 } 1263 1264 private: 1265 size_t vkHeaderVersion = VK_HEADER_VERSION; 1266 bool m_valid = true; 1267 #endif 1268 }; 1269 1270 #if !defined( VK_NO_PROTOTYPES ) 1271 class DispatchLoaderStatic : public DispatchLoaderBase 1272 { 1273 public: 1274 //=== VK_VERSION_1_0 === 1275 vkCreateInstance(const VkInstanceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkInstance * pInstance) const1276 VkResult vkCreateInstance( const VkInstanceCreateInfo * pCreateInfo, 1277 const VkAllocationCallbacks * pAllocator, 1278 VkInstance * pInstance ) const VULKAN_HPP_NOEXCEPT 1279 { 1280 return ::vkCreateInstance( pCreateInfo, pAllocator, pInstance ); 1281 } 1282 vkDestroyInstance(VkInstance instance,const VkAllocationCallbacks * pAllocator) const1283 void vkDestroyInstance( VkInstance instance, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT 1284 { 1285 return ::vkDestroyInstance( instance, pAllocator ); 1286 } 1287 vkEnumeratePhysicalDevices(VkInstance instance,uint32_t * pPhysicalDeviceCount,VkPhysicalDevice * pPhysicalDevices) const1288 VkResult vkEnumeratePhysicalDevices( VkInstance instance, 1289 uint32_t * pPhysicalDeviceCount, 1290 VkPhysicalDevice * pPhysicalDevices ) const VULKAN_HPP_NOEXCEPT 1291 { 1292 return ::vkEnumeratePhysicalDevices( instance, pPhysicalDeviceCount, pPhysicalDevices ); 1293 } 1294 vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures * pFeatures) const1295 void vkGetPhysicalDeviceFeatures( VkPhysicalDevice physicalDevice, 1296 VkPhysicalDeviceFeatures * pFeatures ) const VULKAN_HPP_NOEXCEPT 1297 { 1298 return ::vkGetPhysicalDeviceFeatures( physicalDevice, pFeatures ); 1299 } 1300 vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties * pFormatProperties) const1301 void vkGetPhysicalDeviceFormatProperties( VkPhysicalDevice physicalDevice, 1302 VkFormat format, 1303 VkFormatProperties * pFormatProperties ) const VULKAN_HPP_NOEXCEPT 1304 { 1305 return ::vkGetPhysicalDeviceFormatProperties( physicalDevice, format, pFormatProperties ); 1306 } 1307 vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkImageTiling tiling,VkImageUsageFlags usage,VkImageCreateFlags flags,VkImageFormatProperties * pImageFormatProperties) const1308 VkResult vkGetPhysicalDeviceImageFormatProperties( VkPhysicalDevice physicalDevice, 1309 VkFormat format, 1310 VkImageType type, 1311 VkImageTiling tiling, 1312 VkImageUsageFlags usage, 1313 VkImageCreateFlags flags, 1314 VkImageFormatProperties * pImageFormatProperties ) const 1315 VULKAN_HPP_NOEXCEPT 1316 { 1317 return ::vkGetPhysicalDeviceImageFormatProperties( 1318 physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties ); 1319 } 1320 vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties * pProperties) const1321 void vkGetPhysicalDeviceProperties( VkPhysicalDevice physicalDevice, 1322 VkPhysicalDeviceProperties * pProperties ) const VULKAN_HPP_NOEXCEPT 1323 { 1324 return ::vkGetPhysicalDeviceProperties( physicalDevice, pProperties ); 1325 } 1326 vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties * pQueueFamilyProperties) const1327 void vkGetPhysicalDeviceQueueFamilyProperties( VkPhysicalDevice physicalDevice, 1328 uint32_t * pQueueFamilyPropertyCount, 1329 VkQueueFamilyProperties * pQueueFamilyProperties ) const 1330 VULKAN_HPP_NOEXCEPT 1331 { 1332 return ::vkGetPhysicalDeviceQueueFamilyProperties( 1333 physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties ); 1334 } 1335 vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties * pMemoryProperties) const1336 void vkGetPhysicalDeviceMemoryProperties( 1337 VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties * pMemoryProperties ) const VULKAN_HPP_NOEXCEPT 1338 { 1339 return ::vkGetPhysicalDeviceMemoryProperties( physicalDevice, pMemoryProperties ); 1340 } 1341 vkGetInstanceProcAddr(VkInstance instance,const char * pName) const1342 PFN_vkVoidFunction vkGetInstanceProcAddr( VkInstance instance, const char * pName ) const VULKAN_HPP_NOEXCEPT 1343 { 1344 return ::vkGetInstanceProcAddr( instance, pName ); 1345 } 1346 vkGetDeviceProcAddr(VkDevice device,const char * pName) const1347 PFN_vkVoidFunction vkGetDeviceProcAddr( VkDevice device, const char * pName ) const VULKAN_HPP_NOEXCEPT 1348 { 1349 return ::vkGetDeviceProcAddr( device, pName ); 1350 } 1351 vkCreateDevice(VkPhysicalDevice physicalDevice,const VkDeviceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDevice * pDevice) const1352 VkResult vkCreateDevice( VkPhysicalDevice physicalDevice, 1353 const VkDeviceCreateInfo * pCreateInfo, 1354 const VkAllocationCallbacks * pAllocator, 1355 VkDevice * pDevice ) const VULKAN_HPP_NOEXCEPT 1356 { 1357 return ::vkCreateDevice( physicalDevice, pCreateInfo, pAllocator, pDevice ); 1358 } 1359 vkDestroyDevice(VkDevice device,const VkAllocationCallbacks * pAllocator) const1360 void vkDestroyDevice( VkDevice device, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT 1361 { 1362 return ::vkDestroyDevice( device, pAllocator ); 1363 } 1364 vkEnumerateInstanceExtensionProperties(const char * pLayerName,uint32_t * pPropertyCount,VkExtensionProperties * pProperties) const1365 VkResult vkEnumerateInstanceExtensionProperties( const char * pLayerName, 1366 uint32_t * pPropertyCount, 1367 VkExtensionProperties * pProperties ) const VULKAN_HPP_NOEXCEPT 1368 { 1369 return ::vkEnumerateInstanceExtensionProperties( pLayerName, pPropertyCount, pProperties ); 1370 } 1371 vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,const char * pLayerName,uint32_t * pPropertyCount,VkExtensionProperties * pProperties) const1372 VkResult vkEnumerateDeviceExtensionProperties( VkPhysicalDevice physicalDevice, 1373 const char * pLayerName, 1374 uint32_t * pPropertyCount, 1375 VkExtensionProperties * pProperties ) const VULKAN_HPP_NOEXCEPT 1376 { 1377 return ::vkEnumerateDeviceExtensionProperties( physicalDevice, pLayerName, pPropertyCount, pProperties ); 1378 } 1379 vkEnumerateInstanceLayerProperties(uint32_t * pPropertyCount,VkLayerProperties * pProperties) const1380 VkResult vkEnumerateInstanceLayerProperties( uint32_t * pPropertyCount, 1381 VkLayerProperties * pProperties ) const VULKAN_HPP_NOEXCEPT 1382 { 1383 return ::vkEnumerateInstanceLayerProperties( pPropertyCount, pProperties ); 1384 } 1385 vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkLayerProperties * pProperties) const1386 VkResult vkEnumerateDeviceLayerProperties( VkPhysicalDevice physicalDevice, 1387 uint32_t * pPropertyCount, 1388 VkLayerProperties * pProperties ) const VULKAN_HPP_NOEXCEPT 1389 { 1390 return ::vkEnumerateDeviceLayerProperties( physicalDevice, pPropertyCount, pProperties ); 1391 } 1392 vkGetDeviceQueue(VkDevice device,uint32_t queueFamilyIndex,uint32_t queueIndex,VkQueue * pQueue) const1393 void vkGetDeviceQueue( VkDevice device, 1394 uint32_t queueFamilyIndex, 1395 uint32_t queueIndex, 1396 VkQueue * pQueue ) const VULKAN_HPP_NOEXCEPT 1397 { 1398 return ::vkGetDeviceQueue( device, queueFamilyIndex, queueIndex, pQueue ); 1399 } 1400 vkQueueSubmit(VkQueue queue,uint32_t submitCount,const VkSubmitInfo * pSubmits,VkFence fence) const1401 VkResult vkQueueSubmit( VkQueue queue, 1402 uint32_t submitCount, 1403 const VkSubmitInfo * pSubmits, 1404 VkFence fence ) const VULKAN_HPP_NOEXCEPT 1405 { 1406 return ::vkQueueSubmit( queue, submitCount, pSubmits, fence ); 1407 } 1408 vkQueueWaitIdle(VkQueue queue) const1409 VkResult vkQueueWaitIdle( VkQueue queue ) const VULKAN_HPP_NOEXCEPT 1410 { 1411 return ::vkQueueWaitIdle( queue ); 1412 } 1413 vkDeviceWaitIdle(VkDevice device) const1414 VkResult vkDeviceWaitIdle( VkDevice device ) const VULKAN_HPP_NOEXCEPT 1415 { 1416 return ::vkDeviceWaitIdle( device ); 1417 } 1418 vkAllocateMemory(VkDevice device,const VkMemoryAllocateInfo * pAllocateInfo,const VkAllocationCallbacks * pAllocator,VkDeviceMemory * pMemory) const1419 VkResult vkAllocateMemory( VkDevice device, 1420 const VkMemoryAllocateInfo * pAllocateInfo, 1421 const VkAllocationCallbacks * pAllocator, 1422 VkDeviceMemory * pMemory ) const VULKAN_HPP_NOEXCEPT 1423 { 1424 return ::vkAllocateMemory( device, pAllocateInfo, pAllocator, pMemory ); 1425 } 1426 vkFreeMemory(VkDevice device,VkDeviceMemory memory,const VkAllocationCallbacks * pAllocator) const1427 void vkFreeMemory( VkDevice device, 1428 VkDeviceMemory memory, 1429 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT 1430 { 1431 return ::vkFreeMemory( device, memory, pAllocator ); 1432 } 1433 vkMapMemory(VkDevice device,VkDeviceMemory memory,VkDeviceSize offset,VkDeviceSize size,VkMemoryMapFlags flags,void ** ppData) const1434 VkResult vkMapMemory( VkDevice device, 1435 VkDeviceMemory memory, 1436 VkDeviceSize offset, 1437 VkDeviceSize size, 1438 VkMemoryMapFlags flags, 1439 void ** ppData ) const VULKAN_HPP_NOEXCEPT 1440 { 1441 return ::vkMapMemory( device, memory, offset, size, flags, ppData ); 1442 } 1443 vkUnmapMemory(VkDevice device,VkDeviceMemory memory) const1444 void vkUnmapMemory( VkDevice device, VkDeviceMemory memory ) const VULKAN_HPP_NOEXCEPT 1445 { 1446 return ::vkUnmapMemory( device, memory ); 1447 } 1448 vkFlushMappedMemoryRanges(VkDevice device,uint32_t memoryRangeCount,const VkMappedMemoryRange * pMemoryRanges) const1449 VkResult vkFlushMappedMemoryRanges( VkDevice device, 1450 uint32_t memoryRangeCount, 1451 const VkMappedMemoryRange * pMemoryRanges ) const VULKAN_HPP_NOEXCEPT 1452 { 1453 return ::vkFlushMappedMemoryRanges( device, memoryRangeCount, pMemoryRanges ); 1454 } 1455 vkInvalidateMappedMemoryRanges(VkDevice device,uint32_t memoryRangeCount,const VkMappedMemoryRange * pMemoryRanges) const1456 VkResult vkInvalidateMappedMemoryRanges( VkDevice device, 1457 uint32_t memoryRangeCount, 1458 const VkMappedMemoryRange * pMemoryRanges ) const VULKAN_HPP_NOEXCEPT 1459 { 1460 return ::vkInvalidateMappedMemoryRanges( device, memoryRangeCount, pMemoryRanges ); 1461 } 1462 vkGetDeviceMemoryCommitment(VkDevice device,VkDeviceMemory memory,VkDeviceSize * pCommittedMemoryInBytes) const1463 void vkGetDeviceMemoryCommitment( VkDevice device, 1464 VkDeviceMemory memory, 1465 VkDeviceSize * pCommittedMemoryInBytes ) const VULKAN_HPP_NOEXCEPT 1466 { 1467 return ::vkGetDeviceMemoryCommitment( device, memory, pCommittedMemoryInBytes ); 1468 } 1469 vkBindBufferMemory(VkDevice device,VkBuffer buffer,VkDeviceMemory memory,VkDeviceSize memoryOffset) const1470 VkResult vkBindBufferMemory( VkDevice device, 1471 VkBuffer buffer, 1472 VkDeviceMemory memory, 1473 VkDeviceSize memoryOffset ) const VULKAN_HPP_NOEXCEPT 1474 { 1475 return ::vkBindBufferMemory( device, buffer, memory, memoryOffset ); 1476 } 1477 vkBindImageMemory(VkDevice device,VkImage image,VkDeviceMemory memory,VkDeviceSize memoryOffset) const1478 VkResult vkBindImageMemory( VkDevice device, 1479 VkImage image, 1480 VkDeviceMemory memory, 1481 VkDeviceSize memoryOffset ) const VULKAN_HPP_NOEXCEPT 1482 { 1483 return ::vkBindImageMemory( device, image, memory, memoryOffset ); 1484 } 1485 vkGetBufferMemoryRequirements(VkDevice device,VkBuffer buffer,VkMemoryRequirements * pMemoryRequirements) const1486 void vkGetBufferMemoryRequirements( VkDevice device, 1487 VkBuffer buffer, 1488 VkMemoryRequirements * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT 1489 { 1490 return ::vkGetBufferMemoryRequirements( device, buffer, pMemoryRequirements ); 1491 } 1492 vkGetImageMemoryRequirements(VkDevice device,VkImage image,VkMemoryRequirements * pMemoryRequirements) const1493 void vkGetImageMemoryRequirements( VkDevice device, 1494 VkImage image, 1495 VkMemoryRequirements * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT 1496 { 1497 return ::vkGetImageMemoryRequirements( device, image, pMemoryRequirements ); 1498 } 1499 vkGetImageSparseMemoryRequirements(VkDevice device,VkImage image,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements * pSparseMemoryRequirements) const1500 void vkGetImageSparseMemoryRequirements( VkDevice device, 1501 VkImage image, 1502 uint32_t * pSparseMemoryRequirementCount, 1503 VkSparseImageMemoryRequirements * pSparseMemoryRequirements ) const 1504 VULKAN_HPP_NOEXCEPT 1505 { 1506 return ::vkGetImageSparseMemoryRequirements( 1507 device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements ); 1508 } 1509 vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkSampleCountFlagBits samples,VkImageUsageFlags usage,VkImageTiling tiling,uint32_t * pPropertyCount,VkSparseImageFormatProperties * pProperties) const1510 void vkGetPhysicalDeviceSparseImageFormatProperties( VkPhysicalDevice physicalDevice, 1511 VkFormat format, 1512 VkImageType type, 1513 VkSampleCountFlagBits samples, 1514 VkImageUsageFlags usage, 1515 VkImageTiling tiling, 1516 uint32_t * pPropertyCount, 1517 VkSparseImageFormatProperties * pProperties ) const 1518 VULKAN_HPP_NOEXCEPT 1519 { 1520 return ::vkGetPhysicalDeviceSparseImageFormatProperties( 1521 physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties ); 1522 } 1523 vkQueueBindSparse(VkQueue queue,uint32_t bindInfoCount,const VkBindSparseInfo * pBindInfo,VkFence fence) const1524 VkResult vkQueueBindSparse( VkQueue queue, 1525 uint32_t bindInfoCount, 1526 const VkBindSparseInfo * pBindInfo, 1527 VkFence fence ) const VULKAN_HPP_NOEXCEPT 1528 { 1529 return ::vkQueueBindSparse( queue, bindInfoCount, pBindInfo, fence ); 1530 } 1531 vkCreateFence(VkDevice device,const VkFenceCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkFence * pFence) const1532 VkResult vkCreateFence( VkDevice device, 1533 const VkFenceCreateInfo * pCreateInfo, 1534 const VkAllocationCallbacks * pAllocator, 1535 VkFence * pFence ) const VULKAN_HPP_NOEXCEPT 1536 { 1537 return ::vkCreateFence( device, pCreateInfo, pAllocator, pFence ); 1538 } 1539 vkDestroyFence(VkDevice device,VkFence fence,const VkAllocationCallbacks * pAllocator) const1540 void vkDestroyFence( VkDevice device, 1541 VkFence fence, 1542 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT 1543 { 1544 return ::vkDestroyFence( device, fence, pAllocator ); 1545 } 1546 vkResetFences(VkDevice device,uint32_t fenceCount,const VkFence * pFences) const1547 VkResult vkResetFences( VkDevice device, uint32_t fenceCount, const VkFence * pFences ) const VULKAN_HPP_NOEXCEPT 1548 { 1549 return ::vkResetFences( device, fenceCount, pFences ); 1550 } 1551 vkGetFenceStatus(VkDevice device,VkFence fence) const1552 VkResult vkGetFenceStatus( VkDevice device, VkFence fence ) const VULKAN_HPP_NOEXCEPT 1553 { 1554 return ::vkGetFenceStatus( device, fence ); 1555 } 1556 vkWaitForFences(VkDevice device,uint32_t fenceCount,const VkFence * pFences,VkBool32 waitAll,uint64_t timeout) const1557 VkResult vkWaitForFences( VkDevice device, 1558 uint32_t fenceCount, 1559 const VkFence * pFences, 1560 VkBool32 waitAll, 1561 uint64_t timeout ) const VULKAN_HPP_NOEXCEPT 1562 { 1563 return ::vkWaitForFences( device, fenceCount, pFences, waitAll, timeout ); 1564 } 1565 vkCreateSemaphore(VkDevice device,const VkSemaphoreCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSemaphore * pSemaphore) const1566 VkResult vkCreateSemaphore( VkDevice device, 1567 const VkSemaphoreCreateInfo * pCreateInfo, 1568 const VkAllocationCallbacks * pAllocator, 1569 VkSemaphore * pSemaphore ) const VULKAN_HPP_NOEXCEPT 1570 { 1571 return ::vkCreateSemaphore( device, pCreateInfo, pAllocator, pSemaphore ); 1572 } 1573 vkDestroySemaphore(VkDevice device,VkSemaphore semaphore,const VkAllocationCallbacks * pAllocator) const1574 void vkDestroySemaphore( VkDevice device, 1575 VkSemaphore semaphore, 1576 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT 1577 { 1578 return ::vkDestroySemaphore( device, semaphore, pAllocator ); 1579 } 1580 vkCreateEvent(VkDevice device,const VkEventCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkEvent * pEvent) const1581 VkResult vkCreateEvent( VkDevice device, 1582 const VkEventCreateInfo * pCreateInfo, 1583 const VkAllocationCallbacks * pAllocator, 1584 VkEvent * pEvent ) const VULKAN_HPP_NOEXCEPT 1585 { 1586 return ::vkCreateEvent( device, pCreateInfo, pAllocator, pEvent ); 1587 } 1588 vkDestroyEvent(VkDevice device,VkEvent event,const VkAllocationCallbacks * pAllocator) const1589 void vkDestroyEvent( VkDevice device, 1590 VkEvent event, 1591 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT 1592 { 1593 return ::vkDestroyEvent( device, event, pAllocator ); 1594 } 1595 vkGetEventStatus(VkDevice device,VkEvent event) const1596 VkResult vkGetEventStatus( VkDevice device, VkEvent event ) const VULKAN_HPP_NOEXCEPT 1597 { 1598 return ::vkGetEventStatus( device, event ); 1599 } 1600 vkSetEvent(VkDevice device,VkEvent event) const1601 VkResult vkSetEvent( VkDevice device, VkEvent event ) const VULKAN_HPP_NOEXCEPT 1602 { 1603 return ::vkSetEvent( device, event ); 1604 } 1605 vkResetEvent(VkDevice device,VkEvent event) const1606 VkResult vkResetEvent( VkDevice device, VkEvent event ) const VULKAN_HPP_NOEXCEPT 1607 { 1608 return ::vkResetEvent( device, event ); 1609 } 1610 vkCreateQueryPool(VkDevice device,const VkQueryPoolCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkQueryPool * pQueryPool) const1611 VkResult vkCreateQueryPool( VkDevice device, 1612 const VkQueryPoolCreateInfo * pCreateInfo, 1613 const VkAllocationCallbacks * pAllocator, 1614 VkQueryPool * pQueryPool ) const VULKAN_HPP_NOEXCEPT 1615 { 1616 return ::vkCreateQueryPool( device, pCreateInfo, pAllocator, pQueryPool ); 1617 } 1618 vkDestroyQueryPool(VkDevice device,VkQueryPool queryPool,const VkAllocationCallbacks * pAllocator) const1619 void vkDestroyQueryPool( VkDevice device, 1620 VkQueryPool queryPool, 1621 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT 1622 { 1623 return ::vkDestroyQueryPool( device, queryPool, pAllocator ); 1624 } 1625 vkGetQueryPoolResults(VkDevice device,VkQueryPool queryPool,uint32_t firstQuery,uint32_t queryCount,size_t dataSize,void * pData,VkDeviceSize stride,VkQueryResultFlags flags) const1626 VkResult vkGetQueryPoolResults( VkDevice device, 1627 VkQueryPool queryPool, 1628 uint32_t firstQuery, 1629 uint32_t queryCount, 1630 size_t dataSize, 1631 void * pData, 1632 VkDeviceSize stride, 1633 VkQueryResultFlags flags ) const VULKAN_HPP_NOEXCEPT 1634 { 1635 return ::vkGetQueryPoolResults( device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags ); 1636 } 1637 vkCreateBuffer(VkDevice device,const VkBufferCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkBuffer * pBuffer) const1638 VkResult vkCreateBuffer( VkDevice device, 1639 const VkBufferCreateInfo * pCreateInfo, 1640 const VkAllocationCallbacks * pAllocator, 1641 VkBuffer * pBuffer ) const VULKAN_HPP_NOEXCEPT 1642 { 1643 return ::vkCreateBuffer( device, pCreateInfo, pAllocator, pBuffer ); 1644 } 1645 vkDestroyBuffer(VkDevice device,VkBuffer buffer,const VkAllocationCallbacks * pAllocator) const1646 void vkDestroyBuffer( VkDevice device, 1647 VkBuffer buffer, 1648 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT 1649 { 1650 return ::vkDestroyBuffer( device, buffer, pAllocator ); 1651 } 1652 vkCreateBufferView(VkDevice device,const VkBufferViewCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkBufferView * pView) const1653 VkResult vkCreateBufferView( VkDevice device, 1654 const VkBufferViewCreateInfo * pCreateInfo, 1655 const VkAllocationCallbacks * pAllocator, 1656 VkBufferView * pView ) const VULKAN_HPP_NOEXCEPT 1657 { 1658 return ::vkCreateBufferView( device, pCreateInfo, pAllocator, pView ); 1659 } 1660 vkDestroyBufferView(VkDevice device,VkBufferView bufferView,const VkAllocationCallbacks * pAllocator) const1661 void vkDestroyBufferView( VkDevice device, 1662 VkBufferView bufferView, 1663 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT 1664 { 1665 return ::vkDestroyBufferView( device, bufferView, pAllocator ); 1666 } 1667 vkCreateImage(VkDevice device,const VkImageCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkImage * pImage) const1668 VkResult vkCreateImage( VkDevice device, 1669 const VkImageCreateInfo * pCreateInfo, 1670 const VkAllocationCallbacks * pAllocator, 1671 VkImage * pImage ) const VULKAN_HPP_NOEXCEPT 1672 { 1673 return ::vkCreateImage( device, pCreateInfo, pAllocator, pImage ); 1674 } 1675 vkDestroyImage(VkDevice device,VkImage image,const VkAllocationCallbacks * pAllocator) const1676 void vkDestroyImage( VkDevice device, 1677 VkImage image, 1678 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT 1679 { 1680 return ::vkDestroyImage( device, image, pAllocator ); 1681 } 1682 vkGetImageSubresourceLayout(VkDevice device,VkImage image,const VkImageSubresource * pSubresource,VkSubresourceLayout * pLayout) const1683 void vkGetImageSubresourceLayout( VkDevice device, 1684 VkImage image, 1685 const VkImageSubresource * pSubresource, 1686 VkSubresourceLayout * pLayout ) const VULKAN_HPP_NOEXCEPT 1687 { 1688 return ::vkGetImageSubresourceLayout( device, image, pSubresource, pLayout ); 1689 } 1690 vkCreateImageView(VkDevice device,const VkImageViewCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkImageView * pView) const1691 VkResult vkCreateImageView( VkDevice device, 1692 const VkImageViewCreateInfo * pCreateInfo, 1693 const VkAllocationCallbacks * pAllocator, 1694 VkImageView * pView ) const VULKAN_HPP_NOEXCEPT 1695 { 1696 return ::vkCreateImageView( device, pCreateInfo, pAllocator, pView ); 1697 } 1698 vkDestroyImageView(VkDevice device,VkImageView imageView,const VkAllocationCallbacks * pAllocator) const1699 void vkDestroyImageView( VkDevice device, 1700 VkImageView imageView, 1701 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT 1702 { 1703 return ::vkDestroyImageView( device, imageView, pAllocator ); 1704 } 1705 vkCreateShaderModule(VkDevice device,const VkShaderModuleCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkShaderModule * pShaderModule) const1706 VkResult vkCreateShaderModule( VkDevice device, 1707 const VkShaderModuleCreateInfo * pCreateInfo, 1708 const VkAllocationCallbacks * pAllocator, 1709 VkShaderModule * pShaderModule ) const VULKAN_HPP_NOEXCEPT 1710 { 1711 return ::vkCreateShaderModule( device, pCreateInfo, pAllocator, pShaderModule ); 1712 } 1713 vkDestroyShaderModule(VkDevice device,VkShaderModule shaderModule,const VkAllocationCallbacks * pAllocator) const1714 void vkDestroyShaderModule( VkDevice device, 1715 VkShaderModule shaderModule, 1716 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT 1717 { 1718 return ::vkDestroyShaderModule( device, shaderModule, pAllocator ); 1719 } 1720 vkCreatePipelineCache(VkDevice device,const VkPipelineCacheCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkPipelineCache * pPipelineCache) const1721 VkResult vkCreatePipelineCache( VkDevice device, 1722 const VkPipelineCacheCreateInfo * pCreateInfo, 1723 const VkAllocationCallbacks * pAllocator, 1724 VkPipelineCache * pPipelineCache ) const VULKAN_HPP_NOEXCEPT 1725 { 1726 return ::vkCreatePipelineCache( device, pCreateInfo, pAllocator, pPipelineCache ); 1727 } 1728 vkDestroyPipelineCache(VkDevice device,VkPipelineCache pipelineCache,const VkAllocationCallbacks * pAllocator) const1729 void vkDestroyPipelineCache( VkDevice device, 1730 VkPipelineCache pipelineCache, 1731 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT 1732 { 1733 return ::vkDestroyPipelineCache( device, pipelineCache, pAllocator ); 1734 } 1735 vkGetPipelineCacheData(VkDevice device,VkPipelineCache pipelineCache,size_t * pDataSize,void * pData) const1736 VkResult vkGetPipelineCacheData( VkDevice device, 1737 VkPipelineCache pipelineCache, 1738 size_t * pDataSize, 1739 void * pData ) const VULKAN_HPP_NOEXCEPT 1740 { 1741 return ::vkGetPipelineCacheData( device, pipelineCache, pDataSize, pData ); 1742 } 1743 vkMergePipelineCaches(VkDevice device,VkPipelineCache dstCache,uint32_t srcCacheCount,const VkPipelineCache * pSrcCaches) const1744 VkResult vkMergePipelineCaches( VkDevice device, 1745 VkPipelineCache dstCache, 1746 uint32_t srcCacheCount, 1747 const VkPipelineCache * pSrcCaches ) const VULKAN_HPP_NOEXCEPT 1748 { 1749 return ::vkMergePipelineCaches( device, dstCache, srcCacheCount, pSrcCaches ); 1750 } 1751 vkCreateGraphicsPipelines(VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkGraphicsPipelineCreateInfo * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines) const1752 VkResult vkCreateGraphicsPipelines( VkDevice device, 1753 VkPipelineCache pipelineCache, 1754 uint32_t createInfoCount, 1755 const VkGraphicsPipelineCreateInfo * pCreateInfos, 1756 const VkAllocationCallbacks * pAllocator, 1757 VkPipeline * pPipelines ) const VULKAN_HPP_NOEXCEPT 1758 { 1759 return ::vkCreateGraphicsPipelines( 1760 device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines ); 1761 } 1762 vkCreateComputePipelines(VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkComputePipelineCreateInfo * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines) const1763 VkResult vkCreateComputePipelines( VkDevice device, 1764 VkPipelineCache pipelineCache, 1765 uint32_t createInfoCount, 1766 const VkComputePipelineCreateInfo * pCreateInfos, 1767 const VkAllocationCallbacks * pAllocator, 1768 VkPipeline * pPipelines ) const VULKAN_HPP_NOEXCEPT 1769 { 1770 return ::vkCreateComputePipelines( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines ); 1771 } 1772 vkDestroyPipeline(VkDevice device,VkPipeline pipeline,const VkAllocationCallbacks * pAllocator) const1773 void vkDestroyPipeline( VkDevice device, 1774 VkPipeline pipeline, 1775 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT 1776 { 1777 return ::vkDestroyPipeline( device, pipeline, pAllocator ); 1778 } 1779 vkCreatePipelineLayout(VkDevice device,const VkPipelineLayoutCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkPipelineLayout * pPipelineLayout) const1780 VkResult vkCreatePipelineLayout( VkDevice device, 1781 const VkPipelineLayoutCreateInfo * pCreateInfo, 1782 const VkAllocationCallbacks * pAllocator, 1783 VkPipelineLayout * pPipelineLayout ) const VULKAN_HPP_NOEXCEPT 1784 { 1785 return ::vkCreatePipelineLayout( device, pCreateInfo, pAllocator, pPipelineLayout ); 1786 } 1787 vkDestroyPipelineLayout(VkDevice device,VkPipelineLayout pipelineLayout,const VkAllocationCallbacks * pAllocator) const1788 void vkDestroyPipelineLayout( VkDevice device, 1789 VkPipelineLayout pipelineLayout, 1790 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT 1791 { 1792 return ::vkDestroyPipelineLayout( device, pipelineLayout, pAllocator ); 1793 } 1794 vkCreateSampler(VkDevice device,const VkSamplerCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSampler * pSampler) const1795 VkResult vkCreateSampler( VkDevice device, 1796 const VkSamplerCreateInfo * pCreateInfo, 1797 const VkAllocationCallbacks * pAllocator, 1798 VkSampler * pSampler ) const VULKAN_HPP_NOEXCEPT 1799 { 1800 return ::vkCreateSampler( device, pCreateInfo, pAllocator, pSampler ); 1801 } 1802 vkDestroySampler(VkDevice device,VkSampler sampler,const VkAllocationCallbacks * pAllocator) const1803 void vkDestroySampler( VkDevice device, 1804 VkSampler sampler, 1805 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT 1806 { 1807 return ::vkDestroySampler( device, sampler, pAllocator ); 1808 } 1809 vkCreateDescriptorSetLayout(VkDevice device,const VkDescriptorSetLayoutCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDescriptorSetLayout * pSetLayout) const1810 VkResult vkCreateDescriptorSetLayout( VkDevice device, 1811 const VkDescriptorSetLayoutCreateInfo * pCreateInfo, 1812 const VkAllocationCallbacks * pAllocator, 1813 VkDescriptorSetLayout * pSetLayout ) const VULKAN_HPP_NOEXCEPT 1814 { 1815 return ::vkCreateDescriptorSetLayout( device, pCreateInfo, pAllocator, pSetLayout ); 1816 } 1817 vkDestroyDescriptorSetLayout(VkDevice device,VkDescriptorSetLayout descriptorSetLayout,const VkAllocationCallbacks * pAllocator) const1818 void vkDestroyDescriptorSetLayout( VkDevice device, 1819 VkDescriptorSetLayout descriptorSetLayout, 1820 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT 1821 { 1822 return ::vkDestroyDescriptorSetLayout( device, descriptorSetLayout, pAllocator ); 1823 } 1824 vkCreateDescriptorPool(VkDevice device,const VkDescriptorPoolCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDescriptorPool * pDescriptorPool) const1825 VkResult vkCreateDescriptorPool( VkDevice device, 1826 const VkDescriptorPoolCreateInfo * pCreateInfo, 1827 const VkAllocationCallbacks * pAllocator, 1828 VkDescriptorPool * pDescriptorPool ) const VULKAN_HPP_NOEXCEPT 1829 { 1830 return ::vkCreateDescriptorPool( device, pCreateInfo, pAllocator, pDescriptorPool ); 1831 } 1832 vkDestroyDescriptorPool(VkDevice device,VkDescriptorPool descriptorPool,const VkAllocationCallbacks * pAllocator) const1833 void vkDestroyDescriptorPool( VkDevice device, 1834 VkDescriptorPool descriptorPool, 1835 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT 1836 { 1837 return ::vkDestroyDescriptorPool( device, descriptorPool, pAllocator ); 1838 } 1839 vkResetDescriptorPool(VkDevice device,VkDescriptorPool descriptorPool,VkDescriptorPoolResetFlags flags) const1840 VkResult vkResetDescriptorPool( VkDevice device, 1841 VkDescriptorPool descriptorPool, 1842 VkDescriptorPoolResetFlags flags ) const VULKAN_HPP_NOEXCEPT 1843 { 1844 return ::vkResetDescriptorPool( device, descriptorPool, flags ); 1845 } 1846 vkAllocateDescriptorSets(VkDevice device,const VkDescriptorSetAllocateInfo * pAllocateInfo,VkDescriptorSet * pDescriptorSets) const1847 VkResult vkAllocateDescriptorSets( VkDevice device, 1848 const VkDescriptorSetAllocateInfo * pAllocateInfo, 1849 VkDescriptorSet * pDescriptorSets ) const VULKAN_HPP_NOEXCEPT 1850 { 1851 return ::vkAllocateDescriptorSets( device, pAllocateInfo, pDescriptorSets ); 1852 } 1853 vkFreeDescriptorSets(VkDevice device,VkDescriptorPool descriptorPool,uint32_t descriptorSetCount,const VkDescriptorSet * pDescriptorSets) const1854 VkResult vkFreeDescriptorSets( VkDevice device, 1855 VkDescriptorPool descriptorPool, 1856 uint32_t descriptorSetCount, 1857 const VkDescriptorSet * pDescriptorSets ) const VULKAN_HPP_NOEXCEPT 1858 { 1859 return ::vkFreeDescriptorSets( device, descriptorPool, descriptorSetCount, pDescriptorSets ); 1860 } 1861 vkUpdateDescriptorSets(VkDevice device,uint32_t descriptorWriteCount,const VkWriteDescriptorSet * pDescriptorWrites,uint32_t descriptorCopyCount,const VkCopyDescriptorSet * pDescriptorCopies) const1862 void vkUpdateDescriptorSets( VkDevice device, 1863 uint32_t descriptorWriteCount, 1864 const VkWriteDescriptorSet * pDescriptorWrites, 1865 uint32_t descriptorCopyCount, 1866 const VkCopyDescriptorSet * pDescriptorCopies ) const VULKAN_HPP_NOEXCEPT 1867 { 1868 return ::vkUpdateDescriptorSets( 1869 device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies ); 1870 } 1871 vkCreateFramebuffer(VkDevice device,const VkFramebufferCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkFramebuffer * pFramebuffer) const1872 VkResult vkCreateFramebuffer( VkDevice device, 1873 const VkFramebufferCreateInfo * pCreateInfo, 1874 const VkAllocationCallbacks * pAllocator, 1875 VkFramebuffer * pFramebuffer ) const VULKAN_HPP_NOEXCEPT 1876 { 1877 return ::vkCreateFramebuffer( device, pCreateInfo, pAllocator, pFramebuffer ); 1878 } 1879 vkDestroyFramebuffer(VkDevice device,VkFramebuffer framebuffer,const VkAllocationCallbacks * pAllocator) const1880 void vkDestroyFramebuffer( VkDevice device, 1881 VkFramebuffer framebuffer, 1882 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT 1883 { 1884 return ::vkDestroyFramebuffer( device, framebuffer, pAllocator ); 1885 } 1886 vkCreateRenderPass(VkDevice device,const VkRenderPassCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkRenderPass * pRenderPass) const1887 VkResult vkCreateRenderPass( VkDevice device, 1888 const VkRenderPassCreateInfo * pCreateInfo, 1889 const VkAllocationCallbacks * pAllocator, 1890 VkRenderPass * pRenderPass ) const VULKAN_HPP_NOEXCEPT 1891 { 1892 return ::vkCreateRenderPass( device, pCreateInfo, pAllocator, pRenderPass ); 1893 } 1894 vkDestroyRenderPass(VkDevice device,VkRenderPass renderPass,const VkAllocationCallbacks * pAllocator) const1895 void vkDestroyRenderPass( VkDevice device, 1896 VkRenderPass renderPass, 1897 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT 1898 { 1899 return ::vkDestroyRenderPass( device, renderPass, pAllocator ); 1900 } 1901 vkGetRenderAreaGranularity(VkDevice device,VkRenderPass renderPass,VkExtent2D * pGranularity) const1902 void vkGetRenderAreaGranularity( VkDevice device, 1903 VkRenderPass renderPass, 1904 VkExtent2D * pGranularity ) const VULKAN_HPP_NOEXCEPT 1905 { 1906 return ::vkGetRenderAreaGranularity( device, renderPass, pGranularity ); 1907 } 1908 vkCreateCommandPool(VkDevice device,const VkCommandPoolCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkCommandPool * pCommandPool) const1909 VkResult vkCreateCommandPool( VkDevice device, 1910 const VkCommandPoolCreateInfo * pCreateInfo, 1911 const VkAllocationCallbacks * pAllocator, 1912 VkCommandPool * pCommandPool ) const VULKAN_HPP_NOEXCEPT 1913 { 1914 return ::vkCreateCommandPool( device, pCreateInfo, pAllocator, pCommandPool ); 1915 } 1916 vkDestroyCommandPool(VkDevice device,VkCommandPool commandPool,const VkAllocationCallbacks * pAllocator) const1917 void vkDestroyCommandPool( VkDevice device, 1918 VkCommandPool commandPool, 1919 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT 1920 { 1921 return ::vkDestroyCommandPool( device, commandPool, pAllocator ); 1922 } 1923 vkResetCommandPool(VkDevice device,VkCommandPool commandPool,VkCommandPoolResetFlags flags) const1924 VkResult vkResetCommandPool( VkDevice device, 1925 VkCommandPool commandPool, 1926 VkCommandPoolResetFlags flags ) const VULKAN_HPP_NOEXCEPT 1927 { 1928 return ::vkResetCommandPool( device, commandPool, flags ); 1929 } 1930 vkAllocateCommandBuffers(VkDevice device,const VkCommandBufferAllocateInfo * pAllocateInfo,VkCommandBuffer * pCommandBuffers) const1931 VkResult vkAllocateCommandBuffers( VkDevice device, 1932 const VkCommandBufferAllocateInfo * pAllocateInfo, 1933 VkCommandBuffer * pCommandBuffers ) const VULKAN_HPP_NOEXCEPT 1934 { 1935 return ::vkAllocateCommandBuffers( device, pAllocateInfo, pCommandBuffers ); 1936 } 1937 vkFreeCommandBuffers(VkDevice device,VkCommandPool commandPool,uint32_t commandBufferCount,const VkCommandBuffer * pCommandBuffers) const1938 void vkFreeCommandBuffers( VkDevice device, 1939 VkCommandPool commandPool, 1940 uint32_t commandBufferCount, 1941 const VkCommandBuffer * pCommandBuffers ) const VULKAN_HPP_NOEXCEPT 1942 { 1943 return ::vkFreeCommandBuffers( device, commandPool, commandBufferCount, pCommandBuffers ); 1944 } 1945 vkBeginCommandBuffer(VkCommandBuffer commandBuffer,const VkCommandBufferBeginInfo * pBeginInfo) const1946 VkResult vkBeginCommandBuffer( VkCommandBuffer commandBuffer, 1947 const VkCommandBufferBeginInfo * pBeginInfo ) const VULKAN_HPP_NOEXCEPT 1948 { 1949 return ::vkBeginCommandBuffer( commandBuffer, pBeginInfo ); 1950 } 1951 vkEndCommandBuffer(VkCommandBuffer commandBuffer) const1952 VkResult vkEndCommandBuffer( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT 1953 { 1954 return ::vkEndCommandBuffer( commandBuffer ); 1955 } 1956 vkResetCommandBuffer(VkCommandBuffer commandBuffer,VkCommandBufferResetFlags flags) const1957 VkResult vkResetCommandBuffer( VkCommandBuffer commandBuffer, 1958 VkCommandBufferResetFlags flags ) const VULKAN_HPP_NOEXCEPT 1959 { 1960 return ::vkResetCommandBuffer( commandBuffer, flags ); 1961 } 1962 vkCmdBindPipeline(VkCommandBuffer commandBuffer,VkPipelineBindPoint pipelineBindPoint,VkPipeline pipeline) const1963 void vkCmdBindPipeline( VkCommandBuffer commandBuffer, 1964 VkPipelineBindPoint pipelineBindPoint, 1965 VkPipeline pipeline ) const VULKAN_HPP_NOEXCEPT 1966 { 1967 return ::vkCmdBindPipeline( commandBuffer, pipelineBindPoint, pipeline ); 1968 } 1969 vkCmdSetViewport(VkCommandBuffer commandBuffer,uint32_t firstViewport,uint32_t viewportCount,const VkViewport * pViewports) const1970 void vkCmdSetViewport( VkCommandBuffer commandBuffer, 1971 uint32_t firstViewport, 1972 uint32_t viewportCount, 1973 const VkViewport * pViewports ) const VULKAN_HPP_NOEXCEPT 1974 { 1975 return ::vkCmdSetViewport( commandBuffer, firstViewport, viewportCount, pViewports ); 1976 } 1977 vkCmdSetScissor(VkCommandBuffer commandBuffer,uint32_t firstScissor,uint32_t scissorCount,const VkRect2D * pScissors) const1978 void vkCmdSetScissor( VkCommandBuffer commandBuffer, 1979 uint32_t firstScissor, 1980 uint32_t scissorCount, 1981 const VkRect2D * pScissors ) const VULKAN_HPP_NOEXCEPT 1982 { 1983 return ::vkCmdSetScissor( commandBuffer, firstScissor, scissorCount, pScissors ); 1984 } 1985 vkCmdSetLineWidth(VkCommandBuffer commandBuffer,float lineWidth) const1986 void vkCmdSetLineWidth( VkCommandBuffer commandBuffer, float lineWidth ) const VULKAN_HPP_NOEXCEPT 1987 { 1988 return ::vkCmdSetLineWidth( commandBuffer, lineWidth ); 1989 } 1990 vkCmdSetDepthBias(VkCommandBuffer commandBuffer,float depthBiasConstantFactor,float depthBiasClamp,float depthBiasSlopeFactor) const1991 void vkCmdSetDepthBias( VkCommandBuffer commandBuffer, 1992 float depthBiasConstantFactor, 1993 float depthBiasClamp, 1994 float depthBiasSlopeFactor ) const VULKAN_HPP_NOEXCEPT 1995 { 1996 return ::vkCmdSetDepthBias( commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor ); 1997 } 1998 vkCmdSetBlendConstants(VkCommandBuffer commandBuffer,const float blendConstants[4]) const1999 void vkCmdSetBlendConstants( VkCommandBuffer commandBuffer, 2000 const float blendConstants[4] ) const VULKAN_HPP_NOEXCEPT 2001 { 2002 return ::vkCmdSetBlendConstants( commandBuffer, blendConstants ); 2003 } 2004 vkCmdSetDepthBounds(VkCommandBuffer commandBuffer,float minDepthBounds,float maxDepthBounds) const2005 void vkCmdSetDepthBounds( VkCommandBuffer commandBuffer, 2006 float minDepthBounds, 2007 float maxDepthBounds ) const VULKAN_HPP_NOEXCEPT 2008 { 2009 return ::vkCmdSetDepthBounds( commandBuffer, minDepthBounds, maxDepthBounds ); 2010 } 2011 vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer,VkStencilFaceFlags faceMask,uint32_t compareMask) const2012 void vkCmdSetStencilCompareMask( VkCommandBuffer commandBuffer, 2013 VkStencilFaceFlags faceMask, 2014 uint32_t compareMask ) const VULKAN_HPP_NOEXCEPT 2015 { 2016 return ::vkCmdSetStencilCompareMask( commandBuffer, faceMask, compareMask ); 2017 } 2018 vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer,VkStencilFaceFlags faceMask,uint32_t writeMask) const2019 void vkCmdSetStencilWriteMask( VkCommandBuffer commandBuffer, 2020 VkStencilFaceFlags faceMask, 2021 uint32_t writeMask ) const VULKAN_HPP_NOEXCEPT 2022 { 2023 return ::vkCmdSetStencilWriteMask( commandBuffer, faceMask, writeMask ); 2024 } 2025 vkCmdSetStencilReference(VkCommandBuffer commandBuffer,VkStencilFaceFlags faceMask,uint32_t reference) const2026 void vkCmdSetStencilReference( VkCommandBuffer commandBuffer, 2027 VkStencilFaceFlags faceMask, 2028 uint32_t reference ) const VULKAN_HPP_NOEXCEPT 2029 { 2030 return ::vkCmdSetStencilReference( commandBuffer, faceMask, reference ); 2031 } 2032 vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer,VkPipelineBindPoint pipelineBindPoint,VkPipelineLayout layout,uint32_t firstSet,uint32_t descriptorSetCount,const VkDescriptorSet * pDescriptorSets,uint32_t dynamicOffsetCount,const uint32_t * pDynamicOffsets) const2033 void vkCmdBindDescriptorSets( VkCommandBuffer commandBuffer, 2034 VkPipelineBindPoint pipelineBindPoint, 2035 VkPipelineLayout layout, 2036 uint32_t firstSet, 2037 uint32_t descriptorSetCount, 2038 const VkDescriptorSet * pDescriptorSets, 2039 uint32_t dynamicOffsetCount, 2040 const uint32_t * pDynamicOffsets ) const VULKAN_HPP_NOEXCEPT 2041 { 2042 return ::vkCmdBindDescriptorSets( commandBuffer, 2043 pipelineBindPoint, 2044 layout, 2045 firstSet, 2046 descriptorSetCount, 2047 pDescriptorSets, 2048 dynamicOffsetCount, 2049 pDynamicOffsets ); 2050 } 2051 vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer,VkBuffer buffer,VkDeviceSize offset,VkIndexType indexType) const2052 void vkCmdBindIndexBuffer( VkCommandBuffer commandBuffer, 2053 VkBuffer buffer, 2054 VkDeviceSize offset, 2055 VkIndexType indexType ) const VULKAN_HPP_NOEXCEPT 2056 { 2057 return ::vkCmdBindIndexBuffer( commandBuffer, buffer, offset, indexType ); 2058 } 2059 vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer,uint32_t firstBinding,uint32_t bindingCount,const VkBuffer * pBuffers,const VkDeviceSize * pOffsets) const2060 void vkCmdBindVertexBuffers( VkCommandBuffer commandBuffer, 2061 uint32_t firstBinding, 2062 uint32_t bindingCount, 2063 const VkBuffer * pBuffers, 2064 const VkDeviceSize * pOffsets ) const VULKAN_HPP_NOEXCEPT 2065 { 2066 return ::vkCmdBindVertexBuffers( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets ); 2067 } 2068 vkCmdDraw(VkCommandBuffer commandBuffer,uint32_t vertexCount,uint32_t instanceCount,uint32_t firstVertex,uint32_t firstInstance) const2069 void vkCmdDraw( VkCommandBuffer commandBuffer, 2070 uint32_t vertexCount, 2071 uint32_t instanceCount, 2072 uint32_t firstVertex, 2073 uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT 2074 { 2075 return ::vkCmdDraw( commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance ); 2076 } 2077 vkCmdDrawIndexed(VkCommandBuffer commandBuffer,uint32_t indexCount,uint32_t instanceCount,uint32_t firstIndex,int32_t vertexOffset,uint32_t firstInstance) const2078 void vkCmdDrawIndexed( VkCommandBuffer commandBuffer, 2079 uint32_t indexCount, 2080 uint32_t instanceCount, 2081 uint32_t firstIndex, 2082 int32_t vertexOffset, 2083 uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT 2084 { 2085 return ::vkCmdDrawIndexed( commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance ); 2086 } 2087 vkCmdDrawIndirect(VkCommandBuffer commandBuffer,VkBuffer buffer,VkDeviceSize offset,uint32_t drawCount,uint32_t stride) const2088 void vkCmdDrawIndirect( VkCommandBuffer commandBuffer, 2089 VkBuffer buffer, 2090 VkDeviceSize offset, 2091 uint32_t drawCount, 2092 uint32_t stride ) const VULKAN_HPP_NOEXCEPT 2093 { 2094 return ::vkCmdDrawIndirect( commandBuffer, buffer, offset, drawCount, stride ); 2095 } 2096 vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer,VkBuffer buffer,VkDeviceSize offset,uint32_t drawCount,uint32_t stride) const2097 void vkCmdDrawIndexedIndirect( VkCommandBuffer commandBuffer, 2098 VkBuffer buffer, 2099 VkDeviceSize offset, 2100 uint32_t drawCount, 2101 uint32_t stride ) const VULKAN_HPP_NOEXCEPT 2102 { 2103 return ::vkCmdDrawIndexedIndirect( commandBuffer, buffer, offset, drawCount, stride ); 2104 } 2105 vkCmdDispatch(VkCommandBuffer commandBuffer,uint32_t groupCountX,uint32_t groupCountY,uint32_t groupCountZ) const2106 void vkCmdDispatch( VkCommandBuffer commandBuffer, 2107 uint32_t groupCountX, 2108 uint32_t groupCountY, 2109 uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT 2110 { 2111 return ::vkCmdDispatch( commandBuffer, groupCountX, groupCountY, groupCountZ ); 2112 } 2113 vkCmdDispatchIndirect(VkCommandBuffer commandBuffer,VkBuffer buffer,VkDeviceSize offset) const2114 void vkCmdDispatchIndirect( VkCommandBuffer commandBuffer, 2115 VkBuffer buffer, 2116 VkDeviceSize offset ) const VULKAN_HPP_NOEXCEPT 2117 { 2118 return ::vkCmdDispatchIndirect( commandBuffer, buffer, offset ); 2119 } 2120 vkCmdCopyBuffer(VkCommandBuffer commandBuffer,VkBuffer srcBuffer,VkBuffer dstBuffer,uint32_t regionCount,const VkBufferCopy * pRegions) const2121 void vkCmdCopyBuffer( VkCommandBuffer commandBuffer, 2122 VkBuffer srcBuffer, 2123 VkBuffer dstBuffer, 2124 uint32_t regionCount, 2125 const VkBufferCopy * pRegions ) const VULKAN_HPP_NOEXCEPT 2126 { 2127 return ::vkCmdCopyBuffer( commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions ); 2128 } 2129 vkCmdCopyImage(VkCommandBuffer commandBuffer,VkImage srcImage,VkImageLayout srcImageLayout,VkImage dstImage,VkImageLayout dstImageLayout,uint32_t regionCount,const VkImageCopy * pRegions) const2130 void vkCmdCopyImage( VkCommandBuffer commandBuffer, 2131 VkImage srcImage, 2132 VkImageLayout srcImageLayout, 2133 VkImage dstImage, 2134 VkImageLayout dstImageLayout, 2135 uint32_t regionCount, 2136 const VkImageCopy * pRegions ) const VULKAN_HPP_NOEXCEPT 2137 { 2138 return ::vkCmdCopyImage( 2139 commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions ); 2140 } 2141 vkCmdBlitImage(VkCommandBuffer commandBuffer,VkImage srcImage,VkImageLayout srcImageLayout,VkImage dstImage,VkImageLayout dstImageLayout,uint32_t regionCount,const VkImageBlit * pRegions,VkFilter filter) const2142 void vkCmdBlitImage( VkCommandBuffer commandBuffer, 2143 VkImage srcImage, 2144 VkImageLayout srcImageLayout, 2145 VkImage dstImage, 2146 VkImageLayout dstImageLayout, 2147 uint32_t regionCount, 2148 const VkImageBlit * pRegions, 2149 VkFilter filter ) const VULKAN_HPP_NOEXCEPT 2150 { 2151 return ::vkCmdBlitImage( 2152 commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter ); 2153 } 2154 vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer,VkBuffer srcBuffer,VkImage dstImage,VkImageLayout dstImageLayout,uint32_t regionCount,const VkBufferImageCopy * pRegions) const2155 void vkCmdCopyBufferToImage( VkCommandBuffer commandBuffer, 2156 VkBuffer srcBuffer, 2157 VkImage dstImage, 2158 VkImageLayout dstImageLayout, 2159 uint32_t regionCount, 2160 const VkBufferImageCopy * pRegions ) const VULKAN_HPP_NOEXCEPT 2161 { 2162 return ::vkCmdCopyBufferToImage( commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions ); 2163 } 2164 vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer,VkImage srcImage,VkImageLayout srcImageLayout,VkBuffer dstBuffer,uint32_t regionCount,const VkBufferImageCopy * pRegions) const2165 void vkCmdCopyImageToBuffer( VkCommandBuffer commandBuffer, 2166 VkImage srcImage, 2167 VkImageLayout srcImageLayout, 2168 VkBuffer dstBuffer, 2169 uint32_t regionCount, 2170 const VkBufferImageCopy * pRegions ) const VULKAN_HPP_NOEXCEPT 2171 { 2172 return ::vkCmdCopyImageToBuffer( commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions ); 2173 } 2174 vkCmdUpdateBuffer(VkCommandBuffer commandBuffer,VkBuffer dstBuffer,VkDeviceSize dstOffset,VkDeviceSize dataSize,const void * pData) const2175 void vkCmdUpdateBuffer( VkCommandBuffer commandBuffer, 2176 VkBuffer dstBuffer, 2177 VkDeviceSize dstOffset, 2178 VkDeviceSize dataSize, 2179 const void * pData ) const VULKAN_HPP_NOEXCEPT 2180 { 2181 return ::vkCmdUpdateBuffer( commandBuffer, dstBuffer, dstOffset, dataSize, pData ); 2182 } 2183 vkCmdFillBuffer(VkCommandBuffer commandBuffer,VkBuffer dstBuffer,VkDeviceSize dstOffset,VkDeviceSize size,uint32_t data) const2184 void vkCmdFillBuffer( VkCommandBuffer commandBuffer, 2185 VkBuffer dstBuffer, 2186 VkDeviceSize dstOffset, 2187 VkDeviceSize size, 2188 uint32_t data ) const VULKAN_HPP_NOEXCEPT 2189 { 2190 return ::vkCmdFillBuffer( commandBuffer, dstBuffer, dstOffset, size, data ); 2191 } 2192 vkCmdClearColorImage(VkCommandBuffer commandBuffer,VkImage image,VkImageLayout imageLayout,const VkClearColorValue * pColor,uint32_t rangeCount,const VkImageSubresourceRange * pRanges) const2193 void vkCmdClearColorImage( VkCommandBuffer commandBuffer, 2194 VkImage image, 2195 VkImageLayout imageLayout, 2196 const VkClearColorValue * pColor, 2197 uint32_t rangeCount, 2198 const VkImageSubresourceRange * pRanges ) const VULKAN_HPP_NOEXCEPT 2199 { 2200 return ::vkCmdClearColorImage( commandBuffer, image, imageLayout, pColor, rangeCount, pRanges ); 2201 } 2202 vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer,VkImage image,VkImageLayout imageLayout,const VkClearDepthStencilValue * pDepthStencil,uint32_t rangeCount,const VkImageSubresourceRange * pRanges) const2203 void vkCmdClearDepthStencilImage( VkCommandBuffer commandBuffer, 2204 VkImage image, 2205 VkImageLayout imageLayout, 2206 const VkClearDepthStencilValue * pDepthStencil, 2207 uint32_t rangeCount, 2208 const VkImageSubresourceRange * pRanges ) const VULKAN_HPP_NOEXCEPT 2209 { 2210 return ::vkCmdClearDepthStencilImage( commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges ); 2211 } 2212 vkCmdClearAttachments(VkCommandBuffer commandBuffer,uint32_t attachmentCount,const VkClearAttachment * pAttachments,uint32_t rectCount,const VkClearRect * pRects) const2213 void vkCmdClearAttachments( VkCommandBuffer commandBuffer, 2214 uint32_t attachmentCount, 2215 const VkClearAttachment * pAttachments, 2216 uint32_t rectCount, 2217 const VkClearRect * pRects ) const VULKAN_HPP_NOEXCEPT 2218 { 2219 return ::vkCmdClearAttachments( commandBuffer, attachmentCount, pAttachments, rectCount, pRects ); 2220 } 2221 vkCmdResolveImage(VkCommandBuffer commandBuffer,VkImage srcImage,VkImageLayout srcImageLayout,VkImage dstImage,VkImageLayout dstImageLayout,uint32_t regionCount,const VkImageResolve * pRegions) const2222 void vkCmdResolveImage( VkCommandBuffer commandBuffer, 2223 VkImage srcImage, 2224 VkImageLayout srcImageLayout, 2225 VkImage dstImage, 2226 VkImageLayout dstImageLayout, 2227 uint32_t regionCount, 2228 const VkImageResolve * pRegions ) const VULKAN_HPP_NOEXCEPT 2229 { 2230 return ::vkCmdResolveImage( 2231 commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions ); 2232 } 2233 vkCmdSetEvent(VkCommandBuffer commandBuffer,VkEvent event,VkPipelineStageFlags stageMask) const2234 void vkCmdSetEvent( VkCommandBuffer commandBuffer, 2235 VkEvent event, 2236 VkPipelineStageFlags stageMask ) const VULKAN_HPP_NOEXCEPT 2237 { 2238 return ::vkCmdSetEvent( commandBuffer, event, stageMask ); 2239 } 2240 vkCmdResetEvent(VkCommandBuffer commandBuffer,VkEvent event,VkPipelineStageFlags stageMask) const2241 void vkCmdResetEvent( VkCommandBuffer commandBuffer, 2242 VkEvent event, 2243 VkPipelineStageFlags stageMask ) const VULKAN_HPP_NOEXCEPT 2244 { 2245 return ::vkCmdResetEvent( commandBuffer, event, stageMask ); 2246 } 2247 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) const2248 void vkCmdWaitEvents( VkCommandBuffer commandBuffer, 2249 uint32_t eventCount, 2250 const VkEvent * pEvents, 2251 VkPipelineStageFlags srcStageMask, 2252 VkPipelineStageFlags dstStageMask, 2253 uint32_t memoryBarrierCount, 2254 const VkMemoryBarrier * pMemoryBarriers, 2255 uint32_t bufferMemoryBarrierCount, 2256 const VkBufferMemoryBarrier * pBufferMemoryBarriers, 2257 uint32_t imageMemoryBarrierCount, 2258 const VkImageMemoryBarrier * pImageMemoryBarriers ) const VULKAN_HPP_NOEXCEPT 2259 { 2260 return ::vkCmdWaitEvents( commandBuffer, 2261 eventCount, 2262 pEvents, 2263 srcStageMask, 2264 dstStageMask, 2265 memoryBarrierCount, 2266 pMemoryBarriers, 2267 bufferMemoryBarrierCount, 2268 pBufferMemoryBarriers, 2269 imageMemoryBarrierCount, 2270 pImageMemoryBarriers ); 2271 } 2272 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) const2273 void vkCmdPipelineBarrier( VkCommandBuffer commandBuffer, 2274 VkPipelineStageFlags srcStageMask, 2275 VkPipelineStageFlags dstStageMask, 2276 VkDependencyFlags dependencyFlags, 2277 uint32_t memoryBarrierCount, 2278 const VkMemoryBarrier * pMemoryBarriers, 2279 uint32_t bufferMemoryBarrierCount, 2280 const VkBufferMemoryBarrier * pBufferMemoryBarriers, 2281 uint32_t imageMemoryBarrierCount, 2282 const VkImageMemoryBarrier * pImageMemoryBarriers ) const VULKAN_HPP_NOEXCEPT 2283 { 2284 return ::vkCmdPipelineBarrier( commandBuffer, 2285 srcStageMask, 2286 dstStageMask, 2287 dependencyFlags, 2288 memoryBarrierCount, 2289 pMemoryBarriers, 2290 bufferMemoryBarrierCount, 2291 pBufferMemoryBarriers, 2292 imageMemoryBarrierCount, 2293 pImageMemoryBarriers ); 2294 } 2295 vkCmdBeginQuery(VkCommandBuffer commandBuffer,VkQueryPool queryPool,uint32_t query,VkQueryControlFlags flags) const2296 void vkCmdBeginQuery( VkCommandBuffer commandBuffer, 2297 VkQueryPool queryPool, 2298 uint32_t query, 2299 VkQueryControlFlags flags ) const VULKAN_HPP_NOEXCEPT 2300 { 2301 return ::vkCmdBeginQuery( commandBuffer, queryPool, query, flags ); 2302 } 2303 vkCmdEndQuery(VkCommandBuffer commandBuffer,VkQueryPool queryPool,uint32_t query) const2304 void vkCmdEndQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT 2305 { 2306 return ::vkCmdEndQuery( commandBuffer, queryPool, query ); 2307 } 2308 vkCmdResetQueryPool(VkCommandBuffer commandBuffer,VkQueryPool queryPool,uint32_t firstQuery,uint32_t queryCount) const2309 void vkCmdResetQueryPool( VkCommandBuffer commandBuffer, 2310 VkQueryPool queryPool, 2311 uint32_t firstQuery, 2312 uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT 2313 { 2314 return ::vkCmdResetQueryPool( commandBuffer, queryPool, firstQuery, queryCount ); 2315 } 2316 vkCmdWriteTimestamp(VkCommandBuffer commandBuffer,VkPipelineStageFlagBits pipelineStage,VkQueryPool queryPool,uint32_t query) const2317 void vkCmdWriteTimestamp( VkCommandBuffer commandBuffer, 2318 VkPipelineStageFlagBits pipelineStage, 2319 VkQueryPool queryPool, 2320 uint32_t query ) const VULKAN_HPP_NOEXCEPT 2321 { 2322 return ::vkCmdWriteTimestamp( commandBuffer, pipelineStage, queryPool, query ); 2323 } 2324 vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer,VkQueryPool queryPool,uint32_t firstQuery,uint32_t queryCount,VkBuffer dstBuffer,VkDeviceSize dstOffset,VkDeviceSize stride,VkQueryResultFlags flags) const2325 void vkCmdCopyQueryPoolResults( VkCommandBuffer commandBuffer, 2326 VkQueryPool queryPool, 2327 uint32_t firstQuery, 2328 uint32_t queryCount, 2329 VkBuffer dstBuffer, 2330 VkDeviceSize dstOffset, 2331 VkDeviceSize stride, 2332 VkQueryResultFlags flags ) const VULKAN_HPP_NOEXCEPT 2333 { 2334 return ::vkCmdCopyQueryPoolResults( 2335 commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags ); 2336 } 2337 vkCmdPushConstants(VkCommandBuffer commandBuffer,VkPipelineLayout layout,VkShaderStageFlags stageFlags,uint32_t offset,uint32_t size,const void * pValues) const2338 void vkCmdPushConstants( VkCommandBuffer commandBuffer, 2339 VkPipelineLayout layout, 2340 VkShaderStageFlags stageFlags, 2341 uint32_t offset, 2342 uint32_t size, 2343 const void * pValues ) const VULKAN_HPP_NOEXCEPT 2344 { 2345 return ::vkCmdPushConstants( commandBuffer, layout, stageFlags, offset, size, pValues ); 2346 } 2347 vkCmdBeginRenderPass(VkCommandBuffer commandBuffer,const VkRenderPassBeginInfo * pRenderPassBegin,VkSubpassContents contents) const2348 void vkCmdBeginRenderPass( VkCommandBuffer commandBuffer, 2349 const VkRenderPassBeginInfo * pRenderPassBegin, 2350 VkSubpassContents contents ) const VULKAN_HPP_NOEXCEPT 2351 { 2352 return ::vkCmdBeginRenderPass( commandBuffer, pRenderPassBegin, contents ); 2353 } 2354 vkCmdNextSubpass(VkCommandBuffer commandBuffer,VkSubpassContents contents) const2355 void vkCmdNextSubpass( VkCommandBuffer commandBuffer, VkSubpassContents contents ) const VULKAN_HPP_NOEXCEPT 2356 { 2357 return ::vkCmdNextSubpass( commandBuffer, contents ); 2358 } 2359 vkCmdEndRenderPass(VkCommandBuffer commandBuffer) const2360 void vkCmdEndRenderPass( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT 2361 { 2362 return ::vkCmdEndRenderPass( commandBuffer ); 2363 } 2364 vkCmdExecuteCommands(VkCommandBuffer commandBuffer,uint32_t commandBufferCount,const VkCommandBuffer * pCommandBuffers) const2365 void vkCmdExecuteCommands( VkCommandBuffer commandBuffer, 2366 uint32_t commandBufferCount, 2367 const VkCommandBuffer * pCommandBuffers ) const VULKAN_HPP_NOEXCEPT 2368 { 2369 return ::vkCmdExecuteCommands( commandBuffer, commandBufferCount, pCommandBuffers ); 2370 } 2371 2372 //=== VK_VERSION_1_1 === 2373 vkEnumerateInstanceVersion(uint32_t * pApiVersion) const2374 VkResult vkEnumerateInstanceVersion( uint32_t * pApiVersion ) const VULKAN_HPP_NOEXCEPT 2375 { 2376 return ::vkEnumerateInstanceVersion( pApiVersion ); 2377 } 2378 vkBindBufferMemory2(VkDevice device,uint32_t bindInfoCount,const VkBindBufferMemoryInfo * pBindInfos) const2379 VkResult vkBindBufferMemory2( VkDevice device, 2380 uint32_t bindInfoCount, 2381 const VkBindBufferMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT 2382 { 2383 return ::vkBindBufferMemory2( device, bindInfoCount, pBindInfos ); 2384 } 2385 vkBindImageMemory2(VkDevice device,uint32_t bindInfoCount,const VkBindImageMemoryInfo * pBindInfos) const2386 VkResult vkBindImageMemory2( VkDevice device, 2387 uint32_t bindInfoCount, 2388 const VkBindImageMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT 2389 { 2390 return ::vkBindImageMemory2( device, bindInfoCount, pBindInfos ); 2391 } 2392 vkGetDeviceGroupPeerMemoryFeatures(VkDevice device,uint32_t heapIndex,uint32_t localDeviceIndex,uint32_t remoteDeviceIndex,VkPeerMemoryFeatureFlags * pPeerMemoryFeatures) const2393 void vkGetDeviceGroupPeerMemoryFeatures( VkDevice device, 2394 uint32_t heapIndex, 2395 uint32_t localDeviceIndex, 2396 uint32_t remoteDeviceIndex, 2397 VkPeerMemoryFeatureFlags * pPeerMemoryFeatures ) const VULKAN_HPP_NOEXCEPT 2398 { 2399 return ::vkGetDeviceGroupPeerMemoryFeatures( 2400 device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures ); 2401 } 2402 vkCmdSetDeviceMask(VkCommandBuffer commandBuffer,uint32_t deviceMask) const2403 void vkCmdSetDeviceMask( VkCommandBuffer commandBuffer, uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT 2404 { 2405 return ::vkCmdSetDeviceMask( commandBuffer, deviceMask ); 2406 } 2407 vkCmdDispatchBase(VkCommandBuffer commandBuffer,uint32_t baseGroupX,uint32_t baseGroupY,uint32_t baseGroupZ,uint32_t groupCountX,uint32_t groupCountY,uint32_t groupCountZ) const2408 void vkCmdDispatchBase( VkCommandBuffer commandBuffer, 2409 uint32_t baseGroupX, 2410 uint32_t baseGroupY, 2411 uint32_t baseGroupZ, 2412 uint32_t groupCountX, 2413 uint32_t groupCountY, 2414 uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT 2415 { 2416 return ::vkCmdDispatchBase( 2417 commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ ); 2418 } 2419 vkEnumeratePhysicalDeviceGroups(VkInstance instance,uint32_t * pPhysicalDeviceGroupCount,VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties) const2420 VkResult vkEnumeratePhysicalDeviceGroups( VkInstance instance, 2421 uint32_t * pPhysicalDeviceGroupCount, 2422 VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties ) const 2423 VULKAN_HPP_NOEXCEPT 2424 { 2425 return ::vkEnumeratePhysicalDeviceGroups( instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties ); 2426 } 2427 vkGetImageMemoryRequirements2(VkDevice device,const VkImageMemoryRequirementsInfo2 * pInfo,VkMemoryRequirements2 * pMemoryRequirements) const2428 void vkGetImageMemoryRequirements2( VkDevice device, 2429 const VkImageMemoryRequirementsInfo2 * pInfo, 2430 VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT 2431 { 2432 return ::vkGetImageMemoryRequirements2( device, pInfo, pMemoryRequirements ); 2433 } 2434 vkGetBufferMemoryRequirements2(VkDevice device,const VkBufferMemoryRequirementsInfo2 * pInfo,VkMemoryRequirements2 * pMemoryRequirements) const2435 void vkGetBufferMemoryRequirements2( VkDevice device, 2436 const VkBufferMemoryRequirementsInfo2 * pInfo, 2437 VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT 2438 { 2439 return ::vkGetBufferMemoryRequirements2( device, pInfo, pMemoryRequirements ); 2440 } 2441 vkGetImageSparseMemoryRequirements2(VkDevice device,const VkImageSparseMemoryRequirementsInfo2 * pInfo,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements) const2442 void vkGetImageSparseMemoryRequirements2( VkDevice device, 2443 const VkImageSparseMemoryRequirementsInfo2 * pInfo, 2444 uint32_t * pSparseMemoryRequirementCount, 2445 VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements ) const 2446 VULKAN_HPP_NOEXCEPT 2447 { 2448 return ::vkGetImageSparseMemoryRequirements2( 2449 device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements ); 2450 } 2451 vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures2 * pFeatures) const2452 void vkGetPhysicalDeviceFeatures2( VkPhysicalDevice physicalDevice, 2453 VkPhysicalDeviceFeatures2 * pFeatures ) const VULKAN_HPP_NOEXCEPT 2454 { 2455 return ::vkGetPhysicalDeviceFeatures2( physicalDevice, pFeatures ); 2456 } 2457 vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties2 * pProperties) const2458 void vkGetPhysicalDeviceProperties2( VkPhysicalDevice physicalDevice, 2459 VkPhysicalDeviceProperties2 * pProperties ) const VULKAN_HPP_NOEXCEPT 2460 { 2461 return ::vkGetPhysicalDeviceProperties2( physicalDevice, pProperties ); 2462 } 2463 vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties2 * pFormatProperties) const2464 void vkGetPhysicalDeviceFormatProperties2( VkPhysicalDevice physicalDevice, 2465 VkFormat format, 2466 VkFormatProperties2 * pFormatProperties ) const VULKAN_HPP_NOEXCEPT 2467 { 2468 return ::vkGetPhysicalDeviceFormatProperties2( physicalDevice, format, pFormatProperties ); 2469 } 2470 vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,VkImageFormatProperties2 * pImageFormatProperties) const2471 VkResult vkGetPhysicalDeviceImageFormatProperties2( VkPhysicalDevice physicalDevice, 2472 const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo, 2473 VkImageFormatProperties2 * pImageFormatProperties ) const 2474 VULKAN_HPP_NOEXCEPT 2475 { 2476 return ::vkGetPhysicalDeviceImageFormatProperties2( physicalDevice, pImageFormatInfo, pImageFormatProperties ); 2477 } 2478 vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties2 * pQueueFamilyProperties) const2479 void vkGetPhysicalDeviceQueueFamilyProperties2( VkPhysicalDevice physicalDevice, 2480 uint32_t * pQueueFamilyPropertyCount, 2481 VkQueueFamilyProperties2 * pQueueFamilyProperties ) const 2482 VULKAN_HPP_NOEXCEPT 2483 { 2484 return ::vkGetPhysicalDeviceQueueFamilyProperties2( 2485 physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties ); 2486 } 2487 vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties2 * pMemoryProperties) const2488 void vkGetPhysicalDeviceMemoryProperties2( 2489 VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 * pMemoryProperties ) const VULKAN_HPP_NOEXCEPT 2490 { 2491 return ::vkGetPhysicalDeviceMemoryProperties2( physicalDevice, pMemoryProperties ); 2492 } 2493 vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,uint32_t * pPropertyCount,VkSparseImageFormatProperties2 * pProperties) const2494 void vkGetPhysicalDeviceSparseImageFormatProperties2( VkPhysicalDevice physicalDevice, 2495 const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo, 2496 uint32_t * pPropertyCount, 2497 VkSparseImageFormatProperties2 * pProperties ) const 2498 VULKAN_HPP_NOEXCEPT 2499 { 2500 return ::vkGetPhysicalDeviceSparseImageFormatProperties2( 2501 physicalDevice, pFormatInfo, pPropertyCount, pProperties ); 2502 } 2503 vkTrimCommandPool(VkDevice device,VkCommandPool commandPool,VkCommandPoolTrimFlags flags) const2504 void vkTrimCommandPool( VkDevice device, 2505 VkCommandPool commandPool, 2506 VkCommandPoolTrimFlags flags ) const VULKAN_HPP_NOEXCEPT 2507 { 2508 return ::vkTrimCommandPool( device, commandPool, flags ); 2509 } 2510 vkGetDeviceQueue2(VkDevice device,const VkDeviceQueueInfo2 * pQueueInfo,VkQueue * pQueue) const2511 void vkGetDeviceQueue2( VkDevice device, 2512 const VkDeviceQueueInfo2 * pQueueInfo, 2513 VkQueue * pQueue ) const VULKAN_HPP_NOEXCEPT 2514 { 2515 return ::vkGetDeviceQueue2( device, pQueueInfo, pQueue ); 2516 } 2517 vkCreateSamplerYcbcrConversion(VkDevice device,const VkSamplerYcbcrConversionCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSamplerYcbcrConversion * pYcbcrConversion) const2518 VkResult vkCreateSamplerYcbcrConversion( VkDevice device, 2519 const VkSamplerYcbcrConversionCreateInfo * pCreateInfo, 2520 const VkAllocationCallbacks * pAllocator, 2521 VkSamplerYcbcrConversion * pYcbcrConversion ) const VULKAN_HPP_NOEXCEPT 2522 { 2523 return ::vkCreateSamplerYcbcrConversion( device, pCreateInfo, pAllocator, pYcbcrConversion ); 2524 } 2525 vkDestroySamplerYcbcrConversion(VkDevice device,VkSamplerYcbcrConversion ycbcrConversion,const VkAllocationCallbacks * pAllocator) const2526 void vkDestroySamplerYcbcrConversion( VkDevice device, 2527 VkSamplerYcbcrConversion ycbcrConversion, 2528 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT 2529 { 2530 return ::vkDestroySamplerYcbcrConversion( device, ycbcrConversion, pAllocator ); 2531 } 2532 vkCreateDescriptorUpdateTemplate(VkDevice device,const VkDescriptorUpdateTemplateCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDescriptorUpdateTemplate * pDescriptorUpdateTemplate) const2533 VkResult vkCreateDescriptorUpdateTemplate( VkDevice device, 2534 const VkDescriptorUpdateTemplateCreateInfo * pCreateInfo, 2535 const VkAllocationCallbacks * pAllocator, 2536 VkDescriptorUpdateTemplate * pDescriptorUpdateTemplate ) const 2537 VULKAN_HPP_NOEXCEPT 2538 { 2539 return ::vkCreateDescriptorUpdateTemplate( device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate ); 2540 } 2541 vkDestroyDescriptorUpdateTemplate(VkDevice device,VkDescriptorUpdateTemplate descriptorUpdateTemplate,const VkAllocationCallbacks * pAllocator) const2542 void vkDestroyDescriptorUpdateTemplate( VkDevice device, 2543 VkDescriptorUpdateTemplate descriptorUpdateTemplate, 2544 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT 2545 { 2546 return ::vkDestroyDescriptorUpdateTemplate( device, descriptorUpdateTemplate, pAllocator ); 2547 } 2548 vkUpdateDescriptorSetWithTemplate(VkDevice device,VkDescriptorSet descriptorSet,VkDescriptorUpdateTemplate descriptorUpdateTemplate,const void * pData) const2549 void vkUpdateDescriptorSetWithTemplate( VkDevice device, 2550 VkDescriptorSet descriptorSet, 2551 VkDescriptorUpdateTemplate descriptorUpdateTemplate, 2552 const void * pData ) const VULKAN_HPP_NOEXCEPT 2553 { 2554 return ::vkUpdateDescriptorSetWithTemplate( device, descriptorSet, descriptorUpdateTemplate, pData ); 2555 } 2556 vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,VkExternalBufferProperties * pExternalBufferProperties) const2557 void vkGetPhysicalDeviceExternalBufferProperties( VkPhysicalDevice physicalDevice, 2558 const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo, 2559 VkExternalBufferProperties * pExternalBufferProperties ) const 2560 VULKAN_HPP_NOEXCEPT 2561 { 2562 return ::vkGetPhysicalDeviceExternalBufferProperties( 2563 physicalDevice, pExternalBufferInfo, pExternalBufferProperties ); 2564 } 2565 vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,VkExternalFenceProperties * pExternalFenceProperties) const2566 void vkGetPhysicalDeviceExternalFenceProperties( VkPhysicalDevice physicalDevice, 2567 const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo, 2568 VkExternalFenceProperties * pExternalFenceProperties ) const 2569 VULKAN_HPP_NOEXCEPT 2570 { 2571 return ::vkGetPhysicalDeviceExternalFenceProperties( 2572 physicalDevice, pExternalFenceInfo, pExternalFenceProperties ); 2573 } 2574 vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,VkExternalSemaphoreProperties * pExternalSemaphoreProperties) const2575 void vkGetPhysicalDeviceExternalSemaphoreProperties( 2576 VkPhysicalDevice physicalDevice, 2577 const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo, 2578 VkExternalSemaphoreProperties * pExternalSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT 2579 { 2580 return ::vkGetPhysicalDeviceExternalSemaphoreProperties( 2581 physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties ); 2582 } 2583 vkGetDescriptorSetLayoutSupport(VkDevice device,const VkDescriptorSetLayoutCreateInfo * pCreateInfo,VkDescriptorSetLayoutSupport * pSupport) const2584 void vkGetDescriptorSetLayoutSupport( VkDevice device, 2585 const VkDescriptorSetLayoutCreateInfo * pCreateInfo, 2586 VkDescriptorSetLayoutSupport * pSupport ) const VULKAN_HPP_NOEXCEPT 2587 { 2588 return ::vkGetDescriptorSetLayoutSupport( device, pCreateInfo, pSupport ); 2589 } 2590 2591 //=== VK_VERSION_1_2 === 2592 vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer,VkBuffer buffer,VkDeviceSize offset,VkBuffer countBuffer,VkDeviceSize countBufferOffset,uint32_t maxDrawCount,uint32_t stride) const2593 void vkCmdDrawIndirectCount( VkCommandBuffer commandBuffer, 2594 VkBuffer buffer, 2595 VkDeviceSize offset, 2596 VkBuffer countBuffer, 2597 VkDeviceSize countBufferOffset, 2598 uint32_t maxDrawCount, 2599 uint32_t stride ) const VULKAN_HPP_NOEXCEPT 2600 { 2601 return ::vkCmdDrawIndirectCount( 2602 commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride ); 2603 } 2604 vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer,VkBuffer buffer,VkDeviceSize offset,VkBuffer countBuffer,VkDeviceSize countBufferOffset,uint32_t maxDrawCount,uint32_t stride) const2605 void vkCmdDrawIndexedIndirectCount( VkCommandBuffer commandBuffer, 2606 VkBuffer buffer, 2607 VkDeviceSize offset, 2608 VkBuffer countBuffer, 2609 VkDeviceSize countBufferOffset, 2610 uint32_t maxDrawCount, 2611 uint32_t stride ) const VULKAN_HPP_NOEXCEPT 2612 { 2613 return ::vkCmdDrawIndexedIndirectCount( 2614 commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride ); 2615 } 2616 vkCreateRenderPass2(VkDevice device,const VkRenderPassCreateInfo2 * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkRenderPass * pRenderPass) const2617 VkResult vkCreateRenderPass2( VkDevice device, 2618 const VkRenderPassCreateInfo2 * pCreateInfo, 2619 const VkAllocationCallbacks * pAllocator, 2620 VkRenderPass * pRenderPass ) const VULKAN_HPP_NOEXCEPT 2621 { 2622 return ::vkCreateRenderPass2( device, pCreateInfo, pAllocator, pRenderPass ); 2623 } 2624 vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer,const VkRenderPassBeginInfo * pRenderPassBegin,const VkSubpassBeginInfo * pSubpassBeginInfo) const2625 void vkCmdBeginRenderPass2( VkCommandBuffer commandBuffer, 2626 const VkRenderPassBeginInfo * pRenderPassBegin, 2627 const VkSubpassBeginInfo * pSubpassBeginInfo ) const VULKAN_HPP_NOEXCEPT 2628 { 2629 return ::vkCmdBeginRenderPass2( commandBuffer, pRenderPassBegin, pSubpassBeginInfo ); 2630 } 2631 vkCmdNextSubpass2(VkCommandBuffer commandBuffer,const VkSubpassBeginInfo * pSubpassBeginInfo,const VkSubpassEndInfo * pSubpassEndInfo) const2632 void vkCmdNextSubpass2( VkCommandBuffer commandBuffer, 2633 const VkSubpassBeginInfo * pSubpassBeginInfo, 2634 const VkSubpassEndInfo * pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT 2635 { 2636 return ::vkCmdNextSubpass2( commandBuffer, pSubpassBeginInfo, pSubpassEndInfo ); 2637 } 2638 vkCmdEndRenderPass2(VkCommandBuffer commandBuffer,const VkSubpassEndInfo * pSubpassEndInfo) const2639 void vkCmdEndRenderPass2( VkCommandBuffer commandBuffer, 2640 const VkSubpassEndInfo * pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT 2641 { 2642 return ::vkCmdEndRenderPass2( commandBuffer, pSubpassEndInfo ); 2643 } 2644 vkResetQueryPool(VkDevice device,VkQueryPool queryPool,uint32_t firstQuery,uint32_t queryCount) const2645 void vkResetQueryPool( VkDevice device, 2646 VkQueryPool queryPool, 2647 uint32_t firstQuery, 2648 uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT 2649 { 2650 return ::vkResetQueryPool( device, queryPool, firstQuery, queryCount ); 2651 } 2652 2653 VkResult vkGetSemaphoreCounterValue(VkDevice device,VkSemaphore semaphore,uint64_t * pValue) const2654 vkGetSemaphoreCounterValue( VkDevice device, VkSemaphore semaphore, uint64_t * pValue ) const VULKAN_HPP_NOEXCEPT 2655 { 2656 return ::vkGetSemaphoreCounterValue( device, semaphore, pValue ); 2657 } 2658 vkWaitSemaphores(VkDevice device,const VkSemaphoreWaitInfo * pWaitInfo,uint64_t timeout) const2659 VkResult vkWaitSemaphores( VkDevice device, 2660 const VkSemaphoreWaitInfo * pWaitInfo, 2661 uint64_t timeout ) const VULKAN_HPP_NOEXCEPT 2662 { 2663 return ::vkWaitSemaphores( device, pWaitInfo, timeout ); 2664 } 2665 vkSignalSemaphore(VkDevice device,const VkSemaphoreSignalInfo * pSignalInfo) const2666 VkResult vkSignalSemaphore( VkDevice device, const VkSemaphoreSignalInfo * pSignalInfo ) const VULKAN_HPP_NOEXCEPT 2667 { 2668 return ::vkSignalSemaphore( device, pSignalInfo ); 2669 } 2670 vkGetBufferDeviceAddress(VkDevice device,const VkBufferDeviceAddressInfo * pInfo) const2671 VkDeviceAddress vkGetBufferDeviceAddress( VkDevice device, 2672 const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT 2673 { 2674 return ::vkGetBufferDeviceAddress( device, pInfo ); 2675 } 2676 vkGetBufferOpaqueCaptureAddress(VkDevice device,const VkBufferDeviceAddressInfo * pInfo) const2677 uint64_t vkGetBufferOpaqueCaptureAddress( VkDevice device, 2678 const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT 2679 { 2680 return ::vkGetBufferOpaqueCaptureAddress( device, pInfo ); 2681 } 2682 vkGetDeviceMemoryOpaqueCaptureAddress(VkDevice device,const VkDeviceMemoryOpaqueCaptureAddressInfo * pInfo) const2683 uint64_t vkGetDeviceMemoryOpaqueCaptureAddress( 2684 VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT 2685 { 2686 return ::vkGetDeviceMemoryOpaqueCaptureAddress( device, pInfo ); 2687 } 2688 2689 //=== VK_KHR_surface === 2690 vkDestroySurfaceKHR(VkInstance instance,VkSurfaceKHR surface,const VkAllocationCallbacks * pAllocator) const2691 void vkDestroySurfaceKHR( VkInstance instance, 2692 VkSurfaceKHR surface, 2693 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT 2694 { 2695 return ::vkDestroySurfaceKHR( instance, surface, pAllocator ); 2696 } 2697 vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice,uint32_t queueFamilyIndex,VkSurfaceKHR surface,VkBool32 * pSupported) const2698 VkResult vkGetPhysicalDeviceSurfaceSupportKHR( VkPhysicalDevice physicalDevice, 2699 uint32_t queueFamilyIndex, 2700 VkSurfaceKHR surface, 2701 VkBool32 * pSupported ) const VULKAN_HPP_NOEXCEPT 2702 { 2703 return ::vkGetPhysicalDeviceSurfaceSupportKHR( physicalDevice, queueFamilyIndex, surface, pSupported ); 2704 } 2705 vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice,VkSurfaceKHR surface,VkSurfaceCapabilitiesKHR * pSurfaceCapabilities) const2706 VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR( VkPhysicalDevice physicalDevice, 2707 VkSurfaceKHR surface, 2708 VkSurfaceCapabilitiesKHR * pSurfaceCapabilities ) const 2709 VULKAN_HPP_NOEXCEPT 2710 { 2711 return ::vkGetPhysicalDeviceSurfaceCapabilitiesKHR( physicalDevice, surface, pSurfaceCapabilities ); 2712 } 2713 vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice,VkSurfaceKHR surface,uint32_t * pSurfaceFormatCount,VkSurfaceFormatKHR * pSurfaceFormats) const2714 VkResult vkGetPhysicalDeviceSurfaceFormatsKHR( VkPhysicalDevice physicalDevice, 2715 VkSurfaceKHR surface, 2716 uint32_t * pSurfaceFormatCount, 2717 VkSurfaceFormatKHR * pSurfaceFormats ) const VULKAN_HPP_NOEXCEPT 2718 { 2719 return ::vkGetPhysicalDeviceSurfaceFormatsKHR( physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats ); 2720 } 2721 vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice,VkSurfaceKHR surface,uint32_t * pPresentModeCount,VkPresentModeKHR * pPresentModes) const2722 VkResult vkGetPhysicalDeviceSurfacePresentModesKHR( VkPhysicalDevice physicalDevice, 2723 VkSurfaceKHR surface, 2724 uint32_t * pPresentModeCount, 2725 VkPresentModeKHR * pPresentModes ) const VULKAN_HPP_NOEXCEPT 2726 { 2727 return ::vkGetPhysicalDeviceSurfacePresentModesKHR( physicalDevice, surface, pPresentModeCount, pPresentModes ); 2728 } 2729 2730 //=== VK_KHR_swapchain === 2731 vkCreateSwapchainKHR(VkDevice device,const VkSwapchainCreateInfoKHR * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSwapchainKHR * pSwapchain) const2732 VkResult vkCreateSwapchainKHR( VkDevice device, 2733 const VkSwapchainCreateInfoKHR * pCreateInfo, 2734 const VkAllocationCallbacks * pAllocator, 2735 VkSwapchainKHR * pSwapchain ) const VULKAN_HPP_NOEXCEPT 2736 { 2737 return ::vkCreateSwapchainKHR( device, pCreateInfo, pAllocator, pSwapchain ); 2738 } 2739 vkDestroySwapchainKHR(VkDevice device,VkSwapchainKHR swapchain,const VkAllocationCallbacks * pAllocator) const2740 void vkDestroySwapchainKHR( VkDevice device, 2741 VkSwapchainKHR swapchain, 2742 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT 2743 { 2744 return ::vkDestroySwapchainKHR( device, swapchain, pAllocator ); 2745 } 2746 vkGetSwapchainImagesKHR(VkDevice device,VkSwapchainKHR swapchain,uint32_t * pSwapchainImageCount,VkImage * pSwapchainImages) const2747 VkResult vkGetSwapchainImagesKHR( VkDevice device, 2748 VkSwapchainKHR swapchain, 2749 uint32_t * pSwapchainImageCount, 2750 VkImage * pSwapchainImages ) const VULKAN_HPP_NOEXCEPT 2751 { 2752 return ::vkGetSwapchainImagesKHR( device, swapchain, pSwapchainImageCount, pSwapchainImages ); 2753 } 2754 vkAcquireNextImageKHR(VkDevice device,VkSwapchainKHR swapchain,uint64_t timeout,VkSemaphore semaphore,VkFence fence,uint32_t * pImageIndex) const2755 VkResult vkAcquireNextImageKHR( VkDevice device, 2756 VkSwapchainKHR swapchain, 2757 uint64_t timeout, 2758 VkSemaphore semaphore, 2759 VkFence fence, 2760 uint32_t * pImageIndex ) const VULKAN_HPP_NOEXCEPT 2761 { 2762 return ::vkAcquireNextImageKHR( device, swapchain, timeout, semaphore, fence, pImageIndex ); 2763 } 2764 vkQueuePresentKHR(VkQueue queue,const VkPresentInfoKHR * pPresentInfo) const2765 VkResult vkQueuePresentKHR( VkQueue queue, const VkPresentInfoKHR * pPresentInfo ) const VULKAN_HPP_NOEXCEPT 2766 { 2767 return ::vkQueuePresentKHR( queue, pPresentInfo ); 2768 } 2769 vkGetDeviceGroupPresentCapabilitiesKHR(VkDevice device,VkDeviceGroupPresentCapabilitiesKHR * pDeviceGroupPresentCapabilities) const2770 VkResult vkGetDeviceGroupPresentCapabilitiesKHR( 2771 VkDevice device, VkDeviceGroupPresentCapabilitiesKHR * pDeviceGroupPresentCapabilities ) const VULKAN_HPP_NOEXCEPT 2772 { 2773 return ::vkGetDeviceGroupPresentCapabilitiesKHR( device, pDeviceGroupPresentCapabilities ); 2774 } 2775 vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device,VkSurfaceKHR surface,VkDeviceGroupPresentModeFlagsKHR * pModes) const2776 VkResult vkGetDeviceGroupSurfacePresentModesKHR( 2777 VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR * pModes ) const VULKAN_HPP_NOEXCEPT 2778 { 2779 return ::vkGetDeviceGroupSurfacePresentModesKHR( device, surface, pModes ); 2780 } 2781 vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice,VkSurfaceKHR surface,uint32_t * pRectCount,VkRect2D * pRects) const2782 VkResult vkGetPhysicalDevicePresentRectanglesKHR( VkPhysicalDevice physicalDevice, 2783 VkSurfaceKHR surface, 2784 uint32_t * pRectCount, 2785 VkRect2D * pRects ) const VULKAN_HPP_NOEXCEPT 2786 { 2787 return ::vkGetPhysicalDevicePresentRectanglesKHR( physicalDevice, surface, pRectCount, pRects ); 2788 } 2789 vkAcquireNextImage2KHR(VkDevice device,const VkAcquireNextImageInfoKHR * pAcquireInfo,uint32_t * pImageIndex) const2790 VkResult vkAcquireNextImage2KHR( VkDevice device, 2791 const VkAcquireNextImageInfoKHR * pAcquireInfo, 2792 uint32_t * pImageIndex ) const VULKAN_HPP_NOEXCEPT 2793 { 2794 return ::vkAcquireNextImage2KHR( device, pAcquireInfo, pImageIndex ); 2795 } 2796 2797 //=== VK_KHR_display === 2798 vkGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkDisplayPropertiesKHR * pProperties) const2799 VkResult vkGetPhysicalDeviceDisplayPropertiesKHR( VkPhysicalDevice physicalDevice, 2800 uint32_t * pPropertyCount, 2801 VkDisplayPropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT 2802 { 2803 return ::vkGetPhysicalDeviceDisplayPropertiesKHR( physicalDevice, pPropertyCount, pProperties ); 2804 } 2805 vkGetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkDisplayPlanePropertiesKHR * pProperties) const2806 VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR( VkPhysicalDevice physicalDevice, 2807 uint32_t * pPropertyCount, 2808 VkDisplayPlanePropertiesKHR * pProperties ) const 2809 VULKAN_HPP_NOEXCEPT 2810 { 2811 return ::vkGetPhysicalDeviceDisplayPlanePropertiesKHR( physicalDevice, pPropertyCount, pProperties ); 2812 } 2813 vkGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice,uint32_t planeIndex,uint32_t * pDisplayCount,VkDisplayKHR * pDisplays) const2814 VkResult vkGetDisplayPlaneSupportedDisplaysKHR( VkPhysicalDevice physicalDevice, 2815 uint32_t planeIndex, 2816 uint32_t * pDisplayCount, 2817 VkDisplayKHR * pDisplays ) const VULKAN_HPP_NOEXCEPT 2818 { 2819 return ::vkGetDisplayPlaneSupportedDisplaysKHR( physicalDevice, planeIndex, pDisplayCount, pDisplays ); 2820 } 2821 vkGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice,VkDisplayKHR display,uint32_t * pPropertyCount,VkDisplayModePropertiesKHR * pProperties) const2822 VkResult vkGetDisplayModePropertiesKHR( VkPhysicalDevice physicalDevice, 2823 VkDisplayKHR display, 2824 uint32_t * pPropertyCount, 2825 VkDisplayModePropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT 2826 { 2827 return ::vkGetDisplayModePropertiesKHR( physicalDevice, display, pPropertyCount, pProperties ); 2828 } 2829 vkCreateDisplayModeKHR(VkPhysicalDevice physicalDevice,VkDisplayKHR display,const VkDisplayModeCreateInfoKHR * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDisplayModeKHR * pMode) const2830 VkResult vkCreateDisplayModeKHR( VkPhysicalDevice physicalDevice, 2831 VkDisplayKHR display, 2832 const VkDisplayModeCreateInfoKHR * pCreateInfo, 2833 const VkAllocationCallbacks * pAllocator, 2834 VkDisplayModeKHR * pMode ) const VULKAN_HPP_NOEXCEPT 2835 { 2836 return ::vkCreateDisplayModeKHR( physicalDevice, display, pCreateInfo, pAllocator, pMode ); 2837 } 2838 vkGetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice,VkDisplayModeKHR mode,uint32_t planeIndex,VkDisplayPlaneCapabilitiesKHR * pCapabilities) const2839 VkResult vkGetDisplayPlaneCapabilitiesKHR( VkPhysicalDevice physicalDevice, 2840 VkDisplayModeKHR mode, 2841 uint32_t planeIndex, 2842 VkDisplayPlaneCapabilitiesKHR * pCapabilities ) const VULKAN_HPP_NOEXCEPT 2843 { 2844 return ::vkGetDisplayPlaneCapabilitiesKHR( physicalDevice, mode, planeIndex, pCapabilities ); 2845 } 2846 vkCreateDisplayPlaneSurfaceKHR(VkInstance instance,const VkDisplaySurfaceCreateInfoKHR * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface) const2847 VkResult vkCreateDisplayPlaneSurfaceKHR( VkInstance instance, 2848 const VkDisplaySurfaceCreateInfoKHR * pCreateInfo, 2849 const VkAllocationCallbacks * pAllocator, 2850 VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT 2851 { 2852 return ::vkCreateDisplayPlaneSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface ); 2853 } 2854 2855 //=== VK_KHR_display_swapchain === 2856 vkCreateSharedSwapchainsKHR(VkDevice device,uint32_t swapchainCount,const VkSwapchainCreateInfoKHR * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkSwapchainKHR * pSwapchains) const2857 VkResult vkCreateSharedSwapchainsKHR( VkDevice device, 2858 uint32_t swapchainCount, 2859 const VkSwapchainCreateInfoKHR * pCreateInfos, 2860 const VkAllocationCallbacks * pAllocator, 2861 VkSwapchainKHR * pSwapchains ) const VULKAN_HPP_NOEXCEPT 2862 { 2863 return ::vkCreateSharedSwapchainsKHR( device, swapchainCount, pCreateInfos, pAllocator, pSwapchains ); 2864 } 2865 2866 # if defined( VK_USE_PLATFORM_XLIB_KHR ) 2867 //=== VK_KHR_xlib_surface === 2868 vkCreateXlibSurfaceKHR(VkInstance instance,const VkXlibSurfaceCreateInfoKHR * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface) const2869 VkResult vkCreateXlibSurfaceKHR( VkInstance instance, 2870 const VkXlibSurfaceCreateInfoKHR * pCreateInfo, 2871 const VkAllocationCallbacks * pAllocator, 2872 VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT 2873 { 2874 return ::vkCreateXlibSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface ); 2875 } 2876 vkGetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice,uint32_t queueFamilyIndex,Display * dpy,VisualID visualID) const2877 VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR( VkPhysicalDevice physicalDevice, 2878 uint32_t queueFamilyIndex, 2879 Display * dpy, 2880 VisualID visualID ) const VULKAN_HPP_NOEXCEPT 2881 { 2882 return ::vkGetPhysicalDeviceXlibPresentationSupportKHR( physicalDevice, queueFamilyIndex, dpy, visualID ); 2883 } 2884 # endif /*VK_USE_PLATFORM_XLIB_KHR*/ 2885 2886 # if defined( VK_USE_PLATFORM_XCB_KHR ) 2887 //=== VK_KHR_xcb_surface === 2888 vkCreateXcbSurfaceKHR(VkInstance instance,const VkXcbSurfaceCreateInfoKHR * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface) const2889 VkResult vkCreateXcbSurfaceKHR( VkInstance instance, 2890 const VkXcbSurfaceCreateInfoKHR * pCreateInfo, 2891 const VkAllocationCallbacks * pAllocator, 2892 VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT 2893 { 2894 return ::vkCreateXcbSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface ); 2895 } 2896 vkGetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice,uint32_t queueFamilyIndex,xcb_connection_t * connection,xcb_visualid_t visual_id) const2897 VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR( VkPhysicalDevice physicalDevice, 2898 uint32_t queueFamilyIndex, 2899 xcb_connection_t * connection, 2900 xcb_visualid_t visual_id ) const VULKAN_HPP_NOEXCEPT 2901 { 2902 return ::vkGetPhysicalDeviceXcbPresentationSupportKHR( physicalDevice, queueFamilyIndex, connection, visual_id ); 2903 } 2904 # endif /*VK_USE_PLATFORM_XCB_KHR*/ 2905 2906 # if defined( VK_USE_PLATFORM_WAYLAND_KHR ) 2907 //=== VK_KHR_wayland_surface === 2908 vkCreateWaylandSurfaceKHR(VkInstance instance,const VkWaylandSurfaceCreateInfoKHR * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface) const2909 VkResult vkCreateWaylandSurfaceKHR( VkInstance instance, 2910 const VkWaylandSurfaceCreateInfoKHR * pCreateInfo, 2911 const VkAllocationCallbacks * pAllocator, 2912 VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT 2913 { 2914 return ::vkCreateWaylandSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface ); 2915 } 2916 vkGetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice,uint32_t queueFamilyIndex,struct wl_display * display) const2917 VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR( VkPhysicalDevice physicalDevice, 2918 uint32_t queueFamilyIndex, 2919 struct wl_display * display ) const VULKAN_HPP_NOEXCEPT 2920 { 2921 return ::vkGetPhysicalDeviceWaylandPresentationSupportKHR( physicalDevice, queueFamilyIndex, display ); 2922 } 2923 # endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ 2924 2925 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 2926 //=== VK_KHR_android_surface === 2927 vkCreateAndroidSurfaceKHR(VkInstance instance,const VkAndroidSurfaceCreateInfoKHR * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface) const2928 VkResult vkCreateAndroidSurfaceKHR( VkInstance instance, 2929 const VkAndroidSurfaceCreateInfoKHR * pCreateInfo, 2930 const VkAllocationCallbacks * pAllocator, 2931 VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT 2932 { 2933 return ::vkCreateAndroidSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface ); 2934 } 2935 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 2936 2937 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 2938 //=== VK_KHR_win32_surface === 2939 vkCreateWin32SurfaceKHR(VkInstance instance,const VkWin32SurfaceCreateInfoKHR * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface) const2940 VkResult vkCreateWin32SurfaceKHR( VkInstance instance, 2941 const VkWin32SurfaceCreateInfoKHR * pCreateInfo, 2942 const VkAllocationCallbacks * pAllocator, 2943 VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT 2944 { 2945 return ::vkCreateWin32SurfaceKHR( instance, pCreateInfo, pAllocator, pSurface ); 2946 } 2947 vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice,uint32_t queueFamilyIndex) const2948 VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR( VkPhysicalDevice physicalDevice, 2949 uint32_t queueFamilyIndex ) const VULKAN_HPP_NOEXCEPT 2950 { 2951 return ::vkGetPhysicalDeviceWin32PresentationSupportKHR( physicalDevice, queueFamilyIndex ); 2952 } 2953 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 2954 2955 # if defined( VK_USE_PLATFORM_OHOS_OPENHARMONY ) 2956 //=== VK_OpenHarmony_OHOS_surface === 2957 vkCreateOHOSSurfaceOpenHarmony(VkInstance instance,const VkOHOSSurfaceCreateInfoOpenHarmony * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface) const2958 VkResult vkCreateOHOSSurfaceOpenHarmony(VkInstance instance, 2959 const VkOHOSSurfaceCreateInfoOpenHarmony * pCreateInfo, 2960 const VkAllocationCallbacks * pAllocator, 2961 VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT 2962 { 2963 return ::vkCreateOHOSSurfaceOpenHarmony( instance, pCreateInfo, pAllocator, pSurface ); 2964 } 2965 # endif /*VK_USE_PLATFORM_OHOS_OPENHARMONY*/ 2966 2967 //=== VK_EXT_debug_report === 2968 vkCreateDebugReportCallbackEXT(VkInstance instance,const VkDebugReportCallbackCreateInfoEXT * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDebugReportCallbackEXT * pCallback) const2969 VkResult vkCreateDebugReportCallbackEXT( VkInstance instance, 2970 const VkDebugReportCallbackCreateInfoEXT * pCreateInfo, 2971 const VkAllocationCallbacks * pAllocator, 2972 VkDebugReportCallbackEXT * pCallback ) const VULKAN_HPP_NOEXCEPT 2973 { 2974 return ::vkCreateDebugReportCallbackEXT( instance, pCreateInfo, pAllocator, pCallback ); 2975 } 2976 vkDestroyDebugReportCallbackEXT(VkInstance instance,VkDebugReportCallbackEXT callback,const VkAllocationCallbacks * pAllocator) const2977 void vkDestroyDebugReportCallbackEXT( VkInstance instance, 2978 VkDebugReportCallbackEXT callback, 2979 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT 2980 { 2981 return ::vkDestroyDebugReportCallbackEXT( instance, callback, pAllocator ); 2982 } 2983 vkDebugReportMessageEXT(VkInstance instance,VkDebugReportFlagsEXT flags,VkDebugReportObjectTypeEXT objectType,uint64_t object,size_t location,int32_t messageCode,const char * pLayerPrefix,const char * pMessage) const2984 void vkDebugReportMessageEXT( VkInstance instance, 2985 VkDebugReportFlagsEXT flags, 2986 VkDebugReportObjectTypeEXT objectType, 2987 uint64_t object, 2988 size_t location, 2989 int32_t messageCode, 2990 const char * pLayerPrefix, 2991 const char * pMessage ) const VULKAN_HPP_NOEXCEPT 2992 { 2993 return ::vkDebugReportMessageEXT( 2994 instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage ); 2995 } 2996 2997 //=== VK_EXT_debug_marker === 2998 vkDebugMarkerSetObjectTagEXT(VkDevice device,const VkDebugMarkerObjectTagInfoEXT * pTagInfo) const2999 VkResult vkDebugMarkerSetObjectTagEXT( VkDevice device, 3000 const VkDebugMarkerObjectTagInfoEXT * pTagInfo ) const VULKAN_HPP_NOEXCEPT 3001 { 3002 return ::vkDebugMarkerSetObjectTagEXT( device, pTagInfo ); 3003 } 3004 vkDebugMarkerSetObjectNameEXT(VkDevice device,const VkDebugMarkerObjectNameInfoEXT * pNameInfo) const3005 VkResult vkDebugMarkerSetObjectNameEXT( VkDevice device, 3006 const VkDebugMarkerObjectNameInfoEXT * pNameInfo ) const VULKAN_HPP_NOEXCEPT 3007 { 3008 return ::vkDebugMarkerSetObjectNameEXT( device, pNameInfo ); 3009 } 3010 vkCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer,const VkDebugMarkerMarkerInfoEXT * pMarkerInfo) const3011 void vkCmdDebugMarkerBeginEXT( VkCommandBuffer commandBuffer, 3012 const VkDebugMarkerMarkerInfoEXT * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT 3013 { 3014 return ::vkCmdDebugMarkerBeginEXT( commandBuffer, pMarkerInfo ); 3015 } 3016 vkCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer) const3017 void vkCmdDebugMarkerEndEXT( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT 3018 { 3019 return ::vkCmdDebugMarkerEndEXT( commandBuffer ); 3020 } 3021 vkCmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer,const VkDebugMarkerMarkerInfoEXT * pMarkerInfo) const3022 void vkCmdDebugMarkerInsertEXT( VkCommandBuffer commandBuffer, 3023 const VkDebugMarkerMarkerInfoEXT * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT 3024 { 3025 return ::vkCmdDebugMarkerInsertEXT( commandBuffer, pMarkerInfo ); 3026 } 3027 3028 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 3029 //=== VK_KHR_video_queue === 3030 vkGetPhysicalDeviceVideoCapabilitiesKHR(VkPhysicalDevice physicalDevice,const VkVideoProfileKHR * pVideoProfile,VkVideoCapabilitiesKHR * pCapabilities) const3031 VkResult vkGetPhysicalDeviceVideoCapabilitiesKHR( VkPhysicalDevice physicalDevice, 3032 const VkVideoProfileKHR * pVideoProfile, 3033 VkVideoCapabilitiesKHR * pCapabilities ) const VULKAN_HPP_NOEXCEPT 3034 { 3035 return ::vkGetPhysicalDeviceVideoCapabilitiesKHR( physicalDevice, pVideoProfile, pCapabilities ); 3036 } 3037 vkGetPhysicalDeviceVideoFormatPropertiesKHR(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceVideoFormatInfoKHR * pVideoFormatInfo,uint32_t * pVideoFormatPropertyCount,VkVideoFormatPropertiesKHR * pVideoFormatProperties) const3038 VkResult vkGetPhysicalDeviceVideoFormatPropertiesKHR( VkPhysicalDevice physicalDevice, 3039 const VkPhysicalDeviceVideoFormatInfoKHR * pVideoFormatInfo, 3040 uint32_t * pVideoFormatPropertyCount, 3041 VkVideoFormatPropertiesKHR * pVideoFormatProperties ) const 3042 VULKAN_HPP_NOEXCEPT 3043 { 3044 return ::vkGetPhysicalDeviceVideoFormatPropertiesKHR( 3045 physicalDevice, pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties ); 3046 } 3047 vkCreateVideoSessionKHR(VkDevice device,const VkVideoSessionCreateInfoKHR * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkVideoSessionKHR * pVideoSession) const3048 VkResult vkCreateVideoSessionKHR( VkDevice device, 3049 const VkVideoSessionCreateInfoKHR * pCreateInfo, 3050 const VkAllocationCallbacks * pAllocator, 3051 VkVideoSessionKHR * pVideoSession ) const VULKAN_HPP_NOEXCEPT 3052 { 3053 return ::vkCreateVideoSessionKHR( device, pCreateInfo, pAllocator, pVideoSession ); 3054 } 3055 vkDestroyVideoSessionKHR(VkDevice device,VkVideoSessionKHR videoSession,const VkAllocationCallbacks * pAllocator) const3056 void vkDestroyVideoSessionKHR( VkDevice device, 3057 VkVideoSessionKHR videoSession, 3058 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT 3059 { 3060 return ::vkDestroyVideoSessionKHR( device, videoSession, pAllocator ); 3061 } 3062 vkGetVideoSessionMemoryRequirementsKHR(VkDevice device,VkVideoSessionKHR videoSession,uint32_t * pVideoSessionMemoryRequirementsCount,VkVideoGetMemoryPropertiesKHR * pVideoSessionMemoryRequirements) const3063 VkResult vkGetVideoSessionMemoryRequirementsKHR( 3064 VkDevice device, 3065 VkVideoSessionKHR videoSession, 3066 uint32_t * pVideoSessionMemoryRequirementsCount, 3067 VkVideoGetMemoryPropertiesKHR * pVideoSessionMemoryRequirements ) const VULKAN_HPP_NOEXCEPT 3068 { 3069 return ::vkGetVideoSessionMemoryRequirementsKHR( 3070 device, videoSession, pVideoSessionMemoryRequirementsCount, pVideoSessionMemoryRequirements ); 3071 } 3072 3073 VkResult vkBindVideoSessionMemoryKHR(VkDevice device,VkVideoSessionKHR videoSession,uint32_t videoSessionBindMemoryCount,const VkVideoBindMemoryKHR * pVideoSessionBindMemories) const3074 vkBindVideoSessionMemoryKHR( VkDevice device, 3075 VkVideoSessionKHR videoSession, 3076 uint32_t videoSessionBindMemoryCount, 3077 const VkVideoBindMemoryKHR * pVideoSessionBindMemories ) const VULKAN_HPP_NOEXCEPT 3078 { 3079 return ::vkBindVideoSessionMemoryKHR( 3080 device, videoSession, videoSessionBindMemoryCount, pVideoSessionBindMemories ); 3081 } 3082 vkCreateVideoSessionParametersKHR(VkDevice device,const VkVideoSessionParametersCreateInfoKHR * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkVideoSessionParametersKHR * pVideoSessionParameters) const3083 VkResult vkCreateVideoSessionParametersKHR( VkDevice device, 3084 const VkVideoSessionParametersCreateInfoKHR * pCreateInfo, 3085 const VkAllocationCallbacks * pAllocator, 3086 VkVideoSessionParametersKHR * pVideoSessionParameters ) const 3087 VULKAN_HPP_NOEXCEPT 3088 { 3089 return ::vkCreateVideoSessionParametersKHR( device, pCreateInfo, pAllocator, pVideoSessionParameters ); 3090 } 3091 vkUpdateVideoSessionParametersKHR(VkDevice device,VkVideoSessionParametersKHR videoSessionParameters,const VkVideoSessionParametersUpdateInfoKHR * pUpdateInfo) const3092 VkResult vkUpdateVideoSessionParametersKHR( VkDevice device, 3093 VkVideoSessionParametersKHR videoSessionParameters, 3094 const VkVideoSessionParametersUpdateInfoKHR * pUpdateInfo ) const 3095 VULKAN_HPP_NOEXCEPT 3096 { 3097 return ::vkUpdateVideoSessionParametersKHR( device, videoSessionParameters, pUpdateInfo ); 3098 } 3099 vkDestroyVideoSessionParametersKHR(VkDevice device,VkVideoSessionParametersKHR videoSessionParameters,const VkAllocationCallbacks * pAllocator) const3100 void vkDestroyVideoSessionParametersKHR( VkDevice device, 3101 VkVideoSessionParametersKHR videoSessionParameters, 3102 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT 3103 { 3104 return ::vkDestroyVideoSessionParametersKHR( device, videoSessionParameters, pAllocator ); 3105 } 3106 vkCmdBeginVideoCodingKHR(VkCommandBuffer commandBuffer,const VkVideoBeginCodingInfoKHR * pBeginInfo) const3107 void vkCmdBeginVideoCodingKHR( VkCommandBuffer commandBuffer, 3108 const VkVideoBeginCodingInfoKHR * pBeginInfo ) const VULKAN_HPP_NOEXCEPT 3109 { 3110 return ::vkCmdBeginVideoCodingKHR( commandBuffer, pBeginInfo ); 3111 } 3112 vkCmdEndVideoCodingKHR(VkCommandBuffer commandBuffer,const VkVideoEndCodingInfoKHR * pEndCodingInfo) const3113 void vkCmdEndVideoCodingKHR( VkCommandBuffer commandBuffer, 3114 const VkVideoEndCodingInfoKHR * pEndCodingInfo ) const VULKAN_HPP_NOEXCEPT 3115 { 3116 return ::vkCmdEndVideoCodingKHR( commandBuffer, pEndCodingInfo ); 3117 } 3118 vkCmdControlVideoCodingKHR(VkCommandBuffer commandBuffer,const VkVideoCodingControlInfoKHR * pCodingControlInfo) const3119 void vkCmdControlVideoCodingKHR( VkCommandBuffer commandBuffer, 3120 const VkVideoCodingControlInfoKHR * pCodingControlInfo ) const VULKAN_HPP_NOEXCEPT 3121 { 3122 return ::vkCmdControlVideoCodingKHR( commandBuffer, pCodingControlInfo ); 3123 } 3124 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 3125 3126 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 3127 //=== VK_KHR_video_decode_queue === 3128 vkCmdDecodeVideoKHR(VkCommandBuffer commandBuffer,const VkVideoDecodeInfoKHR * pFrameInfo) const3129 void vkCmdDecodeVideoKHR( VkCommandBuffer commandBuffer, 3130 const VkVideoDecodeInfoKHR * pFrameInfo ) const VULKAN_HPP_NOEXCEPT 3131 { 3132 return ::vkCmdDecodeVideoKHR( commandBuffer, pFrameInfo ); 3133 } 3134 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 3135 3136 //=== VK_EXT_transform_feedback === 3137 vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer,uint32_t firstBinding,uint32_t bindingCount,const VkBuffer * pBuffers,const VkDeviceSize * pOffsets,const VkDeviceSize * pSizes) const3138 void vkCmdBindTransformFeedbackBuffersEXT( VkCommandBuffer commandBuffer, 3139 uint32_t firstBinding, 3140 uint32_t bindingCount, 3141 const VkBuffer * pBuffers, 3142 const VkDeviceSize * pOffsets, 3143 const VkDeviceSize * pSizes ) const VULKAN_HPP_NOEXCEPT 3144 { 3145 return ::vkCmdBindTransformFeedbackBuffersEXT( 3146 commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes ); 3147 } 3148 vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer,uint32_t firstCounterBuffer,uint32_t counterBufferCount,const VkBuffer * pCounterBuffers,const VkDeviceSize * pCounterBufferOffsets) const3149 void vkCmdBeginTransformFeedbackEXT( VkCommandBuffer commandBuffer, 3150 uint32_t firstCounterBuffer, 3151 uint32_t counterBufferCount, 3152 const VkBuffer * pCounterBuffers, 3153 const VkDeviceSize * pCounterBufferOffsets ) const VULKAN_HPP_NOEXCEPT 3154 { 3155 return ::vkCmdBeginTransformFeedbackEXT( 3156 commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets ); 3157 } 3158 vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer,uint32_t firstCounterBuffer,uint32_t counterBufferCount,const VkBuffer * pCounterBuffers,const VkDeviceSize * pCounterBufferOffsets) const3159 void vkCmdEndTransformFeedbackEXT( VkCommandBuffer commandBuffer, 3160 uint32_t firstCounterBuffer, 3161 uint32_t counterBufferCount, 3162 const VkBuffer * pCounterBuffers, 3163 const VkDeviceSize * pCounterBufferOffsets ) const VULKAN_HPP_NOEXCEPT 3164 { 3165 return ::vkCmdEndTransformFeedbackEXT( 3166 commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets ); 3167 } 3168 vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer,VkQueryPool queryPool,uint32_t query,VkQueryControlFlags flags,uint32_t index) const3169 void vkCmdBeginQueryIndexedEXT( VkCommandBuffer commandBuffer, 3170 VkQueryPool queryPool, 3171 uint32_t query, 3172 VkQueryControlFlags flags, 3173 uint32_t index ) const VULKAN_HPP_NOEXCEPT 3174 { 3175 return ::vkCmdBeginQueryIndexedEXT( commandBuffer, queryPool, query, flags, index ); 3176 } 3177 vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer,VkQueryPool queryPool,uint32_t query,uint32_t index) const3178 void vkCmdEndQueryIndexedEXT( VkCommandBuffer commandBuffer, 3179 VkQueryPool queryPool, 3180 uint32_t query, 3181 uint32_t index ) const VULKAN_HPP_NOEXCEPT 3182 { 3183 return ::vkCmdEndQueryIndexedEXT( commandBuffer, queryPool, query, index ); 3184 } 3185 vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer,uint32_t instanceCount,uint32_t firstInstance,VkBuffer counterBuffer,VkDeviceSize counterBufferOffset,uint32_t counterOffset,uint32_t vertexStride) const3186 void vkCmdDrawIndirectByteCountEXT( VkCommandBuffer commandBuffer, 3187 uint32_t instanceCount, 3188 uint32_t firstInstance, 3189 VkBuffer counterBuffer, 3190 VkDeviceSize counterBufferOffset, 3191 uint32_t counterOffset, 3192 uint32_t vertexStride ) const VULKAN_HPP_NOEXCEPT 3193 { 3194 return ::vkCmdDrawIndirectByteCountEXT( 3195 commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride ); 3196 } 3197 3198 //=== VK_NVX_binary_import === 3199 vkCreateCuModuleNVX(VkDevice device,const VkCuModuleCreateInfoNVX * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkCuModuleNVX * pModule) const3200 VkResult vkCreateCuModuleNVX( VkDevice device, 3201 const VkCuModuleCreateInfoNVX * pCreateInfo, 3202 const VkAllocationCallbacks * pAllocator, 3203 VkCuModuleNVX * pModule ) const VULKAN_HPP_NOEXCEPT 3204 { 3205 return ::vkCreateCuModuleNVX( device, pCreateInfo, pAllocator, pModule ); 3206 } 3207 vkCreateCuFunctionNVX(VkDevice device,const VkCuFunctionCreateInfoNVX * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkCuFunctionNVX * pFunction) const3208 VkResult vkCreateCuFunctionNVX( VkDevice device, 3209 const VkCuFunctionCreateInfoNVX * pCreateInfo, 3210 const VkAllocationCallbacks * pAllocator, 3211 VkCuFunctionNVX * pFunction ) const VULKAN_HPP_NOEXCEPT 3212 { 3213 return ::vkCreateCuFunctionNVX( device, pCreateInfo, pAllocator, pFunction ); 3214 } 3215 vkDestroyCuModuleNVX(VkDevice device,VkCuModuleNVX module,const VkAllocationCallbacks * pAllocator) const3216 void vkDestroyCuModuleNVX( VkDevice device, 3217 VkCuModuleNVX module, 3218 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT 3219 { 3220 return ::vkDestroyCuModuleNVX( device, module, pAllocator ); 3221 } 3222 vkDestroyCuFunctionNVX(VkDevice device,VkCuFunctionNVX function,const VkAllocationCallbacks * pAllocator) const3223 void vkDestroyCuFunctionNVX( VkDevice device, 3224 VkCuFunctionNVX function, 3225 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT 3226 { 3227 return ::vkDestroyCuFunctionNVX( device, function, pAllocator ); 3228 } 3229 vkCmdCuLaunchKernelNVX(VkCommandBuffer commandBuffer,const VkCuLaunchInfoNVX * pLaunchInfo) const3230 void vkCmdCuLaunchKernelNVX( VkCommandBuffer commandBuffer, 3231 const VkCuLaunchInfoNVX * pLaunchInfo ) const VULKAN_HPP_NOEXCEPT 3232 { 3233 return ::vkCmdCuLaunchKernelNVX( commandBuffer, pLaunchInfo ); 3234 } 3235 3236 //=== VK_NVX_image_view_handle === 3237 vkGetImageViewHandleNVX(VkDevice device,const VkImageViewHandleInfoNVX * pInfo) const3238 uint32_t vkGetImageViewHandleNVX( VkDevice device, 3239 const VkImageViewHandleInfoNVX * pInfo ) const VULKAN_HPP_NOEXCEPT 3240 { 3241 return ::vkGetImageViewHandleNVX( device, pInfo ); 3242 } 3243 vkGetImageViewAddressNVX(VkDevice device,VkImageView imageView,VkImageViewAddressPropertiesNVX * pProperties) const3244 VkResult vkGetImageViewAddressNVX( VkDevice device, 3245 VkImageView imageView, 3246 VkImageViewAddressPropertiesNVX * pProperties ) const VULKAN_HPP_NOEXCEPT 3247 { 3248 return ::vkGetImageViewAddressNVX( device, imageView, pProperties ); 3249 } 3250 3251 //=== VK_AMD_draw_indirect_count === 3252 vkCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer,VkBuffer buffer,VkDeviceSize offset,VkBuffer countBuffer,VkDeviceSize countBufferOffset,uint32_t maxDrawCount,uint32_t stride) const3253 void vkCmdDrawIndirectCountAMD( VkCommandBuffer commandBuffer, 3254 VkBuffer buffer, 3255 VkDeviceSize offset, 3256 VkBuffer countBuffer, 3257 VkDeviceSize countBufferOffset, 3258 uint32_t maxDrawCount, 3259 uint32_t stride ) const VULKAN_HPP_NOEXCEPT 3260 { 3261 return ::vkCmdDrawIndirectCountAMD( 3262 commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride ); 3263 } 3264 vkCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer,VkBuffer buffer,VkDeviceSize offset,VkBuffer countBuffer,VkDeviceSize countBufferOffset,uint32_t maxDrawCount,uint32_t stride) const3265 void vkCmdDrawIndexedIndirectCountAMD( VkCommandBuffer commandBuffer, 3266 VkBuffer buffer, 3267 VkDeviceSize offset, 3268 VkBuffer countBuffer, 3269 VkDeviceSize countBufferOffset, 3270 uint32_t maxDrawCount, 3271 uint32_t stride ) const VULKAN_HPP_NOEXCEPT 3272 { 3273 return ::vkCmdDrawIndexedIndirectCountAMD( 3274 commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride ); 3275 } 3276 3277 //=== VK_AMD_shader_info === 3278 vkGetShaderInfoAMD(VkDevice device,VkPipeline pipeline,VkShaderStageFlagBits shaderStage,VkShaderInfoTypeAMD infoType,size_t * pInfoSize,void * pInfo) const3279 VkResult vkGetShaderInfoAMD( VkDevice device, 3280 VkPipeline pipeline, 3281 VkShaderStageFlagBits shaderStage, 3282 VkShaderInfoTypeAMD infoType, 3283 size_t * pInfoSize, 3284 void * pInfo ) const VULKAN_HPP_NOEXCEPT 3285 { 3286 return ::vkGetShaderInfoAMD( device, pipeline, shaderStage, infoType, pInfoSize, pInfo ); 3287 } 3288 3289 //=== VK_KHR_dynamic_rendering === 3290 vkCmdBeginRenderingKHR(VkCommandBuffer commandBuffer,const VkRenderingInfoKHR * pRenderingInfo) const3291 void vkCmdBeginRenderingKHR( VkCommandBuffer commandBuffer, 3292 const VkRenderingInfoKHR * pRenderingInfo ) const VULKAN_HPP_NOEXCEPT 3293 { 3294 return ::vkCmdBeginRenderingKHR( commandBuffer, pRenderingInfo ); 3295 } 3296 vkCmdEndRenderingKHR(VkCommandBuffer commandBuffer) const3297 void vkCmdEndRenderingKHR( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT 3298 { 3299 return ::vkCmdEndRenderingKHR( commandBuffer ); 3300 } 3301 3302 # if defined( VK_USE_PLATFORM_GGP ) 3303 //=== VK_GGP_stream_descriptor_surface === 3304 vkCreateStreamDescriptorSurfaceGGP(VkInstance instance,const VkStreamDescriptorSurfaceCreateInfoGGP * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface) const3305 VkResult vkCreateStreamDescriptorSurfaceGGP( VkInstance instance, 3306 const VkStreamDescriptorSurfaceCreateInfoGGP * pCreateInfo, 3307 const VkAllocationCallbacks * pAllocator, 3308 VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT 3309 { 3310 return ::vkCreateStreamDescriptorSurfaceGGP( instance, pCreateInfo, pAllocator, pSurface ); 3311 } 3312 # endif /*VK_USE_PLATFORM_GGP*/ 3313 3314 //=== VK_NV_external_memory_capabilities === 3315 vkGetPhysicalDeviceExternalImageFormatPropertiesNV(VkPhysicalDevice physicalDevice,VkFormat format,VkImageType type,VkImageTiling tiling,VkImageUsageFlags usage,VkImageCreateFlags flags,VkExternalMemoryHandleTypeFlagsNV externalHandleType,VkExternalImageFormatPropertiesNV * pExternalImageFormatProperties) const3316 VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV( 3317 VkPhysicalDevice physicalDevice, 3318 VkFormat format, 3319 VkImageType type, 3320 VkImageTiling tiling, 3321 VkImageUsageFlags usage, 3322 VkImageCreateFlags flags, 3323 VkExternalMemoryHandleTypeFlagsNV externalHandleType, 3324 VkExternalImageFormatPropertiesNV * pExternalImageFormatProperties ) const VULKAN_HPP_NOEXCEPT 3325 { 3326 return ::vkGetPhysicalDeviceExternalImageFormatPropertiesNV( 3327 physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties ); 3328 } 3329 3330 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 3331 //=== VK_NV_external_memory_win32 === 3332 vkGetMemoryWin32HandleNV(VkDevice device,VkDeviceMemory memory,VkExternalMemoryHandleTypeFlagsNV handleType,HANDLE * pHandle) const3333 VkResult vkGetMemoryWin32HandleNV( VkDevice device, 3334 VkDeviceMemory memory, 3335 VkExternalMemoryHandleTypeFlagsNV handleType, 3336 HANDLE * pHandle ) const VULKAN_HPP_NOEXCEPT 3337 { 3338 return ::vkGetMemoryWin32HandleNV( device, memory, handleType, pHandle ); 3339 } 3340 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 3341 3342 //=== VK_KHR_get_physical_device_properties2 === 3343 vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice,VkPhysicalDeviceFeatures2 * pFeatures) const3344 void vkGetPhysicalDeviceFeatures2KHR( VkPhysicalDevice physicalDevice, 3345 VkPhysicalDeviceFeatures2 * pFeatures ) const VULKAN_HPP_NOEXCEPT 3346 { 3347 return ::vkGetPhysicalDeviceFeatures2KHR( physicalDevice, pFeatures ); 3348 } 3349 vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice,VkPhysicalDeviceProperties2 * pProperties) const3350 void vkGetPhysicalDeviceProperties2KHR( VkPhysicalDevice physicalDevice, 3351 VkPhysicalDeviceProperties2 * pProperties ) const VULKAN_HPP_NOEXCEPT 3352 { 3353 return ::vkGetPhysicalDeviceProperties2KHR( physicalDevice, pProperties ); 3354 } 3355 vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice,VkFormat format,VkFormatProperties2 * pFormatProperties) const3356 void vkGetPhysicalDeviceFormatProperties2KHR( VkPhysicalDevice physicalDevice, 3357 VkFormat format, 3358 VkFormatProperties2 * pFormatProperties ) const VULKAN_HPP_NOEXCEPT 3359 { 3360 return ::vkGetPhysicalDeviceFormatProperties2KHR( physicalDevice, format, pFormatProperties ); 3361 } 3362 vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,VkImageFormatProperties2 * pImageFormatProperties) const3363 VkResult vkGetPhysicalDeviceImageFormatProperties2KHR( VkPhysicalDevice physicalDevice, 3364 const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo, 3365 VkImageFormatProperties2 * pImageFormatProperties ) const 3366 VULKAN_HPP_NOEXCEPT 3367 { 3368 return ::vkGetPhysicalDeviceImageFormatProperties2KHR( physicalDevice, pImageFormatInfo, pImageFormatProperties ); 3369 } 3370 vkGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice,uint32_t * pQueueFamilyPropertyCount,VkQueueFamilyProperties2 * pQueueFamilyProperties) const3371 void vkGetPhysicalDeviceQueueFamilyProperties2KHR( VkPhysicalDevice physicalDevice, 3372 uint32_t * pQueueFamilyPropertyCount, 3373 VkQueueFamilyProperties2 * pQueueFamilyProperties ) const 3374 VULKAN_HPP_NOEXCEPT 3375 { 3376 return ::vkGetPhysicalDeviceQueueFamilyProperties2KHR( 3377 physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties ); 3378 } 3379 vkGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice,VkPhysicalDeviceMemoryProperties2 * pMemoryProperties) const3380 void vkGetPhysicalDeviceMemoryProperties2KHR( 3381 VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 * pMemoryProperties ) const VULKAN_HPP_NOEXCEPT 3382 { 3383 return ::vkGetPhysicalDeviceMemoryProperties2KHR( physicalDevice, pMemoryProperties ); 3384 } 3385 vkGetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,uint32_t * pPropertyCount,VkSparseImageFormatProperties2 * pProperties) const3386 void vkGetPhysicalDeviceSparseImageFormatProperties2KHR( VkPhysicalDevice physicalDevice, 3387 const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo, 3388 uint32_t * pPropertyCount, 3389 VkSparseImageFormatProperties2 * pProperties ) const 3390 VULKAN_HPP_NOEXCEPT 3391 { 3392 return ::vkGetPhysicalDeviceSparseImageFormatProperties2KHR( 3393 physicalDevice, pFormatInfo, pPropertyCount, pProperties ); 3394 } 3395 3396 //=== VK_KHR_device_group === 3397 3398 void vkGetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device,uint32_t heapIndex,uint32_t localDeviceIndex,uint32_t remoteDeviceIndex,VkPeerMemoryFeatureFlags * pPeerMemoryFeatures) const3399 vkGetDeviceGroupPeerMemoryFeaturesKHR( VkDevice device, 3400 uint32_t heapIndex, 3401 uint32_t localDeviceIndex, 3402 uint32_t remoteDeviceIndex, 3403 VkPeerMemoryFeatureFlags * pPeerMemoryFeatures ) const VULKAN_HPP_NOEXCEPT 3404 { 3405 return ::vkGetDeviceGroupPeerMemoryFeaturesKHR( 3406 device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures ); 3407 } 3408 vkCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer,uint32_t deviceMask) const3409 void vkCmdSetDeviceMaskKHR( VkCommandBuffer commandBuffer, uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT 3410 { 3411 return ::vkCmdSetDeviceMaskKHR( commandBuffer, deviceMask ); 3412 } 3413 vkCmdDispatchBaseKHR(VkCommandBuffer commandBuffer,uint32_t baseGroupX,uint32_t baseGroupY,uint32_t baseGroupZ,uint32_t groupCountX,uint32_t groupCountY,uint32_t groupCountZ) const3414 void vkCmdDispatchBaseKHR( VkCommandBuffer commandBuffer, 3415 uint32_t baseGroupX, 3416 uint32_t baseGroupY, 3417 uint32_t baseGroupZ, 3418 uint32_t groupCountX, 3419 uint32_t groupCountY, 3420 uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT 3421 { 3422 return ::vkCmdDispatchBaseKHR( 3423 commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ ); 3424 } 3425 3426 # if defined( VK_USE_PLATFORM_VI_NN ) 3427 //=== VK_NN_vi_surface === 3428 vkCreateViSurfaceNN(VkInstance instance,const VkViSurfaceCreateInfoNN * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface) const3429 VkResult vkCreateViSurfaceNN( VkInstance instance, 3430 const VkViSurfaceCreateInfoNN * pCreateInfo, 3431 const VkAllocationCallbacks * pAllocator, 3432 VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT 3433 { 3434 return ::vkCreateViSurfaceNN( instance, pCreateInfo, pAllocator, pSurface ); 3435 } 3436 # endif /*VK_USE_PLATFORM_VI_NN*/ 3437 3438 //=== VK_KHR_maintenance1 === 3439 vkTrimCommandPoolKHR(VkDevice device,VkCommandPool commandPool,VkCommandPoolTrimFlags flags) const3440 void vkTrimCommandPoolKHR( VkDevice device, 3441 VkCommandPool commandPool, 3442 VkCommandPoolTrimFlags flags ) const VULKAN_HPP_NOEXCEPT 3443 { 3444 return ::vkTrimCommandPoolKHR( device, commandPool, flags ); 3445 } 3446 3447 //=== VK_KHR_device_group_creation === 3448 vkEnumeratePhysicalDeviceGroupsKHR(VkInstance instance,uint32_t * pPhysicalDeviceGroupCount,VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties) const3449 VkResult vkEnumeratePhysicalDeviceGroupsKHR( 3450 VkInstance instance, 3451 uint32_t * pPhysicalDeviceGroupCount, 3452 VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties ) const VULKAN_HPP_NOEXCEPT 3453 { 3454 return ::vkEnumeratePhysicalDeviceGroupsKHR( 3455 instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties ); 3456 } 3457 3458 //=== VK_KHR_external_memory_capabilities === 3459 vkGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,VkExternalBufferProperties * pExternalBufferProperties) const3460 void vkGetPhysicalDeviceExternalBufferPropertiesKHR( VkPhysicalDevice physicalDevice, 3461 const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo, 3462 VkExternalBufferProperties * pExternalBufferProperties ) const 3463 VULKAN_HPP_NOEXCEPT 3464 { 3465 return ::vkGetPhysicalDeviceExternalBufferPropertiesKHR( 3466 physicalDevice, pExternalBufferInfo, pExternalBufferProperties ); 3467 } 3468 3469 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 3470 //=== VK_KHR_external_memory_win32 === 3471 vkGetMemoryWin32HandleKHR(VkDevice device,const VkMemoryGetWin32HandleInfoKHR * pGetWin32HandleInfo,HANDLE * pHandle) const3472 VkResult vkGetMemoryWin32HandleKHR( VkDevice device, 3473 const VkMemoryGetWin32HandleInfoKHR * pGetWin32HandleInfo, 3474 HANDLE * pHandle ) const VULKAN_HPP_NOEXCEPT 3475 { 3476 return ::vkGetMemoryWin32HandleKHR( device, pGetWin32HandleInfo, pHandle ); 3477 } 3478 vkGetMemoryWin32HandlePropertiesKHR(VkDevice device,VkExternalMemoryHandleTypeFlagBits handleType,HANDLE handle,VkMemoryWin32HandlePropertiesKHR * pMemoryWin32HandleProperties) const3479 VkResult vkGetMemoryWin32HandlePropertiesKHR( 3480 VkDevice device, 3481 VkExternalMemoryHandleTypeFlagBits handleType, 3482 HANDLE handle, 3483 VkMemoryWin32HandlePropertiesKHR * pMemoryWin32HandleProperties ) const VULKAN_HPP_NOEXCEPT 3484 { 3485 return ::vkGetMemoryWin32HandlePropertiesKHR( device, handleType, handle, pMemoryWin32HandleProperties ); 3486 } 3487 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 3488 3489 //=== VK_KHR_external_memory_fd === 3490 3491 VkResult vkGetMemoryFdKHR(VkDevice device,const VkMemoryGetFdInfoKHR * pGetFdInfo,int * pFd) const3492 vkGetMemoryFdKHR( VkDevice device, const VkMemoryGetFdInfoKHR * pGetFdInfo, int * pFd ) const VULKAN_HPP_NOEXCEPT 3493 { 3494 return ::vkGetMemoryFdKHR( device, pGetFdInfo, pFd ); 3495 } 3496 vkGetMemoryFdPropertiesKHR(VkDevice device,VkExternalMemoryHandleTypeFlagBits handleType,int fd,VkMemoryFdPropertiesKHR * pMemoryFdProperties) const3497 VkResult vkGetMemoryFdPropertiesKHR( VkDevice device, 3498 VkExternalMemoryHandleTypeFlagBits handleType, 3499 int fd, 3500 VkMemoryFdPropertiesKHR * pMemoryFdProperties ) const VULKAN_HPP_NOEXCEPT 3501 { 3502 return ::vkGetMemoryFdPropertiesKHR( device, handleType, fd, pMemoryFdProperties ); 3503 } 3504 3505 //=== VK_KHR_external_semaphore_capabilities === 3506 vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,VkExternalSemaphoreProperties * pExternalSemaphoreProperties) const3507 void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( 3508 VkPhysicalDevice physicalDevice, 3509 const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo, 3510 VkExternalSemaphoreProperties * pExternalSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT 3511 { 3512 return ::vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( 3513 physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties ); 3514 } 3515 3516 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 3517 //=== VK_KHR_external_semaphore_win32 === 3518 vkImportSemaphoreWin32HandleKHR(VkDevice device,const VkImportSemaphoreWin32HandleInfoKHR * pImportSemaphoreWin32HandleInfo) const3519 VkResult vkImportSemaphoreWin32HandleKHR( 3520 VkDevice device, 3521 const VkImportSemaphoreWin32HandleInfoKHR * pImportSemaphoreWin32HandleInfo ) const VULKAN_HPP_NOEXCEPT 3522 { 3523 return ::vkImportSemaphoreWin32HandleKHR( device, pImportSemaphoreWin32HandleInfo ); 3524 } 3525 vkGetSemaphoreWin32HandleKHR(VkDevice device,const VkSemaphoreGetWin32HandleInfoKHR * pGetWin32HandleInfo,HANDLE * pHandle) const3526 VkResult vkGetSemaphoreWin32HandleKHR( VkDevice device, 3527 const VkSemaphoreGetWin32HandleInfoKHR * pGetWin32HandleInfo, 3528 HANDLE * pHandle ) const VULKAN_HPP_NOEXCEPT 3529 { 3530 return ::vkGetSemaphoreWin32HandleKHR( device, pGetWin32HandleInfo, pHandle ); 3531 } 3532 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 3533 3534 //=== VK_KHR_external_semaphore_fd === 3535 3536 VkResult vkImportSemaphoreFdKHR(VkDevice device,const VkImportSemaphoreFdInfoKHR * pImportSemaphoreFdInfo) const3537 vkImportSemaphoreFdKHR( VkDevice device, 3538 const VkImportSemaphoreFdInfoKHR * pImportSemaphoreFdInfo ) const VULKAN_HPP_NOEXCEPT 3539 { 3540 return ::vkImportSemaphoreFdKHR( device, pImportSemaphoreFdInfo ); 3541 } 3542 vkGetSemaphoreFdKHR(VkDevice device,const VkSemaphoreGetFdInfoKHR * pGetFdInfo,int * pFd) const3543 VkResult vkGetSemaphoreFdKHR( VkDevice device, 3544 const VkSemaphoreGetFdInfoKHR * pGetFdInfo, 3545 int * pFd ) const VULKAN_HPP_NOEXCEPT 3546 { 3547 return ::vkGetSemaphoreFdKHR( device, pGetFdInfo, pFd ); 3548 } 3549 3550 //=== VK_KHR_push_descriptor === 3551 vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer,VkPipelineBindPoint pipelineBindPoint,VkPipelineLayout layout,uint32_t set,uint32_t descriptorWriteCount,const VkWriteDescriptorSet * pDescriptorWrites) const3552 void vkCmdPushDescriptorSetKHR( VkCommandBuffer commandBuffer, 3553 VkPipelineBindPoint pipelineBindPoint, 3554 VkPipelineLayout layout, 3555 uint32_t set, 3556 uint32_t descriptorWriteCount, 3557 const VkWriteDescriptorSet * pDescriptorWrites ) const VULKAN_HPP_NOEXCEPT 3558 { 3559 return ::vkCmdPushDescriptorSetKHR( 3560 commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites ); 3561 } 3562 vkCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer,VkDescriptorUpdateTemplate descriptorUpdateTemplate,VkPipelineLayout layout,uint32_t set,const void * pData) const3563 void vkCmdPushDescriptorSetWithTemplateKHR( VkCommandBuffer commandBuffer, 3564 VkDescriptorUpdateTemplate descriptorUpdateTemplate, 3565 VkPipelineLayout layout, 3566 uint32_t set, 3567 const void * pData ) const VULKAN_HPP_NOEXCEPT 3568 { 3569 return ::vkCmdPushDescriptorSetWithTemplateKHR( commandBuffer, descriptorUpdateTemplate, layout, set, pData ); 3570 } 3571 3572 //=== VK_EXT_conditional_rendering === 3573 vkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer,const VkConditionalRenderingBeginInfoEXT * pConditionalRenderingBegin) const3574 void vkCmdBeginConditionalRenderingEXT( 3575 VkCommandBuffer commandBuffer, 3576 const VkConditionalRenderingBeginInfoEXT * pConditionalRenderingBegin ) const VULKAN_HPP_NOEXCEPT 3577 { 3578 return ::vkCmdBeginConditionalRenderingEXT( commandBuffer, pConditionalRenderingBegin ); 3579 } 3580 vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer) const3581 void vkCmdEndConditionalRenderingEXT( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT 3582 { 3583 return ::vkCmdEndConditionalRenderingEXT( commandBuffer ); 3584 } 3585 3586 //=== VK_KHR_descriptor_update_template === 3587 vkCreateDescriptorUpdateTemplateKHR(VkDevice device,const VkDescriptorUpdateTemplateCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDescriptorUpdateTemplate * pDescriptorUpdateTemplate) const3588 VkResult vkCreateDescriptorUpdateTemplateKHR( VkDevice device, 3589 const VkDescriptorUpdateTemplateCreateInfo * pCreateInfo, 3590 const VkAllocationCallbacks * pAllocator, 3591 VkDescriptorUpdateTemplate * pDescriptorUpdateTemplate ) const 3592 VULKAN_HPP_NOEXCEPT 3593 { 3594 return ::vkCreateDescriptorUpdateTemplateKHR( device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate ); 3595 } 3596 vkDestroyDescriptorUpdateTemplateKHR(VkDevice device,VkDescriptorUpdateTemplate descriptorUpdateTemplate,const VkAllocationCallbacks * pAllocator) const3597 void vkDestroyDescriptorUpdateTemplateKHR( VkDevice device, 3598 VkDescriptorUpdateTemplate descriptorUpdateTemplate, 3599 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT 3600 { 3601 return ::vkDestroyDescriptorUpdateTemplateKHR( device, descriptorUpdateTemplate, pAllocator ); 3602 } 3603 vkUpdateDescriptorSetWithTemplateKHR(VkDevice device,VkDescriptorSet descriptorSet,VkDescriptorUpdateTemplate descriptorUpdateTemplate,const void * pData) const3604 void vkUpdateDescriptorSetWithTemplateKHR( VkDevice device, 3605 VkDescriptorSet descriptorSet, 3606 VkDescriptorUpdateTemplate descriptorUpdateTemplate, 3607 const void * pData ) const VULKAN_HPP_NOEXCEPT 3608 { 3609 return ::vkUpdateDescriptorSetWithTemplateKHR( device, descriptorSet, descriptorUpdateTemplate, pData ); 3610 } 3611 3612 //=== VK_NV_clip_space_w_scaling === 3613 vkCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer,uint32_t firstViewport,uint32_t viewportCount,const VkViewportWScalingNV * pViewportWScalings) const3614 void vkCmdSetViewportWScalingNV( VkCommandBuffer commandBuffer, 3615 uint32_t firstViewport, 3616 uint32_t viewportCount, 3617 const VkViewportWScalingNV * pViewportWScalings ) const VULKAN_HPP_NOEXCEPT 3618 { 3619 return ::vkCmdSetViewportWScalingNV( commandBuffer, firstViewport, viewportCount, pViewportWScalings ); 3620 } 3621 3622 //=== VK_EXT_direct_mode_display === 3623 vkReleaseDisplayEXT(VkPhysicalDevice physicalDevice,VkDisplayKHR display) const3624 VkResult vkReleaseDisplayEXT( VkPhysicalDevice physicalDevice, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT 3625 { 3626 return ::vkReleaseDisplayEXT( physicalDevice, display ); 3627 } 3628 3629 # if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) 3630 //=== VK_EXT_acquire_xlib_display === 3631 vkAcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice,Display * dpy,VkDisplayKHR display) const3632 VkResult vkAcquireXlibDisplayEXT( VkPhysicalDevice physicalDevice, 3633 Display * dpy, 3634 VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT 3635 { 3636 return ::vkAcquireXlibDisplayEXT( physicalDevice, dpy, display ); 3637 } 3638 vkGetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice,Display * dpy,RROutput rrOutput,VkDisplayKHR * pDisplay) const3639 VkResult vkGetRandROutputDisplayEXT( VkPhysicalDevice physicalDevice, 3640 Display * dpy, 3641 RROutput rrOutput, 3642 VkDisplayKHR * pDisplay ) const VULKAN_HPP_NOEXCEPT 3643 { 3644 return ::vkGetRandROutputDisplayEXT( physicalDevice, dpy, rrOutput, pDisplay ); 3645 } 3646 # endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ 3647 3648 //=== VK_EXT_display_surface_counter === 3649 vkGetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice,VkSurfaceKHR surface,VkSurfaceCapabilities2EXT * pSurfaceCapabilities) const3650 VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT( VkPhysicalDevice physicalDevice, 3651 VkSurfaceKHR surface, 3652 VkSurfaceCapabilities2EXT * pSurfaceCapabilities ) const 3653 VULKAN_HPP_NOEXCEPT 3654 { 3655 return ::vkGetPhysicalDeviceSurfaceCapabilities2EXT( physicalDevice, surface, pSurfaceCapabilities ); 3656 } 3657 3658 //=== VK_EXT_display_control === 3659 vkDisplayPowerControlEXT(VkDevice device,VkDisplayKHR display,const VkDisplayPowerInfoEXT * pDisplayPowerInfo) const3660 VkResult vkDisplayPowerControlEXT( VkDevice device, 3661 VkDisplayKHR display, 3662 const VkDisplayPowerInfoEXT * pDisplayPowerInfo ) const VULKAN_HPP_NOEXCEPT 3663 { 3664 return ::vkDisplayPowerControlEXT( device, display, pDisplayPowerInfo ); 3665 } 3666 vkRegisterDeviceEventEXT(VkDevice device,const VkDeviceEventInfoEXT * pDeviceEventInfo,const VkAllocationCallbacks * pAllocator,VkFence * pFence) const3667 VkResult vkRegisterDeviceEventEXT( VkDevice device, 3668 const VkDeviceEventInfoEXT * pDeviceEventInfo, 3669 const VkAllocationCallbacks * pAllocator, 3670 VkFence * pFence ) const VULKAN_HPP_NOEXCEPT 3671 { 3672 return ::vkRegisterDeviceEventEXT( device, pDeviceEventInfo, pAllocator, pFence ); 3673 } 3674 vkRegisterDisplayEventEXT(VkDevice device,VkDisplayKHR display,const VkDisplayEventInfoEXT * pDisplayEventInfo,const VkAllocationCallbacks * pAllocator,VkFence * pFence) const3675 VkResult vkRegisterDisplayEventEXT( VkDevice device, 3676 VkDisplayKHR display, 3677 const VkDisplayEventInfoEXT * pDisplayEventInfo, 3678 const VkAllocationCallbacks * pAllocator, 3679 VkFence * pFence ) const VULKAN_HPP_NOEXCEPT 3680 { 3681 return ::vkRegisterDisplayEventEXT( device, display, pDisplayEventInfo, pAllocator, pFence ); 3682 } 3683 vkGetSwapchainCounterEXT(VkDevice device,VkSwapchainKHR swapchain,VkSurfaceCounterFlagBitsEXT counter,uint64_t * pCounterValue) const3684 VkResult vkGetSwapchainCounterEXT( VkDevice device, 3685 VkSwapchainKHR swapchain, 3686 VkSurfaceCounterFlagBitsEXT counter, 3687 uint64_t * pCounterValue ) const VULKAN_HPP_NOEXCEPT 3688 { 3689 return ::vkGetSwapchainCounterEXT( device, swapchain, counter, pCounterValue ); 3690 } 3691 3692 //=== VK_GOOGLE_display_timing === 3693 vkGetRefreshCycleDurationGOOGLE(VkDevice device,VkSwapchainKHR swapchain,VkRefreshCycleDurationGOOGLE * pDisplayTimingProperties) const3694 VkResult vkGetRefreshCycleDurationGOOGLE( VkDevice device, 3695 VkSwapchainKHR swapchain, 3696 VkRefreshCycleDurationGOOGLE * pDisplayTimingProperties ) const 3697 VULKAN_HPP_NOEXCEPT 3698 { 3699 return ::vkGetRefreshCycleDurationGOOGLE( device, swapchain, pDisplayTimingProperties ); 3700 } 3701 vkGetPastPresentationTimingGOOGLE(VkDevice device,VkSwapchainKHR swapchain,uint32_t * pPresentationTimingCount,VkPastPresentationTimingGOOGLE * pPresentationTimings) const3702 VkResult vkGetPastPresentationTimingGOOGLE( VkDevice device, 3703 VkSwapchainKHR swapchain, 3704 uint32_t * pPresentationTimingCount, 3705 VkPastPresentationTimingGOOGLE * pPresentationTimings ) const 3706 VULKAN_HPP_NOEXCEPT 3707 { 3708 return ::vkGetPastPresentationTimingGOOGLE( device, swapchain, pPresentationTimingCount, pPresentationTimings ); 3709 } 3710 3711 //=== VK_EXT_discard_rectangles === 3712 vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer,uint32_t firstDiscardRectangle,uint32_t discardRectangleCount,const VkRect2D * pDiscardRectangles) const3713 void vkCmdSetDiscardRectangleEXT( VkCommandBuffer commandBuffer, 3714 uint32_t firstDiscardRectangle, 3715 uint32_t discardRectangleCount, 3716 const VkRect2D * pDiscardRectangles ) const VULKAN_HPP_NOEXCEPT 3717 { 3718 return ::vkCmdSetDiscardRectangleEXT( 3719 commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles ); 3720 } 3721 3722 //=== VK_EXT_hdr_metadata === 3723 vkSetHdrMetadataEXT(VkDevice device,uint32_t swapchainCount,const VkSwapchainKHR * pSwapchains,const VkHdrMetadataEXT * pMetadata) const3724 void vkSetHdrMetadataEXT( VkDevice device, 3725 uint32_t swapchainCount, 3726 const VkSwapchainKHR * pSwapchains, 3727 const VkHdrMetadataEXT * pMetadata ) const VULKAN_HPP_NOEXCEPT 3728 { 3729 return ::vkSetHdrMetadataEXT( device, swapchainCount, pSwapchains, pMetadata ); 3730 } 3731 3732 //=== VK_KHR_create_renderpass2 === 3733 vkCreateRenderPass2KHR(VkDevice device,const VkRenderPassCreateInfo2 * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkRenderPass * pRenderPass) const3734 VkResult vkCreateRenderPass2KHR( VkDevice device, 3735 const VkRenderPassCreateInfo2 * pCreateInfo, 3736 const VkAllocationCallbacks * pAllocator, 3737 VkRenderPass * pRenderPass ) const VULKAN_HPP_NOEXCEPT 3738 { 3739 return ::vkCreateRenderPass2KHR( device, pCreateInfo, pAllocator, pRenderPass ); 3740 } 3741 vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer,const VkRenderPassBeginInfo * pRenderPassBegin,const VkSubpassBeginInfo * pSubpassBeginInfo) const3742 void vkCmdBeginRenderPass2KHR( VkCommandBuffer commandBuffer, 3743 const VkRenderPassBeginInfo * pRenderPassBegin, 3744 const VkSubpassBeginInfo * pSubpassBeginInfo ) const VULKAN_HPP_NOEXCEPT 3745 { 3746 return ::vkCmdBeginRenderPass2KHR( commandBuffer, pRenderPassBegin, pSubpassBeginInfo ); 3747 } 3748 vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer,const VkSubpassBeginInfo * pSubpassBeginInfo,const VkSubpassEndInfo * pSubpassEndInfo) const3749 void vkCmdNextSubpass2KHR( VkCommandBuffer commandBuffer, 3750 const VkSubpassBeginInfo * pSubpassBeginInfo, 3751 const VkSubpassEndInfo * pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT 3752 { 3753 return ::vkCmdNextSubpass2KHR( commandBuffer, pSubpassBeginInfo, pSubpassEndInfo ); 3754 } 3755 vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer,const VkSubpassEndInfo * pSubpassEndInfo) const3756 void vkCmdEndRenderPass2KHR( VkCommandBuffer commandBuffer, 3757 const VkSubpassEndInfo * pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT 3758 { 3759 return ::vkCmdEndRenderPass2KHR( commandBuffer, pSubpassEndInfo ); 3760 } 3761 3762 //=== VK_KHR_shared_presentable_image === 3763 vkGetSwapchainStatusKHR(VkDevice device,VkSwapchainKHR swapchain) const3764 VkResult vkGetSwapchainStatusKHR( VkDevice device, VkSwapchainKHR swapchain ) const VULKAN_HPP_NOEXCEPT 3765 { 3766 return ::vkGetSwapchainStatusKHR( device, swapchain ); 3767 } 3768 3769 //=== VK_KHR_external_fence_capabilities === 3770 vkGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,VkExternalFenceProperties * pExternalFenceProperties) const3771 void vkGetPhysicalDeviceExternalFencePropertiesKHR( VkPhysicalDevice physicalDevice, 3772 const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo, 3773 VkExternalFenceProperties * pExternalFenceProperties ) const 3774 VULKAN_HPP_NOEXCEPT 3775 { 3776 return ::vkGetPhysicalDeviceExternalFencePropertiesKHR( 3777 physicalDevice, pExternalFenceInfo, pExternalFenceProperties ); 3778 } 3779 3780 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 3781 //=== VK_KHR_external_fence_win32 === 3782 vkImportFenceWin32HandleKHR(VkDevice device,const VkImportFenceWin32HandleInfoKHR * pImportFenceWin32HandleInfo) const3783 VkResult vkImportFenceWin32HandleKHR( 3784 VkDevice device, const VkImportFenceWin32HandleInfoKHR * pImportFenceWin32HandleInfo ) const VULKAN_HPP_NOEXCEPT 3785 { 3786 return ::vkImportFenceWin32HandleKHR( device, pImportFenceWin32HandleInfo ); 3787 } 3788 vkGetFenceWin32HandleKHR(VkDevice device,const VkFenceGetWin32HandleInfoKHR * pGetWin32HandleInfo,HANDLE * pHandle) const3789 VkResult vkGetFenceWin32HandleKHR( VkDevice device, 3790 const VkFenceGetWin32HandleInfoKHR * pGetWin32HandleInfo, 3791 HANDLE * pHandle ) const VULKAN_HPP_NOEXCEPT 3792 { 3793 return ::vkGetFenceWin32HandleKHR( device, pGetWin32HandleInfo, pHandle ); 3794 } 3795 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 3796 3797 //=== VK_KHR_external_fence_fd === 3798 vkImportFenceFdKHR(VkDevice device,const VkImportFenceFdInfoKHR * pImportFenceFdInfo) const3799 VkResult vkImportFenceFdKHR( VkDevice device, 3800 const VkImportFenceFdInfoKHR * pImportFenceFdInfo ) const VULKAN_HPP_NOEXCEPT 3801 { 3802 return ::vkImportFenceFdKHR( device, pImportFenceFdInfo ); 3803 } 3804 3805 VkResult vkGetFenceFdKHR(VkDevice device,const VkFenceGetFdInfoKHR * pGetFdInfo,int * pFd) const3806 vkGetFenceFdKHR( VkDevice device, const VkFenceGetFdInfoKHR * pGetFdInfo, int * pFd ) const VULKAN_HPP_NOEXCEPT 3807 { 3808 return ::vkGetFenceFdKHR( device, pGetFdInfo, pFd ); 3809 } 3810 3811 //=== VK_KHR_performance_query === 3812 vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(VkPhysicalDevice physicalDevice,uint32_t queueFamilyIndex,uint32_t * pCounterCount,VkPerformanceCounterKHR * pCounters,VkPerformanceCounterDescriptionKHR * pCounterDescriptions) const3813 VkResult vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( 3814 VkPhysicalDevice physicalDevice, 3815 uint32_t queueFamilyIndex, 3816 uint32_t * pCounterCount, 3817 VkPerformanceCounterKHR * pCounters, 3818 VkPerformanceCounterDescriptionKHR * pCounterDescriptions ) const VULKAN_HPP_NOEXCEPT 3819 { 3820 return ::vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( 3821 physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions ); 3822 } 3823 vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(VkPhysicalDevice physicalDevice,const VkQueryPoolPerformanceCreateInfoKHR * pPerformanceQueryCreateInfo,uint32_t * pNumPasses) const3824 void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( 3825 VkPhysicalDevice physicalDevice, 3826 const VkQueryPoolPerformanceCreateInfoKHR * pPerformanceQueryCreateInfo, 3827 uint32_t * pNumPasses ) const VULKAN_HPP_NOEXCEPT 3828 { 3829 return ::vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( 3830 physicalDevice, pPerformanceQueryCreateInfo, pNumPasses ); 3831 } 3832 vkAcquireProfilingLockKHR(VkDevice device,const VkAcquireProfilingLockInfoKHR * pInfo) const3833 VkResult vkAcquireProfilingLockKHR( VkDevice device, 3834 const VkAcquireProfilingLockInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT 3835 { 3836 return ::vkAcquireProfilingLockKHR( device, pInfo ); 3837 } 3838 vkReleaseProfilingLockKHR(VkDevice device) const3839 void vkReleaseProfilingLockKHR( VkDevice device ) const VULKAN_HPP_NOEXCEPT 3840 { 3841 return ::vkReleaseProfilingLockKHR( device ); 3842 } 3843 3844 //=== VK_KHR_get_surface_capabilities2 === 3845 vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,VkSurfaceCapabilities2KHR * pSurfaceCapabilities) const3846 VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR( VkPhysicalDevice physicalDevice, 3847 const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, 3848 VkSurfaceCapabilities2KHR * pSurfaceCapabilities ) const 3849 VULKAN_HPP_NOEXCEPT 3850 { 3851 return ::vkGetPhysicalDeviceSurfaceCapabilities2KHR( physicalDevice, pSurfaceInfo, pSurfaceCapabilities ); 3852 } 3853 vkGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,uint32_t * pSurfaceFormatCount,VkSurfaceFormat2KHR * pSurfaceFormats) const3854 VkResult vkGetPhysicalDeviceSurfaceFormats2KHR( VkPhysicalDevice physicalDevice, 3855 const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, 3856 uint32_t * pSurfaceFormatCount, 3857 VkSurfaceFormat2KHR * pSurfaceFormats ) const VULKAN_HPP_NOEXCEPT 3858 { 3859 return ::vkGetPhysicalDeviceSurfaceFormats2KHR( 3860 physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats ); 3861 } 3862 3863 //=== VK_KHR_get_display_properties2 === 3864 vkGetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkDisplayProperties2KHR * pProperties) const3865 VkResult vkGetPhysicalDeviceDisplayProperties2KHR( VkPhysicalDevice physicalDevice, 3866 uint32_t * pPropertyCount, 3867 VkDisplayProperties2KHR * pProperties ) const VULKAN_HPP_NOEXCEPT 3868 { 3869 return ::vkGetPhysicalDeviceDisplayProperties2KHR( physicalDevice, pPropertyCount, pProperties ); 3870 } 3871 vkGetPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkDisplayPlaneProperties2KHR * pProperties) const3872 VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR( VkPhysicalDevice physicalDevice, 3873 uint32_t * pPropertyCount, 3874 VkDisplayPlaneProperties2KHR * pProperties ) const 3875 VULKAN_HPP_NOEXCEPT 3876 { 3877 return ::vkGetPhysicalDeviceDisplayPlaneProperties2KHR( physicalDevice, pPropertyCount, pProperties ); 3878 } 3879 vkGetDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice,VkDisplayKHR display,uint32_t * pPropertyCount,VkDisplayModeProperties2KHR * pProperties) const3880 VkResult vkGetDisplayModeProperties2KHR( VkPhysicalDevice physicalDevice, 3881 VkDisplayKHR display, 3882 uint32_t * pPropertyCount, 3883 VkDisplayModeProperties2KHR * pProperties ) const VULKAN_HPP_NOEXCEPT 3884 { 3885 return ::vkGetDisplayModeProperties2KHR( physicalDevice, display, pPropertyCount, pProperties ); 3886 } 3887 3888 VkResult vkGetDisplayPlaneCapabilities2KHR(VkPhysicalDevice physicalDevice,const VkDisplayPlaneInfo2KHR * pDisplayPlaneInfo,VkDisplayPlaneCapabilities2KHR * pCapabilities) const3889 vkGetDisplayPlaneCapabilities2KHR( VkPhysicalDevice physicalDevice, 3890 const VkDisplayPlaneInfo2KHR * pDisplayPlaneInfo, 3891 VkDisplayPlaneCapabilities2KHR * pCapabilities ) const VULKAN_HPP_NOEXCEPT 3892 { 3893 return ::vkGetDisplayPlaneCapabilities2KHR( physicalDevice, pDisplayPlaneInfo, pCapabilities ); 3894 } 3895 3896 # if defined( VK_USE_PLATFORM_IOS_MVK ) 3897 //=== VK_MVK_ios_surface === 3898 vkCreateIOSSurfaceMVK(VkInstance instance,const VkIOSSurfaceCreateInfoMVK * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface) const3899 VkResult vkCreateIOSSurfaceMVK( VkInstance instance, 3900 const VkIOSSurfaceCreateInfoMVK * pCreateInfo, 3901 const VkAllocationCallbacks * pAllocator, 3902 VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT 3903 { 3904 return ::vkCreateIOSSurfaceMVK( instance, pCreateInfo, pAllocator, pSurface ); 3905 } 3906 # endif /*VK_USE_PLATFORM_IOS_MVK*/ 3907 3908 # if defined( VK_USE_PLATFORM_MACOS_MVK ) 3909 //=== VK_MVK_macos_surface === 3910 vkCreateMacOSSurfaceMVK(VkInstance instance,const VkMacOSSurfaceCreateInfoMVK * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface) const3911 VkResult vkCreateMacOSSurfaceMVK( VkInstance instance, 3912 const VkMacOSSurfaceCreateInfoMVK * pCreateInfo, 3913 const VkAllocationCallbacks * pAllocator, 3914 VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT 3915 { 3916 return ::vkCreateMacOSSurfaceMVK( instance, pCreateInfo, pAllocator, pSurface ); 3917 } 3918 # endif /*VK_USE_PLATFORM_MACOS_MVK*/ 3919 3920 //=== VK_EXT_debug_utils === 3921 vkSetDebugUtilsObjectNameEXT(VkDevice device,const VkDebugUtilsObjectNameInfoEXT * pNameInfo) const3922 VkResult vkSetDebugUtilsObjectNameEXT( VkDevice device, 3923 const VkDebugUtilsObjectNameInfoEXT * pNameInfo ) const VULKAN_HPP_NOEXCEPT 3924 { 3925 return ::vkSetDebugUtilsObjectNameEXT( device, pNameInfo ); 3926 } 3927 vkSetDebugUtilsObjectTagEXT(VkDevice device,const VkDebugUtilsObjectTagInfoEXT * pTagInfo) const3928 VkResult vkSetDebugUtilsObjectTagEXT( VkDevice device, 3929 const VkDebugUtilsObjectTagInfoEXT * pTagInfo ) const VULKAN_HPP_NOEXCEPT 3930 { 3931 return ::vkSetDebugUtilsObjectTagEXT( device, pTagInfo ); 3932 } 3933 vkQueueBeginDebugUtilsLabelEXT(VkQueue queue,const VkDebugUtilsLabelEXT * pLabelInfo) const3934 void vkQueueBeginDebugUtilsLabelEXT( VkQueue queue, 3935 const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT 3936 { 3937 return ::vkQueueBeginDebugUtilsLabelEXT( queue, pLabelInfo ); 3938 } 3939 vkQueueEndDebugUtilsLabelEXT(VkQueue queue) const3940 void vkQueueEndDebugUtilsLabelEXT( VkQueue queue ) const VULKAN_HPP_NOEXCEPT 3941 { 3942 return ::vkQueueEndDebugUtilsLabelEXT( queue ); 3943 } 3944 vkQueueInsertDebugUtilsLabelEXT(VkQueue queue,const VkDebugUtilsLabelEXT * pLabelInfo) const3945 void vkQueueInsertDebugUtilsLabelEXT( VkQueue queue, 3946 const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT 3947 { 3948 return ::vkQueueInsertDebugUtilsLabelEXT( queue, pLabelInfo ); 3949 } 3950 vkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer,const VkDebugUtilsLabelEXT * pLabelInfo) const3951 void vkCmdBeginDebugUtilsLabelEXT( VkCommandBuffer commandBuffer, 3952 const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT 3953 { 3954 return ::vkCmdBeginDebugUtilsLabelEXT( commandBuffer, pLabelInfo ); 3955 } 3956 vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer) const3957 void vkCmdEndDebugUtilsLabelEXT( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT 3958 { 3959 return ::vkCmdEndDebugUtilsLabelEXT( commandBuffer ); 3960 } 3961 vkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer,const VkDebugUtilsLabelEXT * pLabelInfo) const3962 void vkCmdInsertDebugUtilsLabelEXT( VkCommandBuffer commandBuffer, 3963 const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT 3964 { 3965 return ::vkCmdInsertDebugUtilsLabelEXT( commandBuffer, pLabelInfo ); 3966 } 3967 vkCreateDebugUtilsMessengerEXT(VkInstance instance,const VkDebugUtilsMessengerCreateInfoEXT * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkDebugUtilsMessengerEXT * pMessenger) const3968 VkResult vkCreateDebugUtilsMessengerEXT( VkInstance instance, 3969 const VkDebugUtilsMessengerCreateInfoEXT * pCreateInfo, 3970 const VkAllocationCallbacks * pAllocator, 3971 VkDebugUtilsMessengerEXT * pMessenger ) const VULKAN_HPP_NOEXCEPT 3972 { 3973 return ::vkCreateDebugUtilsMessengerEXT( instance, pCreateInfo, pAllocator, pMessenger ); 3974 } 3975 vkDestroyDebugUtilsMessengerEXT(VkInstance instance,VkDebugUtilsMessengerEXT messenger,const VkAllocationCallbacks * pAllocator) const3976 void vkDestroyDebugUtilsMessengerEXT( VkInstance instance, 3977 VkDebugUtilsMessengerEXT messenger, 3978 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT 3979 { 3980 return ::vkDestroyDebugUtilsMessengerEXT( instance, messenger, pAllocator ); 3981 } 3982 vkSubmitDebugUtilsMessageEXT(VkInstance instance,VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,VkDebugUtilsMessageTypeFlagsEXT messageTypes,const VkDebugUtilsMessengerCallbackDataEXT * pCallbackData) const3983 void vkSubmitDebugUtilsMessageEXT( VkInstance instance, 3984 VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, 3985 VkDebugUtilsMessageTypeFlagsEXT messageTypes, 3986 const VkDebugUtilsMessengerCallbackDataEXT * pCallbackData ) const 3987 VULKAN_HPP_NOEXCEPT 3988 { 3989 return ::vkSubmitDebugUtilsMessageEXT( instance, messageSeverity, messageTypes, pCallbackData ); 3990 } 3991 3992 # if defined( VK_USE_PLATFORM_ANDROID_KHR ) 3993 //=== VK_ANDROID_external_memory_android_hardware_buffer === 3994 vkGetAndroidHardwareBufferPropertiesANDROID(VkDevice device,const struct AHardwareBuffer * buffer,VkAndroidHardwareBufferPropertiesANDROID * pProperties) const3995 VkResult vkGetAndroidHardwareBufferPropertiesANDROID( VkDevice device, 3996 const struct AHardwareBuffer * buffer, 3997 VkAndroidHardwareBufferPropertiesANDROID * pProperties ) const 3998 VULKAN_HPP_NOEXCEPT 3999 { 4000 return ::vkGetAndroidHardwareBufferPropertiesANDROID( device, buffer, pProperties ); 4001 } 4002 vkGetMemoryAndroidHardwareBufferANDROID(VkDevice device,const VkMemoryGetAndroidHardwareBufferInfoANDROID * pInfo,struct AHardwareBuffer ** pBuffer) const4003 VkResult vkGetMemoryAndroidHardwareBufferANDROID( VkDevice device, 4004 const VkMemoryGetAndroidHardwareBufferInfoANDROID * pInfo, 4005 struct AHardwareBuffer ** pBuffer ) const VULKAN_HPP_NOEXCEPT 4006 { 4007 return ::vkGetMemoryAndroidHardwareBufferANDROID( device, pInfo, pBuffer ); 4008 } 4009 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 4010 4011 //=== VK_EXT_sample_locations === 4012 vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer,const VkSampleLocationsInfoEXT * pSampleLocationsInfo) const4013 void vkCmdSetSampleLocationsEXT( VkCommandBuffer commandBuffer, 4014 const VkSampleLocationsInfoEXT * pSampleLocationsInfo ) const VULKAN_HPP_NOEXCEPT 4015 { 4016 return ::vkCmdSetSampleLocationsEXT( commandBuffer, pSampleLocationsInfo ); 4017 } 4018 vkGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice,VkSampleCountFlagBits samples,VkMultisamplePropertiesEXT * pMultisampleProperties) const4019 void vkGetPhysicalDeviceMultisamplePropertiesEXT( VkPhysicalDevice physicalDevice, 4020 VkSampleCountFlagBits samples, 4021 VkMultisamplePropertiesEXT * pMultisampleProperties ) const 4022 VULKAN_HPP_NOEXCEPT 4023 { 4024 return ::vkGetPhysicalDeviceMultisamplePropertiesEXT( physicalDevice, samples, pMultisampleProperties ); 4025 } 4026 4027 //=== VK_KHR_get_memory_requirements2 === 4028 vkGetImageMemoryRequirements2KHR(VkDevice device,const VkImageMemoryRequirementsInfo2 * pInfo,VkMemoryRequirements2 * pMemoryRequirements) const4029 void vkGetImageMemoryRequirements2KHR( VkDevice device, 4030 const VkImageMemoryRequirementsInfo2 * pInfo, 4031 VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT 4032 { 4033 return ::vkGetImageMemoryRequirements2KHR( device, pInfo, pMemoryRequirements ); 4034 } 4035 vkGetBufferMemoryRequirements2KHR(VkDevice device,const VkBufferMemoryRequirementsInfo2 * pInfo,VkMemoryRequirements2 * pMemoryRequirements) const4036 void vkGetBufferMemoryRequirements2KHR( VkDevice device, 4037 const VkBufferMemoryRequirementsInfo2 * pInfo, 4038 VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT 4039 { 4040 return ::vkGetBufferMemoryRequirements2KHR( device, pInfo, pMemoryRequirements ); 4041 } 4042 vkGetImageSparseMemoryRequirements2KHR(VkDevice device,const VkImageSparseMemoryRequirementsInfo2 * pInfo,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements) const4043 void vkGetImageSparseMemoryRequirements2KHR( VkDevice device, 4044 const VkImageSparseMemoryRequirementsInfo2 * pInfo, 4045 uint32_t * pSparseMemoryRequirementCount, 4046 VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements ) const 4047 VULKAN_HPP_NOEXCEPT 4048 { 4049 return ::vkGetImageSparseMemoryRequirements2KHR( 4050 device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements ); 4051 } 4052 4053 //=== VK_KHR_acceleration_structure === 4054 4055 VkResult vkCreateAccelerationStructureKHR(VkDevice device,const VkAccelerationStructureCreateInfoKHR * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkAccelerationStructureKHR * pAccelerationStructure) const4056 vkCreateAccelerationStructureKHR( VkDevice device, 4057 const VkAccelerationStructureCreateInfoKHR * pCreateInfo, 4058 const VkAllocationCallbacks * pAllocator, 4059 VkAccelerationStructureKHR * pAccelerationStructure ) const VULKAN_HPP_NOEXCEPT 4060 { 4061 return ::vkCreateAccelerationStructureKHR( device, pCreateInfo, pAllocator, pAccelerationStructure ); 4062 } 4063 vkDestroyAccelerationStructureKHR(VkDevice device,VkAccelerationStructureKHR accelerationStructure,const VkAllocationCallbacks * pAllocator) const4064 void vkDestroyAccelerationStructureKHR( VkDevice device, 4065 VkAccelerationStructureKHR accelerationStructure, 4066 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT 4067 { 4068 return ::vkDestroyAccelerationStructureKHR( device, accelerationStructure, pAllocator ); 4069 } 4070 vkCmdBuildAccelerationStructuresKHR(VkCommandBuffer commandBuffer,uint32_t infoCount,const VkAccelerationStructureBuildGeometryInfoKHR * pInfos,const VkAccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos) const4071 void vkCmdBuildAccelerationStructuresKHR( 4072 VkCommandBuffer commandBuffer, 4073 uint32_t infoCount, 4074 const VkAccelerationStructureBuildGeometryInfoKHR * pInfos, 4075 const VkAccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos ) const VULKAN_HPP_NOEXCEPT 4076 { 4077 return ::vkCmdBuildAccelerationStructuresKHR( commandBuffer, infoCount, pInfos, ppBuildRangeInfos ); 4078 } 4079 vkCmdBuildAccelerationStructuresIndirectKHR(VkCommandBuffer commandBuffer,uint32_t infoCount,const VkAccelerationStructureBuildGeometryInfoKHR * pInfos,const VkDeviceAddress * pIndirectDeviceAddresses,const uint32_t * pIndirectStrides,const uint32_t * const * ppMaxPrimitiveCounts) const4080 void vkCmdBuildAccelerationStructuresIndirectKHR( VkCommandBuffer commandBuffer, 4081 uint32_t infoCount, 4082 const VkAccelerationStructureBuildGeometryInfoKHR * pInfos, 4083 const VkDeviceAddress * pIndirectDeviceAddresses, 4084 const uint32_t * pIndirectStrides, 4085 const uint32_t * const * ppMaxPrimitiveCounts ) const 4086 VULKAN_HPP_NOEXCEPT 4087 { 4088 return ::vkCmdBuildAccelerationStructuresIndirectKHR( 4089 commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts ); 4090 } 4091 vkBuildAccelerationStructuresKHR(VkDevice device,VkDeferredOperationKHR deferredOperation,uint32_t infoCount,const VkAccelerationStructureBuildGeometryInfoKHR * pInfos,const VkAccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos) const4092 VkResult vkBuildAccelerationStructuresKHR( 4093 VkDevice device, 4094 VkDeferredOperationKHR deferredOperation, 4095 uint32_t infoCount, 4096 const VkAccelerationStructureBuildGeometryInfoKHR * pInfos, 4097 const VkAccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos ) const VULKAN_HPP_NOEXCEPT 4098 { 4099 return ::vkBuildAccelerationStructuresKHR( device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos ); 4100 } 4101 4102 VkResult vkCopyAccelerationStructureKHR(VkDevice device,VkDeferredOperationKHR deferredOperation,const VkCopyAccelerationStructureInfoKHR * pInfo) const4103 vkCopyAccelerationStructureKHR( VkDevice device, 4104 VkDeferredOperationKHR deferredOperation, 4105 const VkCopyAccelerationStructureInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT 4106 { 4107 return ::vkCopyAccelerationStructureKHR( device, deferredOperation, pInfo ); 4108 } 4109 vkCopyAccelerationStructureToMemoryKHR(VkDevice device,VkDeferredOperationKHR deferredOperation,const VkCopyAccelerationStructureToMemoryInfoKHR * pInfo) const4110 VkResult vkCopyAccelerationStructureToMemoryKHR( VkDevice device, 4111 VkDeferredOperationKHR deferredOperation, 4112 const VkCopyAccelerationStructureToMemoryInfoKHR * pInfo ) const 4113 VULKAN_HPP_NOEXCEPT 4114 { 4115 return ::vkCopyAccelerationStructureToMemoryKHR( device, deferredOperation, pInfo ); 4116 } 4117 vkCopyMemoryToAccelerationStructureKHR(VkDevice device,VkDeferredOperationKHR deferredOperation,const VkCopyMemoryToAccelerationStructureInfoKHR * pInfo) const4118 VkResult vkCopyMemoryToAccelerationStructureKHR( VkDevice device, 4119 VkDeferredOperationKHR deferredOperation, 4120 const VkCopyMemoryToAccelerationStructureInfoKHR * pInfo ) const 4121 VULKAN_HPP_NOEXCEPT 4122 { 4123 return ::vkCopyMemoryToAccelerationStructureKHR( device, deferredOperation, pInfo ); 4124 } 4125 vkWriteAccelerationStructuresPropertiesKHR(VkDevice device,uint32_t accelerationStructureCount,const VkAccelerationStructureKHR * pAccelerationStructures,VkQueryType queryType,size_t dataSize,void * pData,size_t stride) const4126 VkResult vkWriteAccelerationStructuresPropertiesKHR( VkDevice device, 4127 uint32_t accelerationStructureCount, 4128 const VkAccelerationStructureKHR * pAccelerationStructures, 4129 VkQueryType queryType, 4130 size_t dataSize, 4131 void * pData, 4132 size_t stride ) const VULKAN_HPP_NOEXCEPT 4133 { 4134 return ::vkWriteAccelerationStructuresPropertiesKHR( 4135 device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride ); 4136 } 4137 vkCmdCopyAccelerationStructureKHR(VkCommandBuffer commandBuffer,const VkCopyAccelerationStructureInfoKHR * pInfo) const4138 void vkCmdCopyAccelerationStructureKHR( VkCommandBuffer commandBuffer, 4139 const VkCopyAccelerationStructureInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT 4140 { 4141 return ::vkCmdCopyAccelerationStructureKHR( commandBuffer, pInfo ); 4142 } 4143 vkCmdCopyAccelerationStructureToMemoryKHR(VkCommandBuffer commandBuffer,const VkCopyAccelerationStructureToMemoryInfoKHR * pInfo) const4144 void vkCmdCopyAccelerationStructureToMemoryKHR( VkCommandBuffer commandBuffer, 4145 const VkCopyAccelerationStructureToMemoryInfoKHR * pInfo ) const 4146 VULKAN_HPP_NOEXCEPT 4147 { 4148 return ::vkCmdCopyAccelerationStructureToMemoryKHR( commandBuffer, pInfo ); 4149 } 4150 vkCmdCopyMemoryToAccelerationStructureKHR(VkCommandBuffer commandBuffer,const VkCopyMemoryToAccelerationStructureInfoKHR * pInfo) const4151 void vkCmdCopyMemoryToAccelerationStructureKHR( VkCommandBuffer commandBuffer, 4152 const VkCopyMemoryToAccelerationStructureInfoKHR * pInfo ) const 4153 VULKAN_HPP_NOEXCEPT 4154 { 4155 return ::vkCmdCopyMemoryToAccelerationStructureKHR( commandBuffer, pInfo ); 4156 } 4157 vkGetAccelerationStructureDeviceAddressKHR(VkDevice device,const VkAccelerationStructureDeviceAddressInfoKHR * pInfo) const4158 VkDeviceAddress vkGetAccelerationStructureDeviceAddressKHR( 4159 VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT 4160 { 4161 return ::vkGetAccelerationStructureDeviceAddressKHR( device, pInfo ); 4162 } 4163 vkCmdWriteAccelerationStructuresPropertiesKHR(VkCommandBuffer commandBuffer,uint32_t accelerationStructureCount,const VkAccelerationStructureKHR * pAccelerationStructures,VkQueryType queryType,VkQueryPool queryPool,uint32_t firstQuery) const4164 void vkCmdWriteAccelerationStructuresPropertiesKHR( VkCommandBuffer commandBuffer, 4165 uint32_t accelerationStructureCount, 4166 const VkAccelerationStructureKHR * pAccelerationStructures, 4167 VkQueryType queryType, 4168 VkQueryPool queryPool, 4169 uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT 4170 { 4171 return ::vkCmdWriteAccelerationStructuresPropertiesKHR( 4172 commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery ); 4173 } 4174 vkGetDeviceAccelerationStructureCompatibilityKHR(VkDevice device,const VkAccelerationStructureVersionInfoKHR * pVersionInfo,VkAccelerationStructureCompatibilityKHR * pCompatibility) const4175 void vkGetDeviceAccelerationStructureCompatibilityKHR( 4176 VkDevice device, 4177 const VkAccelerationStructureVersionInfoKHR * pVersionInfo, 4178 VkAccelerationStructureCompatibilityKHR * pCompatibility ) const VULKAN_HPP_NOEXCEPT 4179 { 4180 return ::vkGetDeviceAccelerationStructureCompatibilityKHR( device, pVersionInfo, pCompatibility ); 4181 } 4182 vkGetAccelerationStructureBuildSizesKHR(VkDevice device,VkAccelerationStructureBuildTypeKHR buildType,const VkAccelerationStructureBuildGeometryInfoKHR * pBuildInfo,const uint32_t * pMaxPrimitiveCounts,VkAccelerationStructureBuildSizesInfoKHR * pSizeInfo) const4183 void vkGetAccelerationStructureBuildSizesKHR( VkDevice device, 4184 VkAccelerationStructureBuildTypeKHR buildType, 4185 const VkAccelerationStructureBuildGeometryInfoKHR * pBuildInfo, 4186 const uint32_t * pMaxPrimitiveCounts, 4187 VkAccelerationStructureBuildSizesInfoKHR * pSizeInfo ) const 4188 VULKAN_HPP_NOEXCEPT 4189 { 4190 return ::vkGetAccelerationStructureBuildSizesKHR( device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo ); 4191 } 4192 4193 //=== VK_KHR_sampler_ycbcr_conversion === 4194 vkCreateSamplerYcbcrConversionKHR(VkDevice device,const VkSamplerYcbcrConversionCreateInfo * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSamplerYcbcrConversion * pYcbcrConversion) const4195 VkResult vkCreateSamplerYcbcrConversionKHR( VkDevice device, 4196 const VkSamplerYcbcrConversionCreateInfo * pCreateInfo, 4197 const VkAllocationCallbacks * pAllocator, 4198 VkSamplerYcbcrConversion * pYcbcrConversion ) const VULKAN_HPP_NOEXCEPT 4199 { 4200 return ::vkCreateSamplerYcbcrConversionKHR( device, pCreateInfo, pAllocator, pYcbcrConversion ); 4201 } 4202 vkDestroySamplerYcbcrConversionKHR(VkDevice device,VkSamplerYcbcrConversion ycbcrConversion,const VkAllocationCallbacks * pAllocator) const4203 void vkDestroySamplerYcbcrConversionKHR( VkDevice device, 4204 VkSamplerYcbcrConversion ycbcrConversion, 4205 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT 4206 { 4207 return ::vkDestroySamplerYcbcrConversionKHR( device, ycbcrConversion, pAllocator ); 4208 } 4209 4210 //=== VK_KHR_bind_memory2 === 4211 vkBindBufferMemory2KHR(VkDevice device,uint32_t bindInfoCount,const VkBindBufferMemoryInfo * pBindInfos) const4212 VkResult vkBindBufferMemory2KHR( VkDevice device, 4213 uint32_t bindInfoCount, 4214 const VkBindBufferMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT 4215 { 4216 return ::vkBindBufferMemory2KHR( device, bindInfoCount, pBindInfos ); 4217 } 4218 vkBindImageMemory2KHR(VkDevice device,uint32_t bindInfoCount,const VkBindImageMemoryInfo * pBindInfos) const4219 VkResult vkBindImageMemory2KHR( VkDevice device, 4220 uint32_t bindInfoCount, 4221 const VkBindImageMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT 4222 { 4223 return ::vkBindImageMemory2KHR( device, bindInfoCount, pBindInfos ); 4224 } 4225 4226 //=== VK_EXT_image_drm_format_modifier === 4227 vkGetImageDrmFormatModifierPropertiesEXT(VkDevice device,VkImage image,VkImageDrmFormatModifierPropertiesEXT * pProperties) const4228 VkResult vkGetImageDrmFormatModifierPropertiesEXT( 4229 VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT * pProperties ) const VULKAN_HPP_NOEXCEPT 4230 { 4231 return ::vkGetImageDrmFormatModifierPropertiesEXT( device, image, pProperties ); 4232 } 4233 4234 //=== VK_EXT_validation_cache === 4235 vkCreateValidationCacheEXT(VkDevice device,const VkValidationCacheCreateInfoEXT * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkValidationCacheEXT * pValidationCache) const4236 VkResult vkCreateValidationCacheEXT( VkDevice device, 4237 const VkValidationCacheCreateInfoEXT * pCreateInfo, 4238 const VkAllocationCallbacks * pAllocator, 4239 VkValidationCacheEXT * pValidationCache ) const VULKAN_HPP_NOEXCEPT 4240 { 4241 return ::vkCreateValidationCacheEXT( device, pCreateInfo, pAllocator, pValidationCache ); 4242 } 4243 vkDestroyValidationCacheEXT(VkDevice device,VkValidationCacheEXT validationCache,const VkAllocationCallbacks * pAllocator) const4244 void vkDestroyValidationCacheEXT( VkDevice device, 4245 VkValidationCacheEXT validationCache, 4246 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT 4247 { 4248 return ::vkDestroyValidationCacheEXT( device, validationCache, pAllocator ); 4249 } 4250 vkMergeValidationCachesEXT(VkDevice device,VkValidationCacheEXT dstCache,uint32_t srcCacheCount,const VkValidationCacheEXT * pSrcCaches) const4251 VkResult vkMergeValidationCachesEXT( VkDevice device, 4252 VkValidationCacheEXT dstCache, 4253 uint32_t srcCacheCount, 4254 const VkValidationCacheEXT * pSrcCaches ) const VULKAN_HPP_NOEXCEPT 4255 { 4256 return ::vkMergeValidationCachesEXT( device, dstCache, srcCacheCount, pSrcCaches ); 4257 } 4258 vkGetValidationCacheDataEXT(VkDevice device,VkValidationCacheEXT validationCache,size_t * pDataSize,void * pData) const4259 VkResult vkGetValidationCacheDataEXT( VkDevice device, 4260 VkValidationCacheEXT validationCache, 4261 size_t * pDataSize, 4262 void * pData ) const VULKAN_HPP_NOEXCEPT 4263 { 4264 return ::vkGetValidationCacheDataEXT( device, validationCache, pDataSize, pData ); 4265 } 4266 4267 //=== VK_NV_shading_rate_image === 4268 vkCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer,VkImageView imageView,VkImageLayout imageLayout) const4269 void vkCmdBindShadingRateImageNV( VkCommandBuffer commandBuffer, 4270 VkImageView imageView, 4271 VkImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT 4272 { 4273 return ::vkCmdBindShadingRateImageNV( commandBuffer, imageView, imageLayout ); 4274 } 4275 vkCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer,uint32_t firstViewport,uint32_t viewportCount,const VkShadingRatePaletteNV * pShadingRatePalettes) const4276 void vkCmdSetViewportShadingRatePaletteNV( VkCommandBuffer commandBuffer, 4277 uint32_t firstViewport, 4278 uint32_t viewportCount, 4279 const VkShadingRatePaletteNV * pShadingRatePalettes ) const 4280 VULKAN_HPP_NOEXCEPT 4281 { 4282 return ::vkCmdSetViewportShadingRatePaletteNV( 4283 commandBuffer, firstViewport, viewportCount, pShadingRatePalettes ); 4284 } 4285 4286 void vkCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer,VkCoarseSampleOrderTypeNV sampleOrderType,uint32_t customSampleOrderCount,const VkCoarseSampleOrderCustomNV * pCustomSampleOrders) const4287 vkCmdSetCoarseSampleOrderNV( VkCommandBuffer commandBuffer, 4288 VkCoarseSampleOrderTypeNV sampleOrderType, 4289 uint32_t customSampleOrderCount, 4290 const VkCoarseSampleOrderCustomNV * pCustomSampleOrders ) const VULKAN_HPP_NOEXCEPT 4291 { 4292 return ::vkCmdSetCoarseSampleOrderNV( 4293 commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders ); 4294 } 4295 4296 //=== VK_NV_ray_tracing === 4297 4298 VkResult vkCreateAccelerationStructureNV(VkDevice device,const VkAccelerationStructureCreateInfoNV * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkAccelerationStructureNV * pAccelerationStructure) const4299 vkCreateAccelerationStructureNV( VkDevice device, 4300 const VkAccelerationStructureCreateInfoNV * pCreateInfo, 4301 const VkAllocationCallbacks * pAllocator, 4302 VkAccelerationStructureNV * pAccelerationStructure ) const VULKAN_HPP_NOEXCEPT 4303 { 4304 return ::vkCreateAccelerationStructureNV( device, pCreateInfo, pAllocator, pAccelerationStructure ); 4305 } 4306 vkDestroyAccelerationStructureNV(VkDevice device,VkAccelerationStructureNV accelerationStructure,const VkAllocationCallbacks * pAllocator) const4307 void vkDestroyAccelerationStructureNV( VkDevice device, 4308 VkAccelerationStructureNV accelerationStructure, 4309 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT 4310 { 4311 return ::vkDestroyAccelerationStructureNV( device, accelerationStructure, pAllocator ); 4312 } 4313 vkGetAccelerationStructureMemoryRequirementsNV(VkDevice device,const VkAccelerationStructureMemoryRequirementsInfoNV * pInfo,VkMemoryRequirements2KHR * pMemoryRequirements) const4314 void vkGetAccelerationStructureMemoryRequirementsNV( VkDevice device, 4315 const VkAccelerationStructureMemoryRequirementsInfoNV * pInfo, 4316 VkMemoryRequirements2KHR * pMemoryRequirements ) const 4317 VULKAN_HPP_NOEXCEPT 4318 { 4319 return ::vkGetAccelerationStructureMemoryRequirementsNV( device, pInfo, pMemoryRequirements ); 4320 } 4321 vkBindAccelerationStructureMemoryNV(VkDevice device,uint32_t bindInfoCount,const VkBindAccelerationStructureMemoryInfoNV * pBindInfos) const4322 VkResult vkBindAccelerationStructureMemoryNV( VkDevice device, 4323 uint32_t bindInfoCount, 4324 const VkBindAccelerationStructureMemoryInfoNV * pBindInfos ) const 4325 VULKAN_HPP_NOEXCEPT 4326 { 4327 return ::vkBindAccelerationStructureMemoryNV( device, bindInfoCount, pBindInfos ); 4328 } 4329 vkCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer,const VkAccelerationStructureInfoNV * pInfo,VkBuffer instanceData,VkDeviceSize instanceOffset,VkBool32 update,VkAccelerationStructureNV dst,VkAccelerationStructureNV src,VkBuffer scratch,VkDeviceSize scratchOffset) const4330 void vkCmdBuildAccelerationStructureNV( VkCommandBuffer commandBuffer, 4331 const VkAccelerationStructureInfoNV * pInfo, 4332 VkBuffer instanceData, 4333 VkDeviceSize instanceOffset, 4334 VkBool32 update, 4335 VkAccelerationStructureNV dst, 4336 VkAccelerationStructureNV src, 4337 VkBuffer scratch, 4338 VkDeviceSize scratchOffset ) const VULKAN_HPP_NOEXCEPT 4339 { 4340 return ::vkCmdBuildAccelerationStructureNV( 4341 commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset ); 4342 } 4343 vkCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer,VkAccelerationStructureNV dst,VkAccelerationStructureNV src,VkCopyAccelerationStructureModeKHR mode) const4344 void vkCmdCopyAccelerationStructureNV( VkCommandBuffer commandBuffer, 4345 VkAccelerationStructureNV dst, 4346 VkAccelerationStructureNV src, 4347 VkCopyAccelerationStructureModeKHR mode ) const VULKAN_HPP_NOEXCEPT 4348 { 4349 return ::vkCmdCopyAccelerationStructureNV( commandBuffer, dst, src, mode ); 4350 } 4351 vkCmdTraceRaysNV(VkCommandBuffer commandBuffer,VkBuffer raygenShaderBindingTableBuffer,VkDeviceSize raygenShaderBindingOffset,VkBuffer missShaderBindingTableBuffer,VkDeviceSize missShaderBindingOffset,VkDeviceSize missShaderBindingStride,VkBuffer hitShaderBindingTableBuffer,VkDeviceSize hitShaderBindingOffset,VkDeviceSize hitShaderBindingStride,VkBuffer callableShaderBindingTableBuffer,VkDeviceSize callableShaderBindingOffset,VkDeviceSize callableShaderBindingStride,uint32_t width,uint32_t height,uint32_t depth) const4352 void vkCmdTraceRaysNV( VkCommandBuffer commandBuffer, 4353 VkBuffer raygenShaderBindingTableBuffer, 4354 VkDeviceSize raygenShaderBindingOffset, 4355 VkBuffer missShaderBindingTableBuffer, 4356 VkDeviceSize missShaderBindingOffset, 4357 VkDeviceSize missShaderBindingStride, 4358 VkBuffer hitShaderBindingTableBuffer, 4359 VkDeviceSize hitShaderBindingOffset, 4360 VkDeviceSize hitShaderBindingStride, 4361 VkBuffer callableShaderBindingTableBuffer, 4362 VkDeviceSize callableShaderBindingOffset, 4363 VkDeviceSize callableShaderBindingStride, 4364 uint32_t width, 4365 uint32_t height, 4366 uint32_t depth ) const VULKAN_HPP_NOEXCEPT 4367 { 4368 return ::vkCmdTraceRaysNV( commandBuffer, 4369 raygenShaderBindingTableBuffer, 4370 raygenShaderBindingOffset, 4371 missShaderBindingTableBuffer, 4372 missShaderBindingOffset, 4373 missShaderBindingStride, 4374 hitShaderBindingTableBuffer, 4375 hitShaderBindingOffset, 4376 hitShaderBindingStride, 4377 callableShaderBindingTableBuffer, 4378 callableShaderBindingOffset, 4379 callableShaderBindingStride, 4380 width, 4381 height, 4382 depth ); 4383 } 4384 vkCreateRayTracingPipelinesNV(VkDevice device,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkRayTracingPipelineCreateInfoNV * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines) const4385 VkResult vkCreateRayTracingPipelinesNV( VkDevice device, 4386 VkPipelineCache pipelineCache, 4387 uint32_t createInfoCount, 4388 const VkRayTracingPipelineCreateInfoNV * pCreateInfos, 4389 const VkAllocationCallbacks * pAllocator, 4390 VkPipeline * pPipelines ) const VULKAN_HPP_NOEXCEPT 4391 { 4392 return ::vkCreateRayTracingPipelinesNV( 4393 device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines ); 4394 } 4395 vkGetRayTracingShaderGroupHandlesNV(VkDevice device,VkPipeline pipeline,uint32_t firstGroup,uint32_t groupCount,size_t dataSize,void * pData) const4396 VkResult vkGetRayTracingShaderGroupHandlesNV( VkDevice device, 4397 VkPipeline pipeline, 4398 uint32_t firstGroup, 4399 uint32_t groupCount, 4400 size_t dataSize, 4401 void * pData ) const VULKAN_HPP_NOEXCEPT 4402 { 4403 return ::vkGetRayTracingShaderGroupHandlesNV( device, pipeline, firstGroup, groupCount, dataSize, pData ); 4404 } 4405 vkGetAccelerationStructureHandleNV(VkDevice device,VkAccelerationStructureNV accelerationStructure,size_t dataSize,void * pData) const4406 VkResult vkGetAccelerationStructureHandleNV( VkDevice device, 4407 VkAccelerationStructureNV accelerationStructure, 4408 size_t dataSize, 4409 void * pData ) const VULKAN_HPP_NOEXCEPT 4410 { 4411 return ::vkGetAccelerationStructureHandleNV( device, accelerationStructure, dataSize, pData ); 4412 } 4413 vkCmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer commandBuffer,uint32_t accelerationStructureCount,const VkAccelerationStructureNV * pAccelerationStructures,VkQueryType queryType,VkQueryPool queryPool,uint32_t firstQuery) const4414 void vkCmdWriteAccelerationStructuresPropertiesNV( VkCommandBuffer commandBuffer, 4415 uint32_t accelerationStructureCount, 4416 const VkAccelerationStructureNV * pAccelerationStructures, 4417 VkQueryType queryType, 4418 VkQueryPool queryPool, 4419 uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT 4420 { 4421 return ::vkCmdWriteAccelerationStructuresPropertiesNV( 4422 commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery ); 4423 } 4424 vkCompileDeferredNV(VkDevice device,VkPipeline pipeline,uint32_t shader) const4425 VkResult vkCompileDeferredNV( VkDevice device, VkPipeline pipeline, uint32_t shader ) const VULKAN_HPP_NOEXCEPT 4426 { 4427 return ::vkCompileDeferredNV( device, pipeline, shader ); 4428 } 4429 4430 //=== VK_KHR_maintenance3 === 4431 vkGetDescriptorSetLayoutSupportKHR(VkDevice device,const VkDescriptorSetLayoutCreateInfo * pCreateInfo,VkDescriptorSetLayoutSupport * pSupport) const4432 void vkGetDescriptorSetLayoutSupportKHR( VkDevice device, 4433 const VkDescriptorSetLayoutCreateInfo * pCreateInfo, 4434 VkDescriptorSetLayoutSupport * pSupport ) const VULKAN_HPP_NOEXCEPT 4435 { 4436 return ::vkGetDescriptorSetLayoutSupportKHR( device, pCreateInfo, pSupport ); 4437 } 4438 4439 //=== VK_KHR_draw_indirect_count === 4440 vkCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer,VkBuffer buffer,VkDeviceSize offset,VkBuffer countBuffer,VkDeviceSize countBufferOffset,uint32_t maxDrawCount,uint32_t stride) const4441 void vkCmdDrawIndirectCountKHR( VkCommandBuffer commandBuffer, 4442 VkBuffer buffer, 4443 VkDeviceSize offset, 4444 VkBuffer countBuffer, 4445 VkDeviceSize countBufferOffset, 4446 uint32_t maxDrawCount, 4447 uint32_t stride ) const VULKAN_HPP_NOEXCEPT 4448 { 4449 return ::vkCmdDrawIndirectCountKHR( 4450 commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride ); 4451 } 4452 vkCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer,VkBuffer buffer,VkDeviceSize offset,VkBuffer countBuffer,VkDeviceSize countBufferOffset,uint32_t maxDrawCount,uint32_t stride) const4453 void vkCmdDrawIndexedIndirectCountKHR( VkCommandBuffer commandBuffer, 4454 VkBuffer buffer, 4455 VkDeviceSize offset, 4456 VkBuffer countBuffer, 4457 VkDeviceSize countBufferOffset, 4458 uint32_t maxDrawCount, 4459 uint32_t stride ) const VULKAN_HPP_NOEXCEPT 4460 { 4461 return ::vkCmdDrawIndexedIndirectCountKHR( 4462 commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride ); 4463 } 4464 4465 //=== VK_EXT_external_memory_host === 4466 vkGetMemoryHostPointerPropertiesEXT(VkDevice device,VkExternalMemoryHandleTypeFlagBits handleType,const void * pHostPointer,VkMemoryHostPointerPropertiesEXT * pMemoryHostPointerProperties) const4467 VkResult vkGetMemoryHostPointerPropertiesEXT( 4468 VkDevice device, 4469 VkExternalMemoryHandleTypeFlagBits handleType, 4470 const void * pHostPointer, 4471 VkMemoryHostPointerPropertiesEXT * pMemoryHostPointerProperties ) const VULKAN_HPP_NOEXCEPT 4472 { 4473 return ::vkGetMemoryHostPointerPropertiesEXT( device, handleType, pHostPointer, pMemoryHostPointerProperties ); 4474 } 4475 4476 //=== VK_AMD_buffer_marker === 4477 vkCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer,VkPipelineStageFlagBits pipelineStage,VkBuffer dstBuffer,VkDeviceSize dstOffset,uint32_t marker) const4478 void vkCmdWriteBufferMarkerAMD( VkCommandBuffer commandBuffer, 4479 VkPipelineStageFlagBits pipelineStage, 4480 VkBuffer dstBuffer, 4481 VkDeviceSize dstOffset, 4482 uint32_t marker ) const VULKAN_HPP_NOEXCEPT 4483 { 4484 return ::vkCmdWriteBufferMarkerAMD( commandBuffer, pipelineStage, dstBuffer, dstOffset, marker ); 4485 } 4486 4487 //=== VK_EXT_calibrated_timestamps === 4488 vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice,uint32_t * pTimeDomainCount,VkTimeDomainEXT * pTimeDomains) const4489 VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( VkPhysicalDevice physicalDevice, 4490 uint32_t * pTimeDomainCount, 4491 VkTimeDomainEXT * pTimeDomains ) const VULKAN_HPP_NOEXCEPT 4492 { 4493 return ::vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( physicalDevice, pTimeDomainCount, pTimeDomains ); 4494 } 4495 vkGetCalibratedTimestampsEXT(VkDevice device,uint32_t timestampCount,const VkCalibratedTimestampInfoEXT * pTimestampInfos,uint64_t * pTimestamps,uint64_t * pMaxDeviation) const4496 VkResult vkGetCalibratedTimestampsEXT( VkDevice device, 4497 uint32_t timestampCount, 4498 const VkCalibratedTimestampInfoEXT * pTimestampInfos, 4499 uint64_t * pTimestamps, 4500 uint64_t * pMaxDeviation ) const VULKAN_HPP_NOEXCEPT 4501 { 4502 return ::vkGetCalibratedTimestampsEXT( device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation ); 4503 } 4504 4505 //=== VK_NV_mesh_shader === 4506 vkCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer,uint32_t taskCount,uint32_t firstTask) const4507 void vkCmdDrawMeshTasksNV( VkCommandBuffer commandBuffer, 4508 uint32_t taskCount, 4509 uint32_t firstTask ) const VULKAN_HPP_NOEXCEPT 4510 { 4511 return ::vkCmdDrawMeshTasksNV( commandBuffer, taskCount, firstTask ); 4512 } 4513 vkCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer,VkBuffer buffer,VkDeviceSize offset,uint32_t drawCount,uint32_t stride) const4514 void vkCmdDrawMeshTasksIndirectNV( VkCommandBuffer commandBuffer, 4515 VkBuffer buffer, 4516 VkDeviceSize offset, 4517 uint32_t drawCount, 4518 uint32_t stride ) const VULKAN_HPP_NOEXCEPT 4519 { 4520 return ::vkCmdDrawMeshTasksIndirectNV( commandBuffer, buffer, offset, drawCount, stride ); 4521 } 4522 vkCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer,VkBuffer buffer,VkDeviceSize offset,VkBuffer countBuffer,VkDeviceSize countBufferOffset,uint32_t maxDrawCount,uint32_t stride) const4523 void vkCmdDrawMeshTasksIndirectCountNV( VkCommandBuffer commandBuffer, 4524 VkBuffer buffer, 4525 VkDeviceSize offset, 4526 VkBuffer countBuffer, 4527 VkDeviceSize countBufferOffset, 4528 uint32_t maxDrawCount, 4529 uint32_t stride ) const VULKAN_HPP_NOEXCEPT 4530 { 4531 return ::vkCmdDrawMeshTasksIndirectCountNV( 4532 commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride ); 4533 } 4534 4535 //=== VK_NV_scissor_exclusive === 4536 vkCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer,uint32_t firstExclusiveScissor,uint32_t exclusiveScissorCount,const VkRect2D * pExclusiveScissors) const4537 void vkCmdSetExclusiveScissorNV( VkCommandBuffer commandBuffer, 4538 uint32_t firstExclusiveScissor, 4539 uint32_t exclusiveScissorCount, 4540 const VkRect2D * pExclusiveScissors ) const VULKAN_HPP_NOEXCEPT 4541 { 4542 return ::vkCmdSetExclusiveScissorNV( 4543 commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors ); 4544 } 4545 4546 //=== VK_NV_device_diagnostic_checkpoints === 4547 vkCmdSetCheckpointNV(VkCommandBuffer commandBuffer,const void * pCheckpointMarker) const4548 void vkCmdSetCheckpointNV( VkCommandBuffer commandBuffer, const void * pCheckpointMarker ) const VULKAN_HPP_NOEXCEPT 4549 { 4550 return ::vkCmdSetCheckpointNV( commandBuffer, pCheckpointMarker ); 4551 } 4552 vkGetQueueCheckpointDataNV(VkQueue queue,uint32_t * pCheckpointDataCount,VkCheckpointDataNV * pCheckpointData) const4553 void vkGetQueueCheckpointDataNV( VkQueue queue, 4554 uint32_t * pCheckpointDataCount, 4555 VkCheckpointDataNV * pCheckpointData ) const VULKAN_HPP_NOEXCEPT 4556 { 4557 return ::vkGetQueueCheckpointDataNV( queue, pCheckpointDataCount, pCheckpointData ); 4558 } 4559 4560 //=== VK_KHR_timeline_semaphore === 4561 vkGetSemaphoreCounterValueKHR(VkDevice device,VkSemaphore semaphore,uint64_t * pValue) const4562 VkResult vkGetSemaphoreCounterValueKHR( VkDevice device, 4563 VkSemaphore semaphore, 4564 uint64_t * pValue ) const VULKAN_HPP_NOEXCEPT 4565 { 4566 return ::vkGetSemaphoreCounterValueKHR( device, semaphore, pValue ); 4567 } 4568 vkWaitSemaphoresKHR(VkDevice device,const VkSemaphoreWaitInfo * pWaitInfo,uint64_t timeout) const4569 VkResult vkWaitSemaphoresKHR( VkDevice device, 4570 const VkSemaphoreWaitInfo * pWaitInfo, 4571 uint64_t timeout ) const VULKAN_HPP_NOEXCEPT 4572 { 4573 return ::vkWaitSemaphoresKHR( device, pWaitInfo, timeout ); 4574 } 4575 vkSignalSemaphoreKHR(VkDevice device,const VkSemaphoreSignalInfo * pSignalInfo) const4576 VkResult vkSignalSemaphoreKHR( VkDevice device, 4577 const VkSemaphoreSignalInfo * pSignalInfo ) const VULKAN_HPP_NOEXCEPT 4578 { 4579 return ::vkSignalSemaphoreKHR( device, pSignalInfo ); 4580 } 4581 4582 //=== VK_INTEL_performance_query === 4583 vkInitializePerformanceApiINTEL(VkDevice device,const VkInitializePerformanceApiInfoINTEL * pInitializeInfo) const4584 VkResult vkInitializePerformanceApiINTEL( 4585 VkDevice device, const VkInitializePerformanceApiInfoINTEL * pInitializeInfo ) const VULKAN_HPP_NOEXCEPT 4586 { 4587 return ::vkInitializePerformanceApiINTEL( device, pInitializeInfo ); 4588 } 4589 vkUninitializePerformanceApiINTEL(VkDevice device) const4590 void vkUninitializePerformanceApiINTEL( VkDevice device ) const VULKAN_HPP_NOEXCEPT 4591 { 4592 return ::vkUninitializePerformanceApiINTEL( device ); 4593 } 4594 4595 VkResult vkCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer,const VkPerformanceMarkerInfoINTEL * pMarkerInfo) const4596 vkCmdSetPerformanceMarkerINTEL( VkCommandBuffer commandBuffer, 4597 const VkPerformanceMarkerInfoINTEL * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT 4598 { 4599 return ::vkCmdSetPerformanceMarkerINTEL( commandBuffer, pMarkerInfo ); 4600 } 4601 vkCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer,const VkPerformanceStreamMarkerInfoINTEL * pMarkerInfo) const4602 VkResult vkCmdSetPerformanceStreamMarkerINTEL( 4603 VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT 4604 { 4605 return ::vkCmdSetPerformanceStreamMarkerINTEL( commandBuffer, pMarkerInfo ); 4606 } 4607 4608 VkResult vkCmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer,const VkPerformanceOverrideInfoINTEL * pOverrideInfo) const4609 vkCmdSetPerformanceOverrideINTEL( VkCommandBuffer commandBuffer, 4610 const VkPerformanceOverrideInfoINTEL * pOverrideInfo ) const VULKAN_HPP_NOEXCEPT 4611 { 4612 return ::vkCmdSetPerformanceOverrideINTEL( commandBuffer, pOverrideInfo ); 4613 } 4614 vkAcquirePerformanceConfigurationINTEL(VkDevice device,const VkPerformanceConfigurationAcquireInfoINTEL * pAcquireInfo,VkPerformanceConfigurationINTEL * pConfiguration) const4615 VkResult vkAcquirePerformanceConfigurationINTEL( VkDevice device, 4616 const VkPerformanceConfigurationAcquireInfoINTEL * pAcquireInfo, 4617 VkPerformanceConfigurationINTEL * pConfiguration ) const 4618 VULKAN_HPP_NOEXCEPT 4619 { 4620 return ::vkAcquirePerformanceConfigurationINTEL( device, pAcquireInfo, pConfiguration ); 4621 } 4622 4623 VkResult vkReleasePerformanceConfigurationINTEL(VkDevice device,VkPerformanceConfigurationINTEL configuration) const4624 vkReleasePerformanceConfigurationINTEL( VkDevice device, 4625 VkPerformanceConfigurationINTEL configuration ) const VULKAN_HPP_NOEXCEPT 4626 { 4627 return ::vkReleasePerformanceConfigurationINTEL( device, configuration ); 4628 } 4629 4630 VkResult vkQueueSetPerformanceConfigurationINTEL(VkQueue queue,VkPerformanceConfigurationINTEL configuration) const4631 vkQueueSetPerformanceConfigurationINTEL( VkQueue queue, 4632 VkPerformanceConfigurationINTEL configuration ) const VULKAN_HPP_NOEXCEPT 4633 { 4634 return ::vkQueueSetPerformanceConfigurationINTEL( queue, configuration ); 4635 } 4636 vkGetPerformanceParameterINTEL(VkDevice device,VkPerformanceParameterTypeINTEL parameter,VkPerformanceValueINTEL * pValue) const4637 VkResult vkGetPerformanceParameterINTEL( VkDevice device, 4638 VkPerformanceParameterTypeINTEL parameter, 4639 VkPerformanceValueINTEL * pValue ) const VULKAN_HPP_NOEXCEPT 4640 { 4641 return ::vkGetPerformanceParameterINTEL( device, parameter, pValue ); 4642 } 4643 4644 //=== VK_AMD_display_native_hdr === 4645 vkSetLocalDimmingAMD(VkDevice device,VkSwapchainKHR swapChain,VkBool32 localDimmingEnable) const4646 void vkSetLocalDimmingAMD( VkDevice device, 4647 VkSwapchainKHR swapChain, 4648 VkBool32 localDimmingEnable ) const VULKAN_HPP_NOEXCEPT 4649 { 4650 return ::vkSetLocalDimmingAMD( device, swapChain, localDimmingEnable ); 4651 } 4652 4653 # if defined( VK_USE_PLATFORM_FUCHSIA ) 4654 //=== VK_FUCHSIA_imagepipe_surface === 4655 vkCreateImagePipeSurfaceFUCHSIA(VkInstance instance,const VkImagePipeSurfaceCreateInfoFUCHSIA * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface) const4656 VkResult vkCreateImagePipeSurfaceFUCHSIA( VkInstance instance, 4657 const VkImagePipeSurfaceCreateInfoFUCHSIA * pCreateInfo, 4658 const VkAllocationCallbacks * pAllocator, 4659 VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT 4660 { 4661 return ::vkCreateImagePipeSurfaceFUCHSIA( instance, pCreateInfo, pAllocator, pSurface ); 4662 } 4663 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 4664 4665 # if defined( VK_USE_PLATFORM_METAL_EXT ) 4666 //=== VK_EXT_metal_surface === 4667 vkCreateMetalSurfaceEXT(VkInstance instance,const VkMetalSurfaceCreateInfoEXT * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface) const4668 VkResult vkCreateMetalSurfaceEXT( VkInstance instance, 4669 const VkMetalSurfaceCreateInfoEXT * pCreateInfo, 4670 const VkAllocationCallbacks * pAllocator, 4671 VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT 4672 { 4673 return ::vkCreateMetalSurfaceEXT( instance, pCreateInfo, pAllocator, pSurface ); 4674 } 4675 # endif /*VK_USE_PLATFORM_METAL_EXT*/ 4676 4677 //=== VK_KHR_fragment_shading_rate === 4678 vkGetPhysicalDeviceFragmentShadingRatesKHR(VkPhysicalDevice physicalDevice,uint32_t * pFragmentShadingRateCount,VkPhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates) const4679 VkResult vkGetPhysicalDeviceFragmentShadingRatesKHR( 4680 VkPhysicalDevice physicalDevice, 4681 uint32_t * pFragmentShadingRateCount, 4682 VkPhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates ) const VULKAN_HPP_NOEXCEPT 4683 { 4684 return ::vkGetPhysicalDeviceFragmentShadingRatesKHR( 4685 physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates ); 4686 } 4687 vkCmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer,const VkExtent2D * pFragmentSize,const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) const4688 void vkCmdSetFragmentShadingRateKHR( VkCommandBuffer commandBuffer, 4689 const VkExtent2D * pFragmentSize, 4690 const VkFragmentShadingRateCombinerOpKHR combinerOps[2] ) const 4691 VULKAN_HPP_NOEXCEPT 4692 { 4693 return ::vkCmdSetFragmentShadingRateKHR( commandBuffer, pFragmentSize, combinerOps ); 4694 } 4695 4696 //=== VK_EXT_buffer_device_address === 4697 vkGetBufferDeviceAddressEXT(VkDevice device,const VkBufferDeviceAddressInfo * pInfo) const4698 VkDeviceAddress vkGetBufferDeviceAddressEXT( VkDevice device, 4699 const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT 4700 { 4701 return ::vkGetBufferDeviceAddressEXT( device, pInfo ); 4702 } 4703 4704 //=== VK_EXT_tooling_info === 4705 vkGetPhysicalDeviceToolPropertiesEXT(VkPhysicalDevice physicalDevice,uint32_t * pToolCount,VkPhysicalDeviceToolPropertiesEXT * pToolProperties) const4706 VkResult vkGetPhysicalDeviceToolPropertiesEXT( VkPhysicalDevice physicalDevice, 4707 uint32_t * pToolCount, 4708 VkPhysicalDeviceToolPropertiesEXT * pToolProperties ) const 4709 VULKAN_HPP_NOEXCEPT 4710 { 4711 return ::vkGetPhysicalDeviceToolPropertiesEXT( physicalDevice, pToolCount, pToolProperties ); 4712 } 4713 4714 //=== VK_KHR_present_wait === 4715 vkWaitForPresentKHR(VkDevice device,VkSwapchainKHR swapchain,uint64_t presentId,uint64_t timeout) const4716 VkResult vkWaitForPresentKHR( VkDevice device, 4717 VkSwapchainKHR swapchain, 4718 uint64_t presentId, 4719 uint64_t timeout ) const VULKAN_HPP_NOEXCEPT 4720 { 4721 return ::vkWaitForPresentKHR( device, swapchain, presentId, timeout ); 4722 } 4723 4724 //=== VK_NV_cooperative_matrix === 4725 vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice,uint32_t * pPropertyCount,VkCooperativeMatrixPropertiesNV * pProperties) const4726 VkResult vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( VkPhysicalDevice physicalDevice, 4727 uint32_t * pPropertyCount, 4728 VkCooperativeMatrixPropertiesNV * pProperties ) const 4729 VULKAN_HPP_NOEXCEPT 4730 { 4731 return ::vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( physicalDevice, pPropertyCount, pProperties ); 4732 } 4733 4734 //=== VK_NV_coverage_reduction_mode === 4735 vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(VkPhysicalDevice physicalDevice,uint32_t * pCombinationCount,VkFramebufferMixedSamplesCombinationNV * pCombinations) const4736 VkResult vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( 4737 VkPhysicalDevice physicalDevice, 4738 uint32_t * pCombinationCount, 4739 VkFramebufferMixedSamplesCombinationNV * pCombinations ) const VULKAN_HPP_NOEXCEPT 4740 { 4741 return ::vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( 4742 physicalDevice, pCombinationCount, pCombinations ); 4743 } 4744 4745 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 4746 //=== VK_EXT_full_screen_exclusive === 4747 vkGetPhysicalDeviceSurfacePresentModes2EXT(VkPhysicalDevice physicalDevice,const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,uint32_t * pPresentModeCount,VkPresentModeKHR * pPresentModes) const4748 VkResult vkGetPhysicalDeviceSurfacePresentModes2EXT( VkPhysicalDevice physicalDevice, 4749 const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, 4750 uint32_t * pPresentModeCount, 4751 VkPresentModeKHR * pPresentModes ) const VULKAN_HPP_NOEXCEPT 4752 { 4753 return ::vkGetPhysicalDeviceSurfacePresentModes2EXT( 4754 physicalDevice, pSurfaceInfo, pPresentModeCount, pPresentModes ); 4755 } 4756 vkAcquireFullScreenExclusiveModeEXT(VkDevice device,VkSwapchainKHR swapchain) const4757 VkResult vkAcquireFullScreenExclusiveModeEXT( VkDevice device, VkSwapchainKHR swapchain ) const VULKAN_HPP_NOEXCEPT 4758 { 4759 return ::vkAcquireFullScreenExclusiveModeEXT( device, swapchain ); 4760 } 4761 vkReleaseFullScreenExclusiveModeEXT(VkDevice device,VkSwapchainKHR swapchain) const4762 VkResult vkReleaseFullScreenExclusiveModeEXT( VkDevice device, VkSwapchainKHR swapchain ) const VULKAN_HPP_NOEXCEPT 4763 { 4764 return ::vkReleaseFullScreenExclusiveModeEXT( device, swapchain ); 4765 } 4766 4767 VkResult vkGetDeviceGroupSurfacePresentModes2EXT(VkDevice device,const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,VkDeviceGroupPresentModeFlagsKHR * pModes) const4768 vkGetDeviceGroupSurfacePresentModes2EXT( VkDevice device, 4769 const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, 4770 VkDeviceGroupPresentModeFlagsKHR * pModes ) const VULKAN_HPP_NOEXCEPT 4771 { 4772 return ::vkGetDeviceGroupSurfacePresentModes2EXT( device, pSurfaceInfo, pModes ); 4773 } 4774 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 4775 4776 //=== VK_EXT_headless_surface === 4777 vkCreateHeadlessSurfaceEXT(VkInstance instance,const VkHeadlessSurfaceCreateInfoEXT * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface) const4778 VkResult vkCreateHeadlessSurfaceEXT( VkInstance instance, 4779 const VkHeadlessSurfaceCreateInfoEXT * pCreateInfo, 4780 const VkAllocationCallbacks * pAllocator, 4781 VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT 4782 { 4783 return ::vkCreateHeadlessSurfaceEXT( instance, pCreateInfo, pAllocator, pSurface ); 4784 } 4785 4786 //=== VK_KHR_buffer_device_address === 4787 vkGetBufferDeviceAddressKHR(VkDevice device,const VkBufferDeviceAddressInfo * pInfo) const4788 VkDeviceAddress vkGetBufferDeviceAddressKHR( VkDevice device, 4789 const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT 4790 { 4791 return ::vkGetBufferDeviceAddressKHR( device, pInfo ); 4792 } 4793 vkGetBufferOpaqueCaptureAddressKHR(VkDevice device,const VkBufferDeviceAddressInfo * pInfo) const4794 uint64_t vkGetBufferOpaqueCaptureAddressKHR( VkDevice device, 4795 const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT 4796 { 4797 return ::vkGetBufferOpaqueCaptureAddressKHR( device, pInfo ); 4798 } 4799 vkGetDeviceMemoryOpaqueCaptureAddressKHR(VkDevice device,const VkDeviceMemoryOpaqueCaptureAddressInfo * pInfo) const4800 uint64_t vkGetDeviceMemoryOpaqueCaptureAddressKHR( 4801 VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT 4802 { 4803 return ::vkGetDeviceMemoryOpaqueCaptureAddressKHR( device, pInfo ); 4804 } 4805 4806 //=== VK_EXT_line_rasterization === 4807 vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer,uint32_t lineStippleFactor,uint16_t lineStipplePattern) const4808 void vkCmdSetLineStippleEXT( VkCommandBuffer commandBuffer, 4809 uint32_t lineStippleFactor, 4810 uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT 4811 { 4812 return ::vkCmdSetLineStippleEXT( commandBuffer, lineStippleFactor, lineStipplePattern ); 4813 } 4814 4815 //=== VK_EXT_host_query_reset === 4816 vkResetQueryPoolEXT(VkDevice device,VkQueryPool queryPool,uint32_t firstQuery,uint32_t queryCount) const4817 void vkResetQueryPoolEXT( VkDevice device, 4818 VkQueryPool queryPool, 4819 uint32_t firstQuery, 4820 uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT 4821 { 4822 return ::vkResetQueryPoolEXT( device, queryPool, firstQuery, queryCount ); 4823 } 4824 4825 //=== VK_EXT_extended_dynamic_state === 4826 vkCmdSetCullModeEXT(VkCommandBuffer commandBuffer,VkCullModeFlags cullMode) const4827 void vkCmdSetCullModeEXT( VkCommandBuffer commandBuffer, VkCullModeFlags cullMode ) const VULKAN_HPP_NOEXCEPT 4828 { 4829 return ::vkCmdSetCullModeEXT( commandBuffer, cullMode ); 4830 } 4831 vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer,VkFrontFace frontFace) const4832 void vkCmdSetFrontFaceEXT( VkCommandBuffer commandBuffer, VkFrontFace frontFace ) const VULKAN_HPP_NOEXCEPT 4833 { 4834 return ::vkCmdSetFrontFaceEXT( commandBuffer, frontFace ); 4835 } 4836 vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer,VkPrimitiveTopology primitiveTopology) const4837 void vkCmdSetPrimitiveTopologyEXT( VkCommandBuffer commandBuffer, 4838 VkPrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT 4839 { 4840 return ::vkCmdSetPrimitiveTopologyEXT( commandBuffer, primitiveTopology ); 4841 } 4842 vkCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer,uint32_t viewportCount,const VkViewport * pViewports) const4843 void vkCmdSetViewportWithCountEXT( VkCommandBuffer commandBuffer, 4844 uint32_t viewportCount, 4845 const VkViewport * pViewports ) const VULKAN_HPP_NOEXCEPT 4846 { 4847 return ::vkCmdSetViewportWithCountEXT( commandBuffer, viewportCount, pViewports ); 4848 } 4849 vkCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer,uint32_t scissorCount,const VkRect2D * pScissors) const4850 void vkCmdSetScissorWithCountEXT( VkCommandBuffer commandBuffer, 4851 uint32_t scissorCount, 4852 const VkRect2D * pScissors ) const VULKAN_HPP_NOEXCEPT 4853 { 4854 return ::vkCmdSetScissorWithCountEXT( commandBuffer, scissorCount, pScissors ); 4855 } 4856 vkCmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer,uint32_t firstBinding,uint32_t bindingCount,const VkBuffer * pBuffers,const VkDeviceSize * pOffsets,const VkDeviceSize * pSizes,const VkDeviceSize * pStrides) const4857 void vkCmdBindVertexBuffers2EXT( VkCommandBuffer commandBuffer, 4858 uint32_t firstBinding, 4859 uint32_t bindingCount, 4860 const VkBuffer * pBuffers, 4861 const VkDeviceSize * pOffsets, 4862 const VkDeviceSize * pSizes, 4863 const VkDeviceSize * pStrides ) const VULKAN_HPP_NOEXCEPT 4864 { 4865 return ::vkCmdBindVertexBuffers2EXT( 4866 commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides ); 4867 } 4868 vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer,VkBool32 depthTestEnable) const4869 void vkCmdSetDepthTestEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT 4870 { 4871 return ::vkCmdSetDepthTestEnableEXT( commandBuffer, depthTestEnable ); 4872 } 4873 vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer,VkBool32 depthWriteEnable) const4874 void vkCmdSetDepthWriteEnableEXT( VkCommandBuffer commandBuffer, 4875 VkBool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT 4876 { 4877 return ::vkCmdSetDepthWriteEnableEXT( commandBuffer, depthWriteEnable ); 4878 } 4879 vkCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer,VkCompareOp depthCompareOp) const4880 void vkCmdSetDepthCompareOpEXT( VkCommandBuffer commandBuffer, 4881 VkCompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT 4882 { 4883 return ::vkCmdSetDepthCompareOpEXT( commandBuffer, depthCompareOp ); 4884 } 4885 vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer,VkBool32 depthBoundsTestEnable) const4886 void vkCmdSetDepthBoundsTestEnableEXT( VkCommandBuffer commandBuffer, 4887 VkBool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT 4888 { 4889 return ::vkCmdSetDepthBoundsTestEnableEXT( commandBuffer, depthBoundsTestEnable ); 4890 } 4891 vkCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer,VkBool32 stencilTestEnable) const4892 void vkCmdSetStencilTestEnableEXT( VkCommandBuffer commandBuffer, 4893 VkBool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT 4894 { 4895 return ::vkCmdSetStencilTestEnableEXT( commandBuffer, stencilTestEnable ); 4896 } 4897 vkCmdSetStencilOpEXT(VkCommandBuffer commandBuffer,VkStencilFaceFlags faceMask,VkStencilOp failOp,VkStencilOp passOp,VkStencilOp depthFailOp,VkCompareOp compareOp) const4898 void vkCmdSetStencilOpEXT( VkCommandBuffer commandBuffer, 4899 VkStencilFaceFlags faceMask, 4900 VkStencilOp failOp, 4901 VkStencilOp passOp, 4902 VkStencilOp depthFailOp, 4903 VkCompareOp compareOp ) const VULKAN_HPP_NOEXCEPT 4904 { 4905 return ::vkCmdSetStencilOpEXT( commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp ); 4906 } 4907 4908 //=== VK_KHR_deferred_host_operations === 4909 vkCreateDeferredOperationKHR(VkDevice device,const VkAllocationCallbacks * pAllocator,VkDeferredOperationKHR * pDeferredOperation) const4910 VkResult vkCreateDeferredOperationKHR( VkDevice device, 4911 const VkAllocationCallbacks * pAllocator, 4912 VkDeferredOperationKHR * pDeferredOperation ) const VULKAN_HPP_NOEXCEPT 4913 { 4914 return ::vkCreateDeferredOperationKHR( device, pAllocator, pDeferredOperation ); 4915 } 4916 vkDestroyDeferredOperationKHR(VkDevice device,VkDeferredOperationKHR operation,const VkAllocationCallbacks * pAllocator) const4917 void vkDestroyDeferredOperationKHR( VkDevice device, 4918 VkDeferredOperationKHR operation, 4919 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT 4920 { 4921 return ::vkDestroyDeferredOperationKHR( device, operation, pAllocator ); 4922 } 4923 vkGetDeferredOperationMaxConcurrencyKHR(VkDevice device,VkDeferredOperationKHR operation) const4924 uint32_t vkGetDeferredOperationMaxConcurrencyKHR( VkDevice device, 4925 VkDeferredOperationKHR operation ) const VULKAN_HPP_NOEXCEPT 4926 { 4927 return ::vkGetDeferredOperationMaxConcurrencyKHR( device, operation ); 4928 } 4929 vkGetDeferredOperationResultKHR(VkDevice device,VkDeferredOperationKHR operation) const4930 VkResult vkGetDeferredOperationResultKHR( VkDevice device, 4931 VkDeferredOperationKHR operation ) const VULKAN_HPP_NOEXCEPT 4932 { 4933 return ::vkGetDeferredOperationResultKHR( device, operation ); 4934 } 4935 vkDeferredOperationJoinKHR(VkDevice device,VkDeferredOperationKHR operation) const4936 VkResult vkDeferredOperationJoinKHR( VkDevice device, VkDeferredOperationKHR operation ) const VULKAN_HPP_NOEXCEPT 4937 { 4938 return ::vkDeferredOperationJoinKHR( device, operation ); 4939 } 4940 4941 //=== VK_KHR_pipeline_executable_properties === 4942 4943 VkResult vkGetPipelineExecutablePropertiesKHR(VkDevice device,const VkPipelineInfoKHR * pPipelineInfo,uint32_t * pExecutableCount,VkPipelineExecutablePropertiesKHR * pProperties) const4944 vkGetPipelineExecutablePropertiesKHR( VkDevice device, 4945 const VkPipelineInfoKHR * pPipelineInfo, 4946 uint32_t * pExecutableCount, 4947 VkPipelineExecutablePropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT 4948 { 4949 return ::vkGetPipelineExecutablePropertiesKHR( device, pPipelineInfo, pExecutableCount, pProperties ); 4950 } 4951 4952 VkResult vkGetPipelineExecutableStatisticsKHR(VkDevice device,const VkPipelineExecutableInfoKHR * pExecutableInfo,uint32_t * pStatisticCount,VkPipelineExecutableStatisticKHR * pStatistics) const4953 vkGetPipelineExecutableStatisticsKHR( VkDevice device, 4954 const VkPipelineExecutableInfoKHR * pExecutableInfo, 4955 uint32_t * pStatisticCount, 4956 VkPipelineExecutableStatisticKHR * pStatistics ) const VULKAN_HPP_NOEXCEPT 4957 { 4958 return ::vkGetPipelineExecutableStatisticsKHR( device, pExecutableInfo, pStatisticCount, pStatistics ); 4959 } 4960 vkGetPipelineExecutableInternalRepresentationsKHR(VkDevice device,const VkPipelineExecutableInfoKHR * pExecutableInfo,uint32_t * pInternalRepresentationCount,VkPipelineExecutableInternalRepresentationKHR * pInternalRepresentations) const4961 VkResult vkGetPipelineExecutableInternalRepresentationsKHR( 4962 VkDevice device, 4963 const VkPipelineExecutableInfoKHR * pExecutableInfo, 4964 uint32_t * pInternalRepresentationCount, 4965 VkPipelineExecutableInternalRepresentationKHR * pInternalRepresentations ) const VULKAN_HPP_NOEXCEPT 4966 { 4967 return ::vkGetPipelineExecutableInternalRepresentationsKHR( 4968 device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations ); 4969 } 4970 4971 //=== VK_NV_device_generated_commands === 4972 vkGetGeneratedCommandsMemoryRequirementsNV(VkDevice device,const VkGeneratedCommandsMemoryRequirementsInfoNV * pInfo,VkMemoryRequirements2 * pMemoryRequirements) const4973 void vkGetGeneratedCommandsMemoryRequirementsNV( VkDevice device, 4974 const VkGeneratedCommandsMemoryRequirementsInfoNV * pInfo, 4975 VkMemoryRequirements2 * pMemoryRequirements ) const 4976 VULKAN_HPP_NOEXCEPT 4977 { 4978 return ::vkGetGeneratedCommandsMemoryRequirementsNV( device, pInfo, pMemoryRequirements ); 4979 } 4980 vkCmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer,const VkGeneratedCommandsInfoNV * pGeneratedCommandsInfo) const4981 void vkCmdPreprocessGeneratedCommandsNV( VkCommandBuffer commandBuffer, 4982 const VkGeneratedCommandsInfoNV * pGeneratedCommandsInfo ) const 4983 VULKAN_HPP_NOEXCEPT 4984 { 4985 return ::vkCmdPreprocessGeneratedCommandsNV( commandBuffer, pGeneratedCommandsInfo ); 4986 } 4987 vkCmdExecuteGeneratedCommandsNV(VkCommandBuffer commandBuffer,VkBool32 isPreprocessed,const VkGeneratedCommandsInfoNV * pGeneratedCommandsInfo) const4988 void vkCmdExecuteGeneratedCommandsNV( VkCommandBuffer commandBuffer, 4989 VkBool32 isPreprocessed, 4990 const VkGeneratedCommandsInfoNV * pGeneratedCommandsInfo ) const 4991 VULKAN_HPP_NOEXCEPT 4992 { 4993 return ::vkCmdExecuteGeneratedCommandsNV( commandBuffer, isPreprocessed, pGeneratedCommandsInfo ); 4994 } 4995 vkCmdBindPipelineShaderGroupNV(VkCommandBuffer commandBuffer,VkPipelineBindPoint pipelineBindPoint,VkPipeline pipeline,uint32_t groupIndex) const4996 void vkCmdBindPipelineShaderGroupNV( VkCommandBuffer commandBuffer, 4997 VkPipelineBindPoint pipelineBindPoint, 4998 VkPipeline pipeline, 4999 uint32_t groupIndex ) const VULKAN_HPP_NOEXCEPT 5000 { 5001 return ::vkCmdBindPipelineShaderGroupNV( commandBuffer, pipelineBindPoint, pipeline, groupIndex ); 5002 } 5003 5004 VkResult vkCreateIndirectCommandsLayoutNV(VkDevice device,const VkIndirectCommandsLayoutCreateInfoNV * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkIndirectCommandsLayoutNV * pIndirectCommandsLayout) const5005 vkCreateIndirectCommandsLayoutNV( VkDevice device, 5006 const VkIndirectCommandsLayoutCreateInfoNV * pCreateInfo, 5007 const VkAllocationCallbacks * pAllocator, 5008 VkIndirectCommandsLayoutNV * pIndirectCommandsLayout ) const VULKAN_HPP_NOEXCEPT 5009 { 5010 return ::vkCreateIndirectCommandsLayoutNV( device, pCreateInfo, pAllocator, pIndirectCommandsLayout ); 5011 } 5012 vkDestroyIndirectCommandsLayoutNV(VkDevice device,VkIndirectCommandsLayoutNV indirectCommandsLayout,const VkAllocationCallbacks * pAllocator) const5013 void vkDestroyIndirectCommandsLayoutNV( VkDevice device, 5014 VkIndirectCommandsLayoutNV indirectCommandsLayout, 5015 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT 5016 { 5017 return ::vkDestroyIndirectCommandsLayoutNV( device, indirectCommandsLayout, pAllocator ); 5018 } 5019 5020 //=== VK_EXT_acquire_drm_display === 5021 vkAcquireDrmDisplayEXT(VkPhysicalDevice physicalDevice,int32_t drmFd,VkDisplayKHR display) const5022 VkResult vkAcquireDrmDisplayEXT( VkPhysicalDevice physicalDevice, 5023 int32_t drmFd, 5024 VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT 5025 { 5026 return ::vkAcquireDrmDisplayEXT( physicalDevice, drmFd, display ); 5027 } 5028 vkGetDrmDisplayEXT(VkPhysicalDevice physicalDevice,int32_t drmFd,uint32_t connectorId,VkDisplayKHR * display) const5029 VkResult vkGetDrmDisplayEXT( VkPhysicalDevice physicalDevice, 5030 int32_t drmFd, 5031 uint32_t connectorId, 5032 VkDisplayKHR * display ) const VULKAN_HPP_NOEXCEPT 5033 { 5034 return ::vkGetDrmDisplayEXT( physicalDevice, drmFd, connectorId, display ); 5035 } 5036 5037 //=== VK_EXT_private_data === 5038 vkCreatePrivateDataSlotEXT(VkDevice device,const VkPrivateDataSlotCreateInfoEXT * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkPrivateDataSlotEXT * pPrivateDataSlot) const5039 VkResult vkCreatePrivateDataSlotEXT( VkDevice device, 5040 const VkPrivateDataSlotCreateInfoEXT * pCreateInfo, 5041 const VkAllocationCallbacks * pAllocator, 5042 VkPrivateDataSlotEXT * pPrivateDataSlot ) const VULKAN_HPP_NOEXCEPT 5043 { 5044 return ::vkCreatePrivateDataSlotEXT( device, pCreateInfo, pAllocator, pPrivateDataSlot ); 5045 } 5046 vkDestroyPrivateDataSlotEXT(VkDevice device,VkPrivateDataSlotEXT privateDataSlot,const VkAllocationCallbacks * pAllocator) const5047 void vkDestroyPrivateDataSlotEXT( VkDevice device, 5048 VkPrivateDataSlotEXT privateDataSlot, 5049 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT 5050 { 5051 return ::vkDestroyPrivateDataSlotEXT( device, privateDataSlot, pAllocator ); 5052 } 5053 vkSetPrivateDataEXT(VkDevice device,VkObjectType objectType,uint64_t objectHandle,VkPrivateDataSlotEXT privateDataSlot,uint64_t data) const5054 VkResult vkSetPrivateDataEXT( VkDevice device, 5055 VkObjectType objectType, 5056 uint64_t objectHandle, 5057 VkPrivateDataSlotEXT privateDataSlot, 5058 uint64_t data ) const VULKAN_HPP_NOEXCEPT 5059 { 5060 return ::vkSetPrivateDataEXT( device, objectType, objectHandle, privateDataSlot, data ); 5061 } 5062 vkGetPrivateDataEXT(VkDevice device,VkObjectType objectType,uint64_t objectHandle,VkPrivateDataSlotEXT privateDataSlot,uint64_t * pData) const5063 void vkGetPrivateDataEXT( VkDevice device, 5064 VkObjectType objectType, 5065 uint64_t objectHandle, 5066 VkPrivateDataSlotEXT privateDataSlot, 5067 uint64_t * pData ) const VULKAN_HPP_NOEXCEPT 5068 { 5069 return ::vkGetPrivateDataEXT( device, objectType, objectHandle, privateDataSlot, pData ); 5070 } 5071 5072 # if defined( VK_ENABLE_BETA_EXTENSIONS ) 5073 //=== VK_KHR_video_encode_queue === 5074 vkCmdEncodeVideoKHR(VkCommandBuffer commandBuffer,const VkVideoEncodeInfoKHR * pEncodeInfo) const5075 void vkCmdEncodeVideoKHR( VkCommandBuffer commandBuffer, 5076 const VkVideoEncodeInfoKHR * pEncodeInfo ) const VULKAN_HPP_NOEXCEPT 5077 { 5078 return ::vkCmdEncodeVideoKHR( commandBuffer, pEncodeInfo ); 5079 } 5080 # endif /*VK_ENABLE_BETA_EXTENSIONS*/ 5081 5082 //=== VK_KHR_synchronization2 === 5083 vkCmdSetEvent2KHR(VkCommandBuffer commandBuffer,VkEvent event,const VkDependencyInfoKHR * pDependencyInfo) const5084 void vkCmdSetEvent2KHR( VkCommandBuffer commandBuffer, 5085 VkEvent event, 5086 const VkDependencyInfoKHR * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT 5087 { 5088 return ::vkCmdSetEvent2KHR( commandBuffer, event, pDependencyInfo ); 5089 } 5090 vkCmdResetEvent2KHR(VkCommandBuffer commandBuffer,VkEvent event,VkPipelineStageFlags2KHR stageMask) const5091 void vkCmdResetEvent2KHR( VkCommandBuffer commandBuffer, 5092 VkEvent event, 5093 VkPipelineStageFlags2KHR stageMask ) const VULKAN_HPP_NOEXCEPT 5094 { 5095 return ::vkCmdResetEvent2KHR( commandBuffer, event, stageMask ); 5096 } 5097 vkCmdWaitEvents2KHR(VkCommandBuffer commandBuffer,uint32_t eventCount,const VkEvent * pEvents,const VkDependencyInfoKHR * pDependencyInfos) const5098 void vkCmdWaitEvents2KHR( VkCommandBuffer commandBuffer, 5099 uint32_t eventCount, 5100 const VkEvent * pEvents, 5101 const VkDependencyInfoKHR * pDependencyInfos ) const VULKAN_HPP_NOEXCEPT 5102 { 5103 return ::vkCmdWaitEvents2KHR( commandBuffer, eventCount, pEvents, pDependencyInfos ); 5104 } 5105 vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer,const VkDependencyInfoKHR * pDependencyInfo) const5106 void vkCmdPipelineBarrier2KHR( VkCommandBuffer commandBuffer, 5107 const VkDependencyInfoKHR * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT 5108 { 5109 return ::vkCmdPipelineBarrier2KHR( commandBuffer, pDependencyInfo ); 5110 } 5111 vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer,VkPipelineStageFlags2KHR stage,VkQueryPool queryPool,uint32_t query) const5112 void vkCmdWriteTimestamp2KHR( VkCommandBuffer commandBuffer, 5113 VkPipelineStageFlags2KHR stage, 5114 VkQueryPool queryPool, 5115 uint32_t query ) const VULKAN_HPP_NOEXCEPT 5116 { 5117 return ::vkCmdWriteTimestamp2KHR( commandBuffer, stage, queryPool, query ); 5118 } 5119 vkQueueSubmit2KHR(VkQueue queue,uint32_t submitCount,const VkSubmitInfo2KHR * pSubmits,VkFence fence) const5120 VkResult vkQueueSubmit2KHR( VkQueue queue, 5121 uint32_t submitCount, 5122 const VkSubmitInfo2KHR * pSubmits, 5123 VkFence fence ) const VULKAN_HPP_NOEXCEPT 5124 { 5125 return ::vkQueueSubmit2KHR( queue, submitCount, pSubmits, fence ); 5126 } 5127 vkCmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer,VkPipelineStageFlags2KHR stage,VkBuffer dstBuffer,VkDeviceSize dstOffset,uint32_t marker) const5128 void vkCmdWriteBufferMarker2AMD( VkCommandBuffer commandBuffer, 5129 VkPipelineStageFlags2KHR stage, 5130 VkBuffer dstBuffer, 5131 VkDeviceSize dstOffset, 5132 uint32_t marker ) const VULKAN_HPP_NOEXCEPT 5133 { 5134 return ::vkCmdWriteBufferMarker2AMD( commandBuffer, stage, dstBuffer, dstOffset, marker ); 5135 } 5136 vkGetQueueCheckpointData2NV(VkQueue queue,uint32_t * pCheckpointDataCount,VkCheckpointData2NV * pCheckpointData) const5137 void vkGetQueueCheckpointData2NV( VkQueue queue, 5138 uint32_t * pCheckpointDataCount, 5139 VkCheckpointData2NV * pCheckpointData ) const VULKAN_HPP_NOEXCEPT 5140 { 5141 return ::vkGetQueueCheckpointData2NV( queue, pCheckpointDataCount, pCheckpointData ); 5142 } 5143 5144 //=== VK_NV_fragment_shading_rate_enums === 5145 vkCmdSetFragmentShadingRateEnumNV(VkCommandBuffer commandBuffer,VkFragmentShadingRateNV shadingRate,const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) const5146 void vkCmdSetFragmentShadingRateEnumNV( VkCommandBuffer commandBuffer, 5147 VkFragmentShadingRateNV shadingRate, 5148 const VkFragmentShadingRateCombinerOpKHR combinerOps[2] ) const 5149 VULKAN_HPP_NOEXCEPT 5150 { 5151 return ::vkCmdSetFragmentShadingRateEnumNV( commandBuffer, shadingRate, combinerOps ); 5152 } 5153 5154 //=== VK_KHR_copy_commands2 === 5155 vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer,const VkCopyBufferInfo2KHR * pCopyBufferInfo) const5156 void vkCmdCopyBuffer2KHR( VkCommandBuffer commandBuffer, 5157 const VkCopyBufferInfo2KHR * pCopyBufferInfo ) const VULKAN_HPP_NOEXCEPT 5158 { 5159 return ::vkCmdCopyBuffer2KHR( commandBuffer, pCopyBufferInfo ); 5160 } 5161 vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer,const VkCopyImageInfo2KHR * pCopyImageInfo) const5162 void vkCmdCopyImage2KHR( VkCommandBuffer commandBuffer, 5163 const VkCopyImageInfo2KHR * pCopyImageInfo ) const VULKAN_HPP_NOEXCEPT 5164 { 5165 return ::vkCmdCopyImage2KHR( commandBuffer, pCopyImageInfo ); 5166 } 5167 5168 void vkCmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer,const VkCopyBufferToImageInfo2KHR * pCopyBufferToImageInfo) const5169 vkCmdCopyBufferToImage2KHR( VkCommandBuffer commandBuffer, 5170 const VkCopyBufferToImageInfo2KHR * pCopyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT 5171 { 5172 return ::vkCmdCopyBufferToImage2KHR( commandBuffer, pCopyBufferToImageInfo ); 5173 } 5174 5175 void vkCmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer,const VkCopyImageToBufferInfo2KHR * pCopyImageToBufferInfo) const5176 vkCmdCopyImageToBuffer2KHR( VkCommandBuffer commandBuffer, 5177 const VkCopyImageToBufferInfo2KHR * pCopyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT 5178 { 5179 return ::vkCmdCopyImageToBuffer2KHR( commandBuffer, pCopyImageToBufferInfo ); 5180 } 5181 vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer,const VkBlitImageInfo2KHR * pBlitImageInfo) const5182 void vkCmdBlitImage2KHR( VkCommandBuffer commandBuffer, 5183 const VkBlitImageInfo2KHR * pBlitImageInfo ) const VULKAN_HPP_NOEXCEPT 5184 { 5185 return ::vkCmdBlitImage2KHR( commandBuffer, pBlitImageInfo ); 5186 } 5187 vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer,const VkResolveImageInfo2KHR * pResolveImageInfo) const5188 void vkCmdResolveImage2KHR( VkCommandBuffer commandBuffer, 5189 const VkResolveImageInfo2KHR * pResolveImageInfo ) const VULKAN_HPP_NOEXCEPT 5190 { 5191 return ::vkCmdResolveImage2KHR( commandBuffer, pResolveImageInfo ); 5192 } 5193 5194 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 5195 //=== VK_NV_acquire_winrt_display === 5196 vkAcquireWinrtDisplayNV(VkPhysicalDevice physicalDevice,VkDisplayKHR display) const5197 VkResult vkAcquireWinrtDisplayNV( VkPhysicalDevice physicalDevice, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT 5198 { 5199 return ::vkAcquireWinrtDisplayNV( physicalDevice, display ); 5200 } 5201 vkGetWinrtDisplayNV(VkPhysicalDevice physicalDevice,uint32_t deviceRelativeId,VkDisplayKHR * pDisplay) const5202 VkResult vkGetWinrtDisplayNV( VkPhysicalDevice physicalDevice, 5203 uint32_t deviceRelativeId, 5204 VkDisplayKHR * pDisplay ) const VULKAN_HPP_NOEXCEPT 5205 { 5206 return ::vkGetWinrtDisplayNV( physicalDevice, deviceRelativeId, pDisplay ); 5207 } 5208 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 5209 5210 # if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) 5211 //=== VK_EXT_directfb_surface === 5212 vkCreateDirectFBSurfaceEXT(VkInstance instance,const VkDirectFBSurfaceCreateInfoEXT * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface) const5213 VkResult vkCreateDirectFBSurfaceEXT( VkInstance instance, 5214 const VkDirectFBSurfaceCreateInfoEXT * pCreateInfo, 5215 const VkAllocationCallbacks * pAllocator, 5216 VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT 5217 { 5218 return ::vkCreateDirectFBSurfaceEXT( instance, pCreateInfo, pAllocator, pSurface ); 5219 } 5220 vkGetPhysicalDeviceDirectFBPresentationSupportEXT(VkPhysicalDevice physicalDevice,uint32_t queueFamilyIndex,IDirectFB * dfb) const5221 VkBool32 vkGetPhysicalDeviceDirectFBPresentationSupportEXT( VkPhysicalDevice physicalDevice, 5222 uint32_t queueFamilyIndex, 5223 IDirectFB * dfb ) const VULKAN_HPP_NOEXCEPT 5224 { 5225 return ::vkGetPhysicalDeviceDirectFBPresentationSupportEXT( physicalDevice, queueFamilyIndex, dfb ); 5226 } 5227 # endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ 5228 5229 //=== VK_KHR_ray_tracing_pipeline === 5230 vkCmdTraceRaysKHR(VkCommandBuffer commandBuffer,const VkStridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,const VkStridedDeviceAddressRegionKHR * pMissShaderBindingTable,const VkStridedDeviceAddressRegionKHR * pHitShaderBindingTable,const VkStridedDeviceAddressRegionKHR * pCallableShaderBindingTable,uint32_t width,uint32_t height,uint32_t depth) const5231 void vkCmdTraceRaysKHR( VkCommandBuffer commandBuffer, 5232 const VkStridedDeviceAddressRegionKHR * pRaygenShaderBindingTable, 5233 const VkStridedDeviceAddressRegionKHR * pMissShaderBindingTable, 5234 const VkStridedDeviceAddressRegionKHR * pHitShaderBindingTable, 5235 const VkStridedDeviceAddressRegionKHR * pCallableShaderBindingTable, 5236 uint32_t width, 5237 uint32_t height, 5238 uint32_t depth ) const VULKAN_HPP_NOEXCEPT 5239 { 5240 return ::vkCmdTraceRaysKHR( commandBuffer, 5241 pRaygenShaderBindingTable, 5242 pMissShaderBindingTable, 5243 pHitShaderBindingTable, 5244 pCallableShaderBindingTable, 5245 width, 5246 height, 5247 depth ); 5248 } 5249 vkCreateRayTracingPipelinesKHR(VkDevice device,VkDeferredOperationKHR deferredOperation,VkPipelineCache pipelineCache,uint32_t createInfoCount,const VkRayTracingPipelineCreateInfoKHR * pCreateInfos,const VkAllocationCallbacks * pAllocator,VkPipeline * pPipelines) const5250 VkResult vkCreateRayTracingPipelinesKHR( VkDevice device, 5251 VkDeferredOperationKHR deferredOperation, 5252 VkPipelineCache pipelineCache, 5253 uint32_t createInfoCount, 5254 const VkRayTracingPipelineCreateInfoKHR * pCreateInfos, 5255 const VkAllocationCallbacks * pAllocator, 5256 VkPipeline * pPipelines ) const VULKAN_HPP_NOEXCEPT 5257 { 5258 return ::vkCreateRayTracingPipelinesKHR( 5259 device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines ); 5260 } 5261 vkGetRayTracingShaderGroupHandlesKHR(VkDevice device,VkPipeline pipeline,uint32_t firstGroup,uint32_t groupCount,size_t dataSize,void * pData) const5262 VkResult vkGetRayTracingShaderGroupHandlesKHR( VkDevice device, 5263 VkPipeline pipeline, 5264 uint32_t firstGroup, 5265 uint32_t groupCount, 5266 size_t dataSize, 5267 void * pData ) const VULKAN_HPP_NOEXCEPT 5268 { 5269 return ::vkGetRayTracingShaderGroupHandlesKHR( device, pipeline, firstGroup, groupCount, dataSize, pData ); 5270 } 5271 vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(VkDevice device,VkPipeline pipeline,uint32_t firstGroup,uint32_t groupCount,size_t dataSize,void * pData) const5272 VkResult vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( VkDevice device, 5273 VkPipeline pipeline, 5274 uint32_t firstGroup, 5275 uint32_t groupCount, 5276 size_t dataSize, 5277 void * pData ) const VULKAN_HPP_NOEXCEPT 5278 { 5279 return ::vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( 5280 device, pipeline, firstGroup, groupCount, dataSize, pData ); 5281 } 5282 vkCmdTraceRaysIndirectKHR(VkCommandBuffer commandBuffer,const VkStridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,const VkStridedDeviceAddressRegionKHR * pMissShaderBindingTable,const VkStridedDeviceAddressRegionKHR * pHitShaderBindingTable,const VkStridedDeviceAddressRegionKHR * pCallableShaderBindingTable,VkDeviceAddress indirectDeviceAddress) const5283 void vkCmdTraceRaysIndirectKHR( VkCommandBuffer commandBuffer, 5284 const VkStridedDeviceAddressRegionKHR * pRaygenShaderBindingTable, 5285 const VkStridedDeviceAddressRegionKHR * pMissShaderBindingTable, 5286 const VkStridedDeviceAddressRegionKHR * pHitShaderBindingTable, 5287 const VkStridedDeviceAddressRegionKHR * pCallableShaderBindingTable, 5288 VkDeviceAddress indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT 5289 { 5290 return ::vkCmdTraceRaysIndirectKHR( commandBuffer, 5291 pRaygenShaderBindingTable, 5292 pMissShaderBindingTable, 5293 pHitShaderBindingTable, 5294 pCallableShaderBindingTable, 5295 indirectDeviceAddress ); 5296 } 5297 vkGetRayTracingShaderGroupStackSizeKHR(VkDevice device,VkPipeline pipeline,uint32_t group,VkShaderGroupShaderKHR groupShader) const5298 VkDeviceSize vkGetRayTracingShaderGroupStackSizeKHR( VkDevice device, 5299 VkPipeline pipeline, 5300 uint32_t group, 5301 VkShaderGroupShaderKHR groupShader ) const VULKAN_HPP_NOEXCEPT 5302 { 5303 return ::vkGetRayTracingShaderGroupStackSizeKHR( device, pipeline, group, groupShader ); 5304 } 5305 vkCmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer,uint32_t pipelineStackSize) const5306 void vkCmdSetRayTracingPipelineStackSizeKHR( VkCommandBuffer commandBuffer, 5307 uint32_t pipelineStackSize ) const VULKAN_HPP_NOEXCEPT 5308 { 5309 return ::vkCmdSetRayTracingPipelineStackSizeKHR( commandBuffer, pipelineStackSize ); 5310 } 5311 5312 //=== VK_EXT_vertex_input_dynamic_state === 5313 vkCmdSetVertexInputEXT(VkCommandBuffer commandBuffer,uint32_t vertexBindingDescriptionCount,const VkVertexInputBindingDescription2EXT * pVertexBindingDescriptions,uint32_t vertexAttributeDescriptionCount,const VkVertexInputAttributeDescription2EXT * pVertexAttributeDescriptions) const5314 void vkCmdSetVertexInputEXT( VkCommandBuffer commandBuffer, 5315 uint32_t vertexBindingDescriptionCount, 5316 const VkVertexInputBindingDescription2EXT * pVertexBindingDescriptions, 5317 uint32_t vertexAttributeDescriptionCount, 5318 const VkVertexInputAttributeDescription2EXT * pVertexAttributeDescriptions ) const 5319 VULKAN_HPP_NOEXCEPT 5320 { 5321 return ::vkCmdSetVertexInputEXT( commandBuffer, 5322 vertexBindingDescriptionCount, 5323 pVertexBindingDescriptions, 5324 vertexAttributeDescriptionCount, 5325 pVertexAttributeDescriptions ); 5326 } 5327 5328 # if defined( VK_USE_PLATFORM_FUCHSIA ) 5329 //=== VK_FUCHSIA_external_memory === 5330 vkGetMemoryZirconHandleFUCHSIA(VkDevice device,const VkMemoryGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,zx_handle_t * pZirconHandle) const5331 VkResult vkGetMemoryZirconHandleFUCHSIA( VkDevice device, 5332 const VkMemoryGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo, 5333 zx_handle_t * pZirconHandle ) const VULKAN_HPP_NOEXCEPT 5334 { 5335 return ::vkGetMemoryZirconHandleFUCHSIA( device, pGetZirconHandleInfo, pZirconHandle ); 5336 } 5337 vkGetMemoryZirconHandlePropertiesFUCHSIA(VkDevice device,VkExternalMemoryHandleTypeFlagBits handleType,zx_handle_t zirconHandle,VkMemoryZirconHandlePropertiesFUCHSIA * pMemoryZirconHandleProperties) const5338 VkResult vkGetMemoryZirconHandlePropertiesFUCHSIA( 5339 VkDevice device, 5340 VkExternalMemoryHandleTypeFlagBits handleType, 5341 zx_handle_t zirconHandle, 5342 VkMemoryZirconHandlePropertiesFUCHSIA * pMemoryZirconHandleProperties ) const VULKAN_HPP_NOEXCEPT 5343 { 5344 return ::vkGetMemoryZirconHandlePropertiesFUCHSIA( 5345 device, handleType, zirconHandle, pMemoryZirconHandleProperties ); 5346 } 5347 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 5348 5349 # if defined( VK_USE_PLATFORM_FUCHSIA ) 5350 //=== VK_FUCHSIA_external_semaphore === 5351 vkImportSemaphoreZirconHandleFUCHSIA(VkDevice device,const VkImportSemaphoreZirconHandleInfoFUCHSIA * pImportSemaphoreZirconHandleInfo) const5352 VkResult vkImportSemaphoreZirconHandleFUCHSIA( 5353 VkDevice device, 5354 const VkImportSemaphoreZirconHandleInfoFUCHSIA * pImportSemaphoreZirconHandleInfo ) const VULKAN_HPP_NOEXCEPT 5355 { 5356 return ::vkImportSemaphoreZirconHandleFUCHSIA( device, pImportSemaphoreZirconHandleInfo ); 5357 } 5358 vkGetSemaphoreZirconHandleFUCHSIA(VkDevice device,const VkSemaphoreGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,zx_handle_t * pZirconHandle) const5359 VkResult vkGetSemaphoreZirconHandleFUCHSIA( VkDevice device, 5360 const VkSemaphoreGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo, 5361 zx_handle_t * pZirconHandle ) const VULKAN_HPP_NOEXCEPT 5362 { 5363 return ::vkGetSemaphoreZirconHandleFUCHSIA( device, pGetZirconHandleInfo, pZirconHandle ); 5364 } 5365 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 5366 5367 # if defined( VK_USE_PLATFORM_FUCHSIA ) 5368 //=== VK_FUCHSIA_buffer_collection === 5369 vkCreateBufferCollectionFUCHSIA(VkDevice device,const VkBufferCollectionCreateInfoFUCHSIA * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkBufferCollectionFUCHSIA * pCollection) const5370 VkResult vkCreateBufferCollectionFUCHSIA( VkDevice device, 5371 const VkBufferCollectionCreateInfoFUCHSIA * pCreateInfo, 5372 const VkAllocationCallbacks * pAllocator, 5373 VkBufferCollectionFUCHSIA * pCollection ) const VULKAN_HPP_NOEXCEPT 5374 { 5375 return ::vkCreateBufferCollectionFUCHSIA( device, pCreateInfo, pAllocator, pCollection ); 5376 } 5377 vkSetBufferCollectionImageConstraintsFUCHSIA(VkDevice device,VkBufferCollectionFUCHSIA collection,const VkImageConstraintsInfoFUCHSIA * pImageConstraintsInfo) const5378 VkResult vkSetBufferCollectionImageConstraintsFUCHSIA( 5379 VkDevice device, 5380 VkBufferCollectionFUCHSIA collection, 5381 const VkImageConstraintsInfoFUCHSIA * pImageConstraintsInfo ) const VULKAN_HPP_NOEXCEPT 5382 { 5383 return ::vkSetBufferCollectionImageConstraintsFUCHSIA( device, collection, pImageConstraintsInfo ); 5384 } 5385 vkSetBufferCollectionBufferConstraintsFUCHSIA(VkDevice device,VkBufferCollectionFUCHSIA collection,const VkBufferConstraintsInfoFUCHSIA * pBufferConstraintsInfo) const5386 VkResult vkSetBufferCollectionBufferConstraintsFUCHSIA( 5387 VkDevice device, 5388 VkBufferCollectionFUCHSIA collection, 5389 const VkBufferConstraintsInfoFUCHSIA * pBufferConstraintsInfo ) const VULKAN_HPP_NOEXCEPT 5390 { 5391 return ::vkSetBufferCollectionBufferConstraintsFUCHSIA( device, collection, pBufferConstraintsInfo ); 5392 } 5393 vkDestroyBufferCollectionFUCHSIA(VkDevice device,VkBufferCollectionFUCHSIA collection,const VkAllocationCallbacks * pAllocator) const5394 void vkDestroyBufferCollectionFUCHSIA( VkDevice device, 5395 VkBufferCollectionFUCHSIA collection, 5396 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT 5397 { 5398 return ::vkDestroyBufferCollectionFUCHSIA( device, collection, pAllocator ); 5399 } 5400 vkGetBufferCollectionPropertiesFUCHSIA(VkDevice device,VkBufferCollectionFUCHSIA collection,VkBufferCollectionPropertiesFUCHSIA * pProperties) const5401 VkResult vkGetBufferCollectionPropertiesFUCHSIA( VkDevice device, 5402 VkBufferCollectionFUCHSIA collection, 5403 VkBufferCollectionPropertiesFUCHSIA * pProperties ) const 5404 VULKAN_HPP_NOEXCEPT 5405 { 5406 return ::vkGetBufferCollectionPropertiesFUCHSIA( device, collection, pProperties ); 5407 } 5408 # endif /*VK_USE_PLATFORM_FUCHSIA*/ 5409 5410 //=== VK_HUAWEI_subpass_shading === 5411 vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(VkDevice device,VkRenderPass renderpass,VkExtent2D * pMaxWorkgroupSize) const5412 VkResult vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( VkDevice device, 5413 VkRenderPass renderpass, 5414 VkExtent2D * pMaxWorkgroupSize ) const VULKAN_HPP_NOEXCEPT 5415 { 5416 return ::vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( device, renderpass, pMaxWorkgroupSize ); 5417 } 5418 vkCmdSubpassShadingHUAWEI(VkCommandBuffer commandBuffer) const5419 void vkCmdSubpassShadingHUAWEI( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT 5420 { 5421 return ::vkCmdSubpassShadingHUAWEI( commandBuffer ); 5422 } 5423 5424 //=== VK_HUAWEI_invocation_mask === 5425 vkCmdBindInvocationMaskHUAWEI(VkCommandBuffer commandBuffer,VkImageView imageView,VkImageLayout imageLayout) const5426 void vkCmdBindInvocationMaskHUAWEI( VkCommandBuffer commandBuffer, 5427 VkImageView imageView, 5428 VkImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT 5429 { 5430 return ::vkCmdBindInvocationMaskHUAWEI( commandBuffer, imageView, imageLayout ); 5431 } 5432 5433 //=== VK_NV_external_memory_rdma === 5434 vkGetMemoryRemoteAddressNV(VkDevice device,const VkMemoryGetRemoteAddressInfoNV * pMemoryGetRemoteAddressInfo,VkRemoteAddressNV * pAddress) const5435 VkResult vkGetMemoryRemoteAddressNV( VkDevice device, 5436 const VkMemoryGetRemoteAddressInfoNV * pMemoryGetRemoteAddressInfo, 5437 VkRemoteAddressNV * pAddress ) const VULKAN_HPP_NOEXCEPT 5438 { 5439 return ::vkGetMemoryRemoteAddressNV( device, pMemoryGetRemoteAddressInfo, pAddress ); 5440 } 5441 5442 //=== VK_EXT_extended_dynamic_state2 === 5443 vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer,uint32_t patchControlPoints) const5444 void vkCmdSetPatchControlPointsEXT( VkCommandBuffer commandBuffer, 5445 uint32_t patchControlPoints ) const VULKAN_HPP_NOEXCEPT 5446 { 5447 return ::vkCmdSetPatchControlPointsEXT( commandBuffer, patchControlPoints ); 5448 } 5449 vkCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer,VkBool32 rasterizerDiscardEnable) const5450 void vkCmdSetRasterizerDiscardEnableEXT( VkCommandBuffer commandBuffer, 5451 VkBool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT 5452 { 5453 return ::vkCmdSetRasterizerDiscardEnableEXT( commandBuffer, rasterizerDiscardEnable ); 5454 } 5455 vkCmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer,VkBool32 depthBiasEnable) const5456 void vkCmdSetDepthBiasEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT 5457 { 5458 return ::vkCmdSetDepthBiasEnableEXT( commandBuffer, depthBiasEnable ); 5459 } 5460 vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer,VkLogicOp logicOp) const5461 void vkCmdSetLogicOpEXT( VkCommandBuffer commandBuffer, VkLogicOp logicOp ) const VULKAN_HPP_NOEXCEPT 5462 { 5463 return ::vkCmdSetLogicOpEXT( commandBuffer, logicOp ); 5464 } 5465 vkCmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer,VkBool32 primitiveRestartEnable) const5466 void vkCmdSetPrimitiveRestartEnableEXT( VkCommandBuffer commandBuffer, 5467 VkBool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT 5468 { 5469 return ::vkCmdSetPrimitiveRestartEnableEXT( commandBuffer, primitiveRestartEnable ); 5470 } 5471 5472 # if defined( VK_USE_PLATFORM_SCREEN_QNX ) 5473 //=== VK_QNX_screen_surface === 5474 vkCreateScreenSurfaceQNX(VkInstance instance,const VkScreenSurfaceCreateInfoQNX * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSurfaceKHR * pSurface) const5475 VkResult vkCreateScreenSurfaceQNX( VkInstance instance, 5476 const VkScreenSurfaceCreateInfoQNX * pCreateInfo, 5477 const VkAllocationCallbacks * pAllocator, 5478 VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT 5479 { 5480 return ::vkCreateScreenSurfaceQNX( instance, pCreateInfo, pAllocator, pSurface ); 5481 } 5482 vkGetPhysicalDeviceScreenPresentationSupportQNX(VkPhysicalDevice physicalDevice,uint32_t queueFamilyIndex,struct _screen_window * window) const5483 VkBool32 vkGetPhysicalDeviceScreenPresentationSupportQNX( VkPhysicalDevice physicalDevice, 5484 uint32_t queueFamilyIndex, 5485 struct _screen_window * window ) const VULKAN_HPP_NOEXCEPT 5486 { 5487 return ::vkGetPhysicalDeviceScreenPresentationSupportQNX( physicalDevice, queueFamilyIndex, window ); 5488 } 5489 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 5490 5491 //=== VK_EXT_color_write_enable === 5492 vkCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer,uint32_t attachmentCount,const VkBool32 * pColorWriteEnables) const5493 void vkCmdSetColorWriteEnableEXT( VkCommandBuffer commandBuffer, 5494 uint32_t attachmentCount, 5495 const VkBool32 * pColorWriteEnables ) const VULKAN_HPP_NOEXCEPT 5496 { 5497 return ::vkCmdSetColorWriteEnableEXT( commandBuffer, attachmentCount, pColorWriteEnables ); 5498 } 5499 5500 //=== VK_EXT_multi_draw === 5501 vkCmdDrawMultiEXT(VkCommandBuffer commandBuffer,uint32_t drawCount,const VkMultiDrawInfoEXT * pVertexInfo,uint32_t instanceCount,uint32_t firstInstance,uint32_t stride) const5502 void vkCmdDrawMultiEXT( VkCommandBuffer commandBuffer, 5503 uint32_t drawCount, 5504 const VkMultiDrawInfoEXT * pVertexInfo, 5505 uint32_t instanceCount, 5506 uint32_t firstInstance, 5507 uint32_t stride ) const VULKAN_HPP_NOEXCEPT 5508 { 5509 return ::vkCmdDrawMultiEXT( commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride ); 5510 } 5511 vkCmdDrawMultiIndexedEXT(VkCommandBuffer commandBuffer,uint32_t drawCount,const VkMultiDrawIndexedInfoEXT * pIndexInfo,uint32_t instanceCount,uint32_t firstInstance,uint32_t stride,const int32_t * pVertexOffset) const5512 void vkCmdDrawMultiIndexedEXT( VkCommandBuffer commandBuffer, 5513 uint32_t drawCount, 5514 const VkMultiDrawIndexedInfoEXT * pIndexInfo, 5515 uint32_t instanceCount, 5516 uint32_t firstInstance, 5517 uint32_t stride, 5518 const int32_t * pVertexOffset ) const VULKAN_HPP_NOEXCEPT 5519 { 5520 return ::vkCmdDrawMultiIndexedEXT( 5521 commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset ); 5522 } 5523 5524 //=== VK_EXT_pageable_device_local_memory === 5525 5526 void vkSetDeviceMemoryPriorityEXT(VkDevice device,VkDeviceMemory memory,float priority) const5527 vkSetDeviceMemoryPriorityEXT( VkDevice device, VkDeviceMemory memory, float priority ) const VULKAN_HPP_NOEXCEPT 5528 { 5529 return ::vkSetDeviceMemoryPriorityEXT( device, memory, priority ); 5530 } 5531 5532 //=== VK_KHR_maintenance4 === 5533 vkGetDeviceBufferMemoryRequirementsKHR(VkDevice device,const VkDeviceBufferMemoryRequirementsKHR * pInfo,VkMemoryRequirements2 * pMemoryRequirements) const5534 void vkGetDeviceBufferMemoryRequirementsKHR( VkDevice device, 5535 const VkDeviceBufferMemoryRequirementsKHR * pInfo, 5536 VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT 5537 { 5538 return ::vkGetDeviceBufferMemoryRequirementsKHR( device, pInfo, pMemoryRequirements ); 5539 } 5540 vkGetDeviceImageMemoryRequirementsKHR(VkDevice device,const VkDeviceImageMemoryRequirementsKHR * pInfo,VkMemoryRequirements2 * pMemoryRequirements) const5541 void vkGetDeviceImageMemoryRequirementsKHR( VkDevice device, 5542 const VkDeviceImageMemoryRequirementsKHR * pInfo, 5543 VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT 5544 { 5545 return ::vkGetDeviceImageMemoryRequirementsKHR( device, pInfo, pMemoryRequirements ); 5546 } 5547 vkGetDeviceImageSparseMemoryRequirementsKHR(VkDevice device,const VkDeviceImageMemoryRequirementsKHR * pInfo,uint32_t * pSparseMemoryRequirementCount,VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements) const5548 void vkGetDeviceImageSparseMemoryRequirementsKHR( 5549 VkDevice device, 5550 const VkDeviceImageMemoryRequirementsKHR * pInfo, 5551 uint32_t * pSparseMemoryRequirementCount, 5552 VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT 5553 { 5554 return ::vkGetDeviceImageSparseMemoryRequirementsKHR( 5555 device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements ); 5556 } 5557 }; 5558 #endif 5559 5560 class DispatchLoaderDynamic; 5561 #if !defined( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC ) 5562 # if defined( VK_NO_PROTOTYPES ) 5563 # define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC 1 5564 # else 5565 # define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC 0 5566 # endif 5567 #endif 5568 5569 #if !defined( VULKAN_HPP_STORAGE_API ) 5570 # if defined( VULKAN_HPP_STORAGE_SHARED ) 5571 # if defined( _MSC_VER ) 5572 # if defined( VULKAN_HPP_STORAGE_SHARED_EXPORT ) 5573 # define VULKAN_HPP_STORAGE_API __declspec( dllexport ) 5574 # else 5575 # define VULKAN_HPP_STORAGE_API __declspec( dllimport ) 5576 # endif 5577 # elif defined( __clang__ ) || defined( __GNUC__ ) 5578 # if defined( VULKAN_HPP_STORAGE_SHARED_EXPORT ) 5579 # define VULKAN_HPP_STORAGE_API __attribute__( ( visibility( "default" ) ) ) 5580 # else 5581 # define VULKAN_HPP_STORAGE_API 5582 # endif 5583 # else 5584 # define VULKAN_HPP_STORAGE_API 5585 # pragma warning Unknown import / export semantics 5586 # endif 5587 # else 5588 # define VULKAN_HPP_STORAGE_API 5589 # endif 5590 #endif 5591 5592 #if !defined( VULKAN_HPP_DEFAULT_DISPATCHER ) 5593 # if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 5594 # define VULKAN_HPP_DEFAULT_DISPATCHER ::VULKAN_HPP_NAMESPACE::defaultDispatchLoaderDynamic 5595 # define VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE \ 5596 namespace VULKAN_HPP_NAMESPACE \ 5597 { \ 5598 VULKAN_HPP_STORAGE_API DispatchLoaderDynamic defaultDispatchLoaderDynamic; \ 5599 } 5600 extern VULKAN_HPP_STORAGE_API DispatchLoaderDynamic defaultDispatchLoaderDynamic; 5601 # else getDispatchLoaderStatic()5602 static inline ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic & getDispatchLoaderStatic() 5603 { 5604 static ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic dls; 5605 return dls; 5606 } 5607 # define VULKAN_HPP_DEFAULT_DISPATCHER ::VULKAN_HPP_NAMESPACE::getDispatchLoaderStatic() 5608 # define VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE 5609 # endif 5610 #endif 5611 5612 #if !defined( VULKAN_HPP_DEFAULT_DISPATCHER_TYPE ) 5613 # if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 5614 # define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE ::VULKAN_HPP_NAMESPACE::DispatchLoaderDynamic 5615 # else 5616 # define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic 5617 # endif 5618 #endif 5619 5620 #if defined( VULKAN_HPP_NO_DEFAULT_DISPATCHER ) 5621 # define VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT 5622 # define VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT 5623 # define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT 5624 #else 5625 # define VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT = {} 5626 # define VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT = nullptr 5627 # define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT = VULKAN_HPP_DEFAULT_DISPATCHER 5628 #endif 5629 5630 struct AllocationCallbacks; 5631 5632 template <typename OwnerType, typename Dispatch> 5633 class ObjectDestroy 5634 { 5635 public: 5636 ObjectDestroy() = default; 5637 ObjectDestroy(OwnerType owner,Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT)5638 ObjectDestroy( OwnerType owner, 5639 Optional<const AllocationCallbacks> allocationCallbacks 5640 VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, 5641 Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT 5642 : m_owner( owner ) 5643 , m_allocationCallbacks( allocationCallbacks ) 5644 , m_dispatch( &dispatch ) 5645 {} 5646 getOwner() const5647 OwnerType getOwner() const VULKAN_HPP_NOEXCEPT 5648 { 5649 return m_owner; 5650 } getAllocator() const5651 Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT 5652 { 5653 return m_allocationCallbacks; 5654 } 5655 5656 protected: 5657 template <typename T> destroy(T t)5658 void destroy( T t ) VULKAN_HPP_NOEXCEPT 5659 { 5660 VULKAN_HPP_ASSERT( m_owner && m_dispatch ); 5661 m_owner.destroy( t, m_allocationCallbacks, *m_dispatch ); 5662 } 5663 5664 private: 5665 OwnerType m_owner = {}; 5666 Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr; 5667 Dispatch const * m_dispatch = nullptr; 5668 }; 5669 5670 class NoParent; 5671 5672 template <typename Dispatch> 5673 class ObjectDestroy<NoParent, Dispatch> 5674 { 5675 public: 5676 ObjectDestroy() = default; 5677 ObjectDestroy(Optional<const AllocationCallbacks> allocationCallbacks,Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT)5678 ObjectDestroy( Optional<const AllocationCallbacks> allocationCallbacks, 5679 Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT 5680 : m_allocationCallbacks( allocationCallbacks ) 5681 , m_dispatch( &dispatch ) 5682 {} 5683 getAllocator() const5684 Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT 5685 { 5686 return m_allocationCallbacks; 5687 } 5688 5689 protected: 5690 template <typename T> destroy(T t)5691 void destroy( T t ) VULKAN_HPP_NOEXCEPT 5692 { 5693 VULKAN_HPP_ASSERT( m_dispatch ); 5694 t.destroy( m_allocationCallbacks, *m_dispatch ); 5695 } 5696 5697 private: 5698 Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr; 5699 Dispatch const * m_dispatch = nullptr; 5700 }; 5701 5702 template <typename OwnerType, typename Dispatch> 5703 class ObjectFree 5704 { 5705 public: 5706 ObjectFree() = default; 5707 ObjectFree(OwnerType owner,Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT)5708 ObjectFree( OwnerType owner, 5709 Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, 5710 Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT 5711 : m_owner( owner ) 5712 , m_allocationCallbacks( allocationCallbacks ) 5713 , m_dispatch( &dispatch ) 5714 {} 5715 getOwner() const5716 OwnerType getOwner() const VULKAN_HPP_NOEXCEPT 5717 { 5718 return m_owner; 5719 } 5720 getAllocator() const5721 Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT 5722 { 5723 return m_allocationCallbacks; 5724 } 5725 5726 protected: 5727 template <typename T> destroy(T t)5728 void destroy( T t ) VULKAN_HPP_NOEXCEPT 5729 { 5730 VULKAN_HPP_ASSERT( m_owner && m_dispatch ); 5731 m_owner.free( t, m_allocationCallbacks, *m_dispatch ); 5732 } 5733 5734 private: 5735 OwnerType m_owner = {}; 5736 Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr; 5737 Dispatch const * m_dispatch = nullptr; 5738 }; 5739 5740 template <typename OwnerType, typename Dispatch> 5741 class ObjectRelease 5742 { 5743 public: 5744 ObjectRelease() = default; 5745 ObjectRelease(OwnerType owner,Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT)5746 ObjectRelease( OwnerType owner, 5747 Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT 5748 : m_owner( owner ) 5749 , m_dispatch( &dispatch ) 5750 {} 5751 getOwner() const5752 OwnerType getOwner() const VULKAN_HPP_NOEXCEPT 5753 { 5754 return m_owner; 5755 } 5756 5757 protected: 5758 template <typename T> destroy(T t)5759 void destroy( T t ) VULKAN_HPP_NOEXCEPT 5760 { 5761 VULKAN_HPP_ASSERT( m_owner && m_dispatch ); 5762 m_owner.release( t, *m_dispatch ); 5763 } 5764 5765 private: 5766 OwnerType m_owner = {}; 5767 Dispatch const * m_dispatch = nullptr; 5768 }; 5769 5770 template <typename OwnerType, typename PoolType, typename Dispatch> 5771 class PoolFree 5772 { 5773 public: 5774 PoolFree() = default; 5775 PoolFree(OwnerType owner,PoolType pool,Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT)5776 PoolFree( OwnerType owner, 5777 PoolType pool, 5778 Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT 5779 : m_owner( owner ) 5780 , m_pool( pool ) 5781 , m_dispatch( &dispatch ) 5782 {} 5783 getOwner() const5784 OwnerType getOwner() const VULKAN_HPP_NOEXCEPT 5785 { 5786 return m_owner; 5787 } getPool() const5788 PoolType getPool() const VULKAN_HPP_NOEXCEPT 5789 { 5790 return m_pool; 5791 } 5792 5793 protected: 5794 template <typename T> destroy(T t)5795 void destroy( T t ) VULKAN_HPP_NOEXCEPT 5796 { 5797 m_owner.free( m_pool, t, *m_dispatch ); 5798 } 5799 5800 private: 5801 OwnerType m_owner = OwnerType(); 5802 PoolType m_pool = PoolType(); 5803 Dispatch const * m_dispatch = nullptr; 5804 }; 5805 5806 //================== 5807 //=== BASE TYPEs === 5808 //================== 5809 5810 using Bool32 = uint32_t; 5811 using DeviceAddress = uint64_t; 5812 using DeviceSize = uint64_t; 5813 using RemoteAddressNV = void *; 5814 using SampleMask = uint32_t; 5815 5816 } // namespace VULKAN_HPP_NAMESPACE 5817 5818 #include <vulkan/vulkan_enums.hpp> 5819 5820 #ifndef VULKAN_HPP_NO_EXCEPTIONS 5821 namespace std 5822 { 5823 template <> 5824 struct is_error_code_enum<VULKAN_HPP_NAMESPACE::Result> : public true_type 5825 {}; 5826 } // namespace std 5827 #endif 5828 5829 namespace VULKAN_HPP_NAMESPACE 5830 { 5831 #ifndef VULKAN_HPP_NO_EXCEPTIONS 5832 5833 class ErrorCategoryImpl : public std::error_category 5834 { 5835 public: name() const5836 virtual const char * name() const VULKAN_HPP_NOEXCEPT override 5837 { 5838 return VULKAN_HPP_NAMESPACE_STRING "::Result"; 5839 } message(int ev) const5840 virtual std::string message( int ev ) const override 5841 { 5842 return to_string( static_cast<Result>( ev ) ); 5843 } 5844 }; 5845 5846 class Error 5847 { 5848 public: 5849 Error() VULKAN_HPP_NOEXCEPT = default; 5850 Error( const Error & ) VULKAN_HPP_NOEXCEPT = default; 5851 virtual ~Error() VULKAN_HPP_NOEXCEPT = default; 5852 5853 virtual const char * what() const VULKAN_HPP_NOEXCEPT = 0; 5854 }; 5855 5856 class LogicError 5857 : public Error 5858 , public std::logic_error 5859 { 5860 public: LogicError(const std::string & what)5861 explicit LogicError( const std::string & what ) : Error(), std::logic_error( what ) {} LogicError(char const * what)5862 explicit LogicError( char const * what ) : Error(), std::logic_error( what ) {} 5863 what() const5864 virtual const char * what() const VULKAN_HPP_NOEXCEPT 5865 { 5866 return std::logic_error::what(); 5867 } 5868 }; 5869 5870 class SystemError 5871 : public Error 5872 , public std::system_error 5873 { 5874 public: SystemError(std::error_code ec)5875 SystemError( std::error_code ec ) : Error(), std::system_error( ec ) {} SystemError(std::error_code ec,std::string const & what)5876 SystemError( std::error_code ec, std::string const & what ) : Error(), std::system_error( ec, what ) {} SystemError(std::error_code ec,char const * what)5877 SystemError( std::error_code ec, char const * what ) : Error(), std::system_error( ec, what ) {} SystemError(int ev,std::error_category const & ecat)5878 SystemError( int ev, std::error_category const & ecat ) : Error(), std::system_error( ev, ecat ) {} SystemError(int ev,std::error_category const & ecat,std::string const & what)5879 SystemError( int ev, std::error_category const & ecat, std::string const & what ) 5880 : Error(), std::system_error( ev, ecat, what ) 5881 {} SystemError(int ev,std::error_category const & ecat,char const * what)5882 SystemError( int ev, std::error_category const & ecat, char const * what ) 5883 : Error(), std::system_error( ev, ecat, what ) 5884 {} 5885 what() const5886 virtual const char * what() const VULKAN_HPP_NOEXCEPT 5887 { 5888 return std::system_error::what(); 5889 } 5890 }; 5891 errorCategory()5892 VULKAN_HPP_INLINE const std::error_category & errorCategory() VULKAN_HPP_NOEXCEPT 5893 { 5894 static ErrorCategoryImpl instance; 5895 return instance; 5896 } 5897 make_error_code(Result e)5898 VULKAN_HPP_INLINE std::error_code make_error_code( Result e ) VULKAN_HPP_NOEXCEPT 5899 { 5900 return std::error_code( static_cast<int>( e ), errorCategory() ); 5901 } 5902 make_error_condition(Result e)5903 VULKAN_HPP_INLINE std::error_condition make_error_condition( Result e ) VULKAN_HPP_NOEXCEPT 5904 { 5905 return std::error_condition( static_cast<int>( e ), errorCategory() ); 5906 } 5907 5908 class OutOfHostMemoryError : public SystemError 5909 { 5910 public: OutOfHostMemoryError(std::string const & message)5911 OutOfHostMemoryError( std::string const & message ) 5912 : SystemError( make_error_code( Result::eErrorOutOfHostMemory ), message ) 5913 {} OutOfHostMemoryError(char const * message)5914 OutOfHostMemoryError( char const * message ) 5915 : SystemError( make_error_code( Result::eErrorOutOfHostMemory ), message ) 5916 {} 5917 }; 5918 5919 class OutOfDeviceMemoryError : public SystemError 5920 { 5921 public: OutOfDeviceMemoryError(std::string const & message)5922 OutOfDeviceMemoryError( std::string const & message ) 5923 : SystemError( make_error_code( Result::eErrorOutOfDeviceMemory ), message ) 5924 {} OutOfDeviceMemoryError(char const * message)5925 OutOfDeviceMemoryError( char const * message ) 5926 : SystemError( make_error_code( Result::eErrorOutOfDeviceMemory ), message ) 5927 {} 5928 }; 5929 5930 class InitializationFailedError : public SystemError 5931 { 5932 public: InitializationFailedError(std::string const & message)5933 InitializationFailedError( std::string const & message ) 5934 : SystemError( make_error_code( Result::eErrorInitializationFailed ), message ) 5935 {} InitializationFailedError(char const * message)5936 InitializationFailedError( char const * message ) 5937 : SystemError( make_error_code( Result::eErrorInitializationFailed ), message ) 5938 {} 5939 }; 5940 5941 class DeviceLostError : public SystemError 5942 { 5943 public: DeviceLostError(std::string const & message)5944 DeviceLostError( std::string const & message ) : SystemError( make_error_code( Result::eErrorDeviceLost ), message ) 5945 {} DeviceLostError(char const * message)5946 DeviceLostError( char const * message ) : SystemError( make_error_code( Result::eErrorDeviceLost ), message ) {} 5947 }; 5948 5949 class MemoryMapFailedError : public SystemError 5950 { 5951 public: MemoryMapFailedError(std::string const & message)5952 MemoryMapFailedError( std::string const & message ) 5953 : SystemError( make_error_code( Result::eErrorMemoryMapFailed ), message ) 5954 {} MemoryMapFailedError(char const * message)5955 MemoryMapFailedError( char const * message ) 5956 : SystemError( make_error_code( Result::eErrorMemoryMapFailed ), message ) 5957 {} 5958 }; 5959 5960 class LayerNotPresentError : public SystemError 5961 { 5962 public: LayerNotPresentError(std::string const & message)5963 LayerNotPresentError( std::string const & message ) 5964 : SystemError( make_error_code( Result::eErrorLayerNotPresent ), message ) 5965 {} LayerNotPresentError(char const * message)5966 LayerNotPresentError( char const * message ) 5967 : SystemError( make_error_code( Result::eErrorLayerNotPresent ), message ) 5968 {} 5969 }; 5970 5971 class ExtensionNotPresentError : public SystemError 5972 { 5973 public: ExtensionNotPresentError(std::string const & message)5974 ExtensionNotPresentError( std::string const & message ) 5975 : SystemError( make_error_code( Result::eErrorExtensionNotPresent ), message ) 5976 {} ExtensionNotPresentError(char const * message)5977 ExtensionNotPresentError( char const * message ) 5978 : SystemError( make_error_code( Result::eErrorExtensionNotPresent ), message ) 5979 {} 5980 }; 5981 5982 class FeatureNotPresentError : public SystemError 5983 { 5984 public: FeatureNotPresentError(std::string const & message)5985 FeatureNotPresentError( std::string const & message ) 5986 : SystemError( make_error_code( Result::eErrorFeatureNotPresent ), message ) 5987 {} FeatureNotPresentError(char const * message)5988 FeatureNotPresentError( char const * message ) 5989 : SystemError( make_error_code( Result::eErrorFeatureNotPresent ), message ) 5990 {} 5991 }; 5992 5993 class IncompatibleDriverError : public SystemError 5994 { 5995 public: IncompatibleDriverError(std::string const & message)5996 IncompatibleDriverError( std::string const & message ) 5997 : SystemError( make_error_code( Result::eErrorIncompatibleDriver ), message ) 5998 {} IncompatibleDriverError(char const * message)5999 IncompatibleDriverError( char const * message ) 6000 : SystemError( make_error_code( Result::eErrorIncompatibleDriver ), message ) 6001 {} 6002 }; 6003 6004 class TooManyObjectsError : public SystemError 6005 { 6006 public: TooManyObjectsError(std::string const & message)6007 TooManyObjectsError( std::string const & message ) 6008 : SystemError( make_error_code( Result::eErrorTooManyObjects ), message ) 6009 {} TooManyObjectsError(char const * message)6010 TooManyObjectsError( char const * message ) 6011 : SystemError( make_error_code( Result::eErrorTooManyObjects ), message ) 6012 {} 6013 }; 6014 6015 class FormatNotSupportedError : public SystemError 6016 { 6017 public: FormatNotSupportedError(std::string const & message)6018 FormatNotSupportedError( std::string const & message ) 6019 : SystemError( make_error_code( Result::eErrorFormatNotSupported ), message ) 6020 {} FormatNotSupportedError(char const * message)6021 FormatNotSupportedError( char const * message ) 6022 : SystemError( make_error_code( Result::eErrorFormatNotSupported ), message ) 6023 {} 6024 }; 6025 6026 class FragmentedPoolError : public SystemError 6027 { 6028 public: FragmentedPoolError(std::string const & message)6029 FragmentedPoolError( std::string const & message ) 6030 : SystemError( make_error_code( Result::eErrorFragmentedPool ), message ) 6031 {} FragmentedPoolError(char const * message)6032 FragmentedPoolError( char const * message ) 6033 : SystemError( make_error_code( Result::eErrorFragmentedPool ), message ) 6034 {} 6035 }; 6036 6037 class UnknownError : public SystemError 6038 { 6039 public: UnknownError(std::string const & message)6040 UnknownError( std::string const & message ) : SystemError( make_error_code( Result::eErrorUnknown ), message ) {} UnknownError(char const * message)6041 UnknownError( char const * message ) : SystemError( make_error_code( Result::eErrorUnknown ), message ) {} 6042 }; 6043 6044 class OutOfPoolMemoryError : public SystemError 6045 { 6046 public: OutOfPoolMemoryError(std::string const & message)6047 OutOfPoolMemoryError( std::string const & message ) 6048 : SystemError( make_error_code( Result::eErrorOutOfPoolMemory ), message ) 6049 {} OutOfPoolMemoryError(char const * message)6050 OutOfPoolMemoryError( char const * message ) 6051 : SystemError( make_error_code( Result::eErrorOutOfPoolMemory ), message ) 6052 {} 6053 }; 6054 6055 class InvalidExternalHandleError : public SystemError 6056 { 6057 public: InvalidExternalHandleError(std::string const & message)6058 InvalidExternalHandleError( std::string const & message ) 6059 : SystemError( make_error_code( Result::eErrorInvalidExternalHandle ), message ) 6060 {} InvalidExternalHandleError(char const * message)6061 InvalidExternalHandleError( char const * message ) 6062 : SystemError( make_error_code( Result::eErrorInvalidExternalHandle ), message ) 6063 {} 6064 }; 6065 6066 class FragmentationError : public SystemError 6067 { 6068 public: FragmentationError(std::string const & message)6069 FragmentationError( std::string const & message ) 6070 : SystemError( make_error_code( Result::eErrorFragmentation ), message ) 6071 {} FragmentationError(char const * message)6072 FragmentationError( char const * message ) : SystemError( make_error_code( Result::eErrorFragmentation ), message ) 6073 {} 6074 }; 6075 6076 class InvalidOpaqueCaptureAddressError : public SystemError 6077 { 6078 public: InvalidOpaqueCaptureAddressError(std::string const & message)6079 InvalidOpaqueCaptureAddressError( std::string const & message ) 6080 : SystemError( make_error_code( Result::eErrorInvalidOpaqueCaptureAddress ), message ) 6081 {} InvalidOpaqueCaptureAddressError(char const * message)6082 InvalidOpaqueCaptureAddressError( char const * message ) 6083 : SystemError( make_error_code( Result::eErrorInvalidOpaqueCaptureAddress ), message ) 6084 {} 6085 }; 6086 6087 class SurfaceLostKHRError : public SystemError 6088 { 6089 public: SurfaceLostKHRError(std::string const & message)6090 SurfaceLostKHRError( std::string const & message ) 6091 : SystemError( make_error_code( Result::eErrorSurfaceLostKHR ), message ) 6092 {} SurfaceLostKHRError(char const * message)6093 SurfaceLostKHRError( char const * message ) 6094 : SystemError( make_error_code( Result::eErrorSurfaceLostKHR ), message ) 6095 {} 6096 }; 6097 6098 class NativeWindowInUseKHRError : public SystemError 6099 { 6100 public: NativeWindowInUseKHRError(std::string const & message)6101 NativeWindowInUseKHRError( std::string const & message ) 6102 : SystemError( make_error_code( Result::eErrorNativeWindowInUseKHR ), message ) 6103 {} NativeWindowInUseKHRError(char const * message)6104 NativeWindowInUseKHRError( char const * message ) 6105 : SystemError( make_error_code( Result::eErrorNativeWindowInUseKHR ), message ) 6106 {} 6107 }; 6108 6109 class OutOfDateKHRError : public SystemError 6110 { 6111 public: OutOfDateKHRError(std::string const & message)6112 OutOfDateKHRError( std::string const & message ) 6113 : SystemError( make_error_code( Result::eErrorOutOfDateKHR ), message ) 6114 {} OutOfDateKHRError(char const * message)6115 OutOfDateKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorOutOfDateKHR ), message ) {} 6116 }; 6117 6118 class IncompatibleDisplayKHRError : public SystemError 6119 { 6120 public: IncompatibleDisplayKHRError(std::string const & message)6121 IncompatibleDisplayKHRError( std::string const & message ) 6122 : SystemError( make_error_code( Result::eErrorIncompatibleDisplayKHR ), message ) 6123 {} IncompatibleDisplayKHRError(char const * message)6124 IncompatibleDisplayKHRError( char const * message ) 6125 : SystemError( make_error_code( Result::eErrorIncompatibleDisplayKHR ), message ) 6126 {} 6127 }; 6128 6129 class ValidationFailedEXTError : public SystemError 6130 { 6131 public: ValidationFailedEXTError(std::string const & message)6132 ValidationFailedEXTError( std::string const & message ) 6133 : SystemError( make_error_code( Result::eErrorValidationFailedEXT ), message ) 6134 {} ValidationFailedEXTError(char const * message)6135 ValidationFailedEXTError( char const * message ) 6136 : SystemError( make_error_code( Result::eErrorValidationFailedEXT ), message ) 6137 {} 6138 }; 6139 6140 class InvalidShaderNVError : public SystemError 6141 { 6142 public: InvalidShaderNVError(std::string const & message)6143 InvalidShaderNVError( std::string const & message ) 6144 : SystemError( make_error_code( Result::eErrorInvalidShaderNV ), message ) 6145 {} InvalidShaderNVError(char const * message)6146 InvalidShaderNVError( char const * message ) 6147 : SystemError( make_error_code( Result::eErrorInvalidShaderNV ), message ) 6148 {} 6149 }; 6150 6151 class InvalidDrmFormatModifierPlaneLayoutEXTError : public SystemError 6152 { 6153 public: InvalidDrmFormatModifierPlaneLayoutEXTError(std::string const & message)6154 InvalidDrmFormatModifierPlaneLayoutEXTError( std::string const & message ) 6155 : SystemError( make_error_code( Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT ), message ) 6156 {} InvalidDrmFormatModifierPlaneLayoutEXTError(char const * message)6157 InvalidDrmFormatModifierPlaneLayoutEXTError( char const * message ) 6158 : SystemError( make_error_code( Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT ), message ) 6159 {} 6160 }; 6161 6162 class NotPermittedEXTError : public SystemError 6163 { 6164 public: NotPermittedEXTError(std::string const & message)6165 NotPermittedEXTError( std::string const & message ) 6166 : SystemError( make_error_code( Result::eErrorNotPermittedEXT ), message ) 6167 {} NotPermittedEXTError(char const * message)6168 NotPermittedEXTError( char const * message ) 6169 : SystemError( make_error_code( Result::eErrorNotPermittedEXT ), message ) 6170 {} 6171 }; 6172 6173 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 6174 class FullScreenExclusiveModeLostEXTError : public SystemError 6175 { 6176 public: FullScreenExclusiveModeLostEXTError(std::string const & message)6177 FullScreenExclusiveModeLostEXTError( std::string const & message ) 6178 : SystemError( make_error_code( Result::eErrorFullScreenExclusiveModeLostEXT ), message ) 6179 {} FullScreenExclusiveModeLostEXTError(char const * message)6180 FullScreenExclusiveModeLostEXTError( char const * message ) 6181 : SystemError( make_error_code( Result::eErrorFullScreenExclusiveModeLostEXT ), message ) 6182 {} 6183 }; 6184 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 6185 6186 namespace 6187 { throwResultException(Result result,char const * message)6188 [[noreturn]] void throwResultException( Result result, char const * message ) 6189 { 6190 switch ( result ) 6191 { 6192 case Result::eErrorOutOfHostMemory: throw OutOfHostMemoryError( message ); 6193 case Result::eErrorOutOfDeviceMemory: throw OutOfDeviceMemoryError( message ); 6194 case Result::eErrorInitializationFailed: throw InitializationFailedError( message ); 6195 case Result::eErrorDeviceLost: throw DeviceLostError( message ); 6196 case Result::eErrorMemoryMapFailed: throw MemoryMapFailedError( message ); 6197 case Result::eErrorLayerNotPresent: throw LayerNotPresentError( message ); 6198 case Result::eErrorExtensionNotPresent: throw ExtensionNotPresentError( message ); 6199 case Result::eErrorFeatureNotPresent: throw FeatureNotPresentError( message ); 6200 case Result::eErrorIncompatibleDriver: throw IncompatibleDriverError( message ); 6201 case Result::eErrorTooManyObjects: throw TooManyObjectsError( message ); 6202 case Result::eErrorFormatNotSupported: throw FormatNotSupportedError( message ); 6203 case Result::eErrorFragmentedPool: throw FragmentedPoolError( message ); 6204 case Result::eErrorUnknown: throw UnknownError( message ); 6205 case Result::eErrorOutOfPoolMemory: throw OutOfPoolMemoryError( message ); 6206 case Result::eErrorInvalidExternalHandle: throw InvalidExternalHandleError( message ); 6207 case Result::eErrorFragmentation: throw FragmentationError( message ); 6208 case Result::eErrorInvalidOpaqueCaptureAddress: throw InvalidOpaqueCaptureAddressError( message ); 6209 case Result::eErrorSurfaceLostKHR: throw SurfaceLostKHRError( message ); 6210 case Result::eErrorNativeWindowInUseKHR: throw NativeWindowInUseKHRError( message ); 6211 case Result::eErrorOutOfDateKHR: throw OutOfDateKHRError( message ); 6212 case Result::eErrorIncompatibleDisplayKHR: throw IncompatibleDisplayKHRError( message ); 6213 case Result::eErrorValidationFailedEXT: throw ValidationFailedEXTError( message ); 6214 case Result::eErrorInvalidShaderNV: throw InvalidShaderNVError( message ); 6215 case Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT: 6216 throw InvalidDrmFormatModifierPlaneLayoutEXTError( message ); 6217 case Result::eErrorNotPermittedEXT: throw NotPermittedEXTError( message ); 6218 # if defined( VK_USE_PLATFORM_WIN32_KHR ) 6219 case Result::eErrorFullScreenExclusiveModeLostEXT: throw FullScreenExclusiveModeLostEXTError( message ); 6220 # endif /*VK_USE_PLATFORM_WIN32_KHR*/ 6221 default: throw SystemError( make_error_code( result ) ); 6222 } 6223 } 6224 } // namespace 6225 #endif 6226 6227 template <typename T> ignore(T const &)6228 void ignore( T const & ) VULKAN_HPP_NOEXCEPT 6229 {} 6230 6231 template <typename T> 6232 struct ResultValue 6233 { 6234 #ifdef VULKAN_HPP_HAS_NOEXCEPT ResultValueVULKAN_HPP_NAMESPACE::ResultValue6235 ResultValue( Result r, T & v ) VULKAN_HPP_NOEXCEPT( VULKAN_HPP_NOEXCEPT( T( v ) ) ) 6236 #else 6237 ResultValue( Result r, T & v ) 6238 #endif 6239 : result( r ), value( v ) 6240 {} 6241 6242 #ifdef VULKAN_HPP_HAS_NOEXCEPT ResultValueVULKAN_HPP_NAMESPACE::ResultValue6243 ResultValue( Result r, T && v ) VULKAN_HPP_NOEXCEPT( VULKAN_HPP_NOEXCEPT( T( std::move( v ) ) ) ) 6244 #else 6245 ResultValue( Result r, T && v ) 6246 #endif 6247 : result( r ), value( std::move( v ) ) 6248 {} 6249 6250 Result result; 6251 T value; 6252 operator std::tuple<Result&,T&>VULKAN_HPP_NAMESPACE::ResultValue6253 operator std::tuple<Result &, T &>() VULKAN_HPP_NOEXCEPT 6254 { 6255 return std::tuple<Result &, T &>( result, value ); 6256 } 6257 6258 #if !defined( VULKAN_HPP_DISABLE_IMPLICIT_RESULT_VALUE_CAST ) 6259 VULKAN_HPP_DEPRECATED( 6260 "Implicit-cast operators on vk::ResultValue are deprecated. Explicitly access the value as member of ResultValue." ) operator T const&VULKAN_HPP_NAMESPACE::ResultValue6261 operator T const &() const & VULKAN_HPP_NOEXCEPT 6262 { 6263 return value; 6264 } 6265 6266 VULKAN_HPP_DEPRECATED( 6267 "Implicit-cast operators on vk::ResultValue are deprecated. Explicitly access the value as member of ResultValue." ) operator T&VULKAN_HPP_NAMESPACE::ResultValue6268 operator T &() & VULKAN_HPP_NOEXCEPT 6269 { 6270 return value; 6271 } 6272 6273 VULKAN_HPP_DEPRECATED( 6274 "Implicit-cast operators on vk::ResultValue are deprecated. Explicitly access the value as member of ResultValue." ) operator T const&&VULKAN_HPP_NAMESPACE::ResultValue6275 operator T const &&() const && VULKAN_HPP_NOEXCEPT 6276 { 6277 return std::move( value ); 6278 } 6279 6280 VULKAN_HPP_DEPRECATED( 6281 "Implicit-cast operators on vk::ResultValue are deprecated. Explicitly access the value as member of ResultValue." ) operator T&&VULKAN_HPP_NAMESPACE::ResultValue6282 operator T &&() && VULKAN_HPP_NOEXCEPT 6283 { 6284 return std::move( value ); 6285 } 6286 #endif 6287 }; 6288 6289 #if !defined( VULKAN_HPP_NO_SMART_HANDLE ) 6290 template <typename Type, typename Dispatch> 6291 struct ResultValue<UniqueHandle<Type, Dispatch>> 6292 { 6293 # ifdef VULKAN_HPP_HAS_NOEXCEPT ResultValueVULKAN_HPP_NAMESPACE::ResultValue6294 ResultValue( Result r, UniqueHandle<Type, Dispatch> && v ) VULKAN_HPP_NOEXCEPT 6295 # else 6296 ResultValue( Result r, UniqueHandle<Type, Dispatch> && v ) 6297 # endif 6298 : result( r ) 6299 , value( std::move( v ) ) 6300 {} 6301 asTupleVULKAN_HPP_NAMESPACE::ResultValue6302 std::tuple<Result, UniqueHandle<Type, Dispatch>> asTuple() 6303 { 6304 return std::make_tuple( result, std::move( value ) ); 6305 } 6306 6307 # if !defined( VULKAN_HPP_DISABLE_IMPLICIT_RESULT_VALUE_CAST ) 6308 VULKAN_HPP_DEPRECATED( 6309 "Implicit-cast operators on vk::ResultValue are deprecated. Explicitly access the value as member of ResultValue." ) operator UniqueHandle<Type,Dispatch>&VULKAN_HPP_NAMESPACE::ResultValue6310 operator UniqueHandle<Type, Dispatch> &() & VULKAN_HPP_NOEXCEPT 6311 { 6312 return value; 6313 } 6314 6315 VULKAN_HPP_DEPRECATED( 6316 "Implicit-cast operators on vk::ResultValue are deprecated. Explicitly access the value as member of ResultValue." ) operator UniqueHandle<Type,Dispatch>VULKAN_HPP_NAMESPACE::ResultValue6317 operator UniqueHandle<Type, Dispatch>() VULKAN_HPP_NOEXCEPT 6318 { 6319 return std::move( value ); 6320 } 6321 # endif 6322 6323 Result result; 6324 UniqueHandle<Type, Dispatch> value; 6325 }; 6326 6327 template <typename Type, typename Dispatch> 6328 struct ResultValue<std::vector<UniqueHandle<Type, Dispatch>>> 6329 { 6330 # ifdef VULKAN_HPP_HAS_NOEXCEPT ResultValueVULKAN_HPP_NAMESPACE::ResultValue6331 ResultValue( Result r, std::vector<UniqueHandle<Type, Dispatch>> && v ) VULKAN_HPP_NOEXCEPT 6332 # else 6333 ResultValue( Result r, std::vector<UniqueHandle<Type, Dispatch>> && v ) 6334 # endif 6335 : result( r ) 6336 , value( std::move( v ) ) 6337 {} 6338 asTupleVULKAN_HPP_NAMESPACE::ResultValue6339 std::tuple<Result, std::vector<UniqueHandle<Type, Dispatch>>> asTuple() 6340 { 6341 return std::make_tuple( result, std::move( value ) ); 6342 } 6343 6344 Result result; 6345 std::vector<UniqueHandle<Type, Dispatch>> value; 6346 6347 # if !defined( VULKAN_HPP_DISABLE_IMPLICIT_RESULT_VALUE_CAST ) 6348 VULKAN_HPP_DEPRECATED( 6349 "Implicit-cast operators on vk::ResultValue are deprecated. Explicitly access the value as member of ResultValue." ) operator std::tuple<Result&,std::vector<UniqueHandle<Type,Dispatch>>&>VULKAN_HPP_NAMESPACE::ResultValue6350 operator std::tuple<Result &, std::vector<UniqueHandle<Type, Dispatch>> &>() VULKAN_HPP_NOEXCEPT 6351 { 6352 return std::tuple<Result &, std::vector<UniqueHandle<Type, Dispatch>> &>( result, value ); 6353 } 6354 # endif 6355 }; 6356 #endif 6357 6358 template <typename T> 6359 struct ResultValueType 6360 { 6361 #ifdef VULKAN_HPP_NO_EXCEPTIONS 6362 typedef ResultValue<T> type; 6363 #else 6364 typedef T type; 6365 #endif 6366 }; 6367 6368 template <> 6369 struct ResultValueType<void> 6370 { 6371 #ifdef VULKAN_HPP_NO_EXCEPTIONS 6372 typedef Result type; 6373 #else 6374 typedef void type; 6375 #endif 6376 }; 6377 createResultValue(Result result,char const * message)6378 VULKAN_HPP_INLINE ResultValueType<void>::type createResultValue( Result result, char const * message ) 6379 { 6380 #ifdef VULKAN_HPP_NO_EXCEPTIONS 6381 ignore( message ); 6382 VULKAN_HPP_ASSERT_ON_RESULT( result == Result::eSuccess ); 6383 return result; 6384 #else 6385 if ( result != Result::eSuccess ) 6386 { 6387 throwResultException( result, message ); 6388 } 6389 #endif 6390 } 6391 6392 template <typename T> createResultValue(Result result,T & data,char const * message)6393 VULKAN_HPP_INLINE typename ResultValueType<T>::type createResultValue( Result result, T & data, char const * message ) 6394 { 6395 #ifdef VULKAN_HPP_NO_EXCEPTIONS 6396 ignore( message ); 6397 VULKAN_HPP_ASSERT_ON_RESULT( result == Result::eSuccess ); 6398 return ResultValue<T>( result, std::move( data ) ); 6399 #else 6400 if ( result != Result::eSuccess ) 6401 { 6402 throwResultException( result, message ); 6403 } 6404 return std::move( data ); 6405 #endif 6406 } 6407 createResultValue(Result result,char const * message,std::initializer_list<Result> successCodes)6408 VULKAN_HPP_INLINE Result createResultValue( Result result, 6409 char const * message, 6410 std::initializer_list<Result> successCodes ) 6411 { 6412 #ifdef VULKAN_HPP_NO_EXCEPTIONS 6413 ignore( message ); 6414 ignore( successCodes ); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty 6415 VULKAN_HPP_ASSERT_ON_RESULT( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() ); 6416 #else 6417 if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() ) 6418 { 6419 throwResultException( result, message ); 6420 } 6421 #endif 6422 return result; 6423 } 6424 6425 template <typename T> 6426 VULKAN_HPP_INLINE ResultValue<T> createResultValue(Result result,T & data,char const * message,std::initializer_list<Result> successCodes)6427 createResultValue( Result result, T & data, char const * message, std::initializer_list<Result> successCodes ) 6428 { 6429 #ifdef VULKAN_HPP_NO_EXCEPTIONS 6430 ignore( message ); 6431 ignore( successCodes ); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty 6432 VULKAN_HPP_ASSERT_ON_RESULT( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() ); 6433 #else 6434 if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() ) 6435 { 6436 throwResultException( result, message ); 6437 } 6438 #endif 6439 return ResultValue<T>( result, std::move( data ) ); 6440 } 6441 6442 #ifndef VULKAN_HPP_NO_SMART_HANDLE 6443 template <typename T, typename D> createResultValue(Result result,T & data,char const * message,typename UniqueHandleTraits<T,D>::deleter const & deleter)6444 VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<T, D>>::type createResultValue( 6445 Result result, T & data, char const * message, typename UniqueHandleTraits<T, D>::deleter const & deleter ) 6446 { 6447 # ifdef VULKAN_HPP_NO_EXCEPTIONS 6448 ignore( message ); 6449 VULKAN_HPP_ASSERT_ON_RESULT( result == Result::eSuccess ); 6450 return ResultValue<UniqueHandle<T, D>>( result, UniqueHandle<T, D>( data, deleter ) ); 6451 # else 6452 if ( result != Result::eSuccess ) 6453 { 6454 throwResultException( result, message ); 6455 } 6456 return UniqueHandle<T, D>( data, deleter ); 6457 # endif 6458 } 6459 6460 template <typename T, typename D> 6461 VULKAN_HPP_INLINE ResultValue<UniqueHandle<T, D>> createResultValue(Result result,T & data,char const * message,std::initializer_list<Result> successCodes,typename UniqueHandleTraits<T,D>::deleter const & deleter)6462 createResultValue( Result result, 6463 T & data, 6464 char const * message, 6465 std::initializer_list<Result> successCodes, 6466 typename UniqueHandleTraits<T, D>::deleter const & deleter ) 6467 { 6468 # ifdef VULKAN_HPP_NO_EXCEPTIONS 6469 ignore( message ); 6470 ignore( successCodes ); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty 6471 VULKAN_HPP_ASSERT_ON_RESULT( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() ); 6472 # else 6473 if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() ) 6474 { 6475 throwResultException( result, message ); 6476 } 6477 # endif 6478 return ResultValue<UniqueHandle<T, D>>( result, UniqueHandle<T, D>( data, deleter ) ); 6479 } 6480 6481 template <typename T, typename D> 6482 VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<T, D>>>::type createResultValue(Result result,std::vector<UniqueHandle<T,D>> && data,char const * message)6483 createResultValue( Result result, std::vector<UniqueHandle<T, D>> && data, char const * message ) 6484 { 6485 # ifdef VULKAN_HPP_NO_EXCEPTIONS 6486 ignore( message ); 6487 VULKAN_HPP_ASSERT_ON_RESULT( result == Result::eSuccess ); 6488 return ResultValue<std::vector<UniqueHandle<T, D>>>( result, std::move( data ) ); 6489 # else 6490 if ( result != Result::eSuccess ) 6491 { 6492 throwResultException( result, message ); 6493 } 6494 return std::move( data ); 6495 # endif 6496 } 6497 6498 template <typename T, typename D> 6499 VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<T, D>>> createResultValue(Result result,std::vector<UniqueHandle<T,D>> && data,char const * message,std::initializer_list<Result> successCodes)6500 createResultValue( Result result, 6501 std::vector<UniqueHandle<T, D>> && data, 6502 char const * message, 6503 std::initializer_list<Result> successCodes ) 6504 { 6505 # ifdef VULKAN_HPP_NO_EXCEPTIONS 6506 ignore( message ); 6507 ignore( successCodes ); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty 6508 VULKAN_HPP_ASSERT_ON_RESULT( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() ); 6509 # else 6510 if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() ) 6511 { 6512 throwResultException( result, message ); 6513 } 6514 # endif 6515 return ResultValue<std::vector<UniqueHandle<T, D>>>( result, std::move( data ) ); 6516 } 6517 #endif 6518 } // namespace VULKAN_HPP_NAMESPACE 6519 6520 // clang-format off 6521 #include <vulkan/vulkan_handles.hpp> 6522 #include <vulkan/vulkan_structs.hpp> 6523 #include <vulkan/vulkan_funcs.hpp> 6524 // clang-format on 6525 6526 namespace VULKAN_HPP_NAMESPACE 6527 { 6528 //======================= 6529 //=== STRUCTS EXTENDS === 6530 //======================= 6531 6532 //=== VK_VERSION_1_1 === 6533 template <> 6534 struct StructExtends<PhysicalDeviceSubgroupProperties, PhysicalDeviceProperties2> 6535 { 6536 enum 6537 { 6538 value = true 6539 }; 6540 }; 6541 template <> 6542 struct StructExtends<PhysicalDevice16BitStorageFeatures, PhysicalDeviceFeatures2> 6543 { 6544 enum 6545 { 6546 value = true 6547 }; 6548 }; 6549 template <> 6550 struct StructExtends<PhysicalDevice16BitStorageFeatures, DeviceCreateInfo> 6551 { 6552 enum 6553 { 6554 value = true 6555 }; 6556 }; 6557 template <> 6558 struct StructExtends<MemoryDedicatedRequirements, MemoryRequirements2> 6559 { 6560 enum 6561 { 6562 value = true 6563 }; 6564 }; 6565 template <> 6566 struct StructExtends<MemoryDedicatedAllocateInfo, MemoryAllocateInfo> 6567 { 6568 enum 6569 { 6570 value = true 6571 }; 6572 }; 6573 template <> 6574 struct StructExtends<MemoryAllocateFlagsInfo, MemoryAllocateInfo> 6575 { 6576 enum 6577 { 6578 value = true 6579 }; 6580 }; 6581 template <> 6582 struct StructExtends<DeviceGroupRenderPassBeginInfo, RenderPassBeginInfo> 6583 { 6584 enum 6585 { 6586 value = true 6587 }; 6588 }; 6589 template <> 6590 struct StructExtends<DeviceGroupRenderPassBeginInfo, RenderingInfoKHR> 6591 { 6592 enum 6593 { 6594 value = true 6595 }; 6596 }; 6597 template <> 6598 struct StructExtends<DeviceGroupCommandBufferBeginInfo, CommandBufferBeginInfo> 6599 { 6600 enum 6601 { 6602 value = true 6603 }; 6604 }; 6605 template <> 6606 struct StructExtends<DeviceGroupSubmitInfo, SubmitInfo> 6607 { 6608 enum 6609 { 6610 value = true 6611 }; 6612 }; 6613 template <> 6614 struct StructExtends<DeviceGroupBindSparseInfo, BindSparseInfo> 6615 { 6616 enum 6617 { 6618 value = true 6619 }; 6620 }; 6621 template <> 6622 struct StructExtends<BindBufferMemoryDeviceGroupInfo, BindBufferMemoryInfo> 6623 { 6624 enum 6625 { 6626 value = true 6627 }; 6628 }; 6629 template <> 6630 struct StructExtends<BindImageMemoryDeviceGroupInfo, BindImageMemoryInfo> 6631 { 6632 enum 6633 { 6634 value = true 6635 }; 6636 }; 6637 template <> 6638 struct StructExtends<DeviceGroupDeviceCreateInfo, DeviceCreateInfo> 6639 { 6640 enum 6641 { 6642 value = true 6643 }; 6644 }; 6645 template <> 6646 struct StructExtends<PhysicalDeviceFeatures2, DeviceCreateInfo> 6647 { 6648 enum 6649 { 6650 value = true 6651 }; 6652 }; 6653 template <> 6654 struct StructExtends<PhysicalDevicePointClippingProperties, PhysicalDeviceProperties2> 6655 { 6656 enum 6657 { 6658 value = true 6659 }; 6660 }; 6661 template <> 6662 struct StructExtends<RenderPassInputAttachmentAspectCreateInfo, RenderPassCreateInfo> 6663 { 6664 enum 6665 { 6666 value = true 6667 }; 6668 }; 6669 template <> 6670 struct StructExtends<ImageViewUsageCreateInfo, ImageViewCreateInfo> 6671 { 6672 enum 6673 { 6674 value = true 6675 }; 6676 }; 6677 template <> 6678 struct StructExtends<PipelineTessellationDomainOriginStateCreateInfo, PipelineTessellationStateCreateInfo> 6679 { 6680 enum 6681 { 6682 value = true 6683 }; 6684 }; 6685 template <> 6686 struct StructExtends<RenderPassMultiviewCreateInfo, RenderPassCreateInfo> 6687 { 6688 enum 6689 { 6690 value = true 6691 }; 6692 }; 6693 template <> 6694 struct StructExtends<PhysicalDeviceMultiviewFeatures, PhysicalDeviceFeatures2> 6695 { 6696 enum 6697 { 6698 value = true 6699 }; 6700 }; 6701 template <> 6702 struct StructExtends<PhysicalDeviceMultiviewFeatures, DeviceCreateInfo> 6703 { 6704 enum 6705 { 6706 value = true 6707 }; 6708 }; 6709 template <> 6710 struct StructExtends<PhysicalDeviceMultiviewProperties, PhysicalDeviceProperties2> 6711 { 6712 enum 6713 { 6714 value = true 6715 }; 6716 }; 6717 template <> 6718 struct StructExtends<PhysicalDeviceVariablePointersFeatures, PhysicalDeviceFeatures2> 6719 { 6720 enum 6721 { 6722 value = true 6723 }; 6724 }; 6725 template <> 6726 struct StructExtends<PhysicalDeviceVariablePointersFeatures, DeviceCreateInfo> 6727 { 6728 enum 6729 { 6730 value = true 6731 }; 6732 }; 6733 template <> 6734 struct StructExtends<PhysicalDeviceProtectedMemoryFeatures, PhysicalDeviceFeatures2> 6735 { 6736 enum 6737 { 6738 value = true 6739 }; 6740 }; 6741 template <> 6742 struct StructExtends<PhysicalDeviceProtectedMemoryFeatures, DeviceCreateInfo> 6743 { 6744 enum 6745 { 6746 value = true 6747 }; 6748 }; 6749 template <> 6750 struct StructExtends<PhysicalDeviceProtectedMemoryProperties, PhysicalDeviceProperties2> 6751 { 6752 enum 6753 { 6754 value = true 6755 }; 6756 }; 6757 template <> 6758 struct StructExtends<ProtectedSubmitInfo, SubmitInfo> 6759 { 6760 enum 6761 { 6762 value = true 6763 }; 6764 }; 6765 template <> 6766 struct StructExtends<SamplerYcbcrConversionInfo, SamplerCreateInfo> 6767 { 6768 enum 6769 { 6770 value = true 6771 }; 6772 }; 6773 template <> 6774 struct StructExtends<SamplerYcbcrConversionInfo, ImageViewCreateInfo> 6775 { 6776 enum 6777 { 6778 value = true 6779 }; 6780 }; 6781 template <> 6782 struct StructExtends<BindImagePlaneMemoryInfo, BindImageMemoryInfo> 6783 { 6784 enum 6785 { 6786 value = true 6787 }; 6788 }; 6789 template <> 6790 struct StructExtends<ImagePlaneMemoryRequirementsInfo, ImageMemoryRequirementsInfo2> 6791 { 6792 enum 6793 { 6794 value = true 6795 }; 6796 }; 6797 template <> 6798 struct StructExtends<PhysicalDeviceSamplerYcbcrConversionFeatures, PhysicalDeviceFeatures2> 6799 { 6800 enum 6801 { 6802 value = true 6803 }; 6804 }; 6805 template <> 6806 struct StructExtends<PhysicalDeviceSamplerYcbcrConversionFeatures, DeviceCreateInfo> 6807 { 6808 enum 6809 { 6810 value = true 6811 }; 6812 }; 6813 template <> 6814 struct StructExtends<SamplerYcbcrConversionImageFormatProperties, ImageFormatProperties2> 6815 { 6816 enum 6817 { 6818 value = true 6819 }; 6820 }; 6821 template <> 6822 struct StructExtends<PhysicalDeviceExternalImageFormatInfo, PhysicalDeviceImageFormatInfo2> 6823 { 6824 enum 6825 { 6826 value = true 6827 }; 6828 }; 6829 template <> 6830 struct StructExtends<ExternalImageFormatProperties, ImageFormatProperties2> 6831 { 6832 enum 6833 { 6834 value = true 6835 }; 6836 }; 6837 template <> 6838 struct StructExtends<PhysicalDeviceIDProperties, PhysicalDeviceProperties2> 6839 { 6840 enum 6841 { 6842 value = true 6843 }; 6844 }; 6845 template <> 6846 struct StructExtends<ExternalMemoryImageCreateInfo, ImageCreateInfo> 6847 { 6848 enum 6849 { 6850 value = true 6851 }; 6852 }; 6853 template <> 6854 struct StructExtends<ExternalMemoryBufferCreateInfo, BufferCreateInfo> 6855 { 6856 enum 6857 { 6858 value = true 6859 }; 6860 }; 6861 template <> 6862 struct StructExtends<ExportMemoryAllocateInfo, MemoryAllocateInfo> 6863 { 6864 enum 6865 { 6866 value = true 6867 }; 6868 }; 6869 template <> 6870 struct StructExtends<ExportFenceCreateInfo, FenceCreateInfo> 6871 { 6872 enum 6873 { 6874 value = true 6875 }; 6876 }; 6877 template <> 6878 struct StructExtends<ExportSemaphoreCreateInfo, SemaphoreCreateInfo> 6879 { 6880 enum 6881 { 6882 value = true 6883 }; 6884 }; 6885 template <> 6886 struct StructExtends<PhysicalDeviceMaintenance3Properties, PhysicalDeviceProperties2> 6887 { 6888 enum 6889 { 6890 value = true 6891 }; 6892 }; 6893 template <> 6894 struct StructExtends<PhysicalDeviceShaderDrawParametersFeatures, PhysicalDeviceFeatures2> 6895 { 6896 enum 6897 { 6898 value = true 6899 }; 6900 }; 6901 template <> 6902 struct StructExtends<PhysicalDeviceShaderDrawParametersFeatures, DeviceCreateInfo> 6903 { 6904 enum 6905 { 6906 value = true 6907 }; 6908 }; 6909 6910 //=== VK_VERSION_1_2 === 6911 template <> 6912 struct StructExtends<PhysicalDeviceVulkan11Features, PhysicalDeviceFeatures2> 6913 { 6914 enum 6915 { 6916 value = true 6917 }; 6918 }; 6919 template <> 6920 struct StructExtends<PhysicalDeviceVulkan11Features, DeviceCreateInfo> 6921 { 6922 enum 6923 { 6924 value = true 6925 }; 6926 }; 6927 template <> 6928 struct StructExtends<PhysicalDeviceVulkan11Properties, PhysicalDeviceProperties2> 6929 { 6930 enum 6931 { 6932 value = true 6933 }; 6934 }; 6935 template <> 6936 struct StructExtends<PhysicalDeviceVulkan12Features, PhysicalDeviceFeatures2> 6937 { 6938 enum 6939 { 6940 value = true 6941 }; 6942 }; 6943 template <> 6944 struct StructExtends<PhysicalDeviceVulkan12Features, DeviceCreateInfo> 6945 { 6946 enum 6947 { 6948 value = true 6949 }; 6950 }; 6951 template <> 6952 struct StructExtends<PhysicalDeviceVulkan12Properties, PhysicalDeviceProperties2> 6953 { 6954 enum 6955 { 6956 value = true 6957 }; 6958 }; 6959 template <> 6960 struct StructExtends<ImageFormatListCreateInfo, ImageCreateInfo> 6961 { 6962 enum 6963 { 6964 value = true 6965 }; 6966 }; 6967 template <> 6968 struct StructExtends<ImageFormatListCreateInfo, SwapchainCreateInfoKHR> 6969 { 6970 enum 6971 { 6972 value = true 6973 }; 6974 }; 6975 template <> 6976 struct StructExtends<ImageFormatListCreateInfo, PhysicalDeviceImageFormatInfo2> 6977 { 6978 enum 6979 { 6980 value = true 6981 }; 6982 }; 6983 template <> 6984 struct StructExtends<PhysicalDevice8BitStorageFeatures, PhysicalDeviceFeatures2> 6985 { 6986 enum 6987 { 6988 value = true 6989 }; 6990 }; 6991 template <> 6992 struct StructExtends<PhysicalDevice8BitStorageFeatures, DeviceCreateInfo> 6993 { 6994 enum 6995 { 6996 value = true 6997 }; 6998 }; 6999 template <> 7000 struct StructExtends<PhysicalDeviceDriverProperties, PhysicalDeviceProperties2> 7001 { 7002 enum 7003 { 7004 value = true 7005 }; 7006 }; 7007 template <> 7008 struct StructExtends<PhysicalDeviceShaderAtomicInt64Features, PhysicalDeviceFeatures2> 7009 { 7010 enum 7011 { 7012 value = true 7013 }; 7014 }; 7015 template <> 7016 struct StructExtends<PhysicalDeviceShaderAtomicInt64Features, DeviceCreateInfo> 7017 { 7018 enum 7019 { 7020 value = true 7021 }; 7022 }; 7023 template <> 7024 struct StructExtends<PhysicalDeviceShaderFloat16Int8Features, PhysicalDeviceFeatures2> 7025 { 7026 enum 7027 { 7028 value = true 7029 }; 7030 }; 7031 template <> 7032 struct StructExtends<PhysicalDeviceShaderFloat16Int8Features, DeviceCreateInfo> 7033 { 7034 enum 7035 { 7036 value = true 7037 }; 7038 }; 7039 template <> 7040 struct StructExtends<PhysicalDeviceFloatControlsProperties, PhysicalDeviceProperties2> 7041 { 7042 enum 7043 { 7044 value = true 7045 }; 7046 }; 7047 template <> 7048 struct StructExtends<DescriptorSetLayoutBindingFlagsCreateInfo, DescriptorSetLayoutCreateInfo> 7049 { 7050 enum 7051 { 7052 value = true 7053 }; 7054 }; 7055 template <> 7056 struct StructExtends<PhysicalDeviceDescriptorIndexingFeatures, PhysicalDeviceFeatures2> 7057 { 7058 enum 7059 { 7060 value = true 7061 }; 7062 }; 7063 template <> 7064 struct StructExtends<PhysicalDeviceDescriptorIndexingFeatures, DeviceCreateInfo> 7065 { 7066 enum 7067 { 7068 value = true 7069 }; 7070 }; 7071 template <> 7072 struct StructExtends<PhysicalDeviceDescriptorIndexingProperties, PhysicalDeviceProperties2> 7073 { 7074 enum 7075 { 7076 value = true 7077 }; 7078 }; 7079 template <> 7080 struct StructExtends<DescriptorSetVariableDescriptorCountAllocateInfo, DescriptorSetAllocateInfo> 7081 { 7082 enum 7083 { 7084 value = true 7085 }; 7086 }; 7087 template <> 7088 struct StructExtends<DescriptorSetVariableDescriptorCountLayoutSupport, DescriptorSetLayoutSupport> 7089 { 7090 enum 7091 { 7092 value = true 7093 }; 7094 }; 7095 template <> 7096 struct StructExtends<SubpassDescriptionDepthStencilResolve, SubpassDescription2> 7097 { 7098 enum 7099 { 7100 value = true 7101 }; 7102 }; 7103 template <> 7104 struct StructExtends<PhysicalDeviceDepthStencilResolveProperties, PhysicalDeviceProperties2> 7105 { 7106 enum 7107 { 7108 value = true 7109 }; 7110 }; 7111 template <> 7112 struct StructExtends<PhysicalDeviceScalarBlockLayoutFeatures, PhysicalDeviceFeatures2> 7113 { 7114 enum 7115 { 7116 value = true 7117 }; 7118 }; 7119 template <> 7120 struct StructExtends<PhysicalDeviceScalarBlockLayoutFeatures, DeviceCreateInfo> 7121 { 7122 enum 7123 { 7124 value = true 7125 }; 7126 }; 7127 template <> 7128 struct StructExtends<ImageStencilUsageCreateInfo, ImageCreateInfo> 7129 { 7130 enum 7131 { 7132 value = true 7133 }; 7134 }; 7135 template <> 7136 struct StructExtends<ImageStencilUsageCreateInfo, PhysicalDeviceImageFormatInfo2> 7137 { 7138 enum 7139 { 7140 value = true 7141 }; 7142 }; 7143 template <> 7144 struct StructExtends<SamplerReductionModeCreateInfo, SamplerCreateInfo> 7145 { 7146 enum 7147 { 7148 value = true 7149 }; 7150 }; 7151 template <> 7152 struct StructExtends<PhysicalDeviceSamplerFilterMinmaxProperties, PhysicalDeviceProperties2> 7153 { 7154 enum 7155 { 7156 value = true 7157 }; 7158 }; 7159 template <> 7160 struct StructExtends<PhysicalDeviceVulkanMemoryModelFeatures, PhysicalDeviceFeatures2> 7161 { 7162 enum 7163 { 7164 value = true 7165 }; 7166 }; 7167 template <> 7168 struct StructExtends<PhysicalDeviceVulkanMemoryModelFeatures, DeviceCreateInfo> 7169 { 7170 enum 7171 { 7172 value = true 7173 }; 7174 }; 7175 template <> 7176 struct StructExtends<PhysicalDeviceImagelessFramebufferFeatures, PhysicalDeviceFeatures2> 7177 { 7178 enum 7179 { 7180 value = true 7181 }; 7182 }; 7183 template <> 7184 struct StructExtends<PhysicalDeviceImagelessFramebufferFeatures, DeviceCreateInfo> 7185 { 7186 enum 7187 { 7188 value = true 7189 }; 7190 }; 7191 template <> 7192 struct StructExtends<FramebufferAttachmentsCreateInfo, FramebufferCreateInfo> 7193 { 7194 enum 7195 { 7196 value = true 7197 }; 7198 }; 7199 template <> 7200 struct StructExtends<RenderPassAttachmentBeginInfo, RenderPassBeginInfo> 7201 { 7202 enum 7203 { 7204 value = true 7205 }; 7206 }; 7207 template <> 7208 struct StructExtends<PhysicalDeviceUniformBufferStandardLayoutFeatures, PhysicalDeviceFeatures2> 7209 { 7210 enum 7211 { 7212 value = true 7213 }; 7214 }; 7215 template <> 7216 struct StructExtends<PhysicalDeviceUniformBufferStandardLayoutFeatures, DeviceCreateInfo> 7217 { 7218 enum 7219 { 7220 value = true 7221 }; 7222 }; 7223 template <> 7224 struct StructExtends<PhysicalDeviceShaderSubgroupExtendedTypesFeatures, PhysicalDeviceFeatures2> 7225 { 7226 enum 7227 { 7228 value = true 7229 }; 7230 }; 7231 template <> 7232 struct StructExtends<PhysicalDeviceShaderSubgroupExtendedTypesFeatures, DeviceCreateInfo> 7233 { 7234 enum 7235 { 7236 value = true 7237 }; 7238 }; 7239 template <> 7240 struct StructExtends<PhysicalDeviceSeparateDepthStencilLayoutsFeatures, PhysicalDeviceFeatures2> 7241 { 7242 enum 7243 { 7244 value = true 7245 }; 7246 }; 7247 template <> 7248 struct StructExtends<PhysicalDeviceSeparateDepthStencilLayoutsFeatures, DeviceCreateInfo> 7249 { 7250 enum 7251 { 7252 value = true 7253 }; 7254 }; 7255 template <> 7256 struct StructExtends<AttachmentReferenceStencilLayout, AttachmentReference2> 7257 { 7258 enum 7259 { 7260 value = true 7261 }; 7262 }; 7263 template <> 7264 struct StructExtends<AttachmentDescriptionStencilLayout, AttachmentDescription2> 7265 { 7266 enum 7267 { 7268 value = true 7269 }; 7270 }; 7271 template <> 7272 struct StructExtends<PhysicalDeviceHostQueryResetFeatures, PhysicalDeviceFeatures2> 7273 { 7274 enum 7275 { 7276 value = true 7277 }; 7278 }; 7279 template <> 7280 struct StructExtends<PhysicalDeviceHostQueryResetFeatures, DeviceCreateInfo> 7281 { 7282 enum 7283 { 7284 value = true 7285 }; 7286 }; 7287 template <> 7288 struct StructExtends<PhysicalDeviceTimelineSemaphoreFeatures, PhysicalDeviceFeatures2> 7289 { 7290 enum 7291 { 7292 value = true 7293 }; 7294 }; 7295 template <> 7296 struct StructExtends<PhysicalDeviceTimelineSemaphoreFeatures, DeviceCreateInfo> 7297 { 7298 enum 7299 { 7300 value = true 7301 }; 7302 }; 7303 template <> 7304 struct StructExtends<PhysicalDeviceTimelineSemaphoreProperties, PhysicalDeviceProperties2> 7305 { 7306 enum 7307 { 7308 value = true 7309 }; 7310 }; 7311 template <> 7312 struct StructExtends<SemaphoreTypeCreateInfo, SemaphoreCreateInfo> 7313 { 7314 enum 7315 { 7316 value = true 7317 }; 7318 }; 7319 template <> 7320 struct StructExtends<SemaphoreTypeCreateInfo, PhysicalDeviceExternalSemaphoreInfo> 7321 { 7322 enum 7323 { 7324 value = true 7325 }; 7326 }; 7327 template <> 7328 struct StructExtends<TimelineSemaphoreSubmitInfo, SubmitInfo> 7329 { 7330 enum 7331 { 7332 value = true 7333 }; 7334 }; 7335 template <> 7336 struct StructExtends<TimelineSemaphoreSubmitInfo, BindSparseInfo> 7337 { 7338 enum 7339 { 7340 value = true 7341 }; 7342 }; 7343 template <> 7344 struct StructExtends<PhysicalDeviceBufferDeviceAddressFeatures, PhysicalDeviceFeatures2> 7345 { 7346 enum 7347 { 7348 value = true 7349 }; 7350 }; 7351 template <> 7352 struct StructExtends<PhysicalDeviceBufferDeviceAddressFeatures, DeviceCreateInfo> 7353 { 7354 enum 7355 { 7356 value = true 7357 }; 7358 }; 7359 template <> 7360 struct StructExtends<BufferOpaqueCaptureAddressCreateInfo, BufferCreateInfo> 7361 { 7362 enum 7363 { 7364 value = true 7365 }; 7366 }; 7367 template <> 7368 struct StructExtends<MemoryOpaqueCaptureAddressAllocateInfo, MemoryAllocateInfo> 7369 { 7370 enum 7371 { 7372 value = true 7373 }; 7374 }; 7375 7376 //=== VK_KHR_swapchain === 7377 template <> 7378 struct StructExtends<ImageSwapchainCreateInfoKHR, ImageCreateInfo> 7379 { 7380 enum 7381 { 7382 value = true 7383 }; 7384 }; 7385 template <> 7386 struct StructExtends<BindImageMemorySwapchainInfoKHR, BindImageMemoryInfo> 7387 { 7388 enum 7389 { 7390 value = true 7391 }; 7392 }; 7393 template <> 7394 struct StructExtends<DeviceGroupPresentInfoKHR, PresentInfoKHR> 7395 { 7396 enum 7397 { 7398 value = true 7399 }; 7400 }; 7401 template <> 7402 struct StructExtends<DeviceGroupSwapchainCreateInfoKHR, SwapchainCreateInfoKHR> 7403 { 7404 enum 7405 { 7406 value = true 7407 }; 7408 }; 7409 7410 //=== VK_KHR_display_swapchain === 7411 template <> 7412 struct StructExtends<DisplayPresentInfoKHR, PresentInfoKHR> 7413 { 7414 enum 7415 { 7416 value = true 7417 }; 7418 }; 7419 7420 //=== VK_EXT_debug_report === 7421 template <> 7422 struct StructExtends<DebugReportCallbackCreateInfoEXT, InstanceCreateInfo> 7423 { 7424 enum 7425 { 7426 value = true 7427 }; 7428 }; 7429 7430 //=== VK_AMD_rasterization_order === 7431 template <> 7432 struct StructExtends<PipelineRasterizationStateRasterizationOrderAMD, PipelineRasterizationStateCreateInfo> 7433 { 7434 enum 7435 { 7436 value = true 7437 }; 7438 }; 7439 7440 #if defined( VK_ENABLE_BETA_EXTENSIONS ) 7441 //=== VK_KHR_video_queue === 7442 template <> 7443 struct StructExtends<VideoQueueFamilyProperties2KHR, QueueFamilyProperties2> 7444 { 7445 enum 7446 { 7447 value = true 7448 }; 7449 }; 7450 template <> 7451 struct StructExtends<VideoProfileKHR, QueryPoolCreateInfo> 7452 { 7453 enum 7454 { 7455 value = true 7456 }; 7457 }; 7458 template <> 7459 struct StructExtends<VideoProfileKHR, FormatProperties2> 7460 { 7461 enum 7462 { 7463 value = true 7464 }; 7465 }; 7466 template <> 7467 struct StructExtends<VideoProfileKHR, ImageCreateInfo> 7468 { 7469 enum 7470 { 7471 value = true 7472 }; 7473 }; 7474 template <> 7475 struct StructExtends<VideoProfileKHR, ImageViewCreateInfo> 7476 { 7477 enum 7478 { 7479 value = true 7480 }; 7481 }; 7482 template <> 7483 struct StructExtends<VideoProfileKHR, BufferCreateInfo> 7484 { 7485 enum 7486 { 7487 value = true 7488 }; 7489 }; 7490 template <> 7491 struct StructExtends<VideoProfilesKHR, FormatProperties2> 7492 { 7493 enum 7494 { 7495 value = true 7496 }; 7497 }; 7498 template <> 7499 struct StructExtends<VideoProfilesKHR, ImageCreateInfo> 7500 { 7501 enum 7502 { 7503 value = true 7504 }; 7505 }; 7506 template <> 7507 struct StructExtends<VideoProfilesKHR, ImageViewCreateInfo> 7508 { 7509 enum 7510 { 7511 value = true 7512 }; 7513 }; 7514 template <> 7515 struct StructExtends<VideoProfilesKHR, BufferCreateInfo> 7516 { 7517 enum 7518 { 7519 value = true 7520 }; 7521 }; 7522 #endif /*VK_ENABLE_BETA_EXTENSIONS*/ 7523 7524 //=== VK_NV_dedicated_allocation === 7525 template <> 7526 struct StructExtends<DedicatedAllocationImageCreateInfoNV, ImageCreateInfo> 7527 { 7528 enum 7529 { 7530 value = true 7531 }; 7532 }; 7533 template <> 7534 struct StructExtends<DedicatedAllocationBufferCreateInfoNV, BufferCreateInfo> 7535 { 7536 enum 7537 { 7538 value = true 7539 }; 7540 }; 7541 template <> 7542 struct StructExtends<DedicatedAllocationMemoryAllocateInfoNV, MemoryAllocateInfo> 7543 { 7544 enum 7545 { 7546 value = true 7547 }; 7548 }; 7549 7550 //=== VK_EXT_transform_feedback === 7551 template <> 7552 struct StructExtends<PhysicalDeviceTransformFeedbackFeaturesEXT, PhysicalDeviceFeatures2> 7553 { 7554 enum 7555 { 7556 value = true 7557 }; 7558 }; 7559 template <> 7560 struct StructExtends<PhysicalDeviceTransformFeedbackFeaturesEXT, DeviceCreateInfo> 7561 { 7562 enum 7563 { 7564 value = true 7565 }; 7566 }; 7567 template <> 7568 struct StructExtends<PhysicalDeviceTransformFeedbackPropertiesEXT, PhysicalDeviceProperties2> 7569 { 7570 enum 7571 { 7572 value = true 7573 }; 7574 }; 7575 template <> 7576 struct StructExtends<PipelineRasterizationStateStreamCreateInfoEXT, PipelineRasterizationStateCreateInfo> 7577 { 7578 enum 7579 { 7580 value = true 7581 }; 7582 }; 7583 7584 #if defined( VK_ENABLE_BETA_EXTENSIONS ) 7585 //=== VK_EXT_video_encode_h264 === 7586 template <> 7587 struct StructExtends<VideoEncodeH264CapabilitiesEXT, VideoCapabilitiesKHR> 7588 { 7589 enum 7590 { 7591 value = true 7592 }; 7593 }; 7594 template <> 7595 struct StructExtends<VideoEncodeH264SessionCreateInfoEXT, VideoSessionCreateInfoKHR> 7596 { 7597 enum 7598 { 7599 value = true 7600 }; 7601 }; 7602 template <> 7603 struct StructExtends<VideoEncodeH264SessionParametersCreateInfoEXT, VideoSessionParametersCreateInfoKHR> 7604 { 7605 enum 7606 { 7607 value = true 7608 }; 7609 }; 7610 template <> 7611 struct StructExtends<VideoEncodeH264SessionParametersAddInfoEXT, VideoSessionParametersUpdateInfoKHR> 7612 { 7613 enum 7614 { 7615 value = true 7616 }; 7617 }; 7618 template <> 7619 struct StructExtends<VideoEncodeH264VclFrameInfoEXT, VideoEncodeInfoKHR> 7620 { 7621 enum 7622 { 7623 value = true 7624 }; 7625 }; 7626 template <> 7627 struct StructExtends<VideoEncodeH264EmitPictureParametersEXT, VideoEncodeInfoKHR> 7628 { 7629 enum 7630 { 7631 value = true 7632 }; 7633 }; 7634 template <> 7635 struct StructExtends<VideoEncodeH264ProfileEXT, VideoProfileKHR> 7636 { 7637 enum 7638 { 7639 value = true 7640 }; 7641 }; 7642 template <> 7643 struct StructExtends<VideoEncodeH264ProfileEXT, QueryPoolCreateInfo> 7644 { 7645 enum 7646 { 7647 value = true 7648 }; 7649 }; 7650 template <> 7651 struct StructExtends<VideoEncodeH264ProfileEXT, FormatProperties2> 7652 { 7653 enum 7654 { 7655 value = true 7656 }; 7657 }; 7658 template <> 7659 struct StructExtends<VideoEncodeH264ProfileEXT, ImageCreateInfo> 7660 { 7661 enum 7662 { 7663 value = true 7664 }; 7665 }; 7666 template <> 7667 struct StructExtends<VideoEncodeH264ProfileEXT, ImageViewCreateInfo> 7668 { 7669 enum 7670 { 7671 value = true 7672 }; 7673 }; 7674 template <> 7675 struct StructExtends<VideoEncodeH264ProfileEXT, BufferCreateInfo> 7676 { 7677 enum 7678 { 7679 value = true 7680 }; 7681 }; 7682 template <> 7683 struct StructExtends<VideoEncodeH264RateControlInfoEXT, VideoEncodeRateControlInfoKHR> 7684 { 7685 enum 7686 { 7687 value = true 7688 }; 7689 }; 7690 template <> 7691 struct StructExtends<VideoEncodeH264RateControlLayerInfoEXT, VideoEncodeRateControlLayerInfoKHR> 7692 { 7693 enum 7694 { 7695 value = true 7696 }; 7697 }; 7698 #endif /*VK_ENABLE_BETA_EXTENSIONS*/ 7699 7700 #if defined( VK_ENABLE_BETA_EXTENSIONS ) 7701 //=== VK_EXT_video_encode_h265 === 7702 template <> 7703 struct StructExtends<VideoEncodeH265CapabilitiesEXT, VideoCapabilitiesKHR> 7704 { 7705 enum 7706 { 7707 value = true 7708 }; 7709 }; 7710 template <> 7711 struct StructExtends<VideoEncodeH265SessionCreateInfoEXT, VideoSessionCreateInfoKHR> 7712 { 7713 enum 7714 { 7715 value = true 7716 }; 7717 }; 7718 template <> 7719 struct StructExtends<VideoEncodeH265SessionParametersCreateInfoEXT, VideoSessionParametersCreateInfoKHR> 7720 { 7721 enum 7722 { 7723 value = true 7724 }; 7725 }; 7726 template <> 7727 struct StructExtends<VideoEncodeH265SessionParametersAddInfoEXT, VideoSessionParametersUpdateInfoKHR> 7728 { 7729 enum 7730 { 7731 value = true 7732 }; 7733 }; 7734 template <> 7735 struct StructExtends<VideoEncodeH265VclFrameInfoEXT, VideoEncodeInfoKHR> 7736 { 7737 enum 7738 { 7739 value = true 7740 }; 7741 }; 7742 template <> 7743 struct StructExtends<VideoEncodeH265EmitPictureParametersEXT, VideoEncodeInfoKHR> 7744 { 7745 enum 7746 { 7747 value = true 7748 }; 7749 }; 7750 template <> 7751 struct StructExtends<VideoEncodeH265ProfileEXT, VideoProfileKHR> 7752 { 7753 enum 7754 { 7755 value = true 7756 }; 7757 }; 7758 template <> 7759 struct StructExtends<VideoEncodeH265ProfileEXT, QueryPoolCreateInfo> 7760 { 7761 enum 7762 { 7763 value = true 7764 }; 7765 }; 7766 template <> 7767 struct StructExtends<VideoEncodeH265ProfileEXT, FormatProperties2> 7768 { 7769 enum 7770 { 7771 value = true 7772 }; 7773 }; 7774 template <> 7775 struct StructExtends<VideoEncodeH265ProfileEXT, ImageCreateInfo> 7776 { 7777 enum 7778 { 7779 value = true 7780 }; 7781 }; 7782 template <> 7783 struct StructExtends<VideoEncodeH265ProfileEXT, ImageViewCreateInfo> 7784 { 7785 enum 7786 { 7787 value = true 7788 }; 7789 }; 7790 template <> 7791 struct StructExtends<VideoEncodeH265ProfileEXT, BufferCreateInfo> 7792 { 7793 enum 7794 { 7795 value = true 7796 }; 7797 }; 7798 template <> 7799 struct StructExtends<VideoEncodeH265RateControlInfoEXT, VideoEncodeRateControlInfoKHR> 7800 { 7801 enum 7802 { 7803 value = true 7804 }; 7805 }; 7806 template <> 7807 struct StructExtends<VideoEncodeH265RateControlLayerInfoEXT, VideoEncodeRateControlLayerInfoKHR> 7808 { 7809 enum 7810 { 7811 value = true 7812 }; 7813 }; 7814 #endif /*VK_ENABLE_BETA_EXTENSIONS*/ 7815 7816 #if defined( VK_ENABLE_BETA_EXTENSIONS ) 7817 //=== VK_EXT_video_decode_h264 === 7818 template <> 7819 struct StructExtends<VideoDecodeH264ProfileEXT, VideoProfileKHR> 7820 { 7821 enum 7822 { 7823 value = true 7824 }; 7825 }; 7826 template <> 7827 struct StructExtends<VideoDecodeH264ProfileEXT, QueryPoolCreateInfo> 7828 { 7829 enum 7830 { 7831 value = true 7832 }; 7833 }; 7834 template <> 7835 struct StructExtends<VideoDecodeH264ProfileEXT, FormatProperties2> 7836 { 7837 enum 7838 { 7839 value = true 7840 }; 7841 }; 7842 template <> 7843 struct StructExtends<VideoDecodeH264ProfileEXT, ImageCreateInfo> 7844 { 7845 enum 7846 { 7847 value = true 7848 }; 7849 }; 7850 template <> 7851 struct StructExtends<VideoDecodeH264ProfileEXT, ImageViewCreateInfo> 7852 { 7853 enum 7854 { 7855 value = true 7856 }; 7857 }; 7858 template <> 7859 struct StructExtends<VideoDecodeH264ProfileEXT, BufferCreateInfo> 7860 { 7861 enum 7862 { 7863 value = true 7864 }; 7865 }; 7866 template <> 7867 struct StructExtends<VideoDecodeH264CapabilitiesEXT, VideoCapabilitiesKHR> 7868 { 7869 enum 7870 { 7871 value = true 7872 }; 7873 }; 7874 template <> 7875 struct StructExtends<VideoDecodeH264SessionCreateInfoEXT, VideoSessionCreateInfoKHR> 7876 { 7877 enum 7878 { 7879 value = true 7880 }; 7881 }; 7882 template <> 7883 struct StructExtends<VideoDecodeH264SessionParametersCreateInfoEXT, VideoSessionParametersCreateInfoKHR> 7884 { 7885 enum 7886 { 7887 value = true 7888 }; 7889 }; 7890 template <> 7891 struct StructExtends<VideoDecodeH264SessionParametersAddInfoEXT, VideoSessionParametersUpdateInfoKHR> 7892 { 7893 enum 7894 { 7895 value = true 7896 }; 7897 }; 7898 template <> 7899 struct StructExtends<VideoDecodeH264PictureInfoEXT, VideoDecodeInfoKHR> 7900 { 7901 enum 7902 { 7903 value = true 7904 }; 7905 }; 7906 template <> 7907 struct StructExtends<VideoDecodeH264MvcEXT, VideoDecodeH264PictureInfoEXT> 7908 { 7909 enum 7910 { 7911 value = true 7912 }; 7913 }; 7914 template <> 7915 struct StructExtends<VideoDecodeH264DpbSlotInfoEXT, VideoReferenceSlotKHR> 7916 { 7917 enum 7918 { 7919 value = true 7920 }; 7921 }; 7922 #endif /*VK_ENABLE_BETA_EXTENSIONS*/ 7923 7924 //=== VK_AMD_texture_gather_bias_lod === 7925 template <> 7926 struct StructExtends<TextureLODGatherFormatPropertiesAMD, ImageFormatProperties2> 7927 { 7928 enum 7929 { 7930 value = true 7931 }; 7932 }; 7933 7934 //=== VK_KHR_dynamic_rendering === 7935 template <> 7936 struct StructExtends<PipelineRenderingCreateInfoKHR, GraphicsPipelineCreateInfo> 7937 { 7938 enum 7939 { 7940 value = true 7941 }; 7942 }; 7943 template <> 7944 struct StructExtends<PhysicalDeviceDynamicRenderingFeaturesKHR, PhysicalDeviceFeatures2> 7945 { 7946 enum 7947 { 7948 value = true 7949 }; 7950 }; 7951 template <> 7952 struct StructExtends<PhysicalDeviceDynamicRenderingFeaturesKHR, DeviceCreateInfo> 7953 { 7954 enum 7955 { 7956 value = true 7957 }; 7958 }; 7959 template <> 7960 struct StructExtends<CommandBufferInheritanceRenderingInfoKHR, CommandBufferInheritanceInfo> 7961 { 7962 enum 7963 { 7964 value = true 7965 }; 7966 }; 7967 template <> 7968 struct StructExtends<RenderingFragmentShadingRateAttachmentInfoKHR, RenderingInfoKHR> 7969 { 7970 enum 7971 { 7972 value = true 7973 }; 7974 }; 7975 template <> 7976 struct StructExtends<RenderingFragmentDensityMapAttachmentInfoEXT, RenderingInfoKHR> 7977 { 7978 enum 7979 { 7980 value = true 7981 }; 7982 }; 7983 template <> 7984 struct StructExtends<AttachmentSampleCountInfoAMD, CommandBufferInheritanceInfo> 7985 { 7986 enum 7987 { 7988 value = true 7989 }; 7990 }; 7991 template <> 7992 struct StructExtends<AttachmentSampleCountInfoAMD, GraphicsPipelineCreateInfo> 7993 { 7994 enum 7995 { 7996 value = true 7997 }; 7998 }; 7999 template <> 8000 struct StructExtends<MultiviewPerViewAttributesInfoNVX, CommandBufferInheritanceInfo> 8001 { 8002 enum 8003 { 8004 value = true 8005 }; 8006 }; 8007 template <> 8008 struct StructExtends<MultiviewPerViewAttributesInfoNVX, GraphicsPipelineCreateInfo> 8009 { 8010 enum 8011 { 8012 value = true 8013 }; 8014 }; 8015 template <> 8016 struct StructExtends<MultiviewPerViewAttributesInfoNVX, RenderingInfoKHR> 8017 { 8018 enum 8019 { 8020 value = true 8021 }; 8022 }; 8023 8024 //=== VK_NV_corner_sampled_image === 8025 template <> 8026 struct StructExtends<PhysicalDeviceCornerSampledImageFeaturesNV, PhysicalDeviceFeatures2> 8027 { 8028 enum 8029 { 8030 value = true 8031 }; 8032 }; 8033 template <> 8034 struct StructExtends<PhysicalDeviceCornerSampledImageFeaturesNV, DeviceCreateInfo> 8035 { 8036 enum 8037 { 8038 value = true 8039 }; 8040 }; 8041 8042 //=== VK_NV_external_memory === 8043 template <> 8044 struct StructExtends<ExternalMemoryImageCreateInfoNV, ImageCreateInfo> 8045 { 8046 enum 8047 { 8048 value = true 8049 }; 8050 }; 8051 template <> 8052 struct StructExtends<ExportMemoryAllocateInfoNV, MemoryAllocateInfo> 8053 { 8054 enum 8055 { 8056 value = true 8057 }; 8058 }; 8059 8060 #if defined( VK_USE_PLATFORM_WIN32_KHR ) 8061 //=== VK_NV_external_memory_win32 === 8062 template <> 8063 struct StructExtends<ImportMemoryWin32HandleInfoNV, MemoryAllocateInfo> 8064 { 8065 enum 8066 { 8067 value = true 8068 }; 8069 }; 8070 template <> 8071 struct StructExtends<ExportMemoryWin32HandleInfoNV, MemoryAllocateInfo> 8072 { 8073 enum 8074 { 8075 value = true 8076 }; 8077 }; 8078 #endif /*VK_USE_PLATFORM_WIN32_KHR*/ 8079 8080 #if defined( VK_USE_PLATFORM_WIN32_KHR ) 8081 //=== VK_NV_win32_keyed_mutex === 8082 template <> 8083 struct StructExtends<Win32KeyedMutexAcquireReleaseInfoNV, SubmitInfo> 8084 { 8085 enum 8086 { 8087 value = true 8088 }; 8089 }; 8090 template <> 8091 struct StructExtends<Win32KeyedMutexAcquireReleaseInfoNV, SubmitInfo2KHR> 8092 { 8093 enum 8094 { 8095 value = true 8096 }; 8097 }; 8098 #endif /*VK_USE_PLATFORM_WIN32_KHR*/ 8099 8100 //=== VK_EXT_validation_flags === 8101 template <> 8102 struct StructExtends<ValidationFlagsEXT, InstanceCreateInfo> 8103 { 8104 enum 8105 { 8106 value = true 8107 }; 8108 }; 8109 8110 //=== VK_EXT_texture_compression_astc_hdr === 8111 template <> 8112 struct StructExtends<PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT, PhysicalDeviceFeatures2> 8113 { 8114 enum 8115 { 8116 value = true 8117 }; 8118 }; 8119 template <> 8120 struct StructExtends<PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT, DeviceCreateInfo> 8121 { 8122 enum 8123 { 8124 value = true 8125 }; 8126 }; 8127 8128 //=== VK_EXT_astc_decode_mode === 8129 template <> 8130 struct StructExtends<ImageViewASTCDecodeModeEXT, ImageViewCreateInfo> 8131 { 8132 enum 8133 { 8134 value = true 8135 }; 8136 }; 8137 template <> 8138 struct StructExtends<PhysicalDeviceASTCDecodeFeaturesEXT, PhysicalDeviceFeatures2> 8139 { 8140 enum 8141 { 8142 value = true 8143 }; 8144 }; 8145 template <> 8146 struct StructExtends<PhysicalDeviceASTCDecodeFeaturesEXT, DeviceCreateInfo> 8147 { 8148 enum 8149 { 8150 value = true 8151 }; 8152 }; 8153 8154 #if defined( VK_USE_PLATFORM_WIN32_KHR ) 8155 //=== VK_KHR_external_memory_win32 === 8156 template <> 8157 struct StructExtends<ImportMemoryWin32HandleInfoKHR, MemoryAllocateInfo> 8158 { 8159 enum 8160 { 8161 value = true 8162 }; 8163 }; 8164 template <> 8165 struct StructExtends<ExportMemoryWin32HandleInfoKHR, MemoryAllocateInfo> 8166 { 8167 enum 8168 { 8169 value = true 8170 }; 8171 }; 8172 #endif /*VK_USE_PLATFORM_WIN32_KHR*/ 8173 8174 //=== VK_KHR_external_memory_fd === 8175 template <> 8176 struct StructExtends<ImportMemoryFdInfoKHR, MemoryAllocateInfo> 8177 { 8178 enum 8179 { 8180 value = true 8181 }; 8182 }; 8183 8184 #if defined( VK_USE_PLATFORM_WIN32_KHR ) 8185 //=== VK_KHR_win32_keyed_mutex === 8186 template <> 8187 struct StructExtends<Win32KeyedMutexAcquireReleaseInfoKHR, SubmitInfo> 8188 { 8189 enum 8190 { 8191 value = true 8192 }; 8193 }; 8194 template <> 8195 struct StructExtends<Win32KeyedMutexAcquireReleaseInfoKHR, SubmitInfo2KHR> 8196 { 8197 enum 8198 { 8199 value = true 8200 }; 8201 }; 8202 #endif /*VK_USE_PLATFORM_WIN32_KHR*/ 8203 8204 #if defined( VK_USE_PLATFORM_WIN32_KHR ) 8205 //=== VK_KHR_external_semaphore_win32 === 8206 template <> 8207 struct StructExtends<ExportSemaphoreWin32HandleInfoKHR, SemaphoreCreateInfo> 8208 { 8209 enum 8210 { 8211 value = true 8212 }; 8213 }; 8214 template <> 8215 struct StructExtends<D3D12FenceSubmitInfoKHR, SubmitInfo> 8216 { 8217 enum 8218 { 8219 value = true 8220 }; 8221 }; 8222 #endif /*VK_USE_PLATFORM_WIN32_KHR*/ 8223 8224 //=== VK_KHR_push_descriptor === 8225 template <> 8226 struct StructExtends<PhysicalDevicePushDescriptorPropertiesKHR, PhysicalDeviceProperties2> 8227 { 8228 enum 8229 { 8230 value = true 8231 }; 8232 }; 8233 8234 //=== VK_EXT_conditional_rendering === 8235 template <> 8236 struct StructExtends<PhysicalDeviceConditionalRenderingFeaturesEXT, PhysicalDeviceFeatures2> 8237 { 8238 enum 8239 { 8240 value = true 8241 }; 8242 }; 8243 template <> 8244 struct StructExtends<PhysicalDeviceConditionalRenderingFeaturesEXT, DeviceCreateInfo> 8245 { 8246 enum 8247 { 8248 value = true 8249 }; 8250 }; 8251 template <> 8252 struct StructExtends<CommandBufferInheritanceConditionalRenderingInfoEXT, CommandBufferInheritanceInfo> 8253 { 8254 enum 8255 { 8256 value = true 8257 }; 8258 }; 8259 8260 //=== VK_KHR_incremental_present === 8261 template <> 8262 struct StructExtends<PresentRegionsKHR, PresentInfoKHR> 8263 { 8264 enum 8265 { 8266 value = true 8267 }; 8268 }; 8269 8270 //=== VK_NV_clip_space_w_scaling === 8271 template <> 8272 struct StructExtends<PipelineViewportWScalingStateCreateInfoNV, PipelineViewportStateCreateInfo> 8273 { 8274 enum 8275 { 8276 value = true 8277 }; 8278 }; 8279 8280 //=== VK_EXT_display_control === 8281 template <> 8282 struct StructExtends<SwapchainCounterCreateInfoEXT, SwapchainCreateInfoKHR> 8283 { 8284 enum 8285 { 8286 value = true 8287 }; 8288 }; 8289 8290 //=== VK_GOOGLE_display_timing === 8291 template <> 8292 struct StructExtends<PresentTimesInfoGOOGLE, PresentInfoKHR> 8293 { 8294 enum 8295 { 8296 value = true 8297 }; 8298 }; 8299 8300 //=== VK_NVX_multiview_per_view_attributes === 8301 template <> 8302 struct StructExtends<PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, PhysicalDeviceProperties2> 8303 { 8304 enum 8305 { 8306 value = true 8307 }; 8308 }; 8309 8310 //=== VK_NV_viewport_swizzle === 8311 template <> 8312 struct StructExtends<PipelineViewportSwizzleStateCreateInfoNV, PipelineViewportStateCreateInfo> 8313 { 8314 enum 8315 { 8316 value = true 8317 }; 8318 }; 8319 8320 //=== VK_EXT_discard_rectangles === 8321 template <> 8322 struct StructExtends<PhysicalDeviceDiscardRectanglePropertiesEXT, PhysicalDeviceProperties2> 8323 { 8324 enum 8325 { 8326 value = true 8327 }; 8328 }; 8329 template <> 8330 struct StructExtends<PipelineDiscardRectangleStateCreateInfoEXT, GraphicsPipelineCreateInfo> 8331 { 8332 enum 8333 { 8334 value = true 8335 }; 8336 }; 8337 8338 //=== VK_EXT_conservative_rasterization === 8339 template <> 8340 struct StructExtends<PhysicalDeviceConservativeRasterizationPropertiesEXT, PhysicalDeviceProperties2> 8341 { 8342 enum 8343 { 8344 value = true 8345 }; 8346 }; 8347 template <> 8348 struct StructExtends<PipelineRasterizationConservativeStateCreateInfoEXT, PipelineRasterizationStateCreateInfo> 8349 { 8350 enum 8351 { 8352 value = true 8353 }; 8354 }; 8355 8356 //=== VK_EXT_depth_clip_enable === 8357 template <> 8358 struct StructExtends<PhysicalDeviceDepthClipEnableFeaturesEXT, PhysicalDeviceFeatures2> 8359 { 8360 enum 8361 { 8362 value = true 8363 }; 8364 }; 8365 template <> 8366 struct StructExtends<PhysicalDeviceDepthClipEnableFeaturesEXT, DeviceCreateInfo> 8367 { 8368 enum 8369 { 8370 value = true 8371 }; 8372 }; 8373 template <> 8374 struct StructExtends<PipelineRasterizationDepthClipStateCreateInfoEXT, PipelineRasterizationStateCreateInfo> 8375 { 8376 enum 8377 { 8378 value = true 8379 }; 8380 }; 8381 8382 //=== VK_KHR_shared_presentable_image === 8383 template <> 8384 struct StructExtends<SharedPresentSurfaceCapabilitiesKHR, SurfaceCapabilities2KHR> 8385 { 8386 enum 8387 { 8388 value = true 8389 }; 8390 }; 8391 8392 #if defined( VK_USE_PLATFORM_WIN32_KHR ) 8393 //=== VK_KHR_external_fence_win32 === 8394 template <> 8395 struct StructExtends<ExportFenceWin32HandleInfoKHR, FenceCreateInfo> 8396 { 8397 enum 8398 { 8399 value = true 8400 }; 8401 }; 8402 #endif /*VK_USE_PLATFORM_WIN32_KHR*/ 8403 8404 //=== VK_KHR_performance_query === 8405 template <> 8406 struct StructExtends<PhysicalDevicePerformanceQueryFeaturesKHR, PhysicalDeviceFeatures2> 8407 { 8408 enum 8409 { 8410 value = true 8411 }; 8412 }; 8413 template <> 8414 struct StructExtends<PhysicalDevicePerformanceQueryFeaturesKHR, DeviceCreateInfo> 8415 { 8416 enum 8417 { 8418 value = true 8419 }; 8420 }; 8421 template <> 8422 struct StructExtends<PhysicalDevicePerformanceQueryPropertiesKHR, PhysicalDeviceProperties2> 8423 { 8424 enum 8425 { 8426 value = true 8427 }; 8428 }; 8429 template <> 8430 struct StructExtends<QueryPoolPerformanceCreateInfoKHR, QueryPoolCreateInfo> 8431 { 8432 enum 8433 { 8434 value = true 8435 }; 8436 }; 8437 template <> 8438 struct StructExtends<PerformanceQuerySubmitInfoKHR, SubmitInfo> 8439 { 8440 enum 8441 { 8442 value = true 8443 }; 8444 }; 8445 template <> 8446 struct StructExtends<PerformanceQuerySubmitInfoKHR, SubmitInfo2KHR> 8447 { 8448 enum 8449 { 8450 value = true 8451 }; 8452 }; 8453 8454 //=== VK_EXT_debug_utils === 8455 template <> 8456 struct StructExtends<DebugUtilsMessengerCreateInfoEXT, InstanceCreateInfo> 8457 { 8458 enum 8459 { 8460 value = true 8461 }; 8462 }; 8463 8464 #if defined( VK_USE_PLATFORM_ANDROID_KHR ) 8465 //=== VK_ANDROID_external_memory_android_hardware_buffer === 8466 template <> 8467 struct StructExtends<AndroidHardwareBufferUsageANDROID, ImageFormatProperties2> 8468 { 8469 enum 8470 { 8471 value = true 8472 }; 8473 }; 8474 template <> 8475 struct StructExtends<AndroidHardwareBufferFormatPropertiesANDROID, AndroidHardwareBufferPropertiesANDROID> 8476 { 8477 enum 8478 { 8479 value = true 8480 }; 8481 }; 8482 template <> 8483 struct StructExtends<ImportAndroidHardwareBufferInfoANDROID, MemoryAllocateInfo> 8484 { 8485 enum 8486 { 8487 value = true 8488 }; 8489 }; 8490 template <> 8491 struct StructExtends<ExternalFormatANDROID, ImageCreateInfo> 8492 { 8493 enum 8494 { 8495 value = true 8496 }; 8497 }; 8498 template <> 8499 struct StructExtends<ExternalFormatANDROID, SamplerYcbcrConversionCreateInfo> 8500 { 8501 enum 8502 { 8503 value = true 8504 }; 8505 }; 8506 template <> 8507 struct StructExtends<AndroidHardwareBufferFormatProperties2ANDROID, AndroidHardwareBufferPropertiesANDROID> 8508 { 8509 enum 8510 { 8511 value = true 8512 }; 8513 }; 8514 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 8515 8516 //=== VK_EXT_inline_uniform_block === 8517 template <> 8518 struct StructExtends<PhysicalDeviceInlineUniformBlockFeaturesEXT, PhysicalDeviceFeatures2> 8519 { 8520 enum 8521 { 8522 value = true 8523 }; 8524 }; 8525 template <> 8526 struct StructExtends<PhysicalDeviceInlineUniformBlockFeaturesEXT, DeviceCreateInfo> 8527 { 8528 enum 8529 { 8530 value = true 8531 }; 8532 }; 8533 template <> 8534 struct StructExtends<PhysicalDeviceInlineUniformBlockPropertiesEXT, PhysicalDeviceProperties2> 8535 { 8536 enum 8537 { 8538 value = true 8539 }; 8540 }; 8541 template <> 8542 struct StructExtends<WriteDescriptorSetInlineUniformBlockEXT, WriteDescriptorSet> 8543 { 8544 enum 8545 { 8546 value = true 8547 }; 8548 }; 8549 template <> 8550 struct StructExtends<DescriptorPoolInlineUniformBlockCreateInfoEXT, DescriptorPoolCreateInfo> 8551 { 8552 enum 8553 { 8554 value = true 8555 }; 8556 }; 8557 8558 //=== VK_EXT_sample_locations === 8559 template <> 8560 struct StructExtends<SampleLocationsInfoEXT, ImageMemoryBarrier> 8561 { 8562 enum 8563 { 8564 value = true 8565 }; 8566 }; 8567 template <> 8568 struct StructExtends<SampleLocationsInfoEXT, ImageMemoryBarrier2KHR> 8569 { 8570 enum 8571 { 8572 value = true 8573 }; 8574 }; 8575 template <> 8576 struct StructExtends<RenderPassSampleLocationsBeginInfoEXT, RenderPassBeginInfo> 8577 { 8578 enum 8579 { 8580 value = true 8581 }; 8582 }; 8583 template <> 8584 struct StructExtends<PipelineSampleLocationsStateCreateInfoEXT, PipelineMultisampleStateCreateInfo> 8585 { 8586 enum 8587 { 8588 value = true 8589 }; 8590 }; 8591 template <> 8592 struct StructExtends<PhysicalDeviceSampleLocationsPropertiesEXT, PhysicalDeviceProperties2> 8593 { 8594 enum 8595 { 8596 value = true 8597 }; 8598 }; 8599 8600 //=== VK_EXT_blend_operation_advanced === 8601 template <> 8602 struct StructExtends<PhysicalDeviceBlendOperationAdvancedFeaturesEXT, PhysicalDeviceFeatures2> 8603 { 8604 enum 8605 { 8606 value = true 8607 }; 8608 }; 8609 template <> 8610 struct StructExtends<PhysicalDeviceBlendOperationAdvancedFeaturesEXT, DeviceCreateInfo> 8611 { 8612 enum 8613 { 8614 value = true 8615 }; 8616 }; 8617 template <> 8618 struct StructExtends<PhysicalDeviceBlendOperationAdvancedPropertiesEXT, PhysicalDeviceProperties2> 8619 { 8620 enum 8621 { 8622 value = true 8623 }; 8624 }; 8625 template <> 8626 struct StructExtends<PipelineColorBlendAdvancedStateCreateInfoEXT, PipelineColorBlendStateCreateInfo> 8627 { 8628 enum 8629 { 8630 value = true 8631 }; 8632 }; 8633 8634 //=== VK_NV_fragment_coverage_to_color === 8635 template <> 8636 struct StructExtends<PipelineCoverageToColorStateCreateInfoNV, PipelineMultisampleStateCreateInfo> 8637 { 8638 enum 8639 { 8640 value = true 8641 }; 8642 }; 8643 8644 //=== VK_KHR_acceleration_structure === 8645 template <> 8646 struct StructExtends<WriteDescriptorSetAccelerationStructureKHR, WriteDescriptorSet> 8647 { 8648 enum 8649 { 8650 value = true 8651 }; 8652 }; 8653 template <> 8654 struct StructExtends<PhysicalDeviceAccelerationStructureFeaturesKHR, PhysicalDeviceFeatures2> 8655 { 8656 enum 8657 { 8658 value = true 8659 }; 8660 }; 8661 template <> 8662 struct StructExtends<PhysicalDeviceAccelerationStructureFeaturesKHR, DeviceCreateInfo> 8663 { 8664 enum 8665 { 8666 value = true 8667 }; 8668 }; 8669 template <> 8670 struct StructExtends<PhysicalDeviceAccelerationStructurePropertiesKHR, PhysicalDeviceProperties2> 8671 { 8672 enum 8673 { 8674 value = true 8675 }; 8676 }; 8677 8678 //=== VK_NV_framebuffer_mixed_samples === 8679 template <> 8680 struct StructExtends<PipelineCoverageModulationStateCreateInfoNV, PipelineMultisampleStateCreateInfo> 8681 { 8682 enum 8683 { 8684 value = true 8685 }; 8686 }; 8687 8688 //=== VK_NV_shader_sm_builtins === 8689 template <> 8690 struct StructExtends<PhysicalDeviceShaderSMBuiltinsPropertiesNV, PhysicalDeviceProperties2> 8691 { 8692 enum 8693 { 8694 value = true 8695 }; 8696 }; 8697 template <> 8698 struct StructExtends<PhysicalDeviceShaderSMBuiltinsFeaturesNV, PhysicalDeviceFeatures2> 8699 { 8700 enum 8701 { 8702 value = true 8703 }; 8704 }; 8705 template <> 8706 struct StructExtends<PhysicalDeviceShaderSMBuiltinsFeaturesNV, DeviceCreateInfo> 8707 { 8708 enum 8709 { 8710 value = true 8711 }; 8712 }; 8713 8714 //=== VK_EXT_image_drm_format_modifier === 8715 template <> 8716 struct StructExtends<DrmFormatModifierPropertiesListEXT, FormatProperties2> 8717 { 8718 enum 8719 { 8720 value = true 8721 }; 8722 }; 8723 template <> 8724 struct StructExtends<PhysicalDeviceImageDrmFormatModifierInfoEXT, PhysicalDeviceImageFormatInfo2> 8725 { 8726 enum 8727 { 8728 value = true 8729 }; 8730 }; 8731 template <> 8732 struct StructExtends<ImageDrmFormatModifierListCreateInfoEXT, ImageCreateInfo> 8733 { 8734 enum 8735 { 8736 value = true 8737 }; 8738 }; 8739 template <> 8740 struct StructExtends<ImageDrmFormatModifierExplicitCreateInfoEXT, ImageCreateInfo> 8741 { 8742 enum 8743 { 8744 value = true 8745 }; 8746 }; 8747 template <> 8748 struct StructExtends<DrmFormatModifierPropertiesList2EXT, FormatProperties2> 8749 { 8750 enum 8751 { 8752 value = true 8753 }; 8754 }; 8755 8756 //=== VK_EXT_validation_cache === 8757 template <> 8758 struct StructExtends<ShaderModuleValidationCacheCreateInfoEXT, ShaderModuleCreateInfo> 8759 { 8760 enum 8761 { 8762 value = true 8763 }; 8764 }; 8765 8766 #if defined( VK_ENABLE_BETA_EXTENSIONS ) 8767 //=== VK_KHR_portability_subset === 8768 template <> 8769 struct StructExtends<PhysicalDevicePortabilitySubsetFeaturesKHR, PhysicalDeviceFeatures2> 8770 { 8771 enum 8772 { 8773 value = true 8774 }; 8775 }; 8776 template <> 8777 struct StructExtends<PhysicalDevicePortabilitySubsetFeaturesKHR, DeviceCreateInfo> 8778 { 8779 enum 8780 { 8781 value = true 8782 }; 8783 }; 8784 template <> 8785 struct StructExtends<PhysicalDevicePortabilitySubsetPropertiesKHR, PhysicalDeviceProperties2> 8786 { 8787 enum 8788 { 8789 value = true 8790 }; 8791 }; 8792 #endif /*VK_ENABLE_BETA_EXTENSIONS*/ 8793 8794 //=== VK_NV_shading_rate_image === 8795 template <> 8796 struct StructExtends<PipelineViewportShadingRateImageStateCreateInfoNV, PipelineViewportStateCreateInfo> 8797 { 8798 enum 8799 { 8800 value = true 8801 }; 8802 }; 8803 template <> 8804 struct StructExtends<PhysicalDeviceShadingRateImageFeaturesNV, PhysicalDeviceFeatures2> 8805 { 8806 enum 8807 { 8808 value = true 8809 }; 8810 }; 8811 template <> 8812 struct StructExtends<PhysicalDeviceShadingRateImageFeaturesNV, DeviceCreateInfo> 8813 { 8814 enum 8815 { 8816 value = true 8817 }; 8818 }; 8819 template <> 8820 struct StructExtends<PhysicalDeviceShadingRateImagePropertiesNV, PhysicalDeviceProperties2> 8821 { 8822 enum 8823 { 8824 value = true 8825 }; 8826 }; 8827 template <> 8828 struct StructExtends<PipelineViewportCoarseSampleOrderStateCreateInfoNV, PipelineViewportStateCreateInfo> 8829 { 8830 enum 8831 { 8832 value = true 8833 }; 8834 }; 8835 8836 //=== VK_NV_ray_tracing === 8837 template <> 8838 struct StructExtends<WriteDescriptorSetAccelerationStructureNV, WriteDescriptorSet> 8839 { 8840 enum 8841 { 8842 value = true 8843 }; 8844 }; 8845 template <> 8846 struct StructExtends<PhysicalDeviceRayTracingPropertiesNV, PhysicalDeviceProperties2> 8847 { 8848 enum 8849 { 8850 value = true 8851 }; 8852 }; 8853 8854 //=== VK_NV_representative_fragment_test === 8855 template <> 8856 struct StructExtends<PhysicalDeviceRepresentativeFragmentTestFeaturesNV, PhysicalDeviceFeatures2> 8857 { 8858 enum 8859 { 8860 value = true 8861 }; 8862 }; 8863 template <> 8864 struct StructExtends<PhysicalDeviceRepresentativeFragmentTestFeaturesNV, DeviceCreateInfo> 8865 { 8866 enum 8867 { 8868 value = true 8869 }; 8870 }; 8871 template <> 8872 struct StructExtends<PipelineRepresentativeFragmentTestStateCreateInfoNV, GraphicsPipelineCreateInfo> 8873 { 8874 enum 8875 { 8876 value = true 8877 }; 8878 }; 8879 8880 //=== VK_EXT_filter_cubic === 8881 template <> 8882 struct StructExtends<PhysicalDeviceImageViewImageFormatInfoEXT, PhysicalDeviceImageFormatInfo2> 8883 { 8884 enum 8885 { 8886 value = true 8887 }; 8888 }; 8889 template <> 8890 struct StructExtends<FilterCubicImageViewImageFormatPropertiesEXT, ImageFormatProperties2> 8891 { 8892 enum 8893 { 8894 value = true 8895 }; 8896 }; 8897 8898 //=== VK_EXT_global_priority === 8899 template <> 8900 struct StructExtends<DeviceQueueGlobalPriorityCreateInfoEXT, DeviceQueueCreateInfo> 8901 { 8902 enum 8903 { 8904 value = true 8905 }; 8906 }; 8907 8908 //=== VK_EXT_external_memory_host === 8909 template <> 8910 struct StructExtends<ImportMemoryHostPointerInfoEXT, MemoryAllocateInfo> 8911 { 8912 enum 8913 { 8914 value = true 8915 }; 8916 }; 8917 template <> 8918 struct StructExtends<PhysicalDeviceExternalMemoryHostPropertiesEXT, PhysicalDeviceProperties2> 8919 { 8920 enum 8921 { 8922 value = true 8923 }; 8924 }; 8925 8926 //=== VK_KHR_shader_clock === 8927 template <> 8928 struct StructExtends<PhysicalDeviceShaderClockFeaturesKHR, PhysicalDeviceFeatures2> 8929 { 8930 enum 8931 { 8932 value = true 8933 }; 8934 }; 8935 template <> 8936 struct StructExtends<PhysicalDeviceShaderClockFeaturesKHR, DeviceCreateInfo> 8937 { 8938 enum 8939 { 8940 value = true 8941 }; 8942 }; 8943 8944 //=== VK_AMD_pipeline_compiler_control === 8945 template <> 8946 struct StructExtends<PipelineCompilerControlCreateInfoAMD, GraphicsPipelineCreateInfo> 8947 { 8948 enum 8949 { 8950 value = true 8951 }; 8952 }; 8953 template <> 8954 struct StructExtends<PipelineCompilerControlCreateInfoAMD, ComputePipelineCreateInfo> 8955 { 8956 enum 8957 { 8958 value = true 8959 }; 8960 }; 8961 8962 //=== VK_AMD_shader_core_properties === 8963 template <> 8964 struct StructExtends<PhysicalDeviceShaderCorePropertiesAMD, PhysicalDeviceProperties2> 8965 { 8966 enum 8967 { 8968 value = true 8969 }; 8970 }; 8971 8972 #if defined( VK_ENABLE_BETA_EXTENSIONS ) 8973 //=== VK_EXT_video_decode_h265 === 8974 template <> 8975 struct StructExtends<VideoDecodeH265ProfileEXT, VideoProfileKHR> 8976 { 8977 enum 8978 { 8979 value = true 8980 }; 8981 }; 8982 template <> 8983 struct StructExtends<VideoDecodeH265ProfileEXT, QueryPoolCreateInfo> 8984 { 8985 enum 8986 { 8987 value = true 8988 }; 8989 }; 8990 template <> 8991 struct StructExtends<VideoDecodeH265ProfileEXT, FormatProperties2> 8992 { 8993 enum 8994 { 8995 value = true 8996 }; 8997 }; 8998 template <> 8999 struct StructExtends<VideoDecodeH265ProfileEXT, ImageCreateInfo> 9000 { 9001 enum 9002 { 9003 value = true 9004 }; 9005 }; 9006 template <> 9007 struct StructExtends<VideoDecodeH265ProfileEXT, ImageViewCreateInfo> 9008 { 9009 enum 9010 { 9011 value = true 9012 }; 9013 }; 9014 template <> 9015 struct StructExtends<VideoDecodeH265ProfileEXT, BufferCreateInfo> 9016 { 9017 enum 9018 { 9019 value = true 9020 }; 9021 }; 9022 template <> 9023 struct StructExtends<VideoDecodeH265CapabilitiesEXT, VideoCapabilitiesKHR> 9024 { 9025 enum 9026 { 9027 value = true 9028 }; 9029 }; 9030 template <> 9031 struct StructExtends<VideoDecodeH265SessionCreateInfoEXT, VideoSessionCreateInfoKHR> 9032 { 9033 enum 9034 { 9035 value = true 9036 }; 9037 }; 9038 template <> 9039 struct StructExtends<VideoDecodeH265SessionParametersCreateInfoEXT, VideoSessionParametersCreateInfoKHR> 9040 { 9041 enum 9042 { 9043 value = true 9044 }; 9045 }; 9046 template <> 9047 struct StructExtends<VideoDecodeH265SessionParametersAddInfoEXT, VideoSessionParametersUpdateInfoKHR> 9048 { 9049 enum 9050 { 9051 value = true 9052 }; 9053 }; 9054 template <> 9055 struct StructExtends<VideoDecodeH265PictureInfoEXT, VideoDecodeInfoKHR> 9056 { 9057 enum 9058 { 9059 value = true 9060 }; 9061 }; 9062 template <> 9063 struct StructExtends<VideoDecodeH265DpbSlotInfoEXT, VideoReferenceSlotKHR> 9064 { 9065 enum 9066 { 9067 value = true 9068 }; 9069 }; 9070 #endif /*VK_ENABLE_BETA_EXTENSIONS*/ 9071 9072 //=== VK_AMD_memory_overallocation_behavior === 9073 template <> 9074 struct StructExtends<DeviceMemoryOverallocationCreateInfoAMD, DeviceCreateInfo> 9075 { 9076 enum 9077 { 9078 value = true 9079 }; 9080 }; 9081 9082 //=== VK_EXT_vertex_attribute_divisor === 9083 template <> 9084 struct StructExtends<PhysicalDeviceVertexAttributeDivisorPropertiesEXT, PhysicalDeviceProperties2> 9085 { 9086 enum 9087 { 9088 value = true 9089 }; 9090 }; 9091 template <> 9092 struct StructExtends<PipelineVertexInputDivisorStateCreateInfoEXT, PipelineVertexInputStateCreateInfo> 9093 { 9094 enum 9095 { 9096 value = true 9097 }; 9098 }; 9099 template <> 9100 struct StructExtends<PhysicalDeviceVertexAttributeDivisorFeaturesEXT, PhysicalDeviceFeatures2> 9101 { 9102 enum 9103 { 9104 value = true 9105 }; 9106 }; 9107 template <> 9108 struct StructExtends<PhysicalDeviceVertexAttributeDivisorFeaturesEXT, DeviceCreateInfo> 9109 { 9110 enum 9111 { 9112 value = true 9113 }; 9114 }; 9115 9116 #if defined( VK_USE_PLATFORM_GGP ) 9117 //=== VK_GGP_frame_token === 9118 template <> 9119 struct StructExtends<PresentFrameTokenGGP, PresentInfoKHR> 9120 { 9121 enum 9122 { 9123 value = true 9124 }; 9125 }; 9126 #endif /*VK_USE_PLATFORM_GGP*/ 9127 9128 //=== VK_EXT_pipeline_creation_feedback === 9129 template <> 9130 struct StructExtends<PipelineCreationFeedbackCreateInfoEXT, GraphicsPipelineCreateInfo> 9131 { 9132 enum 9133 { 9134 value = true 9135 }; 9136 }; 9137 template <> 9138 struct StructExtends<PipelineCreationFeedbackCreateInfoEXT, ComputePipelineCreateInfo> 9139 { 9140 enum 9141 { 9142 value = true 9143 }; 9144 }; 9145 template <> 9146 struct StructExtends<PipelineCreationFeedbackCreateInfoEXT, RayTracingPipelineCreateInfoNV> 9147 { 9148 enum 9149 { 9150 value = true 9151 }; 9152 }; 9153 template <> 9154 struct StructExtends<PipelineCreationFeedbackCreateInfoEXT, RayTracingPipelineCreateInfoKHR> 9155 { 9156 enum 9157 { 9158 value = true 9159 }; 9160 }; 9161 9162 //=== VK_NV_compute_shader_derivatives === 9163 template <> 9164 struct StructExtends<PhysicalDeviceComputeShaderDerivativesFeaturesNV, PhysicalDeviceFeatures2> 9165 { 9166 enum 9167 { 9168 value = true 9169 }; 9170 }; 9171 template <> 9172 struct StructExtends<PhysicalDeviceComputeShaderDerivativesFeaturesNV, DeviceCreateInfo> 9173 { 9174 enum 9175 { 9176 value = true 9177 }; 9178 }; 9179 9180 //=== VK_NV_mesh_shader === 9181 template <> 9182 struct StructExtends<PhysicalDeviceMeshShaderFeaturesNV, PhysicalDeviceFeatures2> 9183 { 9184 enum 9185 { 9186 value = true 9187 }; 9188 }; 9189 template <> 9190 struct StructExtends<PhysicalDeviceMeshShaderFeaturesNV, DeviceCreateInfo> 9191 { 9192 enum 9193 { 9194 value = true 9195 }; 9196 }; 9197 template <> 9198 struct StructExtends<PhysicalDeviceMeshShaderPropertiesNV, PhysicalDeviceProperties2> 9199 { 9200 enum 9201 { 9202 value = true 9203 }; 9204 }; 9205 9206 //=== VK_NV_fragment_shader_barycentric === 9207 template <> 9208 struct StructExtends<PhysicalDeviceFragmentShaderBarycentricFeaturesNV, PhysicalDeviceFeatures2> 9209 { 9210 enum 9211 { 9212 value = true 9213 }; 9214 }; 9215 template <> 9216 struct StructExtends<PhysicalDeviceFragmentShaderBarycentricFeaturesNV, DeviceCreateInfo> 9217 { 9218 enum 9219 { 9220 value = true 9221 }; 9222 }; 9223 9224 //=== VK_NV_shader_image_footprint === 9225 template <> 9226 struct StructExtends<PhysicalDeviceShaderImageFootprintFeaturesNV, PhysicalDeviceFeatures2> 9227 { 9228 enum 9229 { 9230 value = true 9231 }; 9232 }; 9233 template <> 9234 struct StructExtends<PhysicalDeviceShaderImageFootprintFeaturesNV, DeviceCreateInfo> 9235 { 9236 enum 9237 { 9238 value = true 9239 }; 9240 }; 9241 9242 //=== VK_NV_scissor_exclusive === 9243 template <> 9244 struct StructExtends<PipelineViewportExclusiveScissorStateCreateInfoNV, PipelineViewportStateCreateInfo> 9245 { 9246 enum 9247 { 9248 value = true 9249 }; 9250 }; 9251 template <> 9252 struct StructExtends<PhysicalDeviceExclusiveScissorFeaturesNV, PhysicalDeviceFeatures2> 9253 { 9254 enum 9255 { 9256 value = true 9257 }; 9258 }; 9259 template <> 9260 struct StructExtends<PhysicalDeviceExclusiveScissorFeaturesNV, DeviceCreateInfo> 9261 { 9262 enum 9263 { 9264 value = true 9265 }; 9266 }; 9267 9268 //=== VK_NV_device_diagnostic_checkpoints === 9269 template <> 9270 struct StructExtends<QueueFamilyCheckpointPropertiesNV, QueueFamilyProperties2> 9271 { 9272 enum 9273 { 9274 value = true 9275 }; 9276 }; 9277 9278 //=== VK_INTEL_shader_integer_functions2 === 9279 template <> 9280 struct StructExtends<PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL, PhysicalDeviceFeatures2> 9281 { 9282 enum 9283 { 9284 value = true 9285 }; 9286 }; 9287 template <> 9288 struct StructExtends<PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL, DeviceCreateInfo> 9289 { 9290 enum 9291 { 9292 value = true 9293 }; 9294 }; 9295 9296 //=== VK_INTEL_performance_query === 9297 template <> 9298 struct StructExtends<QueryPoolPerformanceQueryCreateInfoINTEL, QueryPoolCreateInfo> 9299 { 9300 enum 9301 { 9302 value = true 9303 }; 9304 }; 9305 9306 //=== VK_EXT_pci_bus_info === 9307 template <> 9308 struct StructExtends<PhysicalDevicePCIBusInfoPropertiesEXT, PhysicalDeviceProperties2> 9309 { 9310 enum 9311 { 9312 value = true 9313 }; 9314 }; 9315 9316 //=== VK_AMD_display_native_hdr === 9317 template <> 9318 struct StructExtends<DisplayNativeHdrSurfaceCapabilitiesAMD, SurfaceCapabilities2KHR> 9319 { 9320 enum 9321 { 9322 value = true 9323 }; 9324 }; 9325 template <> 9326 struct StructExtends<SwapchainDisplayNativeHdrCreateInfoAMD, SwapchainCreateInfoKHR> 9327 { 9328 enum 9329 { 9330 value = true 9331 }; 9332 }; 9333 9334 //=== VK_KHR_shader_terminate_invocation === 9335 template <> 9336 struct StructExtends<PhysicalDeviceShaderTerminateInvocationFeaturesKHR, PhysicalDeviceFeatures2> 9337 { 9338 enum 9339 { 9340 value = true 9341 }; 9342 }; 9343 template <> 9344 struct StructExtends<PhysicalDeviceShaderTerminateInvocationFeaturesKHR, DeviceCreateInfo> 9345 { 9346 enum 9347 { 9348 value = true 9349 }; 9350 }; 9351 9352 //=== VK_EXT_fragment_density_map === 9353 template <> 9354 struct StructExtends<PhysicalDeviceFragmentDensityMapFeaturesEXT, PhysicalDeviceFeatures2> 9355 { 9356 enum 9357 { 9358 value = true 9359 }; 9360 }; 9361 template <> 9362 struct StructExtends<PhysicalDeviceFragmentDensityMapFeaturesEXT, DeviceCreateInfo> 9363 { 9364 enum 9365 { 9366 value = true 9367 }; 9368 }; 9369 template <> 9370 struct StructExtends<PhysicalDeviceFragmentDensityMapPropertiesEXT, PhysicalDeviceProperties2> 9371 { 9372 enum 9373 { 9374 value = true 9375 }; 9376 }; 9377 template <> 9378 struct StructExtends<RenderPassFragmentDensityMapCreateInfoEXT, RenderPassCreateInfo> 9379 { 9380 enum 9381 { 9382 value = true 9383 }; 9384 }; 9385 template <> 9386 struct StructExtends<RenderPassFragmentDensityMapCreateInfoEXT, RenderPassCreateInfo2> 9387 { 9388 enum 9389 { 9390 value = true 9391 }; 9392 }; 9393 9394 //=== VK_EXT_subgroup_size_control === 9395 template <> 9396 struct StructExtends<PhysicalDeviceSubgroupSizeControlFeaturesEXT, PhysicalDeviceFeatures2> 9397 { 9398 enum 9399 { 9400 value = true 9401 }; 9402 }; 9403 template <> 9404 struct StructExtends<PhysicalDeviceSubgroupSizeControlFeaturesEXT, DeviceCreateInfo> 9405 { 9406 enum 9407 { 9408 value = true 9409 }; 9410 }; 9411 template <> 9412 struct StructExtends<PhysicalDeviceSubgroupSizeControlPropertiesEXT, PhysicalDeviceProperties2> 9413 { 9414 enum 9415 { 9416 value = true 9417 }; 9418 }; 9419 template <> 9420 struct StructExtends<PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT, PipelineShaderStageCreateInfo> 9421 { 9422 enum 9423 { 9424 value = true 9425 }; 9426 }; 9427 9428 //=== VK_KHR_fragment_shading_rate === 9429 template <> 9430 struct StructExtends<FragmentShadingRateAttachmentInfoKHR, SubpassDescription2> 9431 { 9432 enum 9433 { 9434 value = true 9435 }; 9436 }; 9437 template <> 9438 struct StructExtends<PipelineFragmentShadingRateStateCreateInfoKHR, GraphicsPipelineCreateInfo> 9439 { 9440 enum 9441 { 9442 value = true 9443 }; 9444 }; 9445 template <> 9446 struct StructExtends<PhysicalDeviceFragmentShadingRateFeaturesKHR, PhysicalDeviceFeatures2> 9447 { 9448 enum 9449 { 9450 value = true 9451 }; 9452 }; 9453 template <> 9454 struct StructExtends<PhysicalDeviceFragmentShadingRateFeaturesKHR, DeviceCreateInfo> 9455 { 9456 enum 9457 { 9458 value = true 9459 }; 9460 }; 9461 template <> 9462 struct StructExtends<PhysicalDeviceFragmentShadingRatePropertiesKHR, PhysicalDeviceProperties2> 9463 { 9464 enum 9465 { 9466 value = true 9467 }; 9468 }; 9469 9470 //=== VK_AMD_shader_core_properties2 === 9471 template <> 9472 struct StructExtends<PhysicalDeviceShaderCoreProperties2AMD, PhysicalDeviceProperties2> 9473 { 9474 enum 9475 { 9476 value = true 9477 }; 9478 }; 9479 9480 //=== VK_AMD_device_coherent_memory === 9481 template <> 9482 struct StructExtends<PhysicalDeviceCoherentMemoryFeaturesAMD, PhysicalDeviceFeatures2> 9483 { 9484 enum 9485 { 9486 value = true 9487 }; 9488 }; 9489 template <> 9490 struct StructExtends<PhysicalDeviceCoherentMemoryFeaturesAMD, DeviceCreateInfo> 9491 { 9492 enum 9493 { 9494 value = true 9495 }; 9496 }; 9497 9498 //=== VK_EXT_shader_image_atomic_int64 === 9499 template <> 9500 struct StructExtends<PhysicalDeviceShaderImageAtomicInt64FeaturesEXT, PhysicalDeviceFeatures2> 9501 { 9502 enum 9503 { 9504 value = true 9505 }; 9506 }; 9507 template <> 9508 struct StructExtends<PhysicalDeviceShaderImageAtomicInt64FeaturesEXT, DeviceCreateInfo> 9509 { 9510 enum 9511 { 9512 value = true 9513 }; 9514 }; 9515 9516 //=== VK_EXT_memory_budget === 9517 template <> 9518 struct StructExtends<PhysicalDeviceMemoryBudgetPropertiesEXT, PhysicalDeviceMemoryProperties2> 9519 { 9520 enum 9521 { 9522 value = true 9523 }; 9524 }; 9525 9526 //=== VK_EXT_memory_priority === 9527 template <> 9528 struct StructExtends<PhysicalDeviceMemoryPriorityFeaturesEXT, PhysicalDeviceFeatures2> 9529 { 9530 enum 9531 { 9532 value = true 9533 }; 9534 }; 9535 template <> 9536 struct StructExtends<PhysicalDeviceMemoryPriorityFeaturesEXT, DeviceCreateInfo> 9537 { 9538 enum 9539 { 9540 value = true 9541 }; 9542 }; 9543 template <> 9544 struct StructExtends<MemoryPriorityAllocateInfoEXT, MemoryAllocateInfo> 9545 { 9546 enum 9547 { 9548 value = true 9549 }; 9550 }; 9551 9552 //=== VK_KHR_surface_protected_capabilities === 9553 template <> 9554 struct StructExtends<SurfaceProtectedCapabilitiesKHR, SurfaceCapabilities2KHR> 9555 { 9556 enum 9557 { 9558 value = true 9559 }; 9560 }; 9561 9562 //=== VK_NV_dedicated_allocation_image_aliasing === 9563 template <> 9564 struct StructExtends<PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, PhysicalDeviceFeatures2> 9565 { 9566 enum 9567 { 9568 value = true 9569 }; 9570 }; 9571 template <> 9572 struct StructExtends<PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, DeviceCreateInfo> 9573 { 9574 enum 9575 { 9576 value = true 9577 }; 9578 }; 9579 9580 //=== VK_EXT_buffer_device_address === 9581 template <> 9582 struct StructExtends<PhysicalDeviceBufferDeviceAddressFeaturesEXT, PhysicalDeviceFeatures2> 9583 { 9584 enum 9585 { 9586 value = true 9587 }; 9588 }; 9589 template <> 9590 struct StructExtends<PhysicalDeviceBufferDeviceAddressFeaturesEXT, DeviceCreateInfo> 9591 { 9592 enum 9593 { 9594 value = true 9595 }; 9596 }; 9597 template <> 9598 struct StructExtends<BufferDeviceAddressCreateInfoEXT, BufferCreateInfo> 9599 { 9600 enum 9601 { 9602 value = true 9603 }; 9604 }; 9605 9606 //=== VK_EXT_validation_features === 9607 template <> 9608 struct StructExtends<ValidationFeaturesEXT, InstanceCreateInfo> 9609 { 9610 enum 9611 { 9612 value = true 9613 }; 9614 }; 9615 9616 //=== VK_KHR_present_wait === 9617 template <> 9618 struct StructExtends<PhysicalDevicePresentWaitFeaturesKHR, PhysicalDeviceFeatures2> 9619 { 9620 enum 9621 { 9622 value = true 9623 }; 9624 }; 9625 template <> 9626 struct StructExtends<PhysicalDevicePresentWaitFeaturesKHR, DeviceCreateInfo> 9627 { 9628 enum 9629 { 9630 value = true 9631 }; 9632 }; 9633 9634 //=== VK_NV_cooperative_matrix === 9635 template <> 9636 struct StructExtends<PhysicalDeviceCooperativeMatrixFeaturesNV, PhysicalDeviceFeatures2> 9637 { 9638 enum 9639 { 9640 value = true 9641 }; 9642 }; 9643 template <> 9644 struct StructExtends<PhysicalDeviceCooperativeMatrixFeaturesNV, DeviceCreateInfo> 9645 { 9646 enum 9647 { 9648 value = true 9649 }; 9650 }; 9651 template <> 9652 struct StructExtends<PhysicalDeviceCooperativeMatrixPropertiesNV, PhysicalDeviceProperties2> 9653 { 9654 enum 9655 { 9656 value = true 9657 }; 9658 }; 9659 9660 //=== VK_NV_coverage_reduction_mode === 9661 template <> 9662 struct StructExtends<PhysicalDeviceCoverageReductionModeFeaturesNV, PhysicalDeviceFeatures2> 9663 { 9664 enum 9665 { 9666 value = true 9667 }; 9668 }; 9669 template <> 9670 struct StructExtends<PhysicalDeviceCoverageReductionModeFeaturesNV, DeviceCreateInfo> 9671 { 9672 enum 9673 { 9674 value = true 9675 }; 9676 }; 9677 template <> 9678 struct StructExtends<PipelineCoverageReductionStateCreateInfoNV, PipelineMultisampleStateCreateInfo> 9679 { 9680 enum 9681 { 9682 value = true 9683 }; 9684 }; 9685 9686 //=== VK_EXT_fragment_shader_interlock === 9687 template <> 9688 struct StructExtends<PhysicalDeviceFragmentShaderInterlockFeaturesEXT, PhysicalDeviceFeatures2> 9689 { 9690 enum 9691 { 9692 value = true 9693 }; 9694 }; 9695 template <> 9696 struct StructExtends<PhysicalDeviceFragmentShaderInterlockFeaturesEXT, DeviceCreateInfo> 9697 { 9698 enum 9699 { 9700 value = true 9701 }; 9702 }; 9703 9704 //=== VK_EXT_ycbcr_image_arrays === 9705 template <> 9706 struct StructExtends<PhysicalDeviceYcbcrImageArraysFeaturesEXT, PhysicalDeviceFeatures2> 9707 { 9708 enum 9709 { 9710 value = true 9711 }; 9712 }; 9713 template <> 9714 struct StructExtends<PhysicalDeviceYcbcrImageArraysFeaturesEXT, DeviceCreateInfo> 9715 { 9716 enum 9717 { 9718 value = true 9719 }; 9720 }; 9721 9722 //=== VK_EXT_provoking_vertex === 9723 template <> 9724 struct StructExtends<PhysicalDeviceProvokingVertexFeaturesEXT, PhysicalDeviceFeatures2> 9725 { 9726 enum 9727 { 9728 value = true 9729 }; 9730 }; 9731 template <> 9732 struct StructExtends<PhysicalDeviceProvokingVertexFeaturesEXT, DeviceCreateInfo> 9733 { 9734 enum 9735 { 9736 value = true 9737 }; 9738 }; 9739 template <> 9740 struct StructExtends<PhysicalDeviceProvokingVertexPropertiesEXT, PhysicalDeviceProperties2> 9741 { 9742 enum 9743 { 9744 value = true 9745 }; 9746 }; 9747 template <> 9748 struct StructExtends<PipelineRasterizationProvokingVertexStateCreateInfoEXT, PipelineRasterizationStateCreateInfo> 9749 { 9750 enum 9751 { 9752 value = true 9753 }; 9754 }; 9755 9756 #if defined( VK_USE_PLATFORM_WIN32_KHR ) 9757 //=== VK_EXT_full_screen_exclusive === 9758 template <> 9759 struct StructExtends<SurfaceFullScreenExclusiveInfoEXT, PhysicalDeviceSurfaceInfo2KHR> 9760 { 9761 enum 9762 { 9763 value = true 9764 }; 9765 }; 9766 template <> 9767 struct StructExtends<SurfaceFullScreenExclusiveInfoEXT, SwapchainCreateInfoKHR> 9768 { 9769 enum 9770 { 9771 value = true 9772 }; 9773 }; 9774 template <> 9775 struct StructExtends<SurfaceCapabilitiesFullScreenExclusiveEXT, SurfaceCapabilities2KHR> 9776 { 9777 enum 9778 { 9779 value = true 9780 }; 9781 }; 9782 template <> 9783 struct StructExtends<SurfaceFullScreenExclusiveWin32InfoEXT, PhysicalDeviceSurfaceInfo2KHR> 9784 { 9785 enum 9786 { 9787 value = true 9788 }; 9789 }; 9790 template <> 9791 struct StructExtends<SurfaceFullScreenExclusiveWin32InfoEXT, SwapchainCreateInfoKHR> 9792 { 9793 enum 9794 { 9795 value = true 9796 }; 9797 }; 9798 #endif /*VK_USE_PLATFORM_WIN32_KHR*/ 9799 9800 //=== VK_EXT_line_rasterization === 9801 template <> 9802 struct StructExtends<PhysicalDeviceLineRasterizationFeaturesEXT, PhysicalDeviceFeatures2> 9803 { 9804 enum 9805 { 9806 value = true 9807 }; 9808 }; 9809 template <> 9810 struct StructExtends<PhysicalDeviceLineRasterizationFeaturesEXT, DeviceCreateInfo> 9811 { 9812 enum 9813 { 9814 value = true 9815 }; 9816 }; 9817 template <> 9818 struct StructExtends<PhysicalDeviceLineRasterizationPropertiesEXT, PhysicalDeviceProperties2> 9819 { 9820 enum 9821 { 9822 value = true 9823 }; 9824 }; 9825 template <> 9826 struct StructExtends<PipelineRasterizationLineStateCreateInfoEXT, PipelineRasterizationStateCreateInfo> 9827 { 9828 enum 9829 { 9830 value = true 9831 }; 9832 }; 9833 9834 //=== VK_EXT_shader_atomic_float === 9835 template <> 9836 struct StructExtends<PhysicalDeviceShaderAtomicFloatFeaturesEXT, PhysicalDeviceFeatures2> 9837 { 9838 enum 9839 { 9840 value = true 9841 }; 9842 }; 9843 template <> 9844 struct StructExtends<PhysicalDeviceShaderAtomicFloatFeaturesEXT, DeviceCreateInfo> 9845 { 9846 enum 9847 { 9848 value = true 9849 }; 9850 }; 9851 9852 //=== VK_EXT_index_type_uint8 === 9853 template <> 9854 struct StructExtends<PhysicalDeviceIndexTypeUint8FeaturesEXT, PhysicalDeviceFeatures2> 9855 { 9856 enum 9857 { 9858 value = true 9859 }; 9860 }; 9861 template <> 9862 struct StructExtends<PhysicalDeviceIndexTypeUint8FeaturesEXT, DeviceCreateInfo> 9863 { 9864 enum 9865 { 9866 value = true 9867 }; 9868 }; 9869 9870 //=== VK_EXT_extended_dynamic_state === 9871 template <> 9872 struct StructExtends<PhysicalDeviceExtendedDynamicStateFeaturesEXT, PhysicalDeviceFeatures2> 9873 { 9874 enum 9875 { 9876 value = true 9877 }; 9878 }; 9879 template <> 9880 struct StructExtends<PhysicalDeviceExtendedDynamicStateFeaturesEXT, DeviceCreateInfo> 9881 { 9882 enum 9883 { 9884 value = true 9885 }; 9886 }; 9887 9888 //=== VK_KHR_pipeline_executable_properties === 9889 template <> 9890 struct StructExtends<PhysicalDevicePipelineExecutablePropertiesFeaturesKHR, PhysicalDeviceFeatures2> 9891 { 9892 enum 9893 { 9894 value = true 9895 }; 9896 }; 9897 template <> 9898 struct StructExtends<PhysicalDevicePipelineExecutablePropertiesFeaturesKHR, DeviceCreateInfo> 9899 { 9900 enum 9901 { 9902 value = true 9903 }; 9904 }; 9905 9906 //=== VK_EXT_shader_atomic_float2 === 9907 template <> 9908 struct StructExtends<PhysicalDeviceShaderAtomicFloat2FeaturesEXT, PhysicalDeviceFeatures2> 9909 { 9910 enum 9911 { 9912 value = true 9913 }; 9914 }; 9915 template <> 9916 struct StructExtends<PhysicalDeviceShaderAtomicFloat2FeaturesEXT, DeviceCreateInfo> 9917 { 9918 enum 9919 { 9920 value = true 9921 }; 9922 }; 9923 9924 //=== VK_EXT_shader_demote_to_helper_invocation === 9925 template <> 9926 struct StructExtends<PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT, PhysicalDeviceFeatures2> 9927 { 9928 enum 9929 { 9930 value = true 9931 }; 9932 }; 9933 template <> 9934 struct StructExtends<PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT, DeviceCreateInfo> 9935 { 9936 enum 9937 { 9938 value = true 9939 }; 9940 }; 9941 9942 //=== VK_NV_device_generated_commands === 9943 template <> 9944 struct StructExtends<PhysicalDeviceDeviceGeneratedCommandsPropertiesNV, PhysicalDeviceProperties2> 9945 { 9946 enum 9947 { 9948 value = true 9949 }; 9950 }; 9951 template <> 9952 struct StructExtends<PhysicalDeviceDeviceGeneratedCommandsFeaturesNV, PhysicalDeviceFeatures2> 9953 { 9954 enum 9955 { 9956 value = true 9957 }; 9958 }; 9959 template <> 9960 struct StructExtends<PhysicalDeviceDeviceGeneratedCommandsFeaturesNV, DeviceCreateInfo> 9961 { 9962 enum 9963 { 9964 value = true 9965 }; 9966 }; 9967 template <> 9968 struct StructExtends<GraphicsPipelineShaderGroupsCreateInfoNV, GraphicsPipelineCreateInfo> 9969 { 9970 enum 9971 { 9972 value = true 9973 }; 9974 }; 9975 9976 //=== VK_NV_inherited_viewport_scissor === 9977 template <> 9978 struct StructExtends<PhysicalDeviceInheritedViewportScissorFeaturesNV, PhysicalDeviceFeatures2> 9979 { 9980 enum 9981 { 9982 value = true 9983 }; 9984 }; 9985 template <> 9986 struct StructExtends<PhysicalDeviceInheritedViewportScissorFeaturesNV, DeviceCreateInfo> 9987 { 9988 enum 9989 { 9990 value = true 9991 }; 9992 }; 9993 template <> 9994 struct StructExtends<CommandBufferInheritanceViewportScissorInfoNV, CommandBufferInheritanceInfo> 9995 { 9996 enum 9997 { 9998 value = true 9999 }; 10000 }; 10001 10002 //=== VK_KHR_shader_integer_dot_product === 10003 template <> 10004 struct StructExtends<PhysicalDeviceShaderIntegerDotProductFeaturesKHR, PhysicalDeviceFeatures2> 10005 { 10006 enum 10007 { 10008 value = true 10009 }; 10010 }; 10011 template <> 10012 struct StructExtends<PhysicalDeviceShaderIntegerDotProductFeaturesKHR, DeviceCreateInfo> 10013 { 10014 enum 10015 { 10016 value = true 10017 }; 10018 }; 10019 template <> 10020 struct StructExtends<PhysicalDeviceShaderIntegerDotProductPropertiesKHR, PhysicalDeviceProperties2> 10021 { 10022 enum 10023 { 10024 value = true 10025 }; 10026 }; 10027 10028 //=== VK_EXT_texel_buffer_alignment === 10029 template <> 10030 struct StructExtends<PhysicalDeviceTexelBufferAlignmentFeaturesEXT, PhysicalDeviceFeatures2> 10031 { 10032 enum 10033 { 10034 value = true 10035 }; 10036 }; 10037 template <> 10038 struct StructExtends<PhysicalDeviceTexelBufferAlignmentFeaturesEXT, DeviceCreateInfo> 10039 { 10040 enum 10041 { 10042 value = true 10043 }; 10044 }; 10045 template <> 10046 struct StructExtends<PhysicalDeviceTexelBufferAlignmentPropertiesEXT, PhysicalDeviceProperties2> 10047 { 10048 enum 10049 { 10050 value = true 10051 }; 10052 }; 10053 10054 //=== VK_QCOM_render_pass_transform === 10055 template <> 10056 struct StructExtends<RenderPassTransformBeginInfoQCOM, RenderPassBeginInfo> 10057 { 10058 enum 10059 { 10060 value = true 10061 }; 10062 }; 10063 template <> 10064 struct StructExtends<CommandBufferInheritanceRenderPassTransformInfoQCOM, CommandBufferInheritanceInfo> 10065 { 10066 enum 10067 { 10068 value = true 10069 }; 10070 }; 10071 10072 //=== VK_EXT_device_memory_report === 10073 template <> 10074 struct StructExtends<PhysicalDeviceDeviceMemoryReportFeaturesEXT, PhysicalDeviceFeatures2> 10075 { 10076 enum 10077 { 10078 value = true 10079 }; 10080 }; 10081 template <> 10082 struct StructExtends<PhysicalDeviceDeviceMemoryReportFeaturesEXT, DeviceCreateInfo> 10083 { 10084 enum 10085 { 10086 value = true 10087 }; 10088 }; 10089 template <> 10090 struct StructExtends<DeviceDeviceMemoryReportCreateInfoEXT, DeviceCreateInfo> 10091 { 10092 enum 10093 { 10094 value = true 10095 }; 10096 }; 10097 10098 //=== VK_EXT_robustness2 === 10099 template <> 10100 struct StructExtends<PhysicalDeviceRobustness2FeaturesEXT, PhysicalDeviceFeatures2> 10101 { 10102 enum 10103 { 10104 value = true 10105 }; 10106 }; 10107 template <> 10108 struct StructExtends<PhysicalDeviceRobustness2FeaturesEXT, DeviceCreateInfo> 10109 { 10110 enum 10111 { 10112 value = true 10113 }; 10114 }; 10115 template <> 10116 struct StructExtends<PhysicalDeviceRobustness2PropertiesEXT, PhysicalDeviceProperties2> 10117 { 10118 enum 10119 { 10120 value = true 10121 }; 10122 }; 10123 10124 //=== VK_EXT_custom_border_color === 10125 template <> 10126 struct StructExtends<SamplerCustomBorderColorCreateInfoEXT, SamplerCreateInfo> 10127 { 10128 enum 10129 { 10130 value = true 10131 }; 10132 }; 10133 template <> 10134 struct StructExtends<PhysicalDeviceCustomBorderColorPropertiesEXT, PhysicalDeviceProperties2> 10135 { 10136 enum 10137 { 10138 value = true 10139 }; 10140 }; 10141 template <> 10142 struct StructExtends<PhysicalDeviceCustomBorderColorFeaturesEXT, PhysicalDeviceFeatures2> 10143 { 10144 enum 10145 { 10146 value = true 10147 }; 10148 }; 10149 template <> 10150 struct StructExtends<PhysicalDeviceCustomBorderColorFeaturesEXT, DeviceCreateInfo> 10151 { 10152 enum 10153 { 10154 value = true 10155 }; 10156 }; 10157 10158 //=== VK_KHR_present_id === 10159 template <> 10160 struct StructExtends<PresentIdKHR, PresentInfoKHR> 10161 { 10162 enum 10163 { 10164 value = true 10165 }; 10166 }; 10167 template <> 10168 struct StructExtends<PhysicalDevicePresentIdFeaturesKHR, PhysicalDeviceFeatures2> 10169 { 10170 enum 10171 { 10172 value = true 10173 }; 10174 }; 10175 template <> 10176 struct StructExtends<PhysicalDevicePresentIdFeaturesKHR, DeviceCreateInfo> 10177 { 10178 enum 10179 { 10180 value = true 10181 }; 10182 }; 10183 10184 //=== VK_EXT_private_data === 10185 template <> 10186 struct StructExtends<PhysicalDevicePrivateDataFeaturesEXT, PhysicalDeviceFeatures2> 10187 { 10188 enum 10189 { 10190 value = true 10191 }; 10192 }; 10193 template <> 10194 struct StructExtends<PhysicalDevicePrivateDataFeaturesEXT, DeviceCreateInfo> 10195 { 10196 enum 10197 { 10198 value = true 10199 }; 10200 }; 10201 template <> 10202 struct StructExtends<DevicePrivateDataCreateInfoEXT, DeviceCreateInfo> 10203 { 10204 enum 10205 { 10206 value = true 10207 }; 10208 }; 10209 10210 //=== VK_EXT_pipeline_creation_cache_control === 10211 template <> 10212 struct StructExtends<PhysicalDevicePipelineCreationCacheControlFeaturesEXT, PhysicalDeviceFeatures2> 10213 { 10214 enum 10215 { 10216 value = true 10217 }; 10218 }; 10219 template <> 10220 struct StructExtends<PhysicalDevicePipelineCreationCacheControlFeaturesEXT, DeviceCreateInfo> 10221 { 10222 enum 10223 { 10224 value = true 10225 }; 10226 }; 10227 10228 #if defined( VK_ENABLE_BETA_EXTENSIONS ) 10229 //=== VK_KHR_video_encode_queue === 10230 template <> 10231 struct StructExtends<VideoEncodeRateControlInfoKHR, VideoCodingControlInfoKHR> 10232 { 10233 enum 10234 { 10235 value = true 10236 }; 10237 }; 10238 template <> 10239 struct StructExtends<VideoEncodeRateControlLayerInfoKHR, VideoCodingControlInfoKHR> 10240 { 10241 enum 10242 { 10243 value = true 10244 }; 10245 }; 10246 #endif /*VK_ENABLE_BETA_EXTENSIONS*/ 10247 10248 //=== VK_NV_device_diagnostics_config === 10249 template <> 10250 struct StructExtends<PhysicalDeviceDiagnosticsConfigFeaturesNV, PhysicalDeviceFeatures2> 10251 { 10252 enum 10253 { 10254 value = true 10255 }; 10256 }; 10257 template <> 10258 struct StructExtends<PhysicalDeviceDiagnosticsConfigFeaturesNV, DeviceCreateInfo> 10259 { 10260 enum 10261 { 10262 value = true 10263 }; 10264 }; 10265 template <> 10266 struct StructExtends<DeviceDiagnosticsConfigCreateInfoNV, DeviceCreateInfo> 10267 { 10268 enum 10269 { 10270 value = true 10271 }; 10272 }; 10273 10274 //=== VK_KHR_synchronization2 === 10275 template <> 10276 struct StructExtends<MemoryBarrier2KHR, SubpassDependency2> 10277 { 10278 enum 10279 { 10280 value = true 10281 }; 10282 }; 10283 template <> 10284 struct StructExtends<PhysicalDeviceSynchronization2FeaturesKHR, PhysicalDeviceFeatures2> 10285 { 10286 enum 10287 { 10288 value = true 10289 }; 10290 }; 10291 template <> 10292 struct StructExtends<PhysicalDeviceSynchronization2FeaturesKHR, DeviceCreateInfo> 10293 { 10294 enum 10295 { 10296 value = true 10297 }; 10298 }; 10299 template <> 10300 struct StructExtends<QueueFamilyCheckpointProperties2NV, QueueFamilyProperties2> 10301 { 10302 enum 10303 { 10304 value = true 10305 }; 10306 }; 10307 10308 //=== VK_KHR_shader_subgroup_uniform_control_flow === 10309 template <> 10310 struct StructExtends<PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR, PhysicalDeviceFeatures2> 10311 { 10312 enum 10313 { 10314 value = true 10315 }; 10316 }; 10317 template <> 10318 struct StructExtends<PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR, DeviceCreateInfo> 10319 { 10320 enum 10321 { 10322 value = true 10323 }; 10324 }; 10325 10326 //=== VK_KHR_zero_initialize_workgroup_memory === 10327 template <> 10328 struct StructExtends<PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR, PhysicalDeviceFeatures2> 10329 { 10330 enum 10331 { 10332 value = true 10333 }; 10334 }; 10335 template <> 10336 struct StructExtends<PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR, DeviceCreateInfo> 10337 { 10338 enum 10339 { 10340 value = true 10341 }; 10342 }; 10343 10344 //=== VK_NV_fragment_shading_rate_enums === 10345 template <> 10346 struct StructExtends<PhysicalDeviceFragmentShadingRateEnumsFeaturesNV, PhysicalDeviceFeatures2> 10347 { 10348 enum 10349 { 10350 value = true 10351 }; 10352 }; 10353 template <> 10354 struct StructExtends<PhysicalDeviceFragmentShadingRateEnumsFeaturesNV, DeviceCreateInfo> 10355 { 10356 enum 10357 { 10358 value = true 10359 }; 10360 }; 10361 template <> 10362 struct StructExtends<PhysicalDeviceFragmentShadingRateEnumsPropertiesNV, PhysicalDeviceProperties2> 10363 { 10364 enum 10365 { 10366 value = true 10367 }; 10368 }; 10369 template <> 10370 struct StructExtends<PipelineFragmentShadingRateEnumStateCreateInfoNV, GraphicsPipelineCreateInfo> 10371 { 10372 enum 10373 { 10374 value = true 10375 }; 10376 }; 10377 10378 //=== VK_NV_ray_tracing_motion_blur === 10379 template <> 10380 struct StructExtends<AccelerationStructureGeometryMotionTrianglesDataNV, 10381 AccelerationStructureGeometryTrianglesDataKHR> 10382 { 10383 enum 10384 { 10385 value = true 10386 }; 10387 }; 10388 template <> 10389 struct StructExtends<AccelerationStructureMotionInfoNV, AccelerationStructureCreateInfoKHR> 10390 { 10391 enum 10392 { 10393 value = true 10394 }; 10395 }; 10396 template <> 10397 struct StructExtends<PhysicalDeviceRayTracingMotionBlurFeaturesNV, PhysicalDeviceFeatures2> 10398 { 10399 enum 10400 { 10401 value = true 10402 }; 10403 }; 10404 template <> 10405 struct StructExtends<PhysicalDeviceRayTracingMotionBlurFeaturesNV, DeviceCreateInfo> 10406 { 10407 enum 10408 { 10409 value = true 10410 }; 10411 }; 10412 10413 //=== VK_EXT_ycbcr_2plane_444_formats === 10414 template <> 10415 struct StructExtends<PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT, PhysicalDeviceFeatures2> 10416 { 10417 enum 10418 { 10419 value = true 10420 }; 10421 }; 10422 template <> 10423 struct StructExtends<PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT, DeviceCreateInfo> 10424 { 10425 enum 10426 { 10427 value = true 10428 }; 10429 }; 10430 10431 //=== VK_EXT_fragment_density_map2 === 10432 template <> 10433 struct StructExtends<PhysicalDeviceFragmentDensityMap2FeaturesEXT, PhysicalDeviceFeatures2> 10434 { 10435 enum 10436 { 10437 value = true 10438 }; 10439 }; 10440 template <> 10441 struct StructExtends<PhysicalDeviceFragmentDensityMap2FeaturesEXT, DeviceCreateInfo> 10442 { 10443 enum 10444 { 10445 value = true 10446 }; 10447 }; 10448 template <> 10449 struct StructExtends<PhysicalDeviceFragmentDensityMap2PropertiesEXT, PhysicalDeviceProperties2> 10450 { 10451 enum 10452 { 10453 value = true 10454 }; 10455 }; 10456 10457 //=== VK_QCOM_rotated_copy_commands === 10458 template <> 10459 struct StructExtends<CopyCommandTransformInfoQCOM, BufferImageCopy2KHR> 10460 { 10461 enum 10462 { 10463 value = true 10464 }; 10465 }; 10466 template <> 10467 struct StructExtends<CopyCommandTransformInfoQCOM, ImageBlit2KHR> 10468 { 10469 enum 10470 { 10471 value = true 10472 }; 10473 }; 10474 10475 //=== VK_EXT_image_robustness === 10476 template <> 10477 struct StructExtends<PhysicalDeviceImageRobustnessFeaturesEXT, PhysicalDeviceFeatures2> 10478 { 10479 enum 10480 { 10481 value = true 10482 }; 10483 }; 10484 template <> 10485 struct StructExtends<PhysicalDeviceImageRobustnessFeaturesEXT, DeviceCreateInfo> 10486 { 10487 enum 10488 { 10489 value = true 10490 }; 10491 }; 10492 10493 //=== VK_KHR_workgroup_memory_explicit_layout === 10494 template <> 10495 struct StructExtends<PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR, PhysicalDeviceFeatures2> 10496 { 10497 enum 10498 { 10499 value = true 10500 }; 10501 }; 10502 template <> 10503 struct StructExtends<PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR, DeviceCreateInfo> 10504 { 10505 enum 10506 { 10507 value = true 10508 }; 10509 }; 10510 10511 //=== VK_EXT_4444_formats === 10512 template <> 10513 struct StructExtends<PhysicalDevice4444FormatsFeaturesEXT, PhysicalDeviceFeatures2> 10514 { 10515 enum 10516 { 10517 value = true 10518 }; 10519 }; 10520 template <> 10521 struct StructExtends<PhysicalDevice4444FormatsFeaturesEXT, DeviceCreateInfo> 10522 { 10523 enum 10524 { 10525 value = true 10526 }; 10527 }; 10528 10529 //=== VK_ARM_rasterization_order_attachment_access === 10530 template <> 10531 struct StructExtends<PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM, PhysicalDeviceFeatures2> 10532 { 10533 enum 10534 { 10535 value = true 10536 }; 10537 }; 10538 template <> 10539 struct StructExtends<PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM, DeviceCreateInfo> 10540 { 10541 enum 10542 { 10543 value = true 10544 }; 10545 }; 10546 10547 //=== VK_EXT_rgba10x6_formats === 10548 template <> 10549 struct StructExtends<PhysicalDeviceRGBA10X6FormatsFeaturesEXT, PhysicalDeviceFeatures2> 10550 { 10551 enum 10552 { 10553 value = true 10554 }; 10555 }; 10556 template <> 10557 struct StructExtends<PhysicalDeviceRGBA10X6FormatsFeaturesEXT, DeviceCreateInfo> 10558 { 10559 enum 10560 { 10561 value = true 10562 }; 10563 }; 10564 10565 //=== VK_KHR_ray_tracing_pipeline === 10566 template <> 10567 struct StructExtends<PhysicalDeviceRayTracingPipelineFeaturesKHR, PhysicalDeviceFeatures2> 10568 { 10569 enum 10570 { 10571 value = true 10572 }; 10573 }; 10574 template <> 10575 struct StructExtends<PhysicalDeviceRayTracingPipelineFeaturesKHR, DeviceCreateInfo> 10576 { 10577 enum 10578 { 10579 value = true 10580 }; 10581 }; 10582 template <> 10583 struct StructExtends<PhysicalDeviceRayTracingPipelinePropertiesKHR, PhysicalDeviceProperties2> 10584 { 10585 enum 10586 { 10587 value = true 10588 }; 10589 }; 10590 10591 //=== VK_KHR_ray_query === 10592 template <> 10593 struct StructExtends<PhysicalDeviceRayQueryFeaturesKHR, PhysicalDeviceFeatures2> 10594 { 10595 enum 10596 { 10597 value = true 10598 }; 10599 }; 10600 template <> 10601 struct StructExtends<PhysicalDeviceRayQueryFeaturesKHR, DeviceCreateInfo> 10602 { 10603 enum 10604 { 10605 value = true 10606 }; 10607 }; 10608 10609 //=== VK_VALVE_mutable_descriptor_type === 10610 template <> 10611 struct StructExtends<PhysicalDeviceMutableDescriptorTypeFeaturesVALVE, PhysicalDeviceFeatures2> 10612 { 10613 enum 10614 { 10615 value = true 10616 }; 10617 }; 10618 template <> 10619 struct StructExtends<PhysicalDeviceMutableDescriptorTypeFeaturesVALVE, DeviceCreateInfo> 10620 { 10621 enum 10622 { 10623 value = true 10624 }; 10625 }; 10626 template <> 10627 struct StructExtends<MutableDescriptorTypeCreateInfoVALVE, DescriptorSetLayoutCreateInfo> 10628 { 10629 enum 10630 { 10631 value = true 10632 }; 10633 }; 10634 template <> 10635 struct StructExtends<MutableDescriptorTypeCreateInfoVALVE, DescriptorPoolCreateInfo> 10636 { 10637 enum 10638 { 10639 value = true 10640 }; 10641 }; 10642 10643 //=== VK_EXT_vertex_input_dynamic_state === 10644 template <> 10645 struct StructExtends<PhysicalDeviceVertexInputDynamicStateFeaturesEXT, PhysicalDeviceFeatures2> 10646 { 10647 enum 10648 { 10649 value = true 10650 }; 10651 }; 10652 template <> 10653 struct StructExtends<PhysicalDeviceVertexInputDynamicStateFeaturesEXT, DeviceCreateInfo> 10654 { 10655 enum 10656 { 10657 value = true 10658 }; 10659 }; 10660 10661 //=== VK_EXT_physical_device_drm === 10662 template <> 10663 struct StructExtends<PhysicalDeviceDrmPropertiesEXT, PhysicalDeviceProperties2> 10664 { 10665 enum 10666 { 10667 value = true 10668 }; 10669 }; 10670 10671 //=== VK_EXT_depth_clip_control === 10672 template <> 10673 struct StructExtends<PhysicalDeviceDepthClipControlFeaturesEXT, PhysicalDeviceFeatures2> 10674 { 10675 enum 10676 { 10677 value = true 10678 }; 10679 }; 10680 template <> 10681 struct StructExtends<PhysicalDeviceDepthClipControlFeaturesEXT, DeviceCreateInfo> 10682 { 10683 enum 10684 { 10685 value = true 10686 }; 10687 }; 10688 template <> 10689 struct StructExtends<PipelineViewportDepthClipControlCreateInfoEXT, PipelineViewportStateCreateInfo> 10690 { 10691 enum 10692 { 10693 value = true 10694 }; 10695 }; 10696 10697 //=== VK_EXT_primitive_topology_list_restart === 10698 template <> 10699 struct StructExtends<PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT, PhysicalDeviceFeatures2> 10700 { 10701 enum 10702 { 10703 value = true 10704 }; 10705 }; 10706 template <> 10707 struct StructExtends<PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT, DeviceCreateInfo> 10708 { 10709 enum 10710 { 10711 value = true 10712 }; 10713 }; 10714 10715 //=== VK_KHR_format_feature_flags2 === 10716 template <> 10717 struct StructExtends<FormatProperties3KHR, FormatProperties2> 10718 { 10719 enum 10720 { 10721 value = true 10722 }; 10723 }; 10724 10725 #if defined( VK_USE_PLATFORM_FUCHSIA ) 10726 //=== VK_FUCHSIA_external_memory === 10727 template <> 10728 struct StructExtends<ImportMemoryZirconHandleInfoFUCHSIA, MemoryAllocateInfo> 10729 { 10730 enum 10731 { 10732 value = true 10733 }; 10734 }; 10735 #endif /*VK_USE_PLATFORM_FUCHSIA*/ 10736 10737 #if defined( VK_USE_PLATFORM_FUCHSIA ) 10738 //=== VK_FUCHSIA_buffer_collection === 10739 template <> 10740 struct StructExtends<ImportMemoryBufferCollectionFUCHSIA, MemoryAllocateInfo> 10741 { 10742 enum 10743 { 10744 value = true 10745 }; 10746 }; 10747 template <> 10748 struct StructExtends<BufferCollectionImageCreateInfoFUCHSIA, ImageCreateInfo> 10749 { 10750 enum 10751 { 10752 value = true 10753 }; 10754 }; 10755 template <> 10756 struct StructExtends<BufferCollectionBufferCreateInfoFUCHSIA, BufferCreateInfo> 10757 { 10758 enum 10759 { 10760 value = true 10761 }; 10762 }; 10763 #endif /*VK_USE_PLATFORM_FUCHSIA*/ 10764 10765 //=== VK_HUAWEI_subpass_shading === 10766 template <> 10767 struct StructExtends<SubpassShadingPipelineCreateInfoHUAWEI, ComputePipelineCreateInfo> 10768 { 10769 enum 10770 { 10771 value = true 10772 }; 10773 }; 10774 template <> 10775 struct StructExtends<PhysicalDeviceSubpassShadingFeaturesHUAWEI, PhysicalDeviceFeatures2> 10776 { 10777 enum 10778 { 10779 value = true 10780 }; 10781 }; 10782 template <> 10783 struct StructExtends<PhysicalDeviceSubpassShadingFeaturesHUAWEI, DeviceCreateInfo> 10784 { 10785 enum 10786 { 10787 value = true 10788 }; 10789 }; 10790 template <> 10791 struct StructExtends<PhysicalDeviceSubpassShadingPropertiesHUAWEI, PhysicalDeviceProperties2> 10792 { 10793 enum 10794 { 10795 value = true 10796 }; 10797 }; 10798 10799 //=== VK_HUAWEI_invocation_mask === 10800 template <> 10801 struct StructExtends<PhysicalDeviceInvocationMaskFeaturesHUAWEI, PhysicalDeviceFeatures2> 10802 { 10803 enum 10804 { 10805 value = true 10806 }; 10807 }; 10808 template <> 10809 struct StructExtends<PhysicalDeviceInvocationMaskFeaturesHUAWEI, DeviceCreateInfo> 10810 { 10811 enum 10812 { 10813 value = true 10814 }; 10815 }; 10816 10817 //=== VK_NV_external_memory_rdma === 10818 template <> 10819 struct StructExtends<PhysicalDeviceExternalMemoryRDMAFeaturesNV, PhysicalDeviceFeatures2> 10820 { 10821 enum 10822 { 10823 value = true 10824 }; 10825 }; 10826 template <> 10827 struct StructExtends<PhysicalDeviceExternalMemoryRDMAFeaturesNV, DeviceCreateInfo> 10828 { 10829 enum 10830 { 10831 value = true 10832 }; 10833 }; 10834 10835 //=== VK_EXT_extended_dynamic_state2 === 10836 template <> 10837 struct StructExtends<PhysicalDeviceExtendedDynamicState2FeaturesEXT, PhysicalDeviceFeatures2> 10838 { 10839 enum 10840 { 10841 value = true 10842 }; 10843 }; 10844 template <> 10845 struct StructExtends<PhysicalDeviceExtendedDynamicState2FeaturesEXT, DeviceCreateInfo> 10846 { 10847 enum 10848 { 10849 value = true 10850 }; 10851 }; 10852 10853 //=== VK_EXT_color_write_enable === 10854 template <> 10855 struct StructExtends<PhysicalDeviceColorWriteEnableFeaturesEXT, PhysicalDeviceFeatures2> 10856 { 10857 enum 10858 { 10859 value = true 10860 }; 10861 }; 10862 template <> 10863 struct StructExtends<PhysicalDeviceColorWriteEnableFeaturesEXT, DeviceCreateInfo> 10864 { 10865 enum 10866 { 10867 value = true 10868 }; 10869 }; 10870 template <> 10871 struct StructExtends<PipelineColorWriteCreateInfoEXT, PipelineColorBlendStateCreateInfo> 10872 { 10873 enum 10874 { 10875 value = true 10876 }; 10877 }; 10878 10879 //=== VK_EXT_global_priority_query === 10880 template <> 10881 struct StructExtends<PhysicalDeviceGlobalPriorityQueryFeaturesEXT, PhysicalDeviceFeatures2> 10882 { 10883 enum 10884 { 10885 value = true 10886 }; 10887 }; 10888 template <> 10889 struct StructExtends<PhysicalDeviceGlobalPriorityQueryFeaturesEXT, DeviceCreateInfo> 10890 { 10891 enum 10892 { 10893 value = true 10894 }; 10895 }; 10896 template <> 10897 struct StructExtends<QueueFamilyGlobalPriorityPropertiesEXT, QueueFamilyProperties2> 10898 { 10899 enum 10900 { 10901 value = true 10902 }; 10903 }; 10904 10905 //=== VK_EXT_image_view_min_lod === 10906 template <> 10907 struct StructExtends<PhysicalDeviceImageViewMinLodFeaturesEXT, PhysicalDeviceFeatures2> 10908 { 10909 enum 10910 { 10911 value = true 10912 }; 10913 }; 10914 template <> 10915 struct StructExtends<PhysicalDeviceImageViewMinLodFeaturesEXT, DeviceCreateInfo> 10916 { 10917 enum 10918 { 10919 value = true 10920 }; 10921 }; 10922 template <> 10923 struct StructExtends<ImageViewMinLodCreateInfoEXT, ImageViewCreateInfo> 10924 { 10925 enum 10926 { 10927 value = true 10928 }; 10929 }; 10930 10931 //=== VK_EXT_multi_draw === 10932 template <> 10933 struct StructExtends<PhysicalDeviceMultiDrawFeaturesEXT, PhysicalDeviceFeatures2> 10934 { 10935 enum 10936 { 10937 value = true 10938 }; 10939 }; 10940 template <> 10941 struct StructExtends<PhysicalDeviceMultiDrawFeaturesEXT, DeviceCreateInfo> 10942 { 10943 enum 10944 { 10945 value = true 10946 }; 10947 }; 10948 template <> 10949 struct StructExtends<PhysicalDeviceMultiDrawPropertiesEXT, PhysicalDeviceProperties2> 10950 { 10951 enum 10952 { 10953 value = true 10954 }; 10955 }; 10956 10957 //=== VK_EXT_border_color_swizzle === 10958 template <> 10959 struct StructExtends<PhysicalDeviceBorderColorSwizzleFeaturesEXT, PhysicalDeviceFeatures2> 10960 { 10961 enum 10962 { 10963 value = true 10964 }; 10965 }; 10966 template <> 10967 struct StructExtends<PhysicalDeviceBorderColorSwizzleFeaturesEXT, DeviceCreateInfo> 10968 { 10969 enum 10970 { 10971 value = true 10972 }; 10973 }; 10974 template <> 10975 struct StructExtends<SamplerBorderColorComponentMappingCreateInfoEXT, SamplerCreateInfo> 10976 { 10977 enum 10978 { 10979 value = true 10980 }; 10981 }; 10982 10983 //=== VK_EXT_pageable_device_local_memory === 10984 template <> 10985 struct StructExtends<PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT, PhysicalDeviceFeatures2> 10986 { 10987 enum 10988 { 10989 value = true 10990 }; 10991 }; 10992 template <> 10993 struct StructExtends<PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT, DeviceCreateInfo> 10994 { 10995 enum 10996 { 10997 value = true 10998 }; 10999 }; 11000 11001 //=== VK_KHR_maintenance4 === 11002 template <> 11003 struct StructExtends<PhysicalDeviceMaintenance4FeaturesKHR, PhysicalDeviceFeatures2> 11004 { 11005 enum 11006 { 11007 value = true 11008 }; 11009 }; 11010 template <> 11011 struct StructExtends<PhysicalDeviceMaintenance4FeaturesKHR, DeviceCreateInfo> 11012 { 11013 enum 11014 { 11015 value = true 11016 }; 11017 }; 11018 template <> 11019 struct StructExtends<PhysicalDeviceMaintenance4PropertiesKHR, PhysicalDeviceProperties2> 11020 { 11021 enum 11022 { 11023 value = true 11024 }; 11025 }; 11026 11027 #if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL 11028 class DynamicLoader 11029 { 11030 public: 11031 # ifdef VULKAN_HPP_NO_EXCEPTIONS DynamicLoader(std::string const & vulkanLibraryName={} )11032 DynamicLoader( std::string const & vulkanLibraryName = {} ) VULKAN_HPP_NOEXCEPT 11033 # else 11034 DynamicLoader( std::string const & vulkanLibraryName = {} ) 11035 # endif 11036 { 11037 if ( !vulkanLibraryName.empty() ) 11038 { 11039 # if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNXNTO__ ) || defined( __Fuchsia__ ) 11040 m_library = dlopen( vulkanLibraryName.c_str(), RTLD_NOW | RTLD_LOCAL ); 11041 # elif defined( _WIN32 ) 11042 m_library = ::LoadLibraryA( vulkanLibraryName.c_str() ); 11043 # else 11044 # error unsupported platform 11045 # endif 11046 } 11047 else 11048 { 11049 # if defined( __unix__ ) || defined( __QNXNTO__ ) || defined( __Fuchsia__ ) 11050 m_library = dlopen( "libvulkan.so", RTLD_NOW | RTLD_LOCAL ); 11051 if ( m_library == nullptr ) 11052 { 11053 m_library = dlopen( "libvulkan.so.1", RTLD_NOW | RTLD_LOCAL ); 11054 } 11055 # elif defined( __APPLE__ ) 11056 m_library = dlopen( "libvulkan.dylib", RTLD_NOW | RTLD_LOCAL ); 11057 # elif defined( _WIN32 ) 11058 m_library = ::LoadLibraryA( "vulkan-1.dll" ); 11059 # else 11060 # error unsupported platform 11061 # endif 11062 } 11063 11064 # ifndef VULKAN_HPP_NO_EXCEPTIONS 11065 if ( m_library == nullptr ) 11066 { 11067 // NOTE there should be an InitializationFailedError, but msvc insists on the symbol does not exist within the 11068 // scope of this function. 11069 throw std::runtime_error( "Failed to load vulkan library!" ); 11070 } 11071 # endif 11072 } 11073 11074 DynamicLoader( DynamicLoader const & ) = delete; 11075 DynamicLoader(DynamicLoader && other)11076 DynamicLoader( DynamicLoader && other ) VULKAN_HPP_NOEXCEPT : m_library( other.m_library ) 11077 { 11078 other.m_library = nullptr; 11079 } 11080 11081 DynamicLoader & operator=( DynamicLoader const & ) = delete; 11082 operator =(DynamicLoader && other)11083 DynamicLoader & operator=( DynamicLoader && other ) VULKAN_HPP_NOEXCEPT 11084 { 11085 std::swap( m_library, other.m_library ); 11086 return *this; 11087 } 11088 ~DynamicLoader()11089 ~DynamicLoader() VULKAN_HPP_NOEXCEPT 11090 { 11091 if ( m_library ) 11092 { 11093 # if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNXNTO__ ) || defined( __Fuchsia__ ) 11094 dlclose( m_library ); 11095 # elif defined( _WIN32 ) 11096 ::FreeLibrary( m_library ); 11097 # else 11098 # error unsupported platform 11099 # endif 11100 } 11101 } 11102 11103 template <typename T> getProcAddress(const char * function) const11104 T getProcAddress( const char * function ) const VULKAN_HPP_NOEXCEPT 11105 { 11106 # if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNXNTO__ ) || defined( __Fuchsia__ ) 11107 return (T)dlsym( m_library, function ); 11108 # elif defined( _WIN32 ) 11109 return ( T )::GetProcAddress( m_library, function ); 11110 # else 11111 # error unsupported platform 11112 # endif 11113 } 11114 success() const11115 bool success() const VULKAN_HPP_NOEXCEPT 11116 { 11117 return m_library != nullptr; 11118 } 11119 11120 private: 11121 # if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNXNTO__ ) || defined( __Fuchsia__ ) 11122 void * m_library; 11123 # elif defined( _WIN32 ) 11124 ::HINSTANCE m_library; 11125 # else 11126 # error unsupported platform 11127 # endif 11128 }; 11129 #endif 11130 11131 using PFN_dummy = void ( * )(); 11132 11133 class DispatchLoaderDynamic : public DispatchLoaderBase 11134 { 11135 public: 11136 //=== VK_VERSION_1_0 === 11137 PFN_vkCreateInstance vkCreateInstance = 0; 11138 PFN_vkDestroyInstance vkDestroyInstance = 0; 11139 PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices = 0; 11140 PFN_vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures = 0; 11141 PFN_vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties = 0; 11142 PFN_vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceImageFormatProperties = 0; 11143 PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties = 0; 11144 PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties = 0; 11145 PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties = 0; 11146 PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = 0; 11147 PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr = 0; 11148 PFN_vkCreateDevice vkCreateDevice = 0; 11149 PFN_vkDestroyDevice vkDestroyDevice = 0; 11150 PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties = 0; 11151 PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties = 0; 11152 PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties = 0; 11153 PFN_vkEnumerateDeviceLayerProperties vkEnumerateDeviceLayerProperties = 0; 11154 PFN_vkGetDeviceQueue vkGetDeviceQueue = 0; 11155 PFN_vkQueueSubmit vkQueueSubmit = 0; 11156 PFN_vkQueueWaitIdle vkQueueWaitIdle = 0; 11157 PFN_vkDeviceWaitIdle vkDeviceWaitIdle = 0; 11158 PFN_vkAllocateMemory vkAllocateMemory = 0; 11159 PFN_vkFreeMemory vkFreeMemory = 0; 11160 PFN_vkMapMemory vkMapMemory = 0; 11161 PFN_vkUnmapMemory vkUnmapMemory = 0; 11162 PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges = 0; 11163 PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges = 0; 11164 PFN_vkGetDeviceMemoryCommitment vkGetDeviceMemoryCommitment = 0; 11165 PFN_vkBindBufferMemory vkBindBufferMemory = 0; 11166 PFN_vkBindImageMemory vkBindImageMemory = 0; 11167 PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements = 0; 11168 PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements = 0; 11169 PFN_vkGetImageSparseMemoryRequirements vkGetImageSparseMemoryRequirements = 0; 11170 PFN_vkGetPhysicalDeviceSparseImageFormatProperties vkGetPhysicalDeviceSparseImageFormatProperties = 0; 11171 PFN_vkQueueBindSparse vkQueueBindSparse = 0; 11172 PFN_vkCreateFence vkCreateFence = 0; 11173 PFN_vkDestroyFence vkDestroyFence = 0; 11174 PFN_vkResetFences vkResetFences = 0; 11175 PFN_vkGetFenceStatus vkGetFenceStatus = 0; 11176 PFN_vkWaitForFences vkWaitForFences = 0; 11177 PFN_vkCreateSemaphore vkCreateSemaphore = 0; 11178 PFN_vkDestroySemaphore vkDestroySemaphore = 0; 11179 PFN_vkCreateEvent vkCreateEvent = 0; 11180 PFN_vkDestroyEvent vkDestroyEvent = 0; 11181 PFN_vkGetEventStatus vkGetEventStatus = 0; 11182 PFN_vkSetEvent vkSetEvent = 0; 11183 PFN_vkResetEvent vkResetEvent = 0; 11184 PFN_vkCreateQueryPool vkCreateQueryPool = 0; 11185 PFN_vkDestroyQueryPool vkDestroyQueryPool = 0; 11186 PFN_vkGetQueryPoolResults vkGetQueryPoolResults = 0; 11187 PFN_vkCreateBuffer vkCreateBuffer = 0; 11188 PFN_vkDestroyBuffer vkDestroyBuffer = 0; 11189 PFN_vkCreateBufferView vkCreateBufferView = 0; 11190 PFN_vkDestroyBufferView vkDestroyBufferView = 0; 11191 PFN_vkCreateImage vkCreateImage = 0; 11192 PFN_vkDestroyImage vkDestroyImage = 0; 11193 PFN_vkGetImageSubresourceLayout vkGetImageSubresourceLayout = 0; 11194 PFN_vkCreateImageView vkCreateImageView = 0; 11195 PFN_vkDestroyImageView vkDestroyImageView = 0; 11196 PFN_vkCreateShaderModule vkCreateShaderModule = 0; 11197 PFN_vkDestroyShaderModule vkDestroyShaderModule = 0; 11198 PFN_vkCreatePipelineCache vkCreatePipelineCache = 0; 11199 PFN_vkDestroyPipelineCache vkDestroyPipelineCache = 0; 11200 PFN_vkGetPipelineCacheData vkGetPipelineCacheData = 0; 11201 PFN_vkMergePipelineCaches vkMergePipelineCaches = 0; 11202 PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines = 0; 11203 PFN_vkCreateComputePipelines vkCreateComputePipelines = 0; 11204 PFN_vkDestroyPipeline vkDestroyPipeline = 0; 11205 PFN_vkCreatePipelineLayout vkCreatePipelineLayout = 0; 11206 PFN_vkDestroyPipelineLayout vkDestroyPipelineLayout = 0; 11207 PFN_vkCreateSampler vkCreateSampler = 0; 11208 PFN_vkDestroySampler vkDestroySampler = 0; 11209 PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout = 0; 11210 PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout = 0; 11211 PFN_vkCreateDescriptorPool vkCreateDescriptorPool = 0; 11212 PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool = 0; 11213 PFN_vkResetDescriptorPool vkResetDescriptorPool = 0; 11214 PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets = 0; 11215 PFN_vkFreeDescriptorSets vkFreeDescriptorSets = 0; 11216 PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets = 0; 11217 PFN_vkCreateFramebuffer vkCreateFramebuffer = 0; 11218 PFN_vkDestroyFramebuffer vkDestroyFramebuffer = 0; 11219 PFN_vkCreateRenderPass vkCreateRenderPass = 0; 11220 PFN_vkDestroyRenderPass vkDestroyRenderPass = 0; 11221 PFN_vkGetRenderAreaGranularity vkGetRenderAreaGranularity = 0; 11222 PFN_vkCreateCommandPool vkCreateCommandPool = 0; 11223 PFN_vkDestroyCommandPool vkDestroyCommandPool = 0; 11224 PFN_vkResetCommandPool vkResetCommandPool = 0; 11225 PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers = 0; 11226 PFN_vkFreeCommandBuffers vkFreeCommandBuffers = 0; 11227 PFN_vkBeginCommandBuffer vkBeginCommandBuffer = 0; 11228 PFN_vkEndCommandBuffer vkEndCommandBuffer = 0; 11229 PFN_vkResetCommandBuffer vkResetCommandBuffer = 0; 11230 PFN_vkCmdBindPipeline vkCmdBindPipeline = 0; 11231 PFN_vkCmdSetViewport vkCmdSetViewport = 0; 11232 PFN_vkCmdSetScissor vkCmdSetScissor = 0; 11233 PFN_vkCmdSetLineWidth vkCmdSetLineWidth = 0; 11234 PFN_vkCmdSetDepthBias vkCmdSetDepthBias = 0; 11235 PFN_vkCmdSetBlendConstants vkCmdSetBlendConstants = 0; 11236 PFN_vkCmdSetDepthBounds vkCmdSetDepthBounds = 0; 11237 PFN_vkCmdSetStencilCompareMask vkCmdSetStencilCompareMask = 0; 11238 PFN_vkCmdSetStencilWriteMask vkCmdSetStencilWriteMask = 0; 11239 PFN_vkCmdSetStencilReference vkCmdSetStencilReference = 0; 11240 PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets = 0; 11241 PFN_vkCmdBindIndexBuffer vkCmdBindIndexBuffer = 0; 11242 PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers = 0; 11243 PFN_vkCmdDraw vkCmdDraw = 0; 11244 PFN_vkCmdDrawIndexed vkCmdDrawIndexed = 0; 11245 PFN_vkCmdDrawIndirect vkCmdDrawIndirect = 0; 11246 PFN_vkCmdDrawIndexedIndirect vkCmdDrawIndexedIndirect = 0; 11247 PFN_vkCmdDispatch vkCmdDispatch = 0; 11248 PFN_vkCmdDispatchIndirect vkCmdDispatchIndirect = 0; 11249 PFN_vkCmdCopyBuffer vkCmdCopyBuffer = 0; 11250 PFN_vkCmdCopyImage vkCmdCopyImage = 0; 11251 PFN_vkCmdBlitImage vkCmdBlitImage = 0; 11252 PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage = 0; 11253 PFN_vkCmdCopyImageToBuffer vkCmdCopyImageToBuffer = 0; 11254 PFN_vkCmdUpdateBuffer vkCmdUpdateBuffer = 0; 11255 PFN_vkCmdFillBuffer vkCmdFillBuffer = 0; 11256 PFN_vkCmdClearColorImage vkCmdClearColorImage = 0; 11257 PFN_vkCmdClearDepthStencilImage vkCmdClearDepthStencilImage = 0; 11258 PFN_vkCmdClearAttachments vkCmdClearAttachments = 0; 11259 PFN_vkCmdResolveImage vkCmdResolveImage = 0; 11260 PFN_vkCmdSetEvent vkCmdSetEvent = 0; 11261 PFN_vkCmdResetEvent vkCmdResetEvent = 0; 11262 PFN_vkCmdWaitEvents vkCmdWaitEvents = 0; 11263 PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier = 0; 11264 PFN_vkCmdBeginQuery vkCmdBeginQuery = 0; 11265 PFN_vkCmdEndQuery vkCmdEndQuery = 0; 11266 PFN_vkCmdResetQueryPool vkCmdResetQueryPool = 0; 11267 PFN_vkCmdWriteTimestamp vkCmdWriteTimestamp = 0; 11268 PFN_vkCmdCopyQueryPoolResults vkCmdCopyQueryPoolResults = 0; 11269 PFN_vkCmdPushConstants vkCmdPushConstants = 0; 11270 PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass = 0; 11271 PFN_vkCmdNextSubpass vkCmdNextSubpass = 0; 11272 PFN_vkCmdEndRenderPass vkCmdEndRenderPass = 0; 11273 PFN_vkCmdExecuteCommands vkCmdExecuteCommands = 0; 11274 11275 //=== VK_VERSION_1_1 === 11276 PFN_vkEnumerateInstanceVersion vkEnumerateInstanceVersion = 0; 11277 PFN_vkBindBufferMemory2 vkBindBufferMemory2 = 0; 11278 PFN_vkBindImageMemory2 vkBindImageMemory2 = 0; 11279 PFN_vkGetDeviceGroupPeerMemoryFeatures vkGetDeviceGroupPeerMemoryFeatures = 0; 11280 PFN_vkCmdSetDeviceMask vkCmdSetDeviceMask = 0; 11281 PFN_vkCmdDispatchBase vkCmdDispatchBase = 0; 11282 PFN_vkEnumeratePhysicalDeviceGroups vkEnumeratePhysicalDeviceGroups = 0; 11283 PFN_vkGetImageMemoryRequirements2 vkGetImageMemoryRequirements2 = 0; 11284 PFN_vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2 = 0; 11285 PFN_vkGetImageSparseMemoryRequirements2 vkGetImageSparseMemoryRequirements2 = 0; 11286 PFN_vkGetPhysicalDeviceFeatures2 vkGetPhysicalDeviceFeatures2 = 0; 11287 PFN_vkGetPhysicalDeviceProperties2 vkGetPhysicalDeviceProperties2 = 0; 11288 PFN_vkGetPhysicalDeviceFormatProperties2 vkGetPhysicalDeviceFormatProperties2 = 0; 11289 PFN_vkGetPhysicalDeviceImageFormatProperties2 vkGetPhysicalDeviceImageFormatProperties2 = 0; 11290 PFN_vkGetPhysicalDeviceQueueFamilyProperties2 vkGetPhysicalDeviceQueueFamilyProperties2 = 0; 11291 PFN_vkGetPhysicalDeviceMemoryProperties2 vkGetPhysicalDeviceMemoryProperties2 = 0; 11292 PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 vkGetPhysicalDeviceSparseImageFormatProperties2 = 0; 11293 PFN_vkTrimCommandPool vkTrimCommandPool = 0; 11294 PFN_vkGetDeviceQueue2 vkGetDeviceQueue2 = 0; 11295 PFN_vkCreateSamplerYcbcrConversion vkCreateSamplerYcbcrConversion = 0; 11296 PFN_vkDestroySamplerYcbcrConversion vkDestroySamplerYcbcrConversion = 0; 11297 PFN_vkCreateDescriptorUpdateTemplate vkCreateDescriptorUpdateTemplate = 0; 11298 PFN_vkDestroyDescriptorUpdateTemplate vkDestroyDescriptorUpdateTemplate = 0; 11299 PFN_vkUpdateDescriptorSetWithTemplate vkUpdateDescriptorSetWithTemplate = 0; 11300 PFN_vkGetPhysicalDeviceExternalBufferProperties vkGetPhysicalDeviceExternalBufferProperties = 0; 11301 PFN_vkGetPhysicalDeviceExternalFenceProperties vkGetPhysicalDeviceExternalFenceProperties = 0; 11302 PFN_vkGetPhysicalDeviceExternalSemaphoreProperties vkGetPhysicalDeviceExternalSemaphoreProperties = 0; 11303 PFN_vkGetDescriptorSetLayoutSupport vkGetDescriptorSetLayoutSupport = 0; 11304 11305 //=== VK_VERSION_1_2 === 11306 PFN_vkCmdDrawIndirectCount vkCmdDrawIndirectCount = 0; 11307 PFN_vkCmdDrawIndexedIndirectCount vkCmdDrawIndexedIndirectCount = 0; 11308 PFN_vkCreateRenderPass2 vkCreateRenderPass2 = 0; 11309 PFN_vkCmdBeginRenderPass2 vkCmdBeginRenderPass2 = 0; 11310 PFN_vkCmdNextSubpass2 vkCmdNextSubpass2 = 0; 11311 PFN_vkCmdEndRenderPass2 vkCmdEndRenderPass2 = 0; 11312 PFN_vkResetQueryPool vkResetQueryPool = 0; 11313 PFN_vkGetSemaphoreCounterValue vkGetSemaphoreCounterValue = 0; 11314 PFN_vkWaitSemaphores vkWaitSemaphores = 0; 11315 PFN_vkSignalSemaphore vkSignalSemaphore = 0; 11316 PFN_vkGetBufferDeviceAddress vkGetBufferDeviceAddress = 0; 11317 PFN_vkGetBufferOpaqueCaptureAddress vkGetBufferOpaqueCaptureAddress = 0; 11318 PFN_vkGetDeviceMemoryOpaqueCaptureAddress vkGetDeviceMemoryOpaqueCaptureAddress = 0; 11319 11320 //=== VK_KHR_surface === 11321 PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR = 0; 11322 PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR = 0; 11323 PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceCapabilitiesKHR = 0; 11324 PFN_vkGetPhysicalDeviceSurfaceFormatsKHR vkGetPhysicalDeviceSurfaceFormatsKHR = 0; 11325 PFN_vkGetPhysicalDeviceSurfacePresentModesKHR vkGetPhysicalDeviceSurfacePresentModesKHR = 0; 11326 11327 //=== VK_KHR_swapchain === 11328 PFN_vkCreateSwapchainKHR vkCreateSwapchainKHR = 0; 11329 PFN_vkDestroySwapchainKHR vkDestroySwapchainKHR = 0; 11330 PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR = 0; 11331 PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR = 0; 11332 PFN_vkQueuePresentKHR vkQueuePresentKHR = 0; 11333 PFN_vkGetDeviceGroupPresentCapabilitiesKHR vkGetDeviceGroupPresentCapabilitiesKHR = 0; 11334 PFN_vkGetDeviceGroupSurfacePresentModesKHR vkGetDeviceGroupSurfacePresentModesKHR = 0; 11335 PFN_vkGetPhysicalDevicePresentRectanglesKHR vkGetPhysicalDevicePresentRectanglesKHR = 0; 11336 PFN_vkAcquireNextImage2KHR vkAcquireNextImage2KHR = 0; 11337 11338 //=== VK_KHR_display === 11339 PFN_vkGetPhysicalDeviceDisplayPropertiesKHR vkGetPhysicalDeviceDisplayPropertiesKHR = 0; 11340 PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR vkGetPhysicalDeviceDisplayPlanePropertiesKHR = 0; 11341 PFN_vkGetDisplayPlaneSupportedDisplaysKHR vkGetDisplayPlaneSupportedDisplaysKHR = 0; 11342 PFN_vkGetDisplayModePropertiesKHR vkGetDisplayModePropertiesKHR = 0; 11343 PFN_vkCreateDisplayModeKHR vkCreateDisplayModeKHR = 0; 11344 PFN_vkGetDisplayPlaneCapabilitiesKHR vkGetDisplayPlaneCapabilitiesKHR = 0; 11345 PFN_vkCreateDisplayPlaneSurfaceKHR vkCreateDisplayPlaneSurfaceKHR = 0; 11346 11347 //=== VK_KHR_display_swapchain === 11348 PFN_vkCreateSharedSwapchainsKHR vkCreateSharedSwapchainsKHR = 0; 11349 11350 #if defined( VK_USE_PLATFORM_XLIB_KHR ) 11351 //=== VK_KHR_xlib_surface === 11352 PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHR = 0; 11353 PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR vkGetPhysicalDeviceXlibPresentationSupportKHR = 0; 11354 #else 11355 PFN_dummy vkCreateXlibSurfaceKHR_placeholder = 0; 11356 PFN_dummy vkGetPhysicalDeviceXlibPresentationSupportKHR_placeholder = 0; 11357 #endif /*VK_USE_PLATFORM_XLIB_KHR*/ 11358 11359 #if defined( VK_USE_PLATFORM_XCB_KHR ) 11360 //=== VK_KHR_xcb_surface === 11361 PFN_vkCreateXcbSurfaceKHR vkCreateXcbSurfaceKHR = 0; 11362 PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR vkGetPhysicalDeviceXcbPresentationSupportKHR = 0; 11363 #else 11364 PFN_dummy vkCreateXcbSurfaceKHR_placeholder = 0; 11365 PFN_dummy vkGetPhysicalDeviceXcbPresentationSupportKHR_placeholder = 0; 11366 #endif /*VK_USE_PLATFORM_XCB_KHR*/ 11367 11368 #if defined( VK_USE_PLATFORM_WAYLAND_KHR ) 11369 //=== VK_KHR_wayland_surface === 11370 PFN_vkCreateWaylandSurfaceKHR vkCreateWaylandSurfaceKHR = 0; 11371 PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR vkGetPhysicalDeviceWaylandPresentationSupportKHR = 0; 11372 #else 11373 PFN_dummy vkCreateWaylandSurfaceKHR_placeholder = 0; 11374 PFN_dummy vkGetPhysicalDeviceWaylandPresentationSupportKHR_placeholder = 0; 11375 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ 11376 11377 #if defined( VK_USE_PLATFORM_ANDROID_KHR ) 11378 //=== VK_KHR_android_surface === 11379 PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR = 0; 11380 #else 11381 PFN_dummy vkCreateAndroidSurfaceKHR_placeholder = 0; 11382 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 11383 11384 #if defined( VK_USE_PLATFORM_WIN32_KHR ) 11385 //=== VK_KHR_win32_surface === 11386 PFN_vkCreateWin32SurfaceKHR vkCreateWin32SurfaceKHR = 0; 11387 PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR vkGetPhysicalDeviceWin32PresentationSupportKHR = 0; 11388 #else 11389 PFN_dummy vkCreateWin32SurfaceKHR_placeholder = 0; 11390 PFN_dummy vkGetPhysicalDeviceWin32PresentationSupportKHR_placeholder = 0; 11391 #endif /*VK_USE_PLATFORM_WIN32_KHR*/ 11392 11393 #if defined( VK_USE_PLATFORM_OHOS_OPENHARMONY ) 11394 //=== VK_OpenHarmony_OHOS_surface === 11395 PFN_vkCreateOHOSSurfaceOpenHarmony vkCreateOHOSSurfaceOpenHarmony = 0; 11396 #else 11397 PFN_dummy vkCreateOHOSSurfaceOpenHarmony_placeholder = 0; 11398 #endif /*VK_USE_PLATFORM_OHOS_OPENHARMONY*/ 11399 11400 //=== VK_EXT_debug_report === 11401 PFN_vkCreateDebugReportCallbackEXT vkCreateDebugReportCallbackEXT = 0; 11402 PFN_vkDestroyDebugReportCallbackEXT vkDestroyDebugReportCallbackEXT = 0; 11403 PFN_vkDebugReportMessageEXT vkDebugReportMessageEXT = 0; 11404 11405 //=== VK_EXT_debug_marker === 11406 PFN_vkDebugMarkerSetObjectTagEXT vkDebugMarkerSetObjectTagEXT = 0; 11407 PFN_vkDebugMarkerSetObjectNameEXT vkDebugMarkerSetObjectNameEXT = 0; 11408 PFN_vkCmdDebugMarkerBeginEXT vkCmdDebugMarkerBeginEXT = 0; 11409 PFN_vkCmdDebugMarkerEndEXT vkCmdDebugMarkerEndEXT = 0; 11410 PFN_vkCmdDebugMarkerInsertEXT vkCmdDebugMarkerInsertEXT = 0; 11411 11412 #if defined( VK_ENABLE_BETA_EXTENSIONS ) 11413 //=== VK_KHR_video_queue === 11414 PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR vkGetPhysicalDeviceVideoCapabilitiesKHR = 0; 11415 PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR vkGetPhysicalDeviceVideoFormatPropertiesKHR = 0; 11416 PFN_vkCreateVideoSessionKHR vkCreateVideoSessionKHR = 0; 11417 PFN_vkDestroyVideoSessionKHR vkDestroyVideoSessionKHR = 0; 11418 PFN_vkGetVideoSessionMemoryRequirementsKHR vkGetVideoSessionMemoryRequirementsKHR = 0; 11419 PFN_vkBindVideoSessionMemoryKHR vkBindVideoSessionMemoryKHR = 0; 11420 PFN_vkCreateVideoSessionParametersKHR vkCreateVideoSessionParametersKHR = 0; 11421 PFN_vkUpdateVideoSessionParametersKHR vkUpdateVideoSessionParametersKHR = 0; 11422 PFN_vkDestroyVideoSessionParametersKHR vkDestroyVideoSessionParametersKHR = 0; 11423 PFN_vkCmdBeginVideoCodingKHR vkCmdBeginVideoCodingKHR = 0; 11424 PFN_vkCmdEndVideoCodingKHR vkCmdEndVideoCodingKHR = 0; 11425 PFN_vkCmdControlVideoCodingKHR vkCmdControlVideoCodingKHR = 0; 11426 #else 11427 PFN_dummy vkGetPhysicalDeviceVideoCapabilitiesKHR_placeholder = 0; 11428 PFN_dummy vkGetPhysicalDeviceVideoFormatPropertiesKHR_placeholder = 0; 11429 PFN_dummy vkCreateVideoSessionKHR_placeholder = 0; 11430 PFN_dummy vkDestroyVideoSessionKHR_placeholder = 0; 11431 PFN_dummy vkGetVideoSessionMemoryRequirementsKHR_placeholder = 0; 11432 PFN_dummy vkBindVideoSessionMemoryKHR_placeholder = 0; 11433 PFN_dummy vkCreateVideoSessionParametersKHR_placeholder = 0; 11434 PFN_dummy vkUpdateVideoSessionParametersKHR_placeholder = 0; 11435 PFN_dummy vkDestroyVideoSessionParametersKHR_placeholder = 0; 11436 PFN_dummy vkCmdBeginVideoCodingKHR_placeholder = 0; 11437 PFN_dummy vkCmdEndVideoCodingKHR_placeholder = 0; 11438 PFN_dummy vkCmdControlVideoCodingKHR_placeholder = 0; 11439 #endif /*VK_ENABLE_BETA_EXTENSIONS*/ 11440 11441 #if defined( VK_ENABLE_BETA_EXTENSIONS ) 11442 //=== VK_KHR_video_decode_queue === 11443 PFN_vkCmdDecodeVideoKHR vkCmdDecodeVideoKHR = 0; 11444 #else 11445 PFN_dummy vkCmdDecodeVideoKHR_placeholder = 0; 11446 #endif /*VK_ENABLE_BETA_EXTENSIONS*/ 11447 11448 //=== VK_EXT_transform_feedback === 11449 PFN_vkCmdBindTransformFeedbackBuffersEXT vkCmdBindTransformFeedbackBuffersEXT = 0; 11450 PFN_vkCmdBeginTransformFeedbackEXT vkCmdBeginTransformFeedbackEXT = 0; 11451 PFN_vkCmdEndTransformFeedbackEXT vkCmdEndTransformFeedbackEXT = 0; 11452 PFN_vkCmdBeginQueryIndexedEXT vkCmdBeginQueryIndexedEXT = 0; 11453 PFN_vkCmdEndQueryIndexedEXT vkCmdEndQueryIndexedEXT = 0; 11454 PFN_vkCmdDrawIndirectByteCountEXT vkCmdDrawIndirectByteCountEXT = 0; 11455 11456 //=== VK_NVX_binary_import === 11457 PFN_vkCreateCuModuleNVX vkCreateCuModuleNVX = 0; 11458 PFN_vkCreateCuFunctionNVX vkCreateCuFunctionNVX = 0; 11459 PFN_vkDestroyCuModuleNVX vkDestroyCuModuleNVX = 0; 11460 PFN_vkDestroyCuFunctionNVX vkDestroyCuFunctionNVX = 0; 11461 PFN_vkCmdCuLaunchKernelNVX vkCmdCuLaunchKernelNVX = 0; 11462 11463 //=== VK_NVX_image_view_handle === 11464 PFN_vkGetImageViewHandleNVX vkGetImageViewHandleNVX = 0; 11465 PFN_vkGetImageViewAddressNVX vkGetImageViewAddressNVX = 0; 11466 11467 //=== VK_AMD_draw_indirect_count === 11468 PFN_vkCmdDrawIndirectCountAMD vkCmdDrawIndirectCountAMD = 0; 11469 PFN_vkCmdDrawIndexedIndirectCountAMD vkCmdDrawIndexedIndirectCountAMD = 0; 11470 11471 //=== VK_AMD_shader_info === 11472 PFN_vkGetShaderInfoAMD vkGetShaderInfoAMD = 0; 11473 11474 //=== VK_KHR_dynamic_rendering === 11475 PFN_vkCmdBeginRenderingKHR vkCmdBeginRenderingKHR = 0; 11476 PFN_vkCmdEndRenderingKHR vkCmdEndRenderingKHR = 0; 11477 11478 #if defined( VK_USE_PLATFORM_GGP ) 11479 //=== VK_GGP_stream_descriptor_surface === 11480 PFN_vkCreateStreamDescriptorSurfaceGGP vkCreateStreamDescriptorSurfaceGGP = 0; 11481 #else 11482 PFN_dummy vkCreateStreamDescriptorSurfaceGGP_placeholder = 0; 11483 #endif /*VK_USE_PLATFORM_GGP*/ 11484 11485 //=== VK_NV_external_memory_capabilities === 11486 PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV vkGetPhysicalDeviceExternalImageFormatPropertiesNV = 0; 11487 11488 #if defined( VK_USE_PLATFORM_WIN32_KHR ) 11489 //=== VK_NV_external_memory_win32 === 11490 PFN_vkGetMemoryWin32HandleNV vkGetMemoryWin32HandleNV = 0; 11491 #else 11492 PFN_dummy vkGetMemoryWin32HandleNV_placeholder = 0; 11493 #endif /*VK_USE_PLATFORM_WIN32_KHR*/ 11494 11495 //=== VK_KHR_get_physical_device_properties2 === 11496 PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR = 0; 11497 PFN_vkGetPhysicalDeviceProperties2KHR vkGetPhysicalDeviceProperties2KHR = 0; 11498 PFN_vkGetPhysicalDeviceFormatProperties2KHR vkGetPhysicalDeviceFormatProperties2KHR = 0; 11499 PFN_vkGetPhysicalDeviceImageFormatProperties2KHR vkGetPhysicalDeviceImageFormatProperties2KHR = 0; 11500 PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR vkGetPhysicalDeviceQueueFamilyProperties2KHR = 0; 11501 PFN_vkGetPhysicalDeviceMemoryProperties2KHR vkGetPhysicalDeviceMemoryProperties2KHR = 0; 11502 PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR vkGetPhysicalDeviceSparseImageFormatProperties2KHR = 0; 11503 11504 //=== VK_KHR_device_group === 11505 PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR vkGetDeviceGroupPeerMemoryFeaturesKHR = 0; 11506 PFN_vkCmdSetDeviceMaskKHR vkCmdSetDeviceMaskKHR = 0; 11507 PFN_vkCmdDispatchBaseKHR vkCmdDispatchBaseKHR = 0; 11508 11509 #if defined( VK_USE_PLATFORM_VI_NN ) 11510 //=== VK_NN_vi_surface === 11511 PFN_vkCreateViSurfaceNN vkCreateViSurfaceNN = 0; 11512 #else 11513 PFN_dummy vkCreateViSurfaceNN_placeholder = 0; 11514 #endif /*VK_USE_PLATFORM_VI_NN*/ 11515 11516 //=== VK_KHR_maintenance1 === 11517 PFN_vkTrimCommandPoolKHR vkTrimCommandPoolKHR = 0; 11518 11519 //=== VK_KHR_device_group_creation === 11520 PFN_vkEnumeratePhysicalDeviceGroupsKHR vkEnumeratePhysicalDeviceGroupsKHR = 0; 11521 11522 //=== VK_KHR_external_memory_capabilities === 11523 PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR vkGetPhysicalDeviceExternalBufferPropertiesKHR = 0; 11524 11525 #if defined( VK_USE_PLATFORM_WIN32_KHR ) 11526 //=== VK_KHR_external_memory_win32 === 11527 PFN_vkGetMemoryWin32HandleKHR vkGetMemoryWin32HandleKHR = 0; 11528 PFN_vkGetMemoryWin32HandlePropertiesKHR vkGetMemoryWin32HandlePropertiesKHR = 0; 11529 #else 11530 PFN_dummy vkGetMemoryWin32HandleKHR_placeholder = 0; 11531 PFN_dummy vkGetMemoryWin32HandlePropertiesKHR_placeholder = 0; 11532 #endif /*VK_USE_PLATFORM_WIN32_KHR*/ 11533 11534 //=== VK_KHR_external_memory_fd === 11535 PFN_vkGetMemoryFdKHR vkGetMemoryFdKHR = 0; 11536 PFN_vkGetMemoryFdPropertiesKHR vkGetMemoryFdPropertiesKHR = 0; 11537 11538 //=== VK_KHR_external_semaphore_capabilities === 11539 PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = 0; 11540 11541 #if defined( VK_USE_PLATFORM_WIN32_KHR ) 11542 //=== VK_KHR_external_semaphore_win32 === 11543 PFN_vkImportSemaphoreWin32HandleKHR vkImportSemaphoreWin32HandleKHR = 0; 11544 PFN_vkGetSemaphoreWin32HandleKHR vkGetSemaphoreWin32HandleKHR = 0; 11545 #else 11546 PFN_dummy vkImportSemaphoreWin32HandleKHR_placeholder = 0; 11547 PFN_dummy vkGetSemaphoreWin32HandleKHR_placeholder = 0; 11548 #endif /*VK_USE_PLATFORM_WIN32_KHR*/ 11549 11550 //=== VK_KHR_external_semaphore_fd === 11551 PFN_vkImportSemaphoreFdKHR vkImportSemaphoreFdKHR = 0; 11552 PFN_vkGetSemaphoreFdKHR vkGetSemaphoreFdKHR = 0; 11553 11554 //=== VK_KHR_push_descriptor === 11555 PFN_vkCmdPushDescriptorSetKHR vkCmdPushDescriptorSetKHR = 0; 11556 PFN_vkCmdPushDescriptorSetWithTemplateKHR vkCmdPushDescriptorSetWithTemplateKHR = 0; 11557 11558 //=== VK_EXT_conditional_rendering === 11559 PFN_vkCmdBeginConditionalRenderingEXT vkCmdBeginConditionalRenderingEXT = 0; 11560 PFN_vkCmdEndConditionalRenderingEXT vkCmdEndConditionalRenderingEXT = 0; 11561 11562 //=== VK_KHR_descriptor_update_template === 11563 PFN_vkCreateDescriptorUpdateTemplateKHR vkCreateDescriptorUpdateTemplateKHR = 0; 11564 PFN_vkDestroyDescriptorUpdateTemplateKHR vkDestroyDescriptorUpdateTemplateKHR = 0; 11565 PFN_vkUpdateDescriptorSetWithTemplateKHR vkUpdateDescriptorSetWithTemplateKHR = 0; 11566 11567 //=== VK_NV_clip_space_w_scaling === 11568 PFN_vkCmdSetViewportWScalingNV vkCmdSetViewportWScalingNV = 0; 11569 11570 //=== VK_EXT_direct_mode_display === 11571 PFN_vkReleaseDisplayEXT vkReleaseDisplayEXT = 0; 11572 11573 #if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) 11574 //=== VK_EXT_acquire_xlib_display === 11575 PFN_vkAcquireXlibDisplayEXT vkAcquireXlibDisplayEXT = 0; 11576 PFN_vkGetRandROutputDisplayEXT vkGetRandROutputDisplayEXT = 0; 11577 #else 11578 PFN_dummy vkAcquireXlibDisplayEXT_placeholder = 0; 11579 PFN_dummy vkGetRandROutputDisplayEXT_placeholder = 0; 11580 #endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ 11581 11582 //=== VK_EXT_display_surface_counter === 11583 PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT vkGetPhysicalDeviceSurfaceCapabilities2EXT = 0; 11584 11585 //=== VK_EXT_display_control === 11586 PFN_vkDisplayPowerControlEXT vkDisplayPowerControlEXT = 0; 11587 PFN_vkRegisterDeviceEventEXT vkRegisterDeviceEventEXT = 0; 11588 PFN_vkRegisterDisplayEventEXT vkRegisterDisplayEventEXT = 0; 11589 PFN_vkGetSwapchainCounterEXT vkGetSwapchainCounterEXT = 0; 11590 11591 //=== VK_GOOGLE_display_timing === 11592 PFN_vkGetRefreshCycleDurationGOOGLE vkGetRefreshCycleDurationGOOGLE = 0; 11593 PFN_vkGetPastPresentationTimingGOOGLE vkGetPastPresentationTimingGOOGLE = 0; 11594 11595 //=== VK_EXT_discard_rectangles === 11596 PFN_vkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXT = 0; 11597 11598 //=== VK_EXT_hdr_metadata === 11599 PFN_vkSetHdrMetadataEXT vkSetHdrMetadataEXT = 0; 11600 11601 //=== VK_KHR_create_renderpass2 === 11602 PFN_vkCreateRenderPass2KHR vkCreateRenderPass2KHR = 0; 11603 PFN_vkCmdBeginRenderPass2KHR vkCmdBeginRenderPass2KHR = 0; 11604 PFN_vkCmdNextSubpass2KHR vkCmdNextSubpass2KHR = 0; 11605 PFN_vkCmdEndRenderPass2KHR vkCmdEndRenderPass2KHR = 0; 11606 11607 //=== VK_KHR_shared_presentable_image === 11608 PFN_vkGetSwapchainStatusKHR vkGetSwapchainStatusKHR = 0; 11609 11610 //=== VK_KHR_external_fence_capabilities === 11611 PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR vkGetPhysicalDeviceExternalFencePropertiesKHR = 0; 11612 11613 #if defined( VK_USE_PLATFORM_WIN32_KHR ) 11614 //=== VK_KHR_external_fence_win32 === 11615 PFN_vkImportFenceWin32HandleKHR vkImportFenceWin32HandleKHR = 0; 11616 PFN_vkGetFenceWin32HandleKHR vkGetFenceWin32HandleKHR = 0; 11617 #else 11618 PFN_dummy vkImportFenceWin32HandleKHR_placeholder = 0; 11619 PFN_dummy vkGetFenceWin32HandleKHR_placeholder = 0; 11620 #endif /*VK_USE_PLATFORM_WIN32_KHR*/ 11621 11622 //=== VK_KHR_external_fence_fd === 11623 PFN_vkImportFenceFdKHR vkImportFenceFdKHR = 0; 11624 PFN_vkGetFenceFdKHR vkGetFenceFdKHR = 0; 11625 11626 //=== VK_KHR_performance_query === 11627 PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR 11628 vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = 0; 11629 PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR 11630 vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = 0; 11631 PFN_vkAcquireProfilingLockKHR vkAcquireProfilingLockKHR = 0; 11632 PFN_vkReleaseProfilingLockKHR vkReleaseProfilingLockKHR = 0; 11633 11634 //=== VK_KHR_get_surface_capabilities2 === 11635 PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR vkGetPhysicalDeviceSurfaceCapabilities2KHR = 0; 11636 PFN_vkGetPhysicalDeviceSurfaceFormats2KHR vkGetPhysicalDeviceSurfaceFormats2KHR = 0; 11637 11638 //=== VK_KHR_get_display_properties2 === 11639 PFN_vkGetPhysicalDeviceDisplayProperties2KHR vkGetPhysicalDeviceDisplayProperties2KHR = 0; 11640 PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR vkGetPhysicalDeviceDisplayPlaneProperties2KHR = 0; 11641 PFN_vkGetDisplayModeProperties2KHR vkGetDisplayModeProperties2KHR = 0; 11642 PFN_vkGetDisplayPlaneCapabilities2KHR vkGetDisplayPlaneCapabilities2KHR = 0; 11643 11644 #if defined( VK_USE_PLATFORM_IOS_MVK ) 11645 //=== VK_MVK_ios_surface === 11646 PFN_vkCreateIOSSurfaceMVK vkCreateIOSSurfaceMVK = 0; 11647 #else 11648 PFN_dummy vkCreateIOSSurfaceMVK_placeholder = 0; 11649 #endif /*VK_USE_PLATFORM_IOS_MVK*/ 11650 11651 #if defined( VK_USE_PLATFORM_MACOS_MVK ) 11652 //=== VK_MVK_macos_surface === 11653 PFN_vkCreateMacOSSurfaceMVK vkCreateMacOSSurfaceMVK = 0; 11654 #else 11655 PFN_dummy vkCreateMacOSSurfaceMVK_placeholder = 0; 11656 #endif /*VK_USE_PLATFORM_MACOS_MVK*/ 11657 11658 //=== VK_EXT_debug_utils === 11659 PFN_vkSetDebugUtilsObjectNameEXT vkSetDebugUtilsObjectNameEXT = 0; 11660 PFN_vkSetDebugUtilsObjectTagEXT vkSetDebugUtilsObjectTagEXT = 0; 11661 PFN_vkQueueBeginDebugUtilsLabelEXT vkQueueBeginDebugUtilsLabelEXT = 0; 11662 PFN_vkQueueEndDebugUtilsLabelEXT vkQueueEndDebugUtilsLabelEXT = 0; 11663 PFN_vkQueueInsertDebugUtilsLabelEXT vkQueueInsertDebugUtilsLabelEXT = 0; 11664 PFN_vkCmdBeginDebugUtilsLabelEXT vkCmdBeginDebugUtilsLabelEXT = 0; 11665 PFN_vkCmdEndDebugUtilsLabelEXT vkCmdEndDebugUtilsLabelEXT = 0; 11666 PFN_vkCmdInsertDebugUtilsLabelEXT vkCmdInsertDebugUtilsLabelEXT = 0; 11667 PFN_vkCreateDebugUtilsMessengerEXT vkCreateDebugUtilsMessengerEXT = 0; 11668 PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT = 0; 11669 PFN_vkSubmitDebugUtilsMessageEXT vkSubmitDebugUtilsMessageEXT = 0; 11670 11671 #if defined( VK_USE_PLATFORM_ANDROID_KHR ) 11672 //=== VK_ANDROID_external_memory_android_hardware_buffer === 11673 PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID = 0; 11674 PFN_vkGetMemoryAndroidHardwareBufferANDROID vkGetMemoryAndroidHardwareBufferANDROID = 0; 11675 #else 11676 PFN_dummy vkGetAndroidHardwareBufferPropertiesANDROID_placeholder = 0; 11677 PFN_dummy vkGetMemoryAndroidHardwareBufferANDROID_placeholder = 0; 11678 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 11679 11680 //=== VK_EXT_sample_locations === 11681 PFN_vkCmdSetSampleLocationsEXT vkCmdSetSampleLocationsEXT = 0; 11682 PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT vkGetPhysicalDeviceMultisamplePropertiesEXT = 0; 11683 11684 //=== VK_KHR_get_memory_requirements2 === 11685 PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR = 0; 11686 PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR = 0; 11687 PFN_vkGetImageSparseMemoryRequirements2KHR vkGetImageSparseMemoryRequirements2KHR = 0; 11688 11689 //=== VK_KHR_acceleration_structure === 11690 PFN_vkCreateAccelerationStructureKHR vkCreateAccelerationStructureKHR = 0; 11691 PFN_vkDestroyAccelerationStructureKHR vkDestroyAccelerationStructureKHR = 0; 11692 PFN_vkCmdBuildAccelerationStructuresKHR vkCmdBuildAccelerationStructuresKHR = 0; 11693 PFN_vkCmdBuildAccelerationStructuresIndirectKHR vkCmdBuildAccelerationStructuresIndirectKHR = 0; 11694 PFN_vkBuildAccelerationStructuresKHR vkBuildAccelerationStructuresKHR = 0; 11695 PFN_vkCopyAccelerationStructureKHR vkCopyAccelerationStructureKHR = 0; 11696 PFN_vkCopyAccelerationStructureToMemoryKHR vkCopyAccelerationStructureToMemoryKHR = 0; 11697 PFN_vkCopyMemoryToAccelerationStructureKHR vkCopyMemoryToAccelerationStructureKHR = 0; 11698 PFN_vkWriteAccelerationStructuresPropertiesKHR vkWriteAccelerationStructuresPropertiesKHR = 0; 11699 PFN_vkCmdCopyAccelerationStructureKHR vkCmdCopyAccelerationStructureKHR = 0; 11700 PFN_vkCmdCopyAccelerationStructureToMemoryKHR vkCmdCopyAccelerationStructureToMemoryKHR = 0; 11701 PFN_vkCmdCopyMemoryToAccelerationStructureKHR vkCmdCopyMemoryToAccelerationStructureKHR = 0; 11702 PFN_vkGetAccelerationStructureDeviceAddressKHR vkGetAccelerationStructureDeviceAddressKHR = 0; 11703 PFN_vkCmdWriteAccelerationStructuresPropertiesKHR vkCmdWriteAccelerationStructuresPropertiesKHR = 0; 11704 PFN_vkGetDeviceAccelerationStructureCompatibilityKHR vkGetDeviceAccelerationStructureCompatibilityKHR = 0; 11705 PFN_vkGetAccelerationStructureBuildSizesKHR vkGetAccelerationStructureBuildSizesKHR = 0; 11706 11707 //=== VK_KHR_sampler_ycbcr_conversion === 11708 PFN_vkCreateSamplerYcbcrConversionKHR vkCreateSamplerYcbcrConversionKHR = 0; 11709 PFN_vkDestroySamplerYcbcrConversionKHR vkDestroySamplerYcbcrConversionKHR = 0; 11710 11711 //=== VK_KHR_bind_memory2 === 11712 PFN_vkBindBufferMemory2KHR vkBindBufferMemory2KHR = 0; 11713 PFN_vkBindImageMemory2KHR vkBindImageMemory2KHR = 0; 11714 11715 //=== VK_EXT_image_drm_format_modifier === 11716 PFN_vkGetImageDrmFormatModifierPropertiesEXT vkGetImageDrmFormatModifierPropertiesEXT = 0; 11717 11718 //=== VK_EXT_validation_cache === 11719 PFN_vkCreateValidationCacheEXT vkCreateValidationCacheEXT = 0; 11720 PFN_vkDestroyValidationCacheEXT vkDestroyValidationCacheEXT = 0; 11721 PFN_vkMergeValidationCachesEXT vkMergeValidationCachesEXT = 0; 11722 PFN_vkGetValidationCacheDataEXT vkGetValidationCacheDataEXT = 0; 11723 11724 //=== VK_NV_shading_rate_image === 11725 PFN_vkCmdBindShadingRateImageNV vkCmdBindShadingRateImageNV = 0; 11726 PFN_vkCmdSetViewportShadingRatePaletteNV vkCmdSetViewportShadingRatePaletteNV = 0; 11727 PFN_vkCmdSetCoarseSampleOrderNV vkCmdSetCoarseSampleOrderNV = 0; 11728 11729 //=== VK_NV_ray_tracing === 11730 PFN_vkCreateAccelerationStructureNV vkCreateAccelerationStructureNV = 0; 11731 PFN_vkDestroyAccelerationStructureNV vkDestroyAccelerationStructureNV = 0; 11732 PFN_vkGetAccelerationStructureMemoryRequirementsNV vkGetAccelerationStructureMemoryRequirementsNV = 0; 11733 PFN_vkBindAccelerationStructureMemoryNV vkBindAccelerationStructureMemoryNV = 0; 11734 PFN_vkCmdBuildAccelerationStructureNV vkCmdBuildAccelerationStructureNV = 0; 11735 PFN_vkCmdCopyAccelerationStructureNV vkCmdCopyAccelerationStructureNV = 0; 11736 PFN_vkCmdTraceRaysNV vkCmdTraceRaysNV = 0; 11737 PFN_vkCreateRayTracingPipelinesNV vkCreateRayTracingPipelinesNV = 0; 11738 PFN_vkGetRayTracingShaderGroupHandlesNV vkGetRayTracingShaderGroupHandlesNV = 0; 11739 PFN_vkGetAccelerationStructureHandleNV vkGetAccelerationStructureHandleNV = 0; 11740 PFN_vkCmdWriteAccelerationStructuresPropertiesNV vkCmdWriteAccelerationStructuresPropertiesNV = 0; 11741 PFN_vkCompileDeferredNV vkCompileDeferredNV = 0; 11742 11743 //=== VK_KHR_maintenance3 === 11744 PFN_vkGetDescriptorSetLayoutSupportKHR vkGetDescriptorSetLayoutSupportKHR = 0; 11745 11746 //=== VK_KHR_draw_indirect_count === 11747 PFN_vkCmdDrawIndirectCountKHR vkCmdDrawIndirectCountKHR = 0; 11748 PFN_vkCmdDrawIndexedIndirectCountKHR vkCmdDrawIndexedIndirectCountKHR = 0; 11749 11750 //=== VK_EXT_external_memory_host === 11751 PFN_vkGetMemoryHostPointerPropertiesEXT vkGetMemoryHostPointerPropertiesEXT = 0; 11752 11753 //=== VK_AMD_buffer_marker === 11754 PFN_vkCmdWriteBufferMarkerAMD vkCmdWriteBufferMarkerAMD = 0; 11755 11756 //=== VK_EXT_calibrated_timestamps === 11757 PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = 0; 11758 PFN_vkGetCalibratedTimestampsEXT vkGetCalibratedTimestampsEXT = 0; 11759 11760 //=== VK_NV_mesh_shader === 11761 PFN_vkCmdDrawMeshTasksNV vkCmdDrawMeshTasksNV = 0; 11762 PFN_vkCmdDrawMeshTasksIndirectNV vkCmdDrawMeshTasksIndirectNV = 0; 11763 PFN_vkCmdDrawMeshTasksIndirectCountNV vkCmdDrawMeshTasksIndirectCountNV = 0; 11764 11765 //=== VK_NV_scissor_exclusive === 11766 PFN_vkCmdSetExclusiveScissorNV vkCmdSetExclusiveScissorNV = 0; 11767 11768 //=== VK_NV_device_diagnostic_checkpoints === 11769 PFN_vkCmdSetCheckpointNV vkCmdSetCheckpointNV = 0; 11770 PFN_vkGetQueueCheckpointDataNV vkGetQueueCheckpointDataNV = 0; 11771 11772 //=== VK_KHR_timeline_semaphore === 11773 PFN_vkGetSemaphoreCounterValueKHR vkGetSemaphoreCounterValueKHR = 0; 11774 PFN_vkWaitSemaphoresKHR vkWaitSemaphoresKHR = 0; 11775 PFN_vkSignalSemaphoreKHR vkSignalSemaphoreKHR = 0; 11776 11777 //=== VK_INTEL_performance_query === 11778 PFN_vkInitializePerformanceApiINTEL vkInitializePerformanceApiINTEL = 0; 11779 PFN_vkUninitializePerformanceApiINTEL vkUninitializePerformanceApiINTEL = 0; 11780 PFN_vkCmdSetPerformanceMarkerINTEL vkCmdSetPerformanceMarkerINTEL = 0; 11781 PFN_vkCmdSetPerformanceStreamMarkerINTEL vkCmdSetPerformanceStreamMarkerINTEL = 0; 11782 PFN_vkCmdSetPerformanceOverrideINTEL vkCmdSetPerformanceOverrideINTEL = 0; 11783 PFN_vkAcquirePerformanceConfigurationINTEL vkAcquirePerformanceConfigurationINTEL = 0; 11784 PFN_vkReleasePerformanceConfigurationINTEL vkReleasePerformanceConfigurationINTEL = 0; 11785 PFN_vkQueueSetPerformanceConfigurationINTEL vkQueueSetPerformanceConfigurationINTEL = 0; 11786 PFN_vkGetPerformanceParameterINTEL vkGetPerformanceParameterINTEL = 0; 11787 11788 //=== VK_AMD_display_native_hdr === 11789 PFN_vkSetLocalDimmingAMD vkSetLocalDimmingAMD = 0; 11790 11791 #if defined( VK_USE_PLATFORM_FUCHSIA ) 11792 //=== VK_FUCHSIA_imagepipe_surface === 11793 PFN_vkCreateImagePipeSurfaceFUCHSIA vkCreateImagePipeSurfaceFUCHSIA = 0; 11794 #else 11795 PFN_dummy vkCreateImagePipeSurfaceFUCHSIA_placeholder = 0; 11796 #endif /*VK_USE_PLATFORM_FUCHSIA*/ 11797 11798 #if defined( VK_USE_PLATFORM_METAL_EXT ) 11799 //=== VK_EXT_metal_surface === 11800 PFN_vkCreateMetalSurfaceEXT vkCreateMetalSurfaceEXT = 0; 11801 #else 11802 PFN_dummy vkCreateMetalSurfaceEXT_placeholder = 0; 11803 #endif /*VK_USE_PLATFORM_METAL_EXT*/ 11804 11805 //=== VK_KHR_fragment_shading_rate === 11806 PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR vkGetPhysicalDeviceFragmentShadingRatesKHR = 0; 11807 PFN_vkCmdSetFragmentShadingRateKHR vkCmdSetFragmentShadingRateKHR = 0; 11808 11809 //=== VK_EXT_buffer_device_address === 11810 PFN_vkGetBufferDeviceAddressEXT vkGetBufferDeviceAddressEXT = 0; 11811 11812 //=== VK_EXT_tooling_info === 11813 PFN_vkGetPhysicalDeviceToolPropertiesEXT vkGetPhysicalDeviceToolPropertiesEXT = 0; 11814 11815 //=== VK_KHR_present_wait === 11816 PFN_vkWaitForPresentKHR vkWaitForPresentKHR = 0; 11817 11818 //=== VK_NV_cooperative_matrix === 11819 PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = 0; 11820 11821 //=== VK_NV_coverage_reduction_mode === 11822 PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV 11823 vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = 0; 11824 11825 #if defined( VK_USE_PLATFORM_WIN32_KHR ) 11826 //=== VK_EXT_full_screen_exclusive === 11827 PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT vkGetPhysicalDeviceSurfacePresentModes2EXT = 0; 11828 PFN_vkAcquireFullScreenExclusiveModeEXT vkAcquireFullScreenExclusiveModeEXT = 0; 11829 PFN_vkReleaseFullScreenExclusiveModeEXT vkReleaseFullScreenExclusiveModeEXT = 0; 11830 PFN_vkGetDeviceGroupSurfacePresentModes2EXT vkGetDeviceGroupSurfacePresentModes2EXT = 0; 11831 #else 11832 PFN_dummy vkGetPhysicalDeviceSurfacePresentModes2EXT_placeholder = 0; 11833 PFN_dummy vkAcquireFullScreenExclusiveModeEXT_placeholder = 0; 11834 PFN_dummy vkReleaseFullScreenExclusiveModeEXT_placeholder = 0; 11835 PFN_dummy vkGetDeviceGroupSurfacePresentModes2EXT_placeholder = 0; 11836 #endif /*VK_USE_PLATFORM_WIN32_KHR*/ 11837 11838 //=== VK_EXT_headless_surface === 11839 PFN_vkCreateHeadlessSurfaceEXT vkCreateHeadlessSurfaceEXT = 0; 11840 11841 //=== VK_KHR_buffer_device_address === 11842 PFN_vkGetBufferDeviceAddressKHR vkGetBufferDeviceAddressKHR = 0; 11843 PFN_vkGetBufferOpaqueCaptureAddressKHR vkGetBufferOpaqueCaptureAddressKHR = 0; 11844 PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR vkGetDeviceMemoryOpaqueCaptureAddressKHR = 0; 11845 11846 //=== VK_EXT_line_rasterization === 11847 PFN_vkCmdSetLineStippleEXT vkCmdSetLineStippleEXT = 0; 11848 11849 //=== VK_EXT_host_query_reset === 11850 PFN_vkResetQueryPoolEXT vkResetQueryPoolEXT = 0; 11851 11852 //=== VK_EXT_extended_dynamic_state === 11853 PFN_vkCmdSetCullModeEXT vkCmdSetCullModeEXT = 0; 11854 PFN_vkCmdSetFrontFaceEXT vkCmdSetFrontFaceEXT = 0; 11855 PFN_vkCmdSetPrimitiveTopologyEXT vkCmdSetPrimitiveTopologyEXT = 0; 11856 PFN_vkCmdSetViewportWithCountEXT vkCmdSetViewportWithCountEXT = 0; 11857 PFN_vkCmdSetScissorWithCountEXT vkCmdSetScissorWithCountEXT = 0; 11858 PFN_vkCmdBindVertexBuffers2EXT vkCmdBindVertexBuffers2EXT = 0; 11859 PFN_vkCmdSetDepthTestEnableEXT vkCmdSetDepthTestEnableEXT = 0; 11860 PFN_vkCmdSetDepthWriteEnableEXT vkCmdSetDepthWriteEnableEXT = 0; 11861 PFN_vkCmdSetDepthCompareOpEXT vkCmdSetDepthCompareOpEXT = 0; 11862 PFN_vkCmdSetDepthBoundsTestEnableEXT vkCmdSetDepthBoundsTestEnableEXT = 0; 11863 PFN_vkCmdSetStencilTestEnableEXT vkCmdSetStencilTestEnableEXT = 0; 11864 PFN_vkCmdSetStencilOpEXT vkCmdSetStencilOpEXT = 0; 11865 11866 //=== VK_KHR_deferred_host_operations === 11867 PFN_vkCreateDeferredOperationKHR vkCreateDeferredOperationKHR = 0; 11868 PFN_vkDestroyDeferredOperationKHR vkDestroyDeferredOperationKHR = 0; 11869 PFN_vkGetDeferredOperationMaxConcurrencyKHR vkGetDeferredOperationMaxConcurrencyKHR = 0; 11870 PFN_vkGetDeferredOperationResultKHR vkGetDeferredOperationResultKHR = 0; 11871 PFN_vkDeferredOperationJoinKHR vkDeferredOperationJoinKHR = 0; 11872 11873 //=== VK_KHR_pipeline_executable_properties === 11874 PFN_vkGetPipelineExecutablePropertiesKHR vkGetPipelineExecutablePropertiesKHR = 0; 11875 PFN_vkGetPipelineExecutableStatisticsKHR vkGetPipelineExecutableStatisticsKHR = 0; 11876 PFN_vkGetPipelineExecutableInternalRepresentationsKHR vkGetPipelineExecutableInternalRepresentationsKHR = 0; 11877 11878 //=== VK_NV_device_generated_commands === 11879 PFN_vkGetGeneratedCommandsMemoryRequirementsNV vkGetGeneratedCommandsMemoryRequirementsNV = 0; 11880 PFN_vkCmdPreprocessGeneratedCommandsNV vkCmdPreprocessGeneratedCommandsNV = 0; 11881 PFN_vkCmdExecuteGeneratedCommandsNV vkCmdExecuteGeneratedCommandsNV = 0; 11882 PFN_vkCmdBindPipelineShaderGroupNV vkCmdBindPipelineShaderGroupNV = 0; 11883 PFN_vkCreateIndirectCommandsLayoutNV vkCreateIndirectCommandsLayoutNV = 0; 11884 PFN_vkDestroyIndirectCommandsLayoutNV vkDestroyIndirectCommandsLayoutNV = 0; 11885 11886 //=== VK_EXT_acquire_drm_display === 11887 PFN_vkAcquireDrmDisplayEXT vkAcquireDrmDisplayEXT = 0; 11888 PFN_vkGetDrmDisplayEXT vkGetDrmDisplayEXT = 0; 11889 11890 //=== VK_EXT_private_data === 11891 PFN_vkCreatePrivateDataSlotEXT vkCreatePrivateDataSlotEXT = 0; 11892 PFN_vkDestroyPrivateDataSlotEXT vkDestroyPrivateDataSlotEXT = 0; 11893 PFN_vkSetPrivateDataEXT vkSetPrivateDataEXT = 0; 11894 PFN_vkGetPrivateDataEXT vkGetPrivateDataEXT = 0; 11895 11896 #if defined( VK_ENABLE_BETA_EXTENSIONS ) 11897 //=== VK_KHR_video_encode_queue === 11898 PFN_vkCmdEncodeVideoKHR vkCmdEncodeVideoKHR = 0; 11899 #else 11900 PFN_dummy vkCmdEncodeVideoKHR_placeholder = 0; 11901 #endif /*VK_ENABLE_BETA_EXTENSIONS*/ 11902 11903 //=== VK_KHR_synchronization2 === 11904 PFN_vkCmdSetEvent2KHR vkCmdSetEvent2KHR = 0; 11905 PFN_vkCmdResetEvent2KHR vkCmdResetEvent2KHR = 0; 11906 PFN_vkCmdWaitEvents2KHR vkCmdWaitEvents2KHR = 0; 11907 PFN_vkCmdPipelineBarrier2KHR vkCmdPipelineBarrier2KHR = 0; 11908 PFN_vkCmdWriteTimestamp2KHR vkCmdWriteTimestamp2KHR = 0; 11909 PFN_vkQueueSubmit2KHR vkQueueSubmit2KHR = 0; 11910 PFN_vkCmdWriteBufferMarker2AMD vkCmdWriteBufferMarker2AMD = 0; 11911 PFN_vkGetQueueCheckpointData2NV vkGetQueueCheckpointData2NV = 0; 11912 11913 //=== VK_NV_fragment_shading_rate_enums === 11914 PFN_vkCmdSetFragmentShadingRateEnumNV vkCmdSetFragmentShadingRateEnumNV = 0; 11915 11916 //=== VK_KHR_copy_commands2 === 11917 PFN_vkCmdCopyBuffer2KHR vkCmdCopyBuffer2KHR = 0; 11918 PFN_vkCmdCopyImage2KHR vkCmdCopyImage2KHR = 0; 11919 PFN_vkCmdCopyBufferToImage2KHR vkCmdCopyBufferToImage2KHR = 0; 11920 PFN_vkCmdCopyImageToBuffer2KHR vkCmdCopyImageToBuffer2KHR = 0; 11921 PFN_vkCmdBlitImage2KHR vkCmdBlitImage2KHR = 0; 11922 PFN_vkCmdResolveImage2KHR vkCmdResolveImage2KHR = 0; 11923 11924 #if defined( VK_USE_PLATFORM_WIN32_KHR ) 11925 //=== VK_NV_acquire_winrt_display === 11926 PFN_vkAcquireWinrtDisplayNV vkAcquireWinrtDisplayNV = 0; 11927 PFN_vkGetWinrtDisplayNV vkGetWinrtDisplayNV = 0; 11928 #else 11929 PFN_dummy vkAcquireWinrtDisplayNV_placeholder = 0; 11930 PFN_dummy vkGetWinrtDisplayNV_placeholder = 0; 11931 #endif /*VK_USE_PLATFORM_WIN32_KHR*/ 11932 11933 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) 11934 //=== VK_EXT_directfb_surface === 11935 PFN_vkCreateDirectFBSurfaceEXT vkCreateDirectFBSurfaceEXT = 0; 11936 PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT vkGetPhysicalDeviceDirectFBPresentationSupportEXT = 0; 11937 #else 11938 PFN_dummy vkCreateDirectFBSurfaceEXT_placeholder = 0; 11939 PFN_dummy vkGetPhysicalDeviceDirectFBPresentationSupportEXT_placeholder = 0; 11940 #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ 11941 11942 //=== VK_KHR_ray_tracing_pipeline === 11943 PFN_vkCmdTraceRaysKHR vkCmdTraceRaysKHR = 0; 11944 PFN_vkCreateRayTracingPipelinesKHR vkCreateRayTracingPipelinesKHR = 0; 11945 PFN_vkGetRayTracingShaderGroupHandlesKHR vkGetRayTracingShaderGroupHandlesKHR = 0; 11946 PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = 0; 11947 PFN_vkCmdTraceRaysIndirectKHR vkCmdTraceRaysIndirectKHR = 0; 11948 PFN_vkGetRayTracingShaderGroupStackSizeKHR vkGetRayTracingShaderGroupStackSizeKHR = 0; 11949 PFN_vkCmdSetRayTracingPipelineStackSizeKHR vkCmdSetRayTracingPipelineStackSizeKHR = 0; 11950 11951 //=== VK_EXT_vertex_input_dynamic_state === 11952 PFN_vkCmdSetVertexInputEXT vkCmdSetVertexInputEXT = 0; 11953 11954 #if defined( VK_USE_PLATFORM_FUCHSIA ) 11955 //=== VK_FUCHSIA_external_memory === 11956 PFN_vkGetMemoryZirconHandleFUCHSIA vkGetMemoryZirconHandleFUCHSIA = 0; 11957 PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA vkGetMemoryZirconHandlePropertiesFUCHSIA = 0; 11958 #else 11959 PFN_dummy vkGetMemoryZirconHandleFUCHSIA_placeholder = 0; 11960 PFN_dummy vkGetMemoryZirconHandlePropertiesFUCHSIA_placeholder = 0; 11961 #endif /*VK_USE_PLATFORM_FUCHSIA*/ 11962 11963 #if defined( VK_USE_PLATFORM_FUCHSIA ) 11964 //=== VK_FUCHSIA_external_semaphore === 11965 PFN_vkImportSemaphoreZirconHandleFUCHSIA vkImportSemaphoreZirconHandleFUCHSIA = 0; 11966 PFN_vkGetSemaphoreZirconHandleFUCHSIA vkGetSemaphoreZirconHandleFUCHSIA = 0; 11967 #else 11968 PFN_dummy vkImportSemaphoreZirconHandleFUCHSIA_placeholder = 0; 11969 PFN_dummy vkGetSemaphoreZirconHandleFUCHSIA_placeholder = 0; 11970 #endif /*VK_USE_PLATFORM_FUCHSIA*/ 11971 11972 #if defined( VK_USE_PLATFORM_FUCHSIA ) 11973 //=== VK_FUCHSIA_buffer_collection === 11974 PFN_vkCreateBufferCollectionFUCHSIA vkCreateBufferCollectionFUCHSIA = 0; 11975 PFN_vkSetBufferCollectionImageConstraintsFUCHSIA vkSetBufferCollectionImageConstraintsFUCHSIA = 0; 11976 PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA vkSetBufferCollectionBufferConstraintsFUCHSIA = 0; 11977 PFN_vkDestroyBufferCollectionFUCHSIA vkDestroyBufferCollectionFUCHSIA = 0; 11978 PFN_vkGetBufferCollectionPropertiesFUCHSIA vkGetBufferCollectionPropertiesFUCHSIA = 0; 11979 #else 11980 PFN_dummy vkCreateBufferCollectionFUCHSIA_placeholder = 0; 11981 PFN_dummy vkSetBufferCollectionImageConstraintsFUCHSIA_placeholder = 0; 11982 PFN_dummy vkSetBufferCollectionBufferConstraintsFUCHSIA_placeholder = 0; 11983 PFN_dummy vkDestroyBufferCollectionFUCHSIA_placeholder = 0; 11984 PFN_dummy vkGetBufferCollectionPropertiesFUCHSIA_placeholder = 0; 11985 #endif /*VK_USE_PLATFORM_FUCHSIA*/ 11986 11987 //=== VK_HUAWEI_subpass_shading === 11988 PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = 0; 11989 PFN_vkCmdSubpassShadingHUAWEI vkCmdSubpassShadingHUAWEI = 0; 11990 11991 //=== VK_HUAWEI_invocation_mask === 11992 PFN_vkCmdBindInvocationMaskHUAWEI vkCmdBindInvocationMaskHUAWEI = 0; 11993 11994 //=== VK_NV_external_memory_rdma === 11995 PFN_vkGetMemoryRemoteAddressNV vkGetMemoryRemoteAddressNV = 0; 11996 11997 //=== VK_EXT_extended_dynamic_state2 === 11998 PFN_vkCmdSetPatchControlPointsEXT vkCmdSetPatchControlPointsEXT = 0; 11999 PFN_vkCmdSetRasterizerDiscardEnableEXT vkCmdSetRasterizerDiscardEnableEXT = 0; 12000 PFN_vkCmdSetDepthBiasEnableEXT vkCmdSetDepthBiasEnableEXT = 0; 12001 PFN_vkCmdSetLogicOpEXT vkCmdSetLogicOpEXT = 0; 12002 PFN_vkCmdSetPrimitiveRestartEnableEXT vkCmdSetPrimitiveRestartEnableEXT = 0; 12003 12004 #if defined( VK_USE_PLATFORM_SCREEN_QNX ) 12005 //=== VK_QNX_screen_surface === 12006 PFN_vkCreateScreenSurfaceQNX vkCreateScreenSurfaceQNX = 0; 12007 PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX vkGetPhysicalDeviceScreenPresentationSupportQNX = 0; 12008 #else 12009 PFN_dummy vkCreateScreenSurfaceQNX_placeholder = 0; 12010 PFN_dummy vkGetPhysicalDeviceScreenPresentationSupportQNX_placeholder = 0; 12011 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 12012 12013 //=== VK_EXT_color_write_enable === 12014 PFN_vkCmdSetColorWriteEnableEXT vkCmdSetColorWriteEnableEXT = 0; 12015 12016 //=== VK_EXT_multi_draw === 12017 PFN_vkCmdDrawMultiEXT vkCmdDrawMultiEXT = 0; 12018 PFN_vkCmdDrawMultiIndexedEXT vkCmdDrawMultiIndexedEXT = 0; 12019 12020 //=== VK_EXT_pageable_device_local_memory === 12021 PFN_vkSetDeviceMemoryPriorityEXT vkSetDeviceMemoryPriorityEXT = 0; 12022 12023 //=== VK_KHR_maintenance4 === 12024 PFN_vkGetDeviceBufferMemoryRequirementsKHR vkGetDeviceBufferMemoryRequirementsKHR = 0; 12025 PFN_vkGetDeviceImageMemoryRequirementsKHR vkGetDeviceImageMemoryRequirementsKHR = 0; 12026 PFN_vkGetDeviceImageSparseMemoryRequirementsKHR vkGetDeviceImageSparseMemoryRequirementsKHR = 0; 12027 12028 public: 12029 DispatchLoaderDynamic() VULKAN_HPP_NOEXCEPT = default; 12030 DispatchLoaderDynamic( DispatchLoaderDynamic const & rhs ) VULKAN_HPP_NOEXCEPT = default; 12031 12032 #if !defined( VK_NO_PROTOTYPES ) 12033 // This interface is designed to be used for per-device function pointers in combination with a linked vulkan 12034 // library. 12035 template <typename DynamicLoader> init(VULKAN_HPP_NAMESPACE::Instance const & instance,VULKAN_HPP_NAMESPACE::Device const & device,DynamicLoader const & dl)12036 void init( VULKAN_HPP_NAMESPACE::Instance const & instance, 12037 VULKAN_HPP_NAMESPACE::Device const & device, 12038 DynamicLoader const & dl ) VULKAN_HPP_NOEXCEPT 12039 { 12040 PFN_vkGetInstanceProcAddr getInstanceProcAddr = 12041 dl.template getProcAddress<PFN_vkGetInstanceProcAddr>( "vkGetInstanceProcAddr" ); 12042 PFN_vkGetDeviceProcAddr getDeviceProcAddr = 12043 dl.template getProcAddress<PFN_vkGetDeviceProcAddr>( "vkGetDeviceProcAddr" ); 12044 init( static_cast<VkInstance>( instance ), 12045 getInstanceProcAddr, 12046 static_cast<VkDevice>( device ), 12047 device ? getDeviceProcAddr : nullptr ); 12048 } 12049 12050 // This interface is designed to be used for per-device function pointers in combination with a linked vulkan 12051 // library. 12052 template <typename DynamicLoader 12053 # if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL 12054 = VULKAN_HPP_NAMESPACE::DynamicLoader 12055 # endif 12056 > init(VULKAN_HPP_NAMESPACE::Instance const & instance,VULKAN_HPP_NAMESPACE::Device const & device)12057 void init( VULKAN_HPP_NAMESPACE::Instance const & instance, 12058 VULKAN_HPP_NAMESPACE::Device const & device ) VULKAN_HPP_NOEXCEPT 12059 { 12060 static DynamicLoader dl; 12061 init( instance, device, dl ); 12062 } 12063 #endif // !defined( VK_NO_PROTOTYPES ) 12064 DispatchLoaderDynamic(PFN_vkGetInstanceProcAddr getInstanceProcAddr)12065 DispatchLoaderDynamic( PFN_vkGetInstanceProcAddr getInstanceProcAddr ) VULKAN_HPP_NOEXCEPT 12066 { 12067 init( getInstanceProcAddr ); 12068 } 12069 init(PFN_vkGetInstanceProcAddr getInstanceProcAddr)12070 void init( PFN_vkGetInstanceProcAddr getInstanceProcAddr ) VULKAN_HPP_NOEXCEPT 12071 { 12072 VULKAN_HPP_ASSERT( getInstanceProcAddr ); 12073 12074 vkGetInstanceProcAddr = getInstanceProcAddr; 12075 12076 //=== VK_VERSION_1_0 === 12077 vkCreateInstance = PFN_vkCreateInstance( vkGetInstanceProcAddr( NULL, "vkCreateInstance" ) ); 12078 vkEnumerateInstanceExtensionProperties = PFN_vkEnumerateInstanceExtensionProperties( 12079 vkGetInstanceProcAddr( NULL, "vkEnumerateInstanceExtensionProperties" ) ); 12080 vkEnumerateInstanceLayerProperties = 12081 PFN_vkEnumerateInstanceLayerProperties( vkGetInstanceProcAddr( NULL, "vkEnumerateInstanceLayerProperties" ) ); 12082 12083 //=== VK_VERSION_1_1 === 12084 vkEnumerateInstanceVersion = 12085 PFN_vkEnumerateInstanceVersion( vkGetInstanceProcAddr( NULL, "vkEnumerateInstanceVersion" ) ); 12086 } 12087 12088 // This interface does not require a linked vulkan library. DispatchLoaderDynamic(VkInstance instance,PFN_vkGetInstanceProcAddr getInstanceProcAddr,VkDevice device={},PFN_vkGetDeviceProcAddr getDeviceProcAddr=nullptr)12089 DispatchLoaderDynamic( VkInstance instance, 12090 PFN_vkGetInstanceProcAddr getInstanceProcAddr, 12091 VkDevice device = {}, 12092 PFN_vkGetDeviceProcAddr getDeviceProcAddr = nullptr ) VULKAN_HPP_NOEXCEPT 12093 { 12094 init( instance, getInstanceProcAddr, device, getDeviceProcAddr ); 12095 } 12096 12097 // This interface does not require a linked vulkan library. init(VkInstance instance,PFN_vkGetInstanceProcAddr getInstanceProcAddr,VkDevice device={},PFN_vkGetDeviceProcAddr=nullptr)12098 void init( VkInstance instance, 12099 PFN_vkGetInstanceProcAddr getInstanceProcAddr, 12100 VkDevice device = {}, 12101 PFN_vkGetDeviceProcAddr /*getDeviceProcAddr*/ = nullptr ) VULKAN_HPP_NOEXCEPT 12102 { 12103 VULKAN_HPP_ASSERT( instance && getInstanceProcAddr ); 12104 vkGetInstanceProcAddr = getInstanceProcAddr; 12105 init( VULKAN_HPP_NAMESPACE::Instance( instance ) ); 12106 if ( device ) 12107 { 12108 init( VULKAN_HPP_NAMESPACE::Device( device ) ); 12109 } 12110 } 12111 init(VULKAN_HPP_NAMESPACE::Instance instanceCpp)12112 void init( VULKAN_HPP_NAMESPACE::Instance instanceCpp ) VULKAN_HPP_NOEXCEPT 12113 { 12114 VkInstance instance = static_cast<VkInstance>( instanceCpp ); 12115 12116 //=== VK_VERSION_1_0 === 12117 vkDestroyInstance = PFN_vkDestroyInstance( vkGetInstanceProcAddr( instance, "vkDestroyInstance" ) ); 12118 vkEnumeratePhysicalDevices = 12119 PFN_vkEnumeratePhysicalDevices( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDevices" ) ); 12120 vkGetPhysicalDeviceFeatures = 12121 PFN_vkGetPhysicalDeviceFeatures( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures" ) ); 12122 vkGetPhysicalDeviceFormatProperties = PFN_vkGetPhysicalDeviceFormatProperties( 12123 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties" ) ); 12124 vkGetPhysicalDeviceImageFormatProperties = PFN_vkGetPhysicalDeviceImageFormatProperties( 12125 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties" ) ); 12126 vkGetPhysicalDeviceProperties = 12127 PFN_vkGetPhysicalDeviceProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties" ) ); 12128 vkGetPhysicalDeviceQueueFamilyProperties = PFN_vkGetPhysicalDeviceQueueFamilyProperties( 12129 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties" ) ); 12130 vkGetPhysicalDeviceMemoryProperties = PFN_vkGetPhysicalDeviceMemoryProperties( 12131 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties" ) ); 12132 vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr( vkGetInstanceProcAddr( instance, "vkGetDeviceProcAddr" ) ); 12133 vkCreateDevice = PFN_vkCreateDevice( vkGetInstanceProcAddr( instance, "vkCreateDevice" ) ); 12134 vkDestroyDevice = PFN_vkDestroyDevice( vkGetInstanceProcAddr( instance, "vkDestroyDevice" ) ); 12135 vkEnumerateDeviceExtensionProperties = PFN_vkEnumerateDeviceExtensionProperties( 12136 vkGetInstanceProcAddr( instance, "vkEnumerateDeviceExtensionProperties" ) ); 12137 vkEnumerateDeviceLayerProperties = 12138 PFN_vkEnumerateDeviceLayerProperties( vkGetInstanceProcAddr( instance, "vkEnumerateDeviceLayerProperties" ) ); 12139 vkGetDeviceQueue = PFN_vkGetDeviceQueue( vkGetInstanceProcAddr( instance, "vkGetDeviceQueue" ) ); 12140 vkQueueSubmit = PFN_vkQueueSubmit( vkGetInstanceProcAddr( instance, "vkQueueSubmit" ) ); 12141 vkQueueWaitIdle = PFN_vkQueueWaitIdle( vkGetInstanceProcAddr( instance, "vkQueueWaitIdle" ) ); 12142 vkDeviceWaitIdle = PFN_vkDeviceWaitIdle( vkGetInstanceProcAddr( instance, "vkDeviceWaitIdle" ) ); 12143 vkAllocateMemory = PFN_vkAllocateMemory( vkGetInstanceProcAddr( instance, "vkAllocateMemory" ) ); 12144 vkFreeMemory = PFN_vkFreeMemory( vkGetInstanceProcAddr( instance, "vkFreeMemory" ) ); 12145 vkMapMemory = PFN_vkMapMemory( vkGetInstanceProcAddr( instance, "vkMapMemory" ) ); 12146 vkUnmapMemory = PFN_vkUnmapMemory( vkGetInstanceProcAddr( instance, "vkUnmapMemory" ) ); 12147 vkFlushMappedMemoryRanges = 12148 PFN_vkFlushMappedMemoryRanges( vkGetInstanceProcAddr( instance, "vkFlushMappedMemoryRanges" ) ); 12149 vkInvalidateMappedMemoryRanges = 12150 PFN_vkInvalidateMappedMemoryRanges( vkGetInstanceProcAddr( instance, "vkInvalidateMappedMemoryRanges" ) ); 12151 vkGetDeviceMemoryCommitment = 12152 PFN_vkGetDeviceMemoryCommitment( vkGetInstanceProcAddr( instance, "vkGetDeviceMemoryCommitment" ) ); 12153 vkBindBufferMemory = PFN_vkBindBufferMemory( vkGetInstanceProcAddr( instance, "vkBindBufferMemory" ) ); 12154 vkBindImageMemory = PFN_vkBindImageMemory( vkGetInstanceProcAddr( instance, "vkBindImageMemory" ) ); 12155 vkGetBufferMemoryRequirements = 12156 PFN_vkGetBufferMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetBufferMemoryRequirements" ) ); 12157 vkGetImageMemoryRequirements = 12158 PFN_vkGetImageMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetImageMemoryRequirements" ) ); 12159 vkGetImageSparseMemoryRequirements = PFN_vkGetImageSparseMemoryRequirements( 12160 vkGetInstanceProcAddr( instance, "vkGetImageSparseMemoryRequirements" ) ); 12161 vkGetPhysicalDeviceSparseImageFormatProperties = PFN_vkGetPhysicalDeviceSparseImageFormatProperties( 12162 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties" ) ); 12163 vkQueueBindSparse = PFN_vkQueueBindSparse( vkGetInstanceProcAddr( instance, "vkQueueBindSparse" ) ); 12164 vkCreateFence = PFN_vkCreateFence( vkGetInstanceProcAddr( instance, "vkCreateFence" ) ); 12165 vkDestroyFence = PFN_vkDestroyFence( vkGetInstanceProcAddr( instance, "vkDestroyFence" ) ); 12166 vkResetFences = PFN_vkResetFences( vkGetInstanceProcAddr( instance, "vkResetFences" ) ); 12167 vkGetFenceStatus = PFN_vkGetFenceStatus( vkGetInstanceProcAddr( instance, "vkGetFenceStatus" ) ); 12168 vkWaitForFences = PFN_vkWaitForFences( vkGetInstanceProcAddr( instance, "vkWaitForFences" ) ); 12169 vkCreateSemaphore = PFN_vkCreateSemaphore( vkGetInstanceProcAddr( instance, "vkCreateSemaphore" ) ); 12170 vkDestroySemaphore = PFN_vkDestroySemaphore( vkGetInstanceProcAddr( instance, "vkDestroySemaphore" ) ); 12171 vkCreateEvent = PFN_vkCreateEvent( vkGetInstanceProcAddr( instance, "vkCreateEvent" ) ); 12172 vkDestroyEvent = PFN_vkDestroyEvent( vkGetInstanceProcAddr( instance, "vkDestroyEvent" ) ); 12173 vkGetEventStatus = PFN_vkGetEventStatus( vkGetInstanceProcAddr( instance, "vkGetEventStatus" ) ); 12174 vkSetEvent = PFN_vkSetEvent( vkGetInstanceProcAddr( instance, "vkSetEvent" ) ); 12175 vkResetEvent = PFN_vkResetEvent( vkGetInstanceProcAddr( instance, "vkResetEvent" ) ); 12176 vkCreateQueryPool = PFN_vkCreateQueryPool( vkGetInstanceProcAddr( instance, "vkCreateQueryPool" ) ); 12177 vkDestroyQueryPool = PFN_vkDestroyQueryPool( vkGetInstanceProcAddr( instance, "vkDestroyQueryPool" ) ); 12178 vkGetQueryPoolResults = PFN_vkGetQueryPoolResults( vkGetInstanceProcAddr( instance, "vkGetQueryPoolResults" ) ); 12179 vkCreateBuffer = PFN_vkCreateBuffer( vkGetInstanceProcAddr( instance, "vkCreateBuffer" ) ); 12180 vkDestroyBuffer = PFN_vkDestroyBuffer( vkGetInstanceProcAddr( instance, "vkDestroyBuffer" ) ); 12181 vkCreateBufferView = PFN_vkCreateBufferView( vkGetInstanceProcAddr( instance, "vkCreateBufferView" ) ); 12182 vkDestroyBufferView = PFN_vkDestroyBufferView( vkGetInstanceProcAddr( instance, "vkDestroyBufferView" ) ); 12183 vkCreateImage = PFN_vkCreateImage( vkGetInstanceProcAddr( instance, "vkCreateImage" ) ); 12184 vkDestroyImage = PFN_vkDestroyImage( vkGetInstanceProcAddr( instance, "vkDestroyImage" ) ); 12185 vkGetImageSubresourceLayout = 12186 PFN_vkGetImageSubresourceLayout( vkGetInstanceProcAddr( instance, "vkGetImageSubresourceLayout" ) ); 12187 vkCreateImageView = PFN_vkCreateImageView( vkGetInstanceProcAddr( instance, "vkCreateImageView" ) ); 12188 vkDestroyImageView = PFN_vkDestroyImageView( vkGetInstanceProcAddr( instance, "vkDestroyImageView" ) ); 12189 vkCreateShaderModule = PFN_vkCreateShaderModule( vkGetInstanceProcAddr( instance, "vkCreateShaderModule" ) ); 12190 vkDestroyShaderModule = PFN_vkDestroyShaderModule( vkGetInstanceProcAddr( instance, "vkDestroyShaderModule" ) ); 12191 vkCreatePipelineCache = PFN_vkCreatePipelineCache( vkGetInstanceProcAddr( instance, "vkCreatePipelineCache" ) ); 12192 vkDestroyPipelineCache = 12193 PFN_vkDestroyPipelineCache( vkGetInstanceProcAddr( instance, "vkDestroyPipelineCache" ) ); 12194 vkGetPipelineCacheData = 12195 PFN_vkGetPipelineCacheData( vkGetInstanceProcAddr( instance, "vkGetPipelineCacheData" ) ); 12196 vkMergePipelineCaches = PFN_vkMergePipelineCaches( vkGetInstanceProcAddr( instance, "vkMergePipelineCaches" ) ); 12197 vkCreateGraphicsPipelines = 12198 PFN_vkCreateGraphicsPipelines( vkGetInstanceProcAddr( instance, "vkCreateGraphicsPipelines" ) ); 12199 vkCreateComputePipelines = 12200 PFN_vkCreateComputePipelines( vkGetInstanceProcAddr( instance, "vkCreateComputePipelines" ) ); 12201 vkDestroyPipeline = PFN_vkDestroyPipeline( vkGetInstanceProcAddr( instance, "vkDestroyPipeline" ) ); 12202 vkCreatePipelineLayout = 12203 PFN_vkCreatePipelineLayout( vkGetInstanceProcAddr( instance, "vkCreatePipelineLayout" ) ); 12204 vkDestroyPipelineLayout = 12205 PFN_vkDestroyPipelineLayout( vkGetInstanceProcAddr( instance, "vkDestroyPipelineLayout" ) ); 12206 vkCreateSampler = PFN_vkCreateSampler( vkGetInstanceProcAddr( instance, "vkCreateSampler" ) ); 12207 vkDestroySampler = PFN_vkDestroySampler( vkGetInstanceProcAddr( instance, "vkDestroySampler" ) ); 12208 vkCreateDescriptorSetLayout = 12209 PFN_vkCreateDescriptorSetLayout( vkGetInstanceProcAddr( instance, "vkCreateDescriptorSetLayout" ) ); 12210 vkDestroyDescriptorSetLayout = 12211 PFN_vkDestroyDescriptorSetLayout( vkGetInstanceProcAddr( instance, "vkDestroyDescriptorSetLayout" ) ); 12212 vkCreateDescriptorPool = 12213 PFN_vkCreateDescriptorPool( vkGetInstanceProcAddr( instance, "vkCreateDescriptorPool" ) ); 12214 vkDestroyDescriptorPool = 12215 PFN_vkDestroyDescriptorPool( vkGetInstanceProcAddr( instance, "vkDestroyDescriptorPool" ) ); 12216 vkResetDescriptorPool = PFN_vkResetDescriptorPool( vkGetInstanceProcAddr( instance, "vkResetDescriptorPool" ) ); 12217 vkAllocateDescriptorSets = 12218 PFN_vkAllocateDescriptorSets( vkGetInstanceProcAddr( instance, "vkAllocateDescriptorSets" ) ); 12219 vkFreeDescriptorSets = PFN_vkFreeDescriptorSets( vkGetInstanceProcAddr( instance, "vkFreeDescriptorSets" ) ); 12220 vkUpdateDescriptorSets = 12221 PFN_vkUpdateDescriptorSets( vkGetInstanceProcAddr( instance, "vkUpdateDescriptorSets" ) ); 12222 vkCreateFramebuffer = PFN_vkCreateFramebuffer( vkGetInstanceProcAddr( instance, "vkCreateFramebuffer" ) ); 12223 vkDestroyFramebuffer = PFN_vkDestroyFramebuffer( vkGetInstanceProcAddr( instance, "vkDestroyFramebuffer" ) ); 12224 vkCreateRenderPass = PFN_vkCreateRenderPass( vkGetInstanceProcAddr( instance, "vkCreateRenderPass" ) ); 12225 vkDestroyRenderPass = PFN_vkDestroyRenderPass( vkGetInstanceProcAddr( instance, "vkDestroyRenderPass" ) ); 12226 vkGetRenderAreaGranularity = 12227 PFN_vkGetRenderAreaGranularity( vkGetInstanceProcAddr( instance, "vkGetRenderAreaGranularity" ) ); 12228 vkCreateCommandPool = PFN_vkCreateCommandPool( vkGetInstanceProcAddr( instance, "vkCreateCommandPool" ) ); 12229 vkDestroyCommandPool = PFN_vkDestroyCommandPool( vkGetInstanceProcAddr( instance, "vkDestroyCommandPool" ) ); 12230 vkResetCommandPool = PFN_vkResetCommandPool( vkGetInstanceProcAddr( instance, "vkResetCommandPool" ) ); 12231 vkAllocateCommandBuffers = 12232 PFN_vkAllocateCommandBuffers( vkGetInstanceProcAddr( instance, "vkAllocateCommandBuffers" ) ); 12233 vkFreeCommandBuffers = PFN_vkFreeCommandBuffers( vkGetInstanceProcAddr( instance, "vkFreeCommandBuffers" ) ); 12234 vkBeginCommandBuffer = PFN_vkBeginCommandBuffer( vkGetInstanceProcAddr( instance, "vkBeginCommandBuffer" ) ); 12235 vkEndCommandBuffer = PFN_vkEndCommandBuffer( vkGetInstanceProcAddr( instance, "vkEndCommandBuffer" ) ); 12236 vkResetCommandBuffer = PFN_vkResetCommandBuffer( vkGetInstanceProcAddr( instance, "vkResetCommandBuffer" ) ); 12237 vkCmdBindPipeline = PFN_vkCmdBindPipeline( vkGetInstanceProcAddr( instance, "vkCmdBindPipeline" ) ); 12238 vkCmdSetViewport = PFN_vkCmdSetViewport( vkGetInstanceProcAddr( instance, "vkCmdSetViewport" ) ); 12239 vkCmdSetScissor = PFN_vkCmdSetScissor( vkGetInstanceProcAddr( instance, "vkCmdSetScissor" ) ); 12240 vkCmdSetLineWidth = PFN_vkCmdSetLineWidth( vkGetInstanceProcAddr( instance, "vkCmdSetLineWidth" ) ); 12241 vkCmdSetDepthBias = PFN_vkCmdSetDepthBias( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBias" ) ); 12242 vkCmdSetBlendConstants = 12243 PFN_vkCmdSetBlendConstants( vkGetInstanceProcAddr( instance, "vkCmdSetBlendConstants" ) ); 12244 vkCmdSetDepthBounds = PFN_vkCmdSetDepthBounds( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBounds" ) ); 12245 vkCmdSetStencilCompareMask = 12246 PFN_vkCmdSetStencilCompareMask( vkGetInstanceProcAddr( instance, "vkCmdSetStencilCompareMask" ) ); 12247 vkCmdSetStencilWriteMask = 12248 PFN_vkCmdSetStencilWriteMask( vkGetInstanceProcAddr( instance, "vkCmdSetStencilWriteMask" ) ); 12249 vkCmdSetStencilReference = 12250 PFN_vkCmdSetStencilReference( vkGetInstanceProcAddr( instance, "vkCmdSetStencilReference" ) ); 12251 vkCmdBindDescriptorSets = 12252 PFN_vkCmdBindDescriptorSets( vkGetInstanceProcAddr( instance, "vkCmdBindDescriptorSets" ) ); 12253 vkCmdBindIndexBuffer = PFN_vkCmdBindIndexBuffer( vkGetInstanceProcAddr( instance, "vkCmdBindIndexBuffer" ) ); 12254 vkCmdBindVertexBuffers = 12255 PFN_vkCmdBindVertexBuffers( vkGetInstanceProcAddr( instance, "vkCmdBindVertexBuffers" ) ); 12256 vkCmdDraw = PFN_vkCmdDraw( vkGetInstanceProcAddr( instance, "vkCmdDraw" ) ); 12257 vkCmdDrawIndexed = PFN_vkCmdDrawIndexed( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexed" ) ); 12258 vkCmdDrawIndirect = PFN_vkCmdDrawIndirect( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirect" ) ); 12259 vkCmdDrawIndexedIndirect = 12260 PFN_vkCmdDrawIndexedIndirect( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirect" ) ); 12261 vkCmdDispatch = PFN_vkCmdDispatch( vkGetInstanceProcAddr( instance, "vkCmdDispatch" ) ); 12262 vkCmdDispatchIndirect = PFN_vkCmdDispatchIndirect( vkGetInstanceProcAddr( instance, "vkCmdDispatchIndirect" ) ); 12263 vkCmdCopyBuffer = PFN_vkCmdCopyBuffer( vkGetInstanceProcAddr( instance, "vkCmdCopyBuffer" ) ); 12264 vkCmdCopyImage = PFN_vkCmdCopyImage( vkGetInstanceProcAddr( instance, "vkCmdCopyImage" ) ); 12265 vkCmdBlitImage = PFN_vkCmdBlitImage( vkGetInstanceProcAddr( instance, "vkCmdBlitImage" ) ); 12266 vkCmdCopyBufferToImage = 12267 PFN_vkCmdCopyBufferToImage( vkGetInstanceProcAddr( instance, "vkCmdCopyBufferToImage" ) ); 12268 vkCmdCopyImageToBuffer = 12269 PFN_vkCmdCopyImageToBuffer( vkGetInstanceProcAddr( instance, "vkCmdCopyImageToBuffer" ) ); 12270 vkCmdUpdateBuffer = PFN_vkCmdUpdateBuffer( vkGetInstanceProcAddr( instance, "vkCmdUpdateBuffer" ) ); 12271 vkCmdFillBuffer = PFN_vkCmdFillBuffer( vkGetInstanceProcAddr( instance, "vkCmdFillBuffer" ) ); 12272 vkCmdClearColorImage = PFN_vkCmdClearColorImage( vkGetInstanceProcAddr( instance, "vkCmdClearColorImage" ) ); 12273 vkCmdClearDepthStencilImage = 12274 PFN_vkCmdClearDepthStencilImage( vkGetInstanceProcAddr( instance, "vkCmdClearDepthStencilImage" ) ); 12275 vkCmdClearAttachments = PFN_vkCmdClearAttachments( vkGetInstanceProcAddr( instance, "vkCmdClearAttachments" ) ); 12276 vkCmdResolveImage = PFN_vkCmdResolveImage( vkGetInstanceProcAddr( instance, "vkCmdResolveImage" ) ); 12277 vkCmdSetEvent = PFN_vkCmdSetEvent( vkGetInstanceProcAddr( instance, "vkCmdSetEvent" ) ); 12278 vkCmdResetEvent = PFN_vkCmdResetEvent( vkGetInstanceProcAddr( instance, "vkCmdResetEvent" ) ); 12279 vkCmdWaitEvents = PFN_vkCmdWaitEvents( vkGetInstanceProcAddr( instance, "vkCmdWaitEvents" ) ); 12280 vkCmdPipelineBarrier = PFN_vkCmdPipelineBarrier( vkGetInstanceProcAddr( instance, "vkCmdPipelineBarrier" ) ); 12281 vkCmdBeginQuery = PFN_vkCmdBeginQuery( vkGetInstanceProcAddr( instance, "vkCmdBeginQuery" ) ); 12282 vkCmdEndQuery = PFN_vkCmdEndQuery( vkGetInstanceProcAddr( instance, "vkCmdEndQuery" ) ); 12283 vkCmdResetQueryPool = PFN_vkCmdResetQueryPool( vkGetInstanceProcAddr( instance, "vkCmdResetQueryPool" ) ); 12284 vkCmdWriteTimestamp = PFN_vkCmdWriteTimestamp( vkGetInstanceProcAddr( instance, "vkCmdWriteTimestamp" ) ); 12285 vkCmdCopyQueryPoolResults = 12286 PFN_vkCmdCopyQueryPoolResults( vkGetInstanceProcAddr( instance, "vkCmdCopyQueryPoolResults" ) ); 12287 vkCmdPushConstants = PFN_vkCmdPushConstants( vkGetInstanceProcAddr( instance, "vkCmdPushConstants" ) ); 12288 vkCmdBeginRenderPass = PFN_vkCmdBeginRenderPass( vkGetInstanceProcAddr( instance, "vkCmdBeginRenderPass" ) ); 12289 vkCmdNextSubpass = PFN_vkCmdNextSubpass( vkGetInstanceProcAddr( instance, "vkCmdNextSubpass" ) ); 12290 vkCmdEndRenderPass = PFN_vkCmdEndRenderPass( vkGetInstanceProcAddr( instance, "vkCmdEndRenderPass" ) ); 12291 vkCmdExecuteCommands = PFN_vkCmdExecuteCommands( vkGetInstanceProcAddr( instance, "vkCmdExecuteCommands" ) ); 12292 12293 //=== VK_VERSION_1_1 === 12294 vkBindBufferMemory2 = PFN_vkBindBufferMemory2( vkGetInstanceProcAddr( instance, "vkBindBufferMemory2" ) ); 12295 vkBindImageMemory2 = PFN_vkBindImageMemory2( vkGetInstanceProcAddr( instance, "vkBindImageMemory2" ) ); 12296 vkGetDeviceGroupPeerMemoryFeatures = PFN_vkGetDeviceGroupPeerMemoryFeatures( 12297 vkGetInstanceProcAddr( instance, "vkGetDeviceGroupPeerMemoryFeatures" ) ); 12298 vkCmdSetDeviceMask = PFN_vkCmdSetDeviceMask( vkGetInstanceProcAddr( instance, "vkCmdSetDeviceMask" ) ); 12299 vkCmdDispatchBase = PFN_vkCmdDispatchBase( vkGetInstanceProcAddr( instance, "vkCmdDispatchBase" ) ); 12300 vkEnumeratePhysicalDeviceGroups = 12301 PFN_vkEnumeratePhysicalDeviceGroups( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceGroups" ) ); 12302 vkGetImageMemoryRequirements2 = 12303 PFN_vkGetImageMemoryRequirements2( vkGetInstanceProcAddr( instance, "vkGetImageMemoryRequirements2" ) ); 12304 vkGetBufferMemoryRequirements2 = 12305 PFN_vkGetBufferMemoryRequirements2( vkGetInstanceProcAddr( instance, "vkGetBufferMemoryRequirements2" ) ); 12306 vkGetImageSparseMemoryRequirements2 = PFN_vkGetImageSparseMemoryRequirements2( 12307 vkGetInstanceProcAddr( instance, "vkGetImageSparseMemoryRequirements2" ) ); 12308 vkGetPhysicalDeviceFeatures2 = 12309 PFN_vkGetPhysicalDeviceFeatures2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures2" ) ); 12310 vkGetPhysicalDeviceProperties2 = 12311 PFN_vkGetPhysicalDeviceProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties2" ) ); 12312 vkGetPhysicalDeviceFormatProperties2 = PFN_vkGetPhysicalDeviceFormatProperties2( 12313 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties2" ) ); 12314 vkGetPhysicalDeviceImageFormatProperties2 = PFN_vkGetPhysicalDeviceImageFormatProperties2( 12315 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties2" ) ); 12316 vkGetPhysicalDeviceQueueFamilyProperties2 = PFN_vkGetPhysicalDeviceQueueFamilyProperties2( 12317 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties2" ) ); 12318 vkGetPhysicalDeviceMemoryProperties2 = PFN_vkGetPhysicalDeviceMemoryProperties2( 12319 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties2" ) ); 12320 vkGetPhysicalDeviceSparseImageFormatProperties2 = PFN_vkGetPhysicalDeviceSparseImageFormatProperties2( 12321 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties2" ) ); 12322 vkTrimCommandPool = PFN_vkTrimCommandPool( vkGetInstanceProcAddr( instance, "vkTrimCommandPool" ) ); 12323 vkGetDeviceQueue2 = PFN_vkGetDeviceQueue2( vkGetInstanceProcAddr( instance, "vkGetDeviceQueue2" ) ); 12324 vkCreateSamplerYcbcrConversion = 12325 PFN_vkCreateSamplerYcbcrConversion( vkGetInstanceProcAddr( instance, "vkCreateSamplerYcbcrConversion" ) ); 12326 vkDestroySamplerYcbcrConversion = 12327 PFN_vkDestroySamplerYcbcrConversion( vkGetInstanceProcAddr( instance, "vkDestroySamplerYcbcrConversion" ) ); 12328 vkCreateDescriptorUpdateTemplate = 12329 PFN_vkCreateDescriptorUpdateTemplate( vkGetInstanceProcAddr( instance, "vkCreateDescriptorUpdateTemplate" ) ); 12330 vkDestroyDescriptorUpdateTemplate = 12331 PFN_vkDestroyDescriptorUpdateTemplate( vkGetInstanceProcAddr( instance, "vkDestroyDescriptorUpdateTemplate" ) ); 12332 vkUpdateDescriptorSetWithTemplate = 12333 PFN_vkUpdateDescriptorSetWithTemplate( vkGetInstanceProcAddr( instance, "vkUpdateDescriptorSetWithTemplate" ) ); 12334 vkGetPhysicalDeviceExternalBufferProperties = PFN_vkGetPhysicalDeviceExternalBufferProperties( 12335 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalBufferProperties" ) ); 12336 vkGetPhysicalDeviceExternalFenceProperties = PFN_vkGetPhysicalDeviceExternalFenceProperties( 12337 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalFenceProperties" ) ); 12338 vkGetPhysicalDeviceExternalSemaphoreProperties = PFN_vkGetPhysicalDeviceExternalSemaphoreProperties( 12339 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalSemaphoreProperties" ) ); 12340 vkGetDescriptorSetLayoutSupport = 12341 PFN_vkGetDescriptorSetLayoutSupport( vkGetInstanceProcAddr( instance, "vkGetDescriptorSetLayoutSupport" ) ); 12342 12343 //=== VK_VERSION_1_2 === 12344 vkCmdDrawIndirectCount = 12345 PFN_vkCmdDrawIndirectCount( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectCount" ) ); 12346 vkCmdDrawIndexedIndirectCount = 12347 PFN_vkCmdDrawIndexedIndirectCount( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirectCount" ) ); 12348 vkCreateRenderPass2 = PFN_vkCreateRenderPass2( vkGetInstanceProcAddr( instance, "vkCreateRenderPass2" ) ); 12349 vkCmdBeginRenderPass2 = PFN_vkCmdBeginRenderPass2( vkGetInstanceProcAddr( instance, "vkCmdBeginRenderPass2" ) ); 12350 vkCmdNextSubpass2 = PFN_vkCmdNextSubpass2( vkGetInstanceProcAddr( instance, "vkCmdNextSubpass2" ) ); 12351 vkCmdEndRenderPass2 = PFN_vkCmdEndRenderPass2( vkGetInstanceProcAddr( instance, "vkCmdEndRenderPass2" ) ); 12352 vkResetQueryPool = PFN_vkResetQueryPool( vkGetInstanceProcAddr( instance, "vkResetQueryPool" ) ); 12353 vkGetSemaphoreCounterValue = 12354 PFN_vkGetSemaphoreCounterValue( vkGetInstanceProcAddr( instance, "vkGetSemaphoreCounterValue" ) ); 12355 vkWaitSemaphores = PFN_vkWaitSemaphores( vkGetInstanceProcAddr( instance, "vkWaitSemaphores" ) ); 12356 vkSignalSemaphore = PFN_vkSignalSemaphore( vkGetInstanceProcAddr( instance, "vkSignalSemaphore" ) ); 12357 vkGetBufferDeviceAddress = 12358 PFN_vkGetBufferDeviceAddress( vkGetInstanceProcAddr( instance, "vkGetBufferDeviceAddress" ) ); 12359 vkGetBufferOpaqueCaptureAddress = 12360 PFN_vkGetBufferOpaqueCaptureAddress( vkGetInstanceProcAddr( instance, "vkGetBufferOpaqueCaptureAddress" ) ); 12361 vkGetDeviceMemoryOpaqueCaptureAddress = PFN_vkGetDeviceMemoryOpaqueCaptureAddress( 12362 vkGetInstanceProcAddr( instance, "vkGetDeviceMemoryOpaqueCaptureAddress" ) ); 12363 12364 //=== VK_KHR_surface === 12365 vkDestroySurfaceKHR = PFN_vkDestroySurfaceKHR( vkGetInstanceProcAddr( instance, "vkDestroySurfaceKHR" ) ); 12366 vkGetPhysicalDeviceSurfaceSupportKHR = PFN_vkGetPhysicalDeviceSurfaceSupportKHR( 12367 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceSupportKHR" ) ); 12368 vkGetPhysicalDeviceSurfaceCapabilitiesKHR = PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR( 12369 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR" ) ); 12370 vkGetPhysicalDeviceSurfaceFormatsKHR = PFN_vkGetPhysicalDeviceSurfaceFormatsKHR( 12371 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceFormatsKHR" ) ); 12372 vkGetPhysicalDeviceSurfacePresentModesKHR = PFN_vkGetPhysicalDeviceSurfacePresentModesKHR( 12373 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfacePresentModesKHR" ) ); 12374 12375 //=== VK_KHR_swapchain === 12376 vkCreateSwapchainKHR = PFN_vkCreateSwapchainKHR( vkGetInstanceProcAddr( instance, "vkCreateSwapchainKHR" ) ); 12377 vkDestroySwapchainKHR = PFN_vkDestroySwapchainKHR( vkGetInstanceProcAddr( instance, "vkDestroySwapchainKHR" ) ); 12378 vkGetSwapchainImagesKHR = 12379 PFN_vkGetSwapchainImagesKHR( vkGetInstanceProcAddr( instance, "vkGetSwapchainImagesKHR" ) ); 12380 vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR( vkGetInstanceProcAddr( instance, "vkAcquireNextImageKHR" ) ); 12381 vkQueuePresentKHR = PFN_vkQueuePresentKHR( vkGetInstanceProcAddr( instance, "vkQueuePresentKHR" ) ); 12382 vkGetDeviceGroupPresentCapabilitiesKHR = PFN_vkGetDeviceGroupPresentCapabilitiesKHR( 12383 vkGetInstanceProcAddr( instance, "vkGetDeviceGroupPresentCapabilitiesKHR" ) ); 12384 vkGetDeviceGroupSurfacePresentModesKHR = PFN_vkGetDeviceGroupSurfacePresentModesKHR( 12385 vkGetInstanceProcAddr( instance, "vkGetDeviceGroupSurfacePresentModesKHR" ) ); 12386 vkGetPhysicalDevicePresentRectanglesKHR = PFN_vkGetPhysicalDevicePresentRectanglesKHR( 12387 vkGetInstanceProcAddr( instance, "vkGetPhysicalDevicePresentRectanglesKHR" ) ); 12388 vkAcquireNextImage2KHR = 12389 PFN_vkAcquireNextImage2KHR( vkGetInstanceProcAddr( instance, "vkAcquireNextImage2KHR" ) ); 12390 12391 //=== VK_KHR_display === 12392 vkGetPhysicalDeviceDisplayPropertiesKHR = PFN_vkGetPhysicalDeviceDisplayPropertiesKHR( 12393 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPropertiesKHR" ) ); 12394 vkGetPhysicalDeviceDisplayPlanePropertiesKHR = PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR( 12395 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR" ) ); 12396 vkGetDisplayPlaneSupportedDisplaysKHR = PFN_vkGetDisplayPlaneSupportedDisplaysKHR( 12397 vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneSupportedDisplaysKHR" ) ); 12398 vkGetDisplayModePropertiesKHR = 12399 PFN_vkGetDisplayModePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayModePropertiesKHR" ) ); 12400 vkCreateDisplayModeKHR = 12401 PFN_vkCreateDisplayModeKHR( vkGetInstanceProcAddr( instance, "vkCreateDisplayModeKHR" ) ); 12402 vkGetDisplayPlaneCapabilitiesKHR = 12403 PFN_vkGetDisplayPlaneCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneCapabilitiesKHR" ) ); 12404 vkCreateDisplayPlaneSurfaceKHR = 12405 PFN_vkCreateDisplayPlaneSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateDisplayPlaneSurfaceKHR" ) ); 12406 12407 //=== VK_KHR_display_swapchain === 12408 vkCreateSharedSwapchainsKHR = 12409 PFN_vkCreateSharedSwapchainsKHR( vkGetInstanceProcAddr( instance, "vkCreateSharedSwapchainsKHR" ) ); 12410 12411 #if defined( VK_USE_PLATFORM_XLIB_KHR ) 12412 //=== VK_KHR_xlib_surface === 12413 vkCreateXlibSurfaceKHR = 12414 PFN_vkCreateXlibSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateXlibSurfaceKHR" ) ); 12415 vkGetPhysicalDeviceXlibPresentationSupportKHR = PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR( 12416 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceXlibPresentationSupportKHR" ) ); 12417 #endif /*VK_USE_PLATFORM_XLIB_KHR*/ 12418 12419 #if defined( VK_USE_PLATFORM_XCB_KHR ) 12420 //=== VK_KHR_xcb_surface === 12421 vkCreateXcbSurfaceKHR = PFN_vkCreateXcbSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateXcbSurfaceKHR" ) ); 12422 vkGetPhysicalDeviceXcbPresentationSupportKHR = PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR( 12423 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceXcbPresentationSupportKHR" ) ); 12424 #endif /*VK_USE_PLATFORM_XCB_KHR*/ 12425 12426 #if defined( VK_USE_PLATFORM_WAYLAND_KHR ) 12427 //=== VK_KHR_wayland_surface === 12428 vkCreateWaylandSurfaceKHR = 12429 PFN_vkCreateWaylandSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateWaylandSurfaceKHR" ) ); 12430 vkGetPhysicalDeviceWaylandPresentationSupportKHR = PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR( 12431 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceWaylandPresentationSupportKHR" ) ); 12432 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ 12433 12434 #if defined( VK_USE_PLATFORM_ANDROID_KHR ) 12435 //=== VK_KHR_android_surface === 12436 vkCreateAndroidSurfaceKHR = 12437 PFN_vkCreateAndroidSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateAndroidSurfaceKHR" ) ); 12438 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 12439 12440 #if defined( VK_USE_PLATFORM_WIN32_KHR ) 12441 //=== VK_KHR_win32_surface === 12442 vkCreateWin32SurfaceKHR = 12443 PFN_vkCreateWin32SurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateWin32SurfaceKHR" ) ); 12444 vkGetPhysicalDeviceWin32PresentationSupportKHR = PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR( 12445 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceWin32PresentationSupportKHR" ) ); 12446 #endif /*VK_USE_PLATFORM_WIN32_KHR*/ 12447 12448 #if defined( VK_USE_PLATFORM_OHOS_OPENHARMONY ) 12449 //=== VK_OpenHarmony_OHOS_surface === 12450 vkCreateOHOSSurfaceOpenHarmony = 12451 PFN_vkCreateOHOSSurfaceOpenHarmony( vkGetInstanceProcAddr( instance, "vkCreateOHOSSurfaceOpenHarmony" ) ); 12452 #endif /*VK_USE_PLATFORM_OHOS_OPENHARMONY*/ 12453 12454 //=== VK_EXT_debug_report === 12455 vkCreateDebugReportCallbackEXT = 12456 PFN_vkCreateDebugReportCallbackEXT( vkGetInstanceProcAddr( instance, "vkCreateDebugReportCallbackEXT" ) ); 12457 vkDestroyDebugReportCallbackEXT = 12458 PFN_vkDestroyDebugReportCallbackEXT( vkGetInstanceProcAddr( instance, "vkDestroyDebugReportCallbackEXT" ) ); 12459 vkDebugReportMessageEXT = 12460 PFN_vkDebugReportMessageEXT( vkGetInstanceProcAddr( instance, "vkDebugReportMessageEXT" ) ); 12461 12462 //=== VK_EXT_debug_marker === 12463 vkDebugMarkerSetObjectTagEXT = 12464 PFN_vkDebugMarkerSetObjectTagEXT( vkGetInstanceProcAddr( instance, "vkDebugMarkerSetObjectTagEXT" ) ); 12465 vkDebugMarkerSetObjectNameEXT = 12466 PFN_vkDebugMarkerSetObjectNameEXT( vkGetInstanceProcAddr( instance, "vkDebugMarkerSetObjectNameEXT" ) ); 12467 vkCmdDebugMarkerBeginEXT = 12468 PFN_vkCmdDebugMarkerBeginEXT( vkGetInstanceProcAddr( instance, "vkCmdDebugMarkerBeginEXT" ) ); 12469 vkCmdDebugMarkerEndEXT = 12470 PFN_vkCmdDebugMarkerEndEXT( vkGetInstanceProcAddr( instance, "vkCmdDebugMarkerEndEXT" ) ); 12471 vkCmdDebugMarkerInsertEXT = 12472 PFN_vkCmdDebugMarkerInsertEXT( vkGetInstanceProcAddr( instance, "vkCmdDebugMarkerInsertEXT" ) ); 12473 12474 #if defined( VK_ENABLE_BETA_EXTENSIONS ) 12475 //=== VK_KHR_video_queue === 12476 vkGetPhysicalDeviceVideoCapabilitiesKHR = PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR( 12477 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceVideoCapabilitiesKHR" ) ); 12478 vkGetPhysicalDeviceVideoFormatPropertiesKHR = PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR( 12479 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceVideoFormatPropertiesKHR" ) ); 12480 vkCreateVideoSessionKHR = 12481 PFN_vkCreateVideoSessionKHR( vkGetInstanceProcAddr( instance, "vkCreateVideoSessionKHR" ) ); 12482 vkDestroyVideoSessionKHR = 12483 PFN_vkDestroyVideoSessionKHR( vkGetInstanceProcAddr( instance, "vkDestroyVideoSessionKHR" ) ); 12484 vkGetVideoSessionMemoryRequirementsKHR = PFN_vkGetVideoSessionMemoryRequirementsKHR( 12485 vkGetInstanceProcAddr( instance, "vkGetVideoSessionMemoryRequirementsKHR" ) ); 12486 vkBindVideoSessionMemoryKHR = 12487 PFN_vkBindVideoSessionMemoryKHR( vkGetInstanceProcAddr( instance, "vkBindVideoSessionMemoryKHR" ) ); 12488 vkCreateVideoSessionParametersKHR = 12489 PFN_vkCreateVideoSessionParametersKHR( vkGetInstanceProcAddr( instance, "vkCreateVideoSessionParametersKHR" ) ); 12490 vkUpdateVideoSessionParametersKHR = 12491 PFN_vkUpdateVideoSessionParametersKHR( vkGetInstanceProcAddr( instance, "vkUpdateVideoSessionParametersKHR" ) ); 12492 vkDestroyVideoSessionParametersKHR = PFN_vkDestroyVideoSessionParametersKHR( 12493 vkGetInstanceProcAddr( instance, "vkDestroyVideoSessionParametersKHR" ) ); 12494 vkCmdBeginVideoCodingKHR = 12495 PFN_vkCmdBeginVideoCodingKHR( vkGetInstanceProcAddr( instance, "vkCmdBeginVideoCodingKHR" ) ); 12496 vkCmdEndVideoCodingKHR = 12497 PFN_vkCmdEndVideoCodingKHR( vkGetInstanceProcAddr( instance, "vkCmdEndVideoCodingKHR" ) ); 12498 vkCmdControlVideoCodingKHR = 12499 PFN_vkCmdControlVideoCodingKHR( vkGetInstanceProcAddr( instance, "vkCmdControlVideoCodingKHR" ) ); 12500 #endif /*VK_ENABLE_BETA_EXTENSIONS*/ 12501 12502 #if defined( VK_ENABLE_BETA_EXTENSIONS ) 12503 //=== VK_KHR_video_decode_queue === 12504 vkCmdDecodeVideoKHR = PFN_vkCmdDecodeVideoKHR( vkGetInstanceProcAddr( instance, "vkCmdDecodeVideoKHR" ) ); 12505 #endif /*VK_ENABLE_BETA_EXTENSIONS*/ 12506 12507 //=== VK_EXT_transform_feedback === 12508 vkCmdBindTransformFeedbackBuffersEXT = PFN_vkCmdBindTransformFeedbackBuffersEXT( 12509 vkGetInstanceProcAddr( instance, "vkCmdBindTransformFeedbackBuffersEXT" ) ); 12510 vkCmdBeginTransformFeedbackEXT = 12511 PFN_vkCmdBeginTransformFeedbackEXT( vkGetInstanceProcAddr( instance, "vkCmdBeginTransformFeedbackEXT" ) ); 12512 vkCmdEndTransformFeedbackEXT = 12513 PFN_vkCmdEndTransformFeedbackEXT( vkGetInstanceProcAddr( instance, "vkCmdEndTransformFeedbackEXT" ) ); 12514 vkCmdBeginQueryIndexedEXT = 12515 PFN_vkCmdBeginQueryIndexedEXT( vkGetInstanceProcAddr( instance, "vkCmdBeginQueryIndexedEXT" ) ); 12516 vkCmdEndQueryIndexedEXT = 12517 PFN_vkCmdEndQueryIndexedEXT( vkGetInstanceProcAddr( instance, "vkCmdEndQueryIndexedEXT" ) ); 12518 vkCmdDrawIndirectByteCountEXT = 12519 PFN_vkCmdDrawIndirectByteCountEXT( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectByteCountEXT" ) ); 12520 12521 //=== VK_NVX_binary_import === 12522 vkCreateCuModuleNVX = PFN_vkCreateCuModuleNVX( vkGetInstanceProcAddr( instance, "vkCreateCuModuleNVX" ) ); 12523 vkCreateCuFunctionNVX = PFN_vkCreateCuFunctionNVX( vkGetInstanceProcAddr( instance, "vkCreateCuFunctionNVX" ) ); 12524 vkDestroyCuModuleNVX = PFN_vkDestroyCuModuleNVX( vkGetInstanceProcAddr( instance, "vkDestroyCuModuleNVX" ) ); 12525 vkDestroyCuFunctionNVX = 12526 PFN_vkDestroyCuFunctionNVX( vkGetInstanceProcAddr( instance, "vkDestroyCuFunctionNVX" ) ); 12527 vkCmdCuLaunchKernelNVX = 12528 PFN_vkCmdCuLaunchKernelNVX( vkGetInstanceProcAddr( instance, "vkCmdCuLaunchKernelNVX" ) ); 12529 12530 //=== VK_NVX_image_view_handle === 12531 vkGetImageViewHandleNVX = 12532 PFN_vkGetImageViewHandleNVX( vkGetInstanceProcAddr( instance, "vkGetImageViewHandleNVX" ) ); 12533 vkGetImageViewAddressNVX = 12534 PFN_vkGetImageViewAddressNVX( vkGetInstanceProcAddr( instance, "vkGetImageViewAddressNVX" ) ); 12535 12536 //=== VK_AMD_draw_indirect_count === 12537 vkCmdDrawIndirectCountAMD = 12538 PFN_vkCmdDrawIndirectCountAMD( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectCountAMD" ) ); 12539 if ( !vkCmdDrawIndirectCount ) 12540 vkCmdDrawIndirectCount = vkCmdDrawIndirectCountAMD; 12541 vkCmdDrawIndexedIndirectCountAMD = 12542 PFN_vkCmdDrawIndexedIndirectCountAMD( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirectCountAMD" ) ); 12543 if ( !vkCmdDrawIndexedIndirectCount ) 12544 vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountAMD; 12545 12546 //=== VK_AMD_shader_info === 12547 vkGetShaderInfoAMD = PFN_vkGetShaderInfoAMD( vkGetInstanceProcAddr( instance, "vkGetShaderInfoAMD" ) ); 12548 12549 //=== VK_KHR_dynamic_rendering === 12550 vkCmdBeginRenderingKHR = 12551 PFN_vkCmdBeginRenderingKHR( vkGetInstanceProcAddr( instance, "vkCmdBeginRenderingKHR" ) ); 12552 vkCmdEndRenderingKHR = PFN_vkCmdEndRenderingKHR( vkGetInstanceProcAddr( instance, "vkCmdEndRenderingKHR" ) ); 12553 12554 #if defined( VK_USE_PLATFORM_GGP ) 12555 //=== VK_GGP_stream_descriptor_surface === 12556 vkCreateStreamDescriptorSurfaceGGP = PFN_vkCreateStreamDescriptorSurfaceGGP( 12557 vkGetInstanceProcAddr( instance, "vkCreateStreamDescriptorSurfaceGGP" ) ); 12558 #endif /*VK_USE_PLATFORM_GGP*/ 12559 12560 //=== VK_NV_external_memory_capabilities === 12561 vkGetPhysicalDeviceExternalImageFormatPropertiesNV = PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV( 12562 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV" ) ); 12563 12564 #if defined( VK_USE_PLATFORM_WIN32_KHR ) 12565 //=== VK_NV_external_memory_win32 === 12566 vkGetMemoryWin32HandleNV = 12567 PFN_vkGetMemoryWin32HandleNV( vkGetInstanceProcAddr( instance, "vkGetMemoryWin32HandleNV" ) ); 12568 #endif /*VK_USE_PLATFORM_WIN32_KHR*/ 12569 12570 //=== VK_KHR_get_physical_device_properties2 === 12571 vkGetPhysicalDeviceFeatures2KHR = 12572 PFN_vkGetPhysicalDeviceFeatures2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures2KHR" ) ); 12573 if ( !vkGetPhysicalDeviceFeatures2 ) 12574 vkGetPhysicalDeviceFeatures2 = vkGetPhysicalDeviceFeatures2KHR; 12575 vkGetPhysicalDeviceProperties2KHR = 12576 PFN_vkGetPhysicalDeviceProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties2KHR" ) ); 12577 if ( !vkGetPhysicalDeviceProperties2 ) 12578 vkGetPhysicalDeviceProperties2 = vkGetPhysicalDeviceProperties2KHR; 12579 vkGetPhysicalDeviceFormatProperties2KHR = PFN_vkGetPhysicalDeviceFormatProperties2KHR( 12580 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties2KHR" ) ); 12581 if ( !vkGetPhysicalDeviceFormatProperties2 ) 12582 vkGetPhysicalDeviceFormatProperties2 = vkGetPhysicalDeviceFormatProperties2KHR; 12583 vkGetPhysicalDeviceImageFormatProperties2KHR = PFN_vkGetPhysicalDeviceImageFormatProperties2KHR( 12584 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties2KHR" ) ); 12585 if ( !vkGetPhysicalDeviceImageFormatProperties2 ) 12586 vkGetPhysicalDeviceImageFormatProperties2 = vkGetPhysicalDeviceImageFormatProperties2KHR; 12587 vkGetPhysicalDeviceQueueFamilyProperties2KHR = PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR( 12588 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties2KHR" ) ); 12589 if ( !vkGetPhysicalDeviceQueueFamilyProperties2 ) 12590 vkGetPhysicalDeviceQueueFamilyProperties2 = vkGetPhysicalDeviceQueueFamilyProperties2KHR; 12591 vkGetPhysicalDeviceMemoryProperties2KHR = PFN_vkGetPhysicalDeviceMemoryProperties2KHR( 12592 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties2KHR" ) ); 12593 if ( !vkGetPhysicalDeviceMemoryProperties2 ) 12594 vkGetPhysicalDeviceMemoryProperties2 = vkGetPhysicalDeviceMemoryProperties2KHR; 12595 vkGetPhysicalDeviceSparseImageFormatProperties2KHR = PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR( 12596 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR" ) ); 12597 if ( !vkGetPhysicalDeviceSparseImageFormatProperties2 ) 12598 vkGetPhysicalDeviceSparseImageFormatProperties2 = vkGetPhysicalDeviceSparseImageFormatProperties2KHR; 12599 12600 //=== VK_KHR_device_group === 12601 vkGetDeviceGroupPeerMemoryFeaturesKHR = PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR( 12602 vkGetInstanceProcAddr( instance, "vkGetDeviceGroupPeerMemoryFeaturesKHR" ) ); 12603 if ( !vkGetDeviceGroupPeerMemoryFeatures ) 12604 vkGetDeviceGroupPeerMemoryFeatures = vkGetDeviceGroupPeerMemoryFeaturesKHR; 12605 vkCmdSetDeviceMaskKHR = PFN_vkCmdSetDeviceMaskKHR( vkGetInstanceProcAddr( instance, "vkCmdSetDeviceMaskKHR" ) ); 12606 if ( !vkCmdSetDeviceMask ) 12607 vkCmdSetDeviceMask = vkCmdSetDeviceMaskKHR; 12608 vkCmdDispatchBaseKHR = PFN_vkCmdDispatchBaseKHR( vkGetInstanceProcAddr( instance, "vkCmdDispatchBaseKHR" ) ); 12609 if ( !vkCmdDispatchBase ) 12610 vkCmdDispatchBase = vkCmdDispatchBaseKHR; 12611 12612 #if defined( VK_USE_PLATFORM_VI_NN ) 12613 //=== VK_NN_vi_surface === 12614 vkCreateViSurfaceNN = PFN_vkCreateViSurfaceNN( vkGetInstanceProcAddr( instance, "vkCreateViSurfaceNN" ) ); 12615 #endif /*VK_USE_PLATFORM_VI_NN*/ 12616 12617 //=== VK_KHR_maintenance1 === 12618 vkTrimCommandPoolKHR = PFN_vkTrimCommandPoolKHR( vkGetInstanceProcAddr( instance, "vkTrimCommandPoolKHR" ) ); 12619 if ( !vkTrimCommandPool ) 12620 vkTrimCommandPool = vkTrimCommandPoolKHR; 12621 12622 //=== VK_KHR_device_group_creation === 12623 vkEnumeratePhysicalDeviceGroupsKHR = PFN_vkEnumeratePhysicalDeviceGroupsKHR( 12624 vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceGroupsKHR" ) ); 12625 if ( !vkEnumeratePhysicalDeviceGroups ) 12626 vkEnumeratePhysicalDeviceGroups = vkEnumeratePhysicalDeviceGroupsKHR; 12627 12628 //=== VK_KHR_external_memory_capabilities === 12629 vkGetPhysicalDeviceExternalBufferPropertiesKHR = PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR( 12630 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalBufferPropertiesKHR" ) ); 12631 if ( !vkGetPhysicalDeviceExternalBufferProperties ) 12632 vkGetPhysicalDeviceExternalBufferProperties = vkGetPhysicalDeviceExternalBufferPropertiesKHR; 12633 12634 #if defined( VK_USE_PLATFORM_WIN32_KHR ) 12635 //=== VK_KHR_external_memory_win32 === 12636 vkGetMemoryWin32HandleKHR = 12637 PFN_vkGetMemoryWin32HandleKHR( vkGetInstanceProcAddr( instance, "vkGetMemoryWin32HandleKHR" ) ); 12638 vkGetMemoryWin32HandlePropertiesKHR = PFN_vkGetMemoryWin32HandlePropertiesKHR( 12639 vkGetInstanceProcAddr( instance, "vkGetMemoryWin32HandlePropertiesKHR" ) ); 12640 #endif /*VK_USE_PLATFORM_WIN32_KHR*/ 12641 12642 //=== VK_KHR_external_memory_fd === 12643 vkGetMemoryFdKHR = PFN_vkGetMemoryFdKHR( vkGetInstanceProcAddr( instance, "vkGetMemoryFdKHR" ) ); 12644 vkGetMemoryFdPropertiesKHR = 12645 PFN_vkGetMemoryFdPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetMemoryFdPropertiesKHR" ) ); 12646 12647 //=== VK_KHR_external_semaphore_capabilities === 12648 vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( 12649 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR" ) ); 12650 if ( !vkGetPhysicalDeviceExternalSemaphoreProperties ) 12651 vkGetPhysicalDeviceExternalSemaphoreProperties = vkGetPhysicalDeviceExternalSemaphorePropertiesKHR; 12652 12653 #if defined( VK_USE_PLATFORM_WIN32_KHR ) 12654 //=== VK_KHR_external_semaphore_win32 === 12655 vkImportSemaphoreWin32HandleKHR = 12656 PFN_vkImportSemaphoreWin32HandleKHR( vkGetInstanceProcAddr( instance, "vkImportSemaphoreWin32HandleKHR" ) ); 12657 vkGetSemaphoreWin32HandleKHR = 12658 PFN_vkGetSemaphoreWin32HandleKHR( vkGetInstanceProcAddr( instance, "vkGetSemaphoreWin32HandleKHR" ) ); 12659 #endif /*VK_USE_PLATFORM_WIN32_KHR*/ 12660 12661 //=== VK_KHR_external_semaphore_fd === 12662 vkImportSemaphoreFdKHR = 12663 PFN_vkImportSemaphoreFdKHR( vkGetInstanceProcAddr( instance, "vkImportSemaphoreFdKHR" ) ); 12664 vkGetSemaphoreFdKHR = PFN_vkGetSemaphoreFdKHR( vkGetInstanceProcAddr( instance, "vkGetSemaphoreFdKHR" ) ); 12665 12666 //=== VK_KHR_push_descriptor === 12667 vkCmdPushDescriptorSetKHR = 12668 PFN_vkCmdPushDescriptorSetKHR( vkGetInstanceProcAddr( instance, "vkCmdPushDescriptorSetKHR" ) ); 12669 vkCmdPushDescriptorSetWithTemplateKHR = PFN_vkCmdPushDescriptorSetWithTemplateKHR( 12670 vkGetInstanceProcAddr( instance, "vkCmdPushDescriptorSetWithTemplateKHR" ) ); 12671 12672 //=== VK_EXT_conditional_rendering === 12673 vkCmdBeginConditionalRenderingEXT = 12674 PFN_vkCmdBeginConditionalRenderingEXT( vkGetInstanceProcAddr( instance, "vkCmdBeginConditionalRenderingEXT" ) ); 12675 vkCmdEndConditionalRenderingEXT = 12676 PFN_vkCmdEndConditionalRenderingEXT( vkGetInstanceProcAddr( instance, "vkCmdEndConditionalRenderingEXT" ) ); 12677 12678 //=== VK_KHR_descriptor_update_template === 12679 vkCreateDescriptorUpdateTemplateKHR = PFN_vkCreateDescriptorUpdateTemplateKHR( 12680 vkGetInstanceProcAddr( instance, "vkCreateDescriptorUpdateTemplateKHR" ) ); 12681 if ( !vkCreateDescriptorUpdateTemplate ) 12682 vkCreateDescriptorUpdateTemplate = vkCreateDescriptorUpdateTemplateKHR; 12683 vkDestroyDescriptorUpdateTemplateKHR = PFN_vkDestroyDescriptorUpdateTemplateKHR( 12684 vkGetInstanceProcAddr( instance, "vkDestroyDescriptorUpdateTemplateKHR" ) ); 12685 if ( !vkDestroyDescriptorUpdateTemplate ) 12686 vkDestroyDescriptorUpdateTemplate = vkDestroyDescriptorUpdateTemplateKHR; 12687 vkUpdateDescriptorSetWithTemplateKHR = PFN_vkUpdateDescriptorSetWithTemplateKHR( 12688 vkGetInstanceProcAddr( instance, "vkUpdateDescriptorSetWithTemplateKHR" ) ); 12689 if ( !vkUpdateDescriptorSetWithTemplate ) 12690 vkUpdateDescriptorSetWithTemplate = vkUpdateDescriptorSetWithTemplateKHR; 12691 12692 //=== VK_NV_clip_space_w_scaling === 12693 vkCmdSetViewportWScalingNV = 12694 PFN_vkCmdSetViewportWScalingNV( vkGetInstanceProcAddr( instance, "vkCmdSetViewportWScalingNV" ) ); 12695 12696 //=== VK_EXT_direct_mode_display === 12697 vkReleaseDisplayEXT = PFN_vkReleaseDisplayEXT( vkGetInstanceProcAddr( instance, "vkReleaseDisplayEXT" ) ); 12698 12699 #if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) 12700 //=== VK_EXT_acquire_xlib_display === 12701 vkAcquireXlibDisplayEXT = 12702 PFN_vkAcquireXlibDisplayEXT( vkGetInstanceProcAddr( instance, "vkAcquireXlibDisplayEXT" ) ); 12703 vkGetRandROutputDisplayEXT = 12704 PFN_vkGetRandROutputDisplayEXT( vkGetInstanceProcAddr( instance, "vkGetRandROutputDisplayEXT" ) ); 12705 #endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ 12706 12707 //=== VK_EXT_display_surface_counter === 12708 vkGetPhysicalDeviceSurfaceCapabilities2EXT = PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT( 12709 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilities2EXT" ) ); 12710 12711 //=== VK_EXT_display_control === 12712 vkDisplayPowerControlEXT = 12713 PFN_vkDisplayPowerControlEXT( vkGetInstanceProcAddr( instance, "vkDisplayPowerControlEXT" ) ); 12714 vkRegisterDeviceEventEXT = 12715 PFN_vkRegisterDeviceEventEXT( vkGetInstanceProcAddr( instance, "vkRegisterDeviceEventEXT" ) ); 12716 vkRegisterDisplayEventEXT = 12717 PFN_vkRegisterDisplayEventEXT( vkGetInstanceProcAddr( instance, "vkRegisterDisplayEventEXT" ) ); 12718 vkGetSwapchainCounterEXT = 12719 PFN_vkGetSwapchainCounterEXT( vkGetInstanceProcAddr( instance, "vkGetSwapchainCounterEXT" ) ); 12720 12721 //=== VK_GOOGLE_display_timing === 12722 vkGetRefreshCycleDurationGOOGLE = 12723 PFN_vkGetRefreshCycleDurationGOOGLE( vkGetInstanceProcAddr( instance, "vkGetRefreshCycleDurationGOOGLE" ) ); 12724 vkGetPastPresentationTimingGOOGLE = 12725 PFN_vkGetPastPresentationTimingGOOGLE( vkGetInstanceProcAddr( instance, "vkGetPastPresentationTimingGOOGLE" ) ); 12726 12727 //=== VK_EXT_discard_rectangles === 12728 vkCmdSetDiscardRectangleEXT = 12729 PFN_vkCmdSetDiscardRectangleEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDiscardRectangleEXT" ) ); 12730 12731 //=== VK_EXT_hdr_metadata === 12732 vkSetHdrMetadataEXT = PFN_vkSetHdrMetadataEXT( vkGetInstanceProcAddr( instance, "vkSetHdrMetadataEXT" ) ); 12733 12734 //=== VK_KHR_create_renderpass2 === 12735 vkCreateRenderPass2KHR = 12736 PFN_vkCreateRenderPass2KHR( vkGetInstanceProcAddr( instance, "vkCreateRenderPass2KHR" ) ); 12737 if ( !vkCreateRenderPass2 ) 12738 vkCreateRenderPass2 = vkCreateRenderPass2KHR; 12739 vkCmdBeginRenderPass2KHR = 12740 PFN_vkCmdBeginRenderPass2KHR( vkGetInstanceProcAddr( instance, "vkCmdBeginRenderPass2KHR" ) ); 12741 if ( !vkCmdBeginRenderPass2 ) 12742 vkCmdBeginRenderPass2 = vkCmdBeginRenderPass2KHR; 12743 vkCmdNextSubpass2KHR = PFN_vkCmdNextSubpass2KHR( vkGetInstanceProcAddr( instance, "vkCmdNextSubpass2KHR" ) ); 12744 if ( !vkCmdNextSubpass2 ) 12745 vkCmdNextSubpass2 = vkCmdNextSubpass2KHR; 12746 vkCmdEndRenderPass2KHR = 12747 PFN_vkCmdEndRenderPass2KHR( vkGetInstanceProcAddr( instance, "vkCmdEndRenderPass2KHR" ) ); 12748 if ( !vkCmdEndRenderPass2 ) 12749 vkCmdEndRenderPass2 = vkCmdEndRenderPass2KHR; 12750 12751 //=== VK_KHR_shared_presentable_image === 12752 vkGetSwapchainStatusKHR = 12753 PFN_vkGetSwapchainStatusKHR( vkGetInstanceProcAddr( instance, "vkGetSwapchainStatusKHR" ) ); 12754 12755 //=== VK_KHR_external_fence_capabilities === 12756 vkGetPhysicalDeviceExternalFencePropertiesKHR = PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR( 12757 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalFencePropertiesKHR" ) ); 12758 if ( !vkGetPhysicalDeviceExternalFenceProperties ) 12759 vkGetPhysicalDeviceExternalFenceProperties = vkGetPhysicalDeviceExternalFencePropertiesKHR; 12760 12761 #if defined( VK_USE_PLATFORM_WIN32_KHR ) 12762 //=== VK_KHR_external_fence_win32 === 12763 vkImportFenceWin32HandleKHR = 12764 PFN_vkImportFenceWin32HandleKHR( vkGetInstanceProcAddr( instance, "vkImportFenceWin32HandleKHR" ) ); 12765 vkGetFenceWin32HandleKHR = 12766 PFN_vkGetFenceWin32HandleKHR( vkGetInstanceProcAddr( instance, "vkGetFenceWin32HandleKHR" ) ); 12767 #endif /*VK_USE_PLATFORM_WIN32_KHR*/ 12768 12769 //=== VK_KHR_external_fence_fd === 12770 vkImportFenceFdKHR = PFN_vkImportFenceFdKHR( vkGetInstanceProcAddr( instance, "vkImportFenceFdKHR" ) ); 12771 vkGetFenceFdKHR = PFN_vkGetFenceFdKHR( vkGetInstanceProcAddr( instance, "vkGetFenceFdKHR" ) ); 12772 12773 //=== VK_KHR_performance_query === 12774 vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = 12775 PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( 12776 vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR" ) ); 12777 vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = 12778 PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( 12779 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR" ) ); 12780 vkAcquireProfilingLockKHR = 12781 PFN_vkAcquireProfilingLockKHR( vkGetInstanceProcAddr( instance, "vkAcquireProfilingLockKHR" ) ); 12782 vkReleaseProfilingLockKHR = 12783 PFN_vkReleaseProfilingLockKHR( vkGetInstanceProcAddr( instance, "vkReleaseProfilingLockKHR" ) ); 12784 12785 //=== VK_KHR_get_surface_capabilities2 === 12786 vkGetPhysicalDeviceSurfaceCapabilities2KHR = PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR( 12787 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilities2KHR" ) ); 12788 vkGetPhysicalDeviceSurfaceFormats2KHR = PFN_vkGetPhysicalDeviceSurfaceFormats2KHR( 12789 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceFormats2KHR" ) ); 12790 12791 //=== VK_KHR_get_display_properties2 === 12792 vkGetPhysicalDeviceDisplayProperties2KHR = PFN_vkGetPhysicalDeviceDisplayProperties2KHR( 12793 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayProperties2KHR" ) ); 12794 vkGetPhysicalDeviceDisplayPlaneProperties2KHR = PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR( 12795 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPlaneProperties2KHR" ) ); 12796 vkGetDisplayModeProperties2KHR = 12797 PFN_vkGetDisplayModeProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetDisplayModeProperties2KHR" ) ); 12798 vkGetDisplayPlaneCapabilities2KHR = 12799 PFN_vkGetDisplayPlaneCapabilities2KHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneCapabilities2KHR" ) ); 12800 12801 #if defined( VK_USE_PLATFORM_IOS_MVK ) 12802 //=== VK_MVK_ios_surface === 12803 vkCreateIOSSurfaceMVK = PFN_vkCreateIOSSurfaceMVK( vkGetInstanceProcAddr( instance, "vkCreateIOSSurfaceMVK" ) ); 12804 #endif /*VK_USE_PLATFORM_IOS_MVK*/ 12805 12806 #if defined( VK_USE_PLATFORM_MACOS_MVK ) 12807 //=== VK_MVK_macos_surface === 12808 vkCreateMacOSSurfaceMVK = 12809 PFN_vkCreateMacOSSurfaceMVK( vkGetInstanceProcAddr( instance, "vkCreateMacOSSurfaceMVK" ) ); 12810 #endif /*VK_USE_PLATFORM_MACOS_MVK*/ 12811 12812 //=== VK_EXT_debug_utils === 12813 vkSetDebugUtilsObjectNameEXT = 12814 PFN_vkSetDebugUtilsObjectNameEXT( vkGetInstanceProcAddr( instance, "vkSetDebugUtilsObjectNameEXT" ) ); 12815 vkSetDebugUtilsObjectTagEXT = 12816 PFN_vkSetDebugUtilsObjectTagEXT( vkGetInstanceProcAddr( instance, "vkSetDebugUtilsObjectTagEXT" ) ); 12817 vkQueueBeginDebugUtilsLabelEXT = 12818 PFN_vkQueueBeginDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkQueueBeginDebugUtilsLabelEXT" ) ); 12819 vkQueueEndDebugUtilsLabelEXT = 12820 PFN_vkQueueEndDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkQueueEndDebugUtilsLabelEXT" ) ); 12821 vkQueueInsertDebugUtilsLabelEXT = 12822 PFN_vkQueueInsertDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkQueueInsertDebugUtilsLabelEXT" ) ); 12823 vkCmdBeginDebugUtilsLabelEXT = 12824 PFN_vkCmdBeginDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkCmdBeginDebugUtilsLabelEXT" ) ); 12825 vkCmdEndDebugUtilsLabelEXT = 12826 PFN_vkCmdEndDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkCmdEndDebugUtilsLabelEXT" ) ); 12827 vkCmdInsertDebugUtilsLabelEXT = 12828 PFN_vkCmdInsertDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkCmdInsertDebugUtilsLabelEXT" ) ); 12829 vkCreateDebugUtilsMessengerEXT = 12830 PFN_vkCreateDebugUtilsMessengerEXT( vkGetInstanceProcAddr( instance, "vkCreateDebugUtilsMessengerEXT" ) ); 12831 vkDestroyDebugUtilsMessengerEXT = 12832 PFN_vkDestroyDebugUtilsMessengerEXT( vkGetInstanceProcAddr( instance, "vkDestroyDebugUtilsMessengerEXT" ) ); 12833 vkSubmitDebugUtilsMessageEXT = 12834 PFN_vkSubmitDebugUtilsMessageEXT( vkGetInstanceProcAddr( instance, "vkSubmitDebugUtilsMessageEXT" ) ); 12835 12836 #if defined( VK_USE_PLATFORM_ANDROID_KHR ) 12837 //=== VK_ANDROID_external_memory_android_hardware_buffer === 12838 vkGetAndroidHardwareBufferPropertiesANDROID = PFN_vkGetAndroidHardwareBufferPropertiesANDROID( 12839 vkGetInstanceProcAddr( instance, "vkGetAndroidHardwareBufferPropertiesANDROID" ) ); 12840 vkGetMemoryAndroidHardwareBufferANDROID = PFN_vkGetMemoryAndroidHardwareBufferANDROID( 12841 vkGetInstanceProcAddr( instance, "vkGetMemoryAndroidHardwareBufferANDROID" ) ); 12842 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 12843 12844 //=== VK_EXT_sample_locations === 12845 vkCmdSetSampleLocationsEXT = 12846 PFN_vkCmdSetSampleLocationsEXT( vkGetInstanceProcAddr( instance, "vkCmdSetSampleLocationsEXT" ) ); 12847 vkGetPhysicalDeviceMultisamplePropertiesEXT = PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT( 12848 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMultisamplePropertiesEXT" ) ); 12849 12850 //=== VK_KHR_get_memory_requirements2 === 12851 vkGetImageMemoryRequirements2KHR = 12852 PFN_vkGetImageMemoryRequirements2KHR( vkGetInstanceProcAddr( instance, "vkGetImageMemoryRequirements2KHR" ) ); 12853 if ( !vkGetImageMemoryRequirements2 ) 12854 vkGetImageMemoryRequirements2 = vkGetImageMemoryRequirements2KHR; 12855 vkGetBufferMemoryRequirements2KHR = 12856 PFN_vkGetBufferMemoryRequirements2KHR( vkGetInstanceProcAddr( instance, "vkGetBufferMemoryRequirements2KHR" ) ); 12857 if ( !vkGetBufferMemoryRequirements2 ) 12858 vkGetBufferMemoryRequirements2 = vkGetBufferMemoryRequirements2KHR; 12859 vkGetImageSparseMemoryRequirements2KHR = PFN_vkGetImageSparseMemoryRequirements2KHR( 12860 vkGetInstanceProcAddr( instance, "vkGetImageSparseMemoryRequirements2KHR" ) ); 12861 if ( !vkGetImageSparseMemoryRequirements2 ) 12862 vkGetImageSparseMemoryRequirements2 = vkGetImageSparseMemoryRequirements2KHR; 12863 12864 //=== VK_KHR_acceleration_structure === 12865 vkCreateAccelerationStructureKHR = 12866 PFN_vkCreateAccelerationStructureKHR( vkGetInstanceProcAddr( instance, "vkCreateAccelerationStructureKHR" ) ); 12867 vkDestroyAccelerationStructureKHR = 12868 PFN_vkDestroyAccelerationStructureKHR( vkGetInstanceProcAddr( instance, "vkDestroyAccelerationStructureKHR" ) ); 12869 vkCmdBuildAccelerationStructuresKHR = PFN_vkCmdBuildAccelerationStructuresKHR( 12870 vkGetInstanceProcAddr( instance, "vkCmdBuildAccelerationStructuresKHR" ) ); 12871 vkCmdBuildAccelerationStructuresIndirectKHR = PFN_vkCmdBuildAccelerationStructuresIndirectKHR( 12872 vkGetInstanceProcAddr( instance, "vkCmdBuildAccelerationStructuresIndirectKHR" ) ); 12873 vkBuildAccelerationStructuresKHR = 12874 PFN_vkBuildAccelerationStructuresKHR( vkGetInstanceProcAddr( instance, "vkBuildAccelerationStructuresKHR" ) ); 12875 vkCopyAccelerationStructureKHR = 12876 PFN_vkCopyAccelerationStructureKHR( vkGetInstanceProcAddr( instance, "vkCopyAccelerationStructureKHR" ) ); 12877 vkCopyAccelerationStructureToMemoryKHR = PFN_vkCopyAccelerationStructureToMemoryKHR( 12878 vkGetInstanceProcAddr( instance, "vkCopyAccelerationStructureToMemoryKHR" ) ); 12879 vkCopyMemoryToAccelerationStructureKHR = PFN_vkCopyMemoryToAccelerationStructureKHR( 12880 vkGetInstanceProcAddr( instance, "vkCopyMemoryToAccelerationStructureKHR" ) ); 12881 vkWriteAccelerationStructuresPropertiesKHR = PFN_vkWriteAccelerationStructuresPropertiesKHR( 12882 vkGetInstanceProcAddr( instance, "vkWriteAccelerationStructuresPropertiesKHR" ) ); 12883 vkCmdCopyAccelerationStructureKHR = 12884 PFN_vkCmdCopyAccelerationStructureKHR( vkGetInstanceProcAddr( instance, "vkCmdCopyAccelerationStructureKHR" ) ); 12885 vkCmdCopyAccelerationStructureToMemoryKHR = PFN_vkCmdCopyAccelerationStructureToMemoryKHR( 12886 vkGetInstanceProcAddr( instance, "vkCmdCopyAccelerationStructureToMemoryKHR" ) ); 12887 vkCmdCopyMemoryToAccelerationStructureKHR = PFN_vkCmdCopyMemoryToAccelerationStructureKHR( 12888 vkGetInstanceProcAddr( instance, "vkCmdCopyMemoryToAccelerationStructureKHR" ) ); 12889 vkGetAccelerationStructureDeviceAddressKHR = PFN_vkGetAccelerationStructureDeviceAddressKHR( 12890 vkGetInstanceProcAddr( instance, "vkGetAccelerationStructureDeviceAddressKHR" ) ); 12891 vkCmdWriteAccelerationStructuresPropertiesKHR = PFN_vkCmdWriteAccelerationStructuresPropertiesKHR( 12892 vkGetInstanceProcAddr( instance, "vkCmdWriteAccelerationStructuresPropertiesKHR" ) ); 12893 vkGetDeviceAccelerationStructureCompatibilityKHR = PFN_vkGetDeviceAccelerationStructureCompatibilityKHR( 12894 vkGetInstanceProcAddr( instance, "vkGetDeviceAccelerationStructureCompatibilityKHR" ) ); 12895 vkGetAccelerationStructureBuildSizesKHR = PFN_vkGetAccelerationStructureBuildSizesKHR( 12896 vkGetInstanceProcAddr( instance, "vkGetAccelerationStructureBuildSizesKHR" ) ); 12897 12898 //=== VK_KHR_sampler_ycbcr_conversion === 12899 vkCreateSamplerYcbcrConversionKHR = 12900 PFN_vkCreateSamplerYcbcrConversionKHR( vkGetInstanceProcAddr( instance, "vkCreateSamplerYcbcrConversionKHR" ) ); 12901 if ( !vkCreateSamplerYcbcrConversion ) 12902 vkCreateSamplerYcbcrConversion = vkCreateSamplerYcbcrConversionKHR; 12903 vkDestroySamplerYcbcrConversionKHR = PFN_vkDestroySamplerYcbcrConversionKHR( 12904 vkGetInstanceProcAddr( instance, "vkDestroySamplerYcbcrConversionKHR" ) ); 12905 if ( !vkDestroySamplerYcbcrConversion ) 12906 vkDestroySamplerYcbcrConversion = vkDestroySamplerYcbcrConversionKHR; 12907 12908 //=== VK_KHR_bind_memory2 === 12909 vkBindBufferMemory2KHR = 12910 PFN_vkBindBufferMemory2KHR( vkGetInstanceProcAddr( instance, "vkBindBufferMemory2KHR" ) ); 12911 if ( !vkBindBufferMemory2 ) 12912 vkBindBufferMemory2 = vkBindBufferMemory2KHR; 12913 vkBindImageMemory2KHR = PFN_vkBindImageMemory2KHR( vkGetInstanceProcAddr( instance, "vkBindImageMemory2KHR" ) ); 12914 if ( !vkBindImageMemory2 ) 12915 vkBindImageMemory2 = vkBindImageMemory2KHR; 12916 12917 //=== VK_EXT_image_drm_format_modifier === 12918 vkGetImageDrmFormatModifierPropertiesEXT = PFN_vkGetImageDrmFormatModifierPropertiesEXT( 12919 vkGetInstanceProcAddr( instance, "vkGetImageDrmFormatModifierPropertiesEXT" ) ); 12920 12921 //=== VK_EXT_validation_cache === 12922 vkCreateValidationCacheEXT = 12923 PFN_vkCreateValidationCacheEXT( vkGetInstanceProcAddr( instance, "vkCreateValidationCacheEXT" ) ); 12924 vkDestroyValidationCacheEXT = 12925 PFN_vkDestroyValidationCacheEXT( vkGetInstanceProcAddr( instance, "vkDestroyValidationCacheEXT" ) ); 12926 vkMergeValidationCachesEXT = 12927 PFN_vkMergeValidationCachesEXT( vkGetInstanceProcAddr( instance, "vkMergeValidationCachesEXT" ) ); 12928 vkGetValidationCacheDataEXT = 12929 PFN_vkGetValidationCacheDataEXT( vkGetInstanceProcAddr( instance, "vkGetValidationCacheDataEXT" ) ); 12930 12931 //=== VK_NV_shading_rate_image === 12932 vkCmdBindShadingRateImageNV = 12933 PFN_vkCmdBindShadingRateImageNV( vkGetInstanceProcAddr( instance, "vkCmdBindShadingRateImageNV" ) ); 12934 vkCmdSetViewportShadingRatePaletteNV = PFN_vkCmdSetViewportShadingRatePaletteNV( 12935 vkGetInstanceProcAddr( instance, "vkCmdSetViewportShadingRatePaletteNV" ) ); 12936 vkCmdSetCoarseSampleOrderNV = 12937 PFN_vkCmdSetCoarseSampleOrderNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoarseSampleOrderNV" ) ); 12938 12939 //=== VK_NV_ray_tracing === 12940 vkCreateAccelerationStructureNV = 12941 PFN_vkCreateAccelerationStructureNV( vkGetInstanceProcAddr( instance, "vkCreateAccelerationStructureNV" ) ); 12942 vkDestroyAccelerationStructureNV = 12943 PFN_vkDestroyAccelerationStructureNV( vkGetInstanceProcAddr( instance, "vkDestroyAccelerationStructureNV" ) ); 12944 vkGetAccelerationStructureMemoryRequirementsNV = PFN_vkGetAccelerationStructureMemoryRequirementsNV( 12945 vkGetInstanceProcAddr( instance, "vkGetAccelerationStructureMemoryRequirementsNV" ) ); 12946 vkBindAccelerationStructureMemoryNV = PFN_vkBindAccelerationStructureMemoryNV( 12947 vkGetInstanceProcAddr( instance, "vkBindAccelerationStructureMemoryNV" ) ); 12948 vkCmdBuildAccelerationStructureNV = 12949 PFN_vkCmdBuildAccelerationStructureNV( vkGetInstanceProcAddr( instance, "vkCmdBuildAccelerationStructureNV" ) ); 12950 vkCmdCopyAccelerationStructureNV = 12951 PFN_vkCmdCopyAccelerationStructureNV( vkGetInstanceProcAddr( instance, "vkCmdCopyAccelerationStructureNV" ) ); 12952 vkCmdTraceRaysNV = PFN_vkCmdTraceRaysNV( vkGetInstanceProcAddr( instance, "vkCmdTraceRaysNV" ) ); 12953 vkCreateRayTracingPipelinesNV = 12954 PFN_vkCreateRayTracingPipelinesNV( vkGetInstanceProcAddr( instance, "vkCreateRayTracingPipelinesNV" ) ); 12955 vkGetRayTracingShaderGroupHandlesNV = PFN_vkGetRayTracingShaderGroupHandlesNV( 12956 vkGetInstanceProcAddr( instance, "vkGetRayTracingShaderGroupHandlesNV" ) ); 12957 if ( !vkGetRayTracingShaderGroupHandlesKHR ) 12958 vkGetRayTracingShaderGroupHandlesKHR = vkGetRayTracingShaderGroupHandlesNV; 12959 vkGetAccelerationStructureHandleNV = PFN_vkGetAccelerationStructureHandleNV( 12960 vkGetInstanceProcAddr( instance, "vkGetAccelerationStructureHandleNV" ) ); 12961 vkCmdWriteAccelerationStructuresPropertiesNV = PFN_vkCmdWriteAccelerationStructuresPropertiesNV( 12962 vkGetInstanceProcAddr( instance, "vkCmdWriteAccelerationStructuresPropertiesNV" ) ); 12963 vkCompileDeferredNV = PFN_vkCompileDeferredNV( vkGetInstanceProcAddr( instance, "vkCompileDeferredNV" ) ); 12964 12965 //=== VK_KHR_maintenance3 === 12966 vkGetDescriptorSetLayoutSupportKHR = PFN_vkGetDescriptorSetLayoutSupportKHR( 12967 vkGetInstanceProcAddr( instance, "vkGetDescriptorSetLayoutSupportKHR" ) ); 12968 if ( !vkGetDescriptorSetLayoutSupport ) 12969 vkGetDescriptorSetLayoutSupport = vkGetDescriptorSetLayoutSupportKHR; 12970 12971 //=== VK_KHR_draw_indirect_count === 12972 vkCmdDrawIndirectCountKHR = 12973 PFN_vkCmdDrawIndirectCountKHR( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectCountKHR" ) ); 12974 if ( !vkCmdDrawIndirectCount ) 12975 vkCmdDrawIndirectCount = vkCmdDrawIndirectCountKHR; 12976 vkCmdDrawIndexedIndirectCountKHR = 12977 PFN_vkCmdDrawIndexedIndirectCountKHR( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirectCountKHR" ) ); 12978 if ( !vkCmdDrawIndexedIndirectCount ) 12979 vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountKHR; 12980 12981 //=== VK_EXT_external_memory_host === 12982 vkGetMemoryHostPointerPropertiesEXT = PFN_vkGetMemoryHostPointerPropertiesEXT( 12983 vkGetInstanceProcAddr( instance, "vkGetMemoryHostPointerPropertiesEXT" ) ); 12984 12985 //=== VK_AMD_buffer_marker === 12986 vkCmdWriteBufferMarkerAMD = 12987 PFN_vkCmdWriteBufferMarkerAMD( vkGetInstanceProcAddr( instance, "vkCmdWriteBufferMarkerAMD" ) ); 12988 12989 //=== VK_EXT_calibrated_timestamps === 12990 vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( 12991 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT" ) ); 12992 vkGetCalibratedTimestampsEXT = 12993 PFN_vkGetCalibratedTimestampsEXT( vkGetInstanceProcAddr( instance, "vkGetCalibratedTimestampsEXT" ) ); 12994 12995 //=== VK_NV_mesh_shader === 12996 vkCmdDrawMeshTasksNV = PFN_vkCmdDrawMeshTasksNV( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksNV" ) ); 12997 vkCmdDrawMeshTasksIndirectNV = 12998 PFN_vkCmdDrawMeshTasksIndirectNV( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksIndirectNV" ) ); 12999 vkCmdDrawMeshTasksIndirectCountNV = 13000 PFN_vkCmdDrawMeshTasksIndirectCountNV( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksIndirectCountNV" ) ); 13001 13002 //=== VK_NV_scissor_exclusive === 13003 vkCmdSetExclusiveScissorNV = 13004 PFN_vkCmdSetExclusiveScissorNV( vkGetInstanceProcAddr( instance, "vkCmdSetExclusiveScissorNV" ) ); 13005 13006 //=== VK_NV_device_diagnostic_checkpoints === 13007 vkCmdSetCheckpointNV = PFN_vkCmdSetCheckpointNV( vkGetInstanceProcAddr( instance, "vkCmdSetCheckpointNV" ) ); 13008 vkGetQueueCheckpointDataNV = 13009 PFN_vkGetQueueCheckpointDataNV( vkGetInstanceProcAddr( instance, "vkGetQueueCheckpointDataNV" ) ); 13010 13011 //=== VK_KHR_timeline_semaphore === 13012 vkGetSemaphoreCounterValueKHR = 13013 PFN_vkGetSemaphoreCounterValueKHR( vkGetInstanceProcAddr( instance, "vkGetSemaphoreCounterValueKHR" ) ); 13014 if ( !vkGetSemaphoreCounterValue ) 13015 vkGetSemaphoreCounterValue = vkGetSemaphoreCounterValueKHR; 13016 vkWaitSemaphoresKHR = PFN_vkWaitSemaphoresKHR( vkGetInstanceProcAddr( instance, "vkWaitSemaphoresKHR" ) ); 13017 if ( !vkWaitSemaphores ) 13018 vkWaitSemaphores = vkWaitSemaphoresKHR; 13019 vkSignalSemaphoreKHR = PFN_vkSignalSemaphoreKHR( vkGetInstanceProcAddr( instance, "vkSignalSemaphoreKHR" ) ); 13020 if ( !vkSignalSemaphore ) 13021 vkSignalSemaphore = vkSignalSemaphoreKHR; 13022 13023 //=== VK_INTEL_performance_query === 13024 vkInitializePerformanceApiINTEL = 13025 PFN_vkInitializePerformanceApiINTEL( vkGetInstanceProcAddr( instance, "vkInitializePerformanceApiINTEL" ) ); 13026 vkUninitializePerformanceApiINTEL = 13027 PFN_vkUninitializePerformanceApiINTEL( vkGetInstanceProcAddr( instance, "vkUninitializePerformanceApiINTEL" ) ); 13028 vkCmdSetPerformanceMarkerINTEL = 13029 PFN_vkCmdSetPerformanceMarkerINTEL( vkGetInstanceProcAddr( instance, "vkCmdSetPerformanceMarkerINTEL" ) ); 13030 vkCmdSetPerformanceStreamMarkerINTEL = PFN_vkCmdSetPerformanceStreamMarkerINTEL( 13031 vkGetInstanceProcAddr( instance, "vkCmdSetPerformanceStreamMarkerINTEL" ) ); 13032 vkCmdSetPerformanceOverrideINTEL = 13033 PFN_vkCmdSetPerformanceOverrideINTEL( vkGetInstanceProcAddr( instance, "vkCmdSetPerformanceOverrideINTEL" ) ); 13034 vkAcquirePerformanceConfigurationINTEL = PFN_vkAcquirePerformanceConfigurationINTEL( 13035 vkGetInstanceProcAddr( instance, "vkAcquirePerformanceConfigurationINTEL" ) ); 13036 vkReleasePerformanceConfigurationINTEL = PFN_vkReleasePerformanceConfigurationINTEL( 13037 vkGetInstanceProcAddr( instance, "vkReleasePerformanceConfigurationINTEL" ) ); 13038 vkQueueSetPerformanceConfigurationINTEL = PFN_vkQueueSetPerformanceConfigurationINTEL( 13039 vkGetInstanceProcAddr( instance, "vkQueueSetPerformanceConfigurationINTEL" ) ); 13040 vkGetPerformanceParameterINTEL = 13041 PFN_vkGetPerformanceParameterINTEL( vkGetInstanceProcAddr( instance, "vkGetPerformanceParameterINTEL" ) ); 13042 13043 //=== VK_AMD_display_native_hdr === 13044 vkSetLocalDimmingAMD = PFN_vkSetLocalDimmingAMD( vkGetInstanceProcAddr( instance, "vkSetLocalDimmingAMD" ) ); 13045 13046 #if defined( VK_USE_PLATFORM_FUCHSIA ) 13047 //=== VK_FUCHSIA_imagepipe_surface === 13048 vkCreateImagePipeSurfaceFUCHSIA = 13049 PFN_vkCreateImagePipeSurfaceFUCHSIA( vkGetInstanceProcAddr( instance, "vkCreateImagePipeSurfaceFUCHSIA" ) ); 13050 #endif /*VK_USE_PLATFORM_FUCHSIA*/ 13051 13052 #if defined( VK_USE_PLATFORM_METAL_EXT ) 13053 //=== VK_EXT_metal_surface === 13054 vkCreateMetalSurfaceEXT = 13055 PFN_vkCreateMetalSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateMetalSurfaceEXT" ) ); 13056 #endif /*VK_USE_PLATFORM_METAL_EXT*/ 13057 13058 //=== VK_KHR_fragment_shading_rate === 13059 vkGetPhysicalDeviceFragmentShadingRatesKHR = PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR( 13060 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFragmentShadingRatesKHR" ) ); 13061 vkCmdSetFragmentShadingRateKHR = 13062 PFN_vkCmdSetFragmentShadingRateKHR( vkGetInstanceProcAddr( instance, "vkCmdSetFragmentShadingRateKHR" ) ); 13063 13064 //=== VK_EXT_buffer_device_address === 13065 vkGetBufferDeviceAddressEXT = 13066 PFN_vkGetBufferDeviceAddressEXT( vkGetInstanceProcAddr( instance, "vkGetBufferDeviceAddressEXT" ) ); 13067 if ( !vkGetBufferDeviceAddress ) 13068 vkGetBufferDeviceAddress = vkGetBufferDeviceAddressEXT; 13069 13070 //=== VK_EXT_tooling_info === 13071 vkGetPhysicalDeviceToolPropertiesEXT = PFN_vkGetPhysicalDeviceToolPropertiesEXT( 13072 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceToolPropertiesEXT" ) ); 13073 13074 //=== VK_KHR_present_wait === 13075 vkWaitForPresentKHR = PFN_vkWaitForPresentKHR( vkGetInstanceProcAddr( instance, "vkWaitForPresentKHR" ) ); 13076 13077 //=== VK_NV_cooperative_matrix === 13078 vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( 13079 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV" ) ); 13080 13081 //=== VK_NV_coverage_reduction_mode === 13082 vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = 13083 PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( 13084 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" ) ); 13085 13086 #if defined( VK_USE_PLATFORM_WIN32_KHR ) 13087 //=== VK_EXT_full_screen_exclusive === 13088 vkGetPhysicalDeviceSurfacePresentModes2EXT = PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT( 13089 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfacePresentModes2EXT" ) ); 13090 vkAcquireFullScreenExclusiveModeEXT = PFN_vkAcquireFullScreenExclusiveModeEXT( 13091 vkGetInstanceProcAddr( instance, "vkAcquireFullScreenExclusiveModeEXT" ) ); 13092 vkReleaseFullScreenExclusiveModeEXT = PFN_vkReleaseFullScreenExclusiveModeEXT( 13093 vkGetInstanceProcAddr( instance, "vkReleaseFullScreenExclusiveModeEXT" ) ); 13094 vkGetDeviceGroupSurfacePresentModes2EXT = PFN_vkGetDeviceGroupSurfacePresentModes2EXT( 13095 vkGetInstanceProcAddr( instance, "vkGetDeviceGroupSurfacePresentModes2EXT" ) ); 13096 #endif /*VK_USE_PLATFORM_WIN32_KHR*/ 13097 13098 //=== VK_EXT_headless_surface === 13099 vkCreateHeadlessSurfaceEXT = 13100 PFN_vkCreateHeadlessSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateHeadlessSurfaceEXT" ) ); 13101 13102 //=== VK_KHR_buffer_device_address === 13103 vkGetBufferDeviceAddressKHR = 13104 PFN_vkGetBufferDeviceAddressKHR( vkGetInstanceProcAddr( instance, "vkGetBufferDeviceAddressKHR" ) ); 13105 if ( !vkGetBufferDeviceAddress ) 13106 vkGetBufferDeviceAddress = vkGetBufferDeviceAddressKHR; 13107 vkGetBufferOpaqueCaptureAddressKHR = PFN_vkGetBufferOpaqueCaptureAddressKHR( 13108 vkGetInstanceProcAddr( instance, "vkGetBufferOpaqueCaptureAddressKHR" ) ); 13109 if ( !vkGetBufferOpaqueCaptureAddress ) 13110 vkGetBufferOpaqueCaptureAddress = vkGetBufferOpaqueCaptureAddressKHR; 13111 vkGetDeviceMemoryOpaqueCaptureAddressKHR = PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR( 13112 vkGetInstanceProcAddr( instance, "vkGetDeviceMemoryOpaqueCaptureAddressKHR" ) ); 13113 if ( !vkGetDeviceMemoryOpaqueCaptureAddress ) 13114 vkGetDeviceMemoryOpaqueCaptureAddress = vkGetDeviceMemoryOpaqueCaptureAddressKHR; 13115 13116 //=== VK_EXT_line_rasterization === 13117 vkCmdSetLineStippleEXT = 13118 PFN_vkCmdSetLineStippleEXT( vkGetInstanceProcAddr( instance, "vkCmdSetLineStippleEXT" ) ); 13119 13120 //=== VK_EXT_host_query_reset === 13121 vkResetQueryPoolEXT = PFN_vkResetQueryPoolEXT( vkGetInstanceProcAddr( instance, "vkResetQueryPoolEXT" ) ); 13122 if ( !vkResetQueryPool ) 13123 vkResetQueryPool = vkResetQueryPoolEXT; 13124 13125 //=== VK_EXT_extended_dynamic_state === 13126 vkCmdSetCullModeEXT = PFN_vkCmdSetCullModeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetCullModeEXT" ) ); 13127 vkCmdSetFrontFaceEXT = PFN_vkCmdSetFrontFaceEXT( vkGetInstanceProcAddr( instance, "vkCmdSetFrontFaceEXT" ) ); 13128 vkCmdSetPrimitiveTopologyEXT = 13129 PFN_vkCmdSetPrimitiveTopologyEXT( vkGetInstanceProcAddr( instance, "vkCmdSetPrimitiveTopologyEXT" ) ); 13130 vkCmdSetViewportWithCountEXT = 13131 PFN_vkCmdSetViewportWithCountEXT( vkGetInstanceProcAddr( instance, "vkCmdSetViewportWithCountEXT" ) ); 13132 vkCmdSetScissorWithCountEXT = 13133 PFN_vkCmdSetScissorWithCountEXT( vkGetInstanceProcAddr( instance, "vkCmdSetScissorWithCountEXT" ) ); 13134 vkCmdBindVertexBuffers2EXT = 13135 PFN_vkCmdBindVertexBuffers2EXT( vkGetInstanceProcAddr( instance, "vkCmdBindVertexBuffers2EXT" ) ); 13136 vkCmdSetDepthTestEnableEXT = 13137 PFN_vkCmdSetDepthTestEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthTestEnableEXT" ) ); 13138 vkCmdSetDepthWriteEnableEXT = 13139 PFN_vkCmdSetDepthWriteEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthWriteEnableEXT" ) ); 13140 vkCmdSetDepthCompareOpEXT = 13141 PFN_vkCmdSetDepthCompareOpEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthCompareOpEXT" ) ); 13142 vkCmdSetDepthBoundsTestEnableEXT = 13143 PFN_vkCmdSetDepthBoundsTestEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBoundsTestEnableEXT" ) ); 13144 vkCmdSetStencilTestEnableEXT = 13145 PFN_vkCmdSetStencilTestEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetStencilTestEnableEXT" ) ); 13146 vkCmdSetStencilOpEXT = PFN_vkCmdSetStencilOpEXT( vkGetInstanceProcAddr( instance, "vkCmdSetStencilOpEXT" ) ); 13147 13148 //=== VK_KHR_deferred_host_operations === 13149 vkCreateDeferredOperationKHR = 13150 PFN_vkCreateDeferredOperationKHR( vkGetInstanceProcAddr( instance, "vkCreateDeferredOperationKHR" ) ); 13151 vkDestroyDeferredOperationKHR = 13152 PFN_vkDestroyDeferredOperationKHR( vkGetInstanceProcAddr( instance, "vkDestroyDeferredOperationKHR" ) ); 13153 vkGetDeferredOperationMaxConcurrencyKHR = PFN_vkGetDeferredOperationMaxConcurrencyKHR( 13154 vkGetInstanceProcAddr( instance, "vkGetDeferredOperationMaxConcurrencyKHR" ) ); 13155 vkGetDeferredOperationResultKHR = 13156 PFN_vkGetDeferredOperationResultKHR( vkGetInstanceProcAddr( instance, "vkGetDeferredOperationResultKHR" ) ); 13157 vkDeferredOperationJoinKHR = 13158 PFN_vkDeferredOperationJoinKHR( vkGetInstanceProcAddr( instance, "vkDeferredOperationJoinKHR" ) ); 13159 13160 //=== VK_KHR_pipeline_executable_properties === 13161 vkGetPipelineExecutablePropertiesKHR = PFN_vkGetPipelineExecutablePropertiesKHR( 13162 vkGetInstanceProcAddr( instance, "vkGetPipelineExecutablePropertiesKHR" ) ); 13163 vkGetPipelineExecutableStatisticsKHR = PFN_vkGetPipelineExecutableStatisticsKHR( 13164 vkGetInstanceProcAddr( instance, "vkGetPipelineExecutableStatisticsKHR" ) ); 13165 vkGetPipelineExecutableInternalRepresentationsKHR = PFN_vkGetPipelineExecutableInternalRepresentationsKHR( 13166 vkGetInstanceProcAddr( instance, "vkGetPipelineExecutableInternalRepresentationsKHR" ) ); 13167 13168 //=== VK_NV_device_generated_commands === 13169 vkGetGeneratedCommandsMemoryRequirementsNV = PFN_vkGetGeneratedCommandsMemoryRequirementsNV( 13170 vkGetInstanceProcAddr( instance, "vkGetGeneratedCommandsMemoryRequirementsNV" ) ); 13171 vkCmdPreprocessGeneratedCommandsNV = PFN_vkCmdPreprocessGeneratedCommandsNV( 13172 vkGetInstanceProcAddr( instance, "vkCmdPreprocessGeneratedCommandsNV" ) ); 13173 vkCmdExecuteGeneratedCommandsNV = 13174 PFN_vkCmdExecuteGeneratedCommandsNV( vkGetInstanceProcAddr( instance, "vkCmdExecuteGeneratedCommandsNV" ) ); 13175 vkCmdBindPipelineShaderGroupNV = 13176 PFN_vkCmdBindPipelineShaderGroupNV( vkGetInstanceProcAddr( instance, "vkCmdBindPipelineShaderGroupNV" ) ); 13177 vkCreateIndirectCommandsLayoutNV = 13178 PFN_vkCreateIndirectCommandsLayoutNV( vkGetInstanceProcAddr( instance, "vkCreateIndirectCommandsLayoutNV" ) ); 13179 vkDestroyIndirectCommandsLayoutNV = 13180 PFN_vkDestroyIndirectCommandsLayoutNV( vkGetInstanceProcAddr( instance, "vkDestroyIndirectCommandsLayoutNV" ) ); 13181 13182 //=== VK_EXT_acquire_drm_display === 13183 vkAcquireDrmDisplayEXT = 13184 PFN_vkAcquireDrmDisplayEXT( vkGetInstanceProcAddr( instance, "vkAcquireDrmDisplayEXT" ) ); 13185 vkGetDrmDisplayEXT = PFN_vkGetDrmDisplayEXT( vkGetInstanceProcAddr( instance, "vkGetDrmDisplayEXT" ) ); 13186 13187 //=== VK_EXT_private_data === 13188 vkCreatePrivateDataSlotEXT = 13189 PFN_vkCreatePrivateDataSlotEXT( vkGetInstanceProcAddr( instance, "vkCreatePrivateDataSlotEXT" ) ); 13190 vkDestroyPrivateDataSlotEXT = 13191 PFN_vkDestroyPrivateDataSlotEXT( vkGetInstanceProcAddr( instance, "vkDestroyPrivateDataSlotEXT" ) ); 13192 vkSetPrivateDataEXT = PFN_vkSetPrivateDataEXT( vkGetInstanceProcAddr( instance, "vkSetPrivateDataEXT" ) ); 13193 vkGetPrivateDataEXT = PFN_vkGetPrivateDataEXT( vkGetInstanceProcAddr( instance, "vkGetPrivateDataEXT" ) ); 13194 13195 #if defined( VK_ENABLE_BETA_EXTENSIONS ) 13196 //=== VK_KHR_video_encode_queue === 13197 vkCmdEncodeVideoKHR = PFN_vkCmdEncodeVideoKHR( vkGetInstanceProcAddr( instance, "vkCmdEncodeVideoKHR" ) ); 13198 #endif /*VK_ENABLE_BETA_EXTENSIONS*/ 13199 13200 //=== VK_KHR_synchronization2 === 13201 vkCmdSetEvent2KHR = PFN_vkCmdSetEvent2KHR( vkGetInstanceProcAddr( instance, "vkCmdSetEvent2KHR" ) ); 13202 vkCmdResetEvent2KHR = PFN_vkCmdResetEvent2KHR( vkGetInstanceProcAddr( instance, "vkCmdResetEvent2KHR" ) ); 13203 vkCmdWaitEvents2KHR = PFN_vkCmdWaitEvents2KHR( vkGetInstanceProcAddr( instance, "vkCmdWaitEvents2KHR" ) ); 13204 vkCmdPipelineBarrier2KHR = 13205 PFN_vkCmdPipelineBarrier2KHR( vkGetInstanceProcAddr( instance, "vkCmdPipelineBarrier2KHR" ) ); 13206 vkCmdWriteTimestamp2KHR = 13207 PFN_vkCmdWriteTimestamp2KHR( vkGetInstanceProcAddr( instance, "vkCmdWriteTimestamp2KHR" ) ); 13208 vkQueueSubmit2KHR = PFN_vkQueueSubmit2KHR( vkGetInstanceProcAddr( instance, "vkQueueSubmit2KHR" ) ); 13209 vkCmdWriteBufferMarker2AMD = 13210 PFN_vkCmdWriteBufferMarker2AMD( vkGetInstanceProcAddr( instance, "vkCmdWriteBufferMarker2AMD" ) ); 13211 vkGetQueueCheckpointData2NV = 13212 PFN_vkGetQueueCheckpointData2NV( vkGetInstanceProcAddr( instance, "vkGetQueueCheckpointData2NV" ) ); 13213 13214 //=== VK_NV_fragment_shading_rate_enums === 13215 vkCmdSetFragmentShadingRateEnumNV = 13216 PFN_vkCmdSetFragmentShadingRateEnumNV( vkGetInstanceProcAddr( instance, "vkCmdSetFragmentShadingRateEnumNV" ) ); 13217 13218 //=== VK_KHR_copy_commands2 === 13219 vkCmdCopyBuffer2KHR = PFN_vkCmdCopyBuffer2KHR( vkGetInstanceProcAddr( instance, "vkCmdCopyBuffer2KHR" ) ); 13220 vkCmdCopyImage2KHR = PFN_vkCmdCopyImage2KHR( vkGetInstanceProcAddr( instance, "vkCmdCopyImage2KHR" ) ); 13221 vkCmdCopyBufferToImage2KHR = 13222 PFN_vkCmdCopyBufferToImage2KHR( vkGetInstanceProcAddr( instance, "vkCmdCopyBufferToImage2KHR" ) ); 13223 vkCmdCopyImageToBuffer2KHR = 13224 PFN_vkCmdCopyImageToBuffer2KHR( vkGetInstanceProcAddr( instance, "vkCmdCopyImageToBuffer2KHR" ) ); 13225 vkCmdBlitImage2KHR = PFN_vkCmdBlitImage2KHR( vkGetInstanceProcAddr( instance, "vkCmdBlitImage2KHR" ) ); 13226 vkCmdResolveImage2KHR = PFN_vkCmdResolveImage2KHR( vkGetInstanceProcAddr( instance, "vkCmdResolveImage2KHR" ) ); 13227 13228 #if defined( VK_USE_PLATFORM_WIN32_KHR ) 13229 //=== VK_NV_acquire_winrt_display === 13230 vkAcquireWinrtDisplayNV = 13231 PFN_vkAcquireWinrtDisplayNV( vkGetInstanceProcAddr( instance, "vkAcquireWinrtDisplayNV" ) ); 13232 vkGetWinrtDisplayNV = PFN_vkGetWinrtDisplayNV( vkGetInstanceProcAddr( instance, "vkGetWinrtDisplayNV" ) ); 13233 #endif /*VK_USE_PLATFORM_WIN32_KHR*/ 13234 13235 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) 13236 //=== VK_EXT_directfb_surface === 13237 vkCreateDirectFBSurfaceEXT = 13238 PFN_vkCreateDirectFBSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateDirectFBSurfaceEXT" ) ); 13239 vkGetPhysicalDeviceDirectFBPresentationSupportEXT = PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT( 13240 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDirectFBPresentationSupportEXT" ) ); 13241 #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ 13242 13243 //=== VK_KHR_ray_tracing_pipeline === 13244 vkCmdTraceRaysKHR = PFN_vkCmdTraceRaysKHR( vkGetInstanceProcAddr( instance, "vkCmdTraceRaysKHR" ) ); 13245 vkCreateRayTracingPipelinesKHR = 13246 PFN_vkCreateRayTracingPipelinesKHR( vkGetInstanceProcAddr( instance, "vkCreateRayTracingPipelinesKHR" ) ); 13247 vkGetRayTracingShaderGroupHandlesKHR = PFN_vkGetRayTracingShaderGroupHandlesKHR( 13248 vkGetInstanceProcAddr( instance, "vkGetRayTracingShaderGroupHandlesKHR" ) ); 13249 vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( 13250 vkGetInstanceProcAddr( instance, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR" ) ); 13251 vkCmdTraceRaysIndirectKHR = 13252 PFN_vkCmdTraceRaysIndirectKHR( vkGetInstanceProcAddr( instance, "vkCmdTraceRaysIndirectKHR" ) ); 13253 vkGetRayTracingShaderGroupStackSizeKHR = PFN_vkGetRayTracingShaderGroupStackSizeKHR( 13254 vkGetInstanceProcAddr( instance, "vkGetRayTracingShaderGroupStackSizeKHR" ) ); 13255 vkCmdSetRayTracingPipelineStackSizeKHR = PFN_vkCmdSetRayTracingPipelineStackSizeKHR( 13256 vkGetInstanceProcAddr( instance, "vkCmdSetRayTracingPipelineStackSizeKHR" ) ); 13257 13258 //=== VK_EXT_vertex_input_dynamic_state === 13259 vkCmdSetVertexInputEXT = 13260 PFN_vkCmdSetVertexInputEXT( vkGetInstanceProcAddr( instance, "vkCmdSetVertexInputEXT" ) ); 13261 13262 #if defined( VK_USE_PLATFORM_FUCHSIA ) 13263 //=== VK_FUCHSIA_external_memory === 13264 vkGetMemoryZirconHandleFUCHSIA = 13265 PFN_vkGetMemoryZirconHandleFUCHSIA( vkGetInstanceProcAddr( instance, "vkGetMemoryZirconHandleFUCHSIA" ) ); 13266 vkGetMemoryZirconHandlePropertiesFUCHSIA = PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA( 13267 vkGetInstanceProcAddr( instance, "vkGetMemoryZirconHandlePropertiesFUCHSIA" ) ); 13268 #endif /*VK_USE_PLATFORM_FUCHSIA*/ 13269 13270 #if defined( VK_USE_PLATFORM_FUCHSIA ) 13271 //=== VK_FUCHSIA_external_semaphore === 13272 vkImportSemaphoreZirconHandleFUCHSIA = PFN_vkImportSemaphoreZirconHandleFUCHSIA( 13273 vkGetInstanceProcAddr( instance, "vkImportSemaphoreZirconHandleFUCHSIA" ) ); 13274 vkGetSemaphoreZirconHandleFUCHSIA = 13275 PFN_vkGetSemaphoreZirconHandleFUCHSIA( vkGetInstanceProcAddr( instance, "vkGetSemaphoreZirconHandleFUCHSIA" ) ); 13276 #endif /*VK_USE_PLATFORM_FUCHSIA*/ 13277 13278 #if defined( VK_USE_PLATFORM_FUCHSIA ) 13279 //=== VK_FUCHSIA_buffer_collection === 13280 vkCreateBufferCollectionFUCHSIA = 13281 PFN_vkCreateBufferCollectionFUCHSIA( vkGetInstanceProcAddr( instance, "vkCreateBufferCollectionFUCHSIA" ) ); 13282 vkSetBufferCollectionImageConstraintsFUCHSIA = PFN_vkSetBufferCollectionImageConstraintsFUCHSIA( 13283 vkGetInstanceProcAddr( instance, "vkSetBufferCollectionImageConstraintsFUCHSIA" ) ); 13284 vkSetBufferCollectionBufferConstraintsFUCHSIA = PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA( 13285 vkGetInstanceProcAddr( instance, "vkSetBufferCollectionBufferConstraintsFUCHSIA" ) ); 13286 vkDestroyBufferCollectionFUCHSIA = 13287 PFN_vkDestroyBufferCollectionFUCHSIA( vkGetInstanceProcAddr( instance, "vkDestroyBufferCollectionFUCHSIA" ) ); 13288 vkGetBufferCollectionPropertiesFUCHSIA = PFN_vkGetBufferCollectionPropertiesFUCHSIA( 13289 vkGetInstanceProcAddr( instance, "vkGetBufferCollectionPropertiesFUCHSIA" ) ); 13290 #endif /*VK_USE_PLATFORM_FUCHSIA*/ 13291 13292 //=== VK_HUAWEI_subpass_shading === 13293 vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( 13294 vkGetInstanceProcAddr( instance, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI" ) ); 13295 vkCmdSubpassShadingHUAWEI = 13296 PFN_vkCmdSubpassShadingHUAWEI( vkGetInstanceProcAddr( instance, "vkCmdSubpassShadingHUAWEI" ) ); 13297 13298 //=== VK_HUAWEI_invocation_mask === 13299 vkCmdBindInvocationMaskHUAWEI = 13300 PFN_vkCmdBindInvocationMaskHUAWEI( vkGetInstanceProcAddr( instance, "vkCmdBindInvocationMaskHUAWEI" ) ); 13301 13302 //=== VK_NV_external_memory_rdma === 13303 vkGetMemoryRemoteAddressNV = 13304 PFN_vkGetMemoryRemoteAddressNV( vkGetInstanceProcAddr( instance, "vkGetMemoryRemoteAddressNV" ) ); 13305 13306 //=== VK_EXT_extended_dynamic_state2 === 13307 vkCmdSetPatchControlPointsEXT = 13308 PFN_vkCmdSetPatchControlPointsEXT( vkGetInstanceProcAddr( instance, "vkCmdSetPatchControlPointsEXT" ) ); 13309 vkCmdSetRasterizerDiscardEnableEXT = PFN_vkCmdSetRasterizerDiscardEnableEXT( 13310 vkGetInstanceProcAddr( instance, "vkCmdSetRasterizerDiscardEnableEXT" ) ); 13311 vkCmdSetDepthBiasEnableEXT = 13312 PFN_vkCmdSetDepthBiasEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBiasEnableEXT" ) ); 13313 vkCmdSetLogicOpEXT = PFN_vkCmdSetLogicOpEXT( vkGetInstanceProcAddr( instance, "vkCmdSetLogicOpEXT" ) ); 13314 vkCmdSetPrimitiveRestartEnableEXT = 13315 PFN_vkCmdSetPrimitiveRestartEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetPrimitiveRestartEnableEXT" ) ); 13316 13317 #if defined( VK_USE_PLATFORM_SCREEN_QNX ) 13318 //=== VK_QNX_screen_surface === 13319 vkCreateScreenSurfaceQNX = 13320 PFN_vkCreateScreenSurfaceQNX( vkGetInstanceProcAddr( instance, "vkCreateScreenSurfaceQNX" ) ); 13321 vkGetPhysicalDeviceScreenPresentationSupportQNX = PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX( 13322 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceScreenPresentationSupportQNX" ) ); 13323 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/ 13324 13325 //=== VK_EXT_color_write_enable === 13326 vkCmdSetColorWriteEnableEXT = 13327 PFN_vkCmdSetColorWriteEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetColorWriteEnableEXT" ) ); 13328 13329 //=== VK_EXT_multi_draw === 13330 vkCmdDrawMultiEXT = PFN_vkCmdDrawMultiEXT( vkGetInstanceProcAddr( instance, "vkCmdDrawMultiEXT" ) ); 13331 vkCmdDrawMultiIndexedEXT = 13332 PFN_vkCmdDrawMultiIndexedEXT( vkGetInstanceProcAddr( instance, "vkCmdDrawMultiIndexedEXT" ) ); 13333 13334 //=== VK_EXT_pageable_device_local_memory === 13335 vkSetDeviceMemoryPriorityEXT = 13336 PFN_vkSetDeviceMemoryPriorityEXT( vkGetInstanceProcAddr( instance, "vkSetDeviceMemoryPriorityEXT" ) ); 13337 13338 //=== VK_KHR_maintenance4 === 13339 vkGetDeviceBufferMemoryRequirementsKHR = PFN_vkGetDeviceBufferMemoryRequirementsKHR( 13340 vkGetInstanceProcAddr( instance, "vkGetDeviceBufferMemoryRequirementsKHR" ) ); 13341 vkGetDeviceImageMemoryRequirementsKHR = PFN_vkGetDeviceImageMemoryRequirementsKHR( 13342 vkGetInstanceProcAddr( instance, "vkGetDeviceImageMemoryRequirementsKHR" ) ); 13343 vkGetDeviceImageSparseMemoryRequirementsKHR = PFN_vkGetDeviceImageSparseMemoryRequirementsKHR( 13344 vkGetInstanceProcAddr( instance, "vkGetDeviceImageSparseMemoryRequirementsKHR" ) ); 13345 } 13346 init(VULKAN_HPP_NAMESPACE::Device deviceCpp)13347 void init( VULKAN_HPP_NAMESPACE::Device deviceCpp ) VULKAN_HPP_NOEXCEPT 13348 { 13349 VkDevice device = static_cast<VkDevice>( deviceCpp ); 13350 13351 //=== VK_VERSION_1_0 === 13352 vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr( vkGetDeviceProcAddr( device, "vkGetDeviceProcAddr" ) ); 13353 vkDestroyDevice = PFN_vkDestroyDevice( vkGetDeviceProcAddr( device, "vkDestroyDevice" ) ); 13354 vkGetDeviceQueue = PFN_vkGetDeviceQueue( vkGetDeviceProcAddr( device, "vkGetDeviceQueue" ) ); 13355 vkQueueSubmit = PFN_vkQueueSubmit( vkGetDeviceProcAddr( device, "vkQueueSubmit" ) ); 13356 vkQueueWaitIdle = PFN_vkQueueWaitIdle( vkGetDeviceProcAddr( device, "vkQueueWaitIdle" ) ); 13357 vkDeviceWaitIdle = PFN_vkDeviceWaitIdle( vkGetDeviceProcAddr( device, "vkDeviceWaitIdle" ) ); 13358 vkAllocateMemory = PFN_vkAllocateMemory( vkGetDeviceProcAddr( device, "vkAllocateMemory" ) ); 13359 vkFreeMemory = PFN_vkFreeMemory( vkGetDeviceProcAddr( device, "vkFreeMemory" ) ); 13360 vkMapMemory = PFN_vkMapMemory( vkGetDeviceProcAddr( device, "vkMapMemory" ) ); 13361 vkUnmapMemory = PFN_vkUnmapMemory( vkGetDeviceProcAddr( device, "vkUnmapMemory" ) ); 13362 vkFlushMappedMemoryRanges = 13363 PFN_vkFlushMappedMemoryRanges( vkGetDeviceProcAddr( device, "vkFlushMappedMemoryRanges" ) ); 13364 vkInvalidateMappedMemoryRanges = 13365 PFN_vkInvalidateMappedMemoryRanges( vkGetDeviceProcAddr( device, "vkInvalidateMappedMemoryRanges" ) ); 13366 vkGetDeviceMemoryCommitment = 13367 PFN_vkGetDeviceMemoryCommitment( vkGetDeviceProcAddr( device, "vkGetDeviceMemoryCommitment" ) ); 13368 vkBindBufferMemory = PFN_vkBindBufferMemory( vkGetDeviceProcAddr( device, "vkBindBufferMemory" ) ); 13369 vkBindImageMemory = PFN_vkBindImageMemory( vkGetDeviceProcAddr( device, "vkBindImageMemory" ) ); 13370 vkGetBufferMemoryRequirements = 13371 PFN_vkGetBufferMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements" ) ); 13372 vkGetImageMemoryRequirements = 13373 PFN_vkGetImageMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements" ) ); 13374 vkGetImageSparseMemoryRequirements = 13375 PFN_vkGetImageSparseMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements" ) ); 13376 vkQueueBindSparse = PFN_vkQueueBindSparse( vkGetDeviceProcAddr( device, "vkQueueBindSparse" ) ); 13377 vkCreateFence = PFN_vkCreateFence( vkGetDeviceProcAddr( device, "vkCreateFence" ) ); 13378 vkDestroyFence = PFN_vkDestroyFence( vkGetDeviceProcAddr( device, "vkDestroyFence" ) ); 13379 vkResetFences = PFN_vkResetFences( vkGetDeviceProcAddr( device, "vkResetFences" ) ); 13380 vkGetFenceStatus = PFN_vkGetFenceStatus( vkGetDeviceProcAddr( device, "vkGetFenceStatus" ) ); 13381 vkWaitForFences = PFN_vkWaitForFences( vkGetDeviceProcAddr( device, "vkWaitForFences" ) ); 13382 vkCreateSemaphore = PFN_vkCreateSemaphore( vkGetDeviceProcAddr( device, "vkCreateSemaphore" ) ); 13383 vkDestroySemaphore = PFN_vkDestroySemaphore( vkGetDeviceProcAddr( device, "vkDestroySemaphore" ) ); 13384 vkCreateEvent = PFN_vkCreateEvent( vkGetDeviceProcAddr( device, "vkCreateEvent" ) ); 13385 vkDestroyEvent = PFN_vkDestroyEvent( vkGetDeviceProcAddr( device, "vkDestroyEvent" ) ); 13386 vkGetEventStatus = PFN_vkGetEventStatus( vkGetDeviceProcAddr( device, "vkGetEventStatus" ) ); 13387 vkSetEvent = PFN_vkSetEvent( vkGetDeviceProcAddr( device, "vkSetEvent" ) ); 13388 vkResetEvent = PFN_vkResetEvent( vkGetDeviceProcAddr( device, "vkResetEvent" ) ); 13389 vkCreateQueryPool = PFN_vkCreateQueryPool( vkGetDeviceProcAddr( device, "vkCreateQueryPool" ) ); 13390 vkDestroyQueryPool = PFN_vkDestroyQueryPool( vkGetDeviceProcAddr( device, "vkDestroyQueryPool" ) ); 13391 vkGetQueryPoolResults = PFN_vkGetQueryPoolResults( vkGetDeviceProcAddr( device, "vkGetQueryPoolResults" ) ); 13392 vkCreateBuffer = PFN_vkCreateBuffer( vkGetDeviceProcAddr( device, "vkCreateBuffer" ) ); 13393 vkDestroyBuffer = PFN_vkDestroyBuffer( vkGetDeviceProcAddr( device, "vkDestroyBuffer" ) ); 13394 vkCreateBufferView = PFN_vkCreateBufferView( vkGetDeviceProcAddr( device, "vkCreateBufferView" ) ); 13395 vkDestroyBufferView = PFN_vkDestroyBufferView( vkGetDeviceProcAddr( device, "vkDestroyBufferView" ) ); 13396 vkCreateImage = PFN_vkCreateImage( vkGetDeviceProcAddr( device, "vkCreateImage" ) ); 13397 vkDestroyImage = PFN_vkDestroyImage( vkGetDeviceProcAddr( device, "vkDestroyImage" ) ); 13398 vkGetImageSubresourceLayout = 13399 PFN_vkGetImageSubresourceLayout( vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout" ) ); 13400 vkCreateImageView = PFN_vkCreateImageView( vkGetDeviceProcAddr( device, "vkCreateImageView" ) ); 13401 vkDestroyImageView = PFN_vkDestroyImageView( vkGetDeviceProcAddr( device, "vkDestroyImageView" ) ); 13402 vkCreateShaderModule = PFN_vkCreateShaderModule( vkGetDeviceProcAddr( device, "vkCreateShaderModule" ) ); 13403 vkDestroyShaderModule = PFN_vkDestroyShaderModule( vkGetDeviceProcAddr( device, "vkDestroyShaderModule" ) ); 13404 vkCreatePipelineCache = PFN_vkCreatePipelineCache( vkGetDeviceProcAddr( device, "vkCreatePipelineCache" ) ); 13405 vkDestroyPipelineCache = PFN_vkDestroyPipelineCache( vkGetDeviceProcAddr( device, "vkDestroyPipelineCache" ) ); 13406 vkGetPipelineCacheData = PFN_vkGetPipelineCacheData( vkGetDeviceProcAddr( device, "vkGetPipelineCacheData" ) ); 13407 vkMergePipelineCaches = PFN_vkMergePipelineCaches( vkGetDeviceProcAddr( device, "vkMergePipelineCaches" ) ); 13408 vkCreateGraphicsPipelines = 13409 PFN_vkCreateGraphicsPipelines( vkGetDeviceProcAddr( device, "vkCreateGraphicsPipelines" ) ); 13410 vkCreateComputePipelines = 13411 PFN_vkCreateComputePipelines( vkGetDeviceProcAddr( device, "vkCreateComputePipelines" ) ); 13412 vkDestroyPipeline = PFN_vkDestroyPipeline( vkGetDeviceProcAddr( device, "vkDestroyPipeline" ) ); 13413 vkCreatePipelineLayout = PFN_vkCreatePipelineLayout( vkGetDeviceProcAddr( device, "vkCreatePipelineLayout" ) ); 13414 vkDestroyPipelineLayout = PFN_vkDestroyPipelineLayout( vkGetDeviceProcAddr( device, "vkDestroyPipelineLayout" ) ); 13415 vkCreateSampler = PFN_vkCreateSampler( vkGetDeviceProcAddr( device, "vkCreateSampler" ) ); 13416 vkDestroySampler = PFN_vkDestroySampler( vkGetDeviceProcAddr( device, "vkDestroySampler" ) ); 13417 vkCreateDescriptorSetLayout = 13418 PFN_vkCreateDescriptorSetLayout( vkGetDeviceProcAddr( device, "vkCreateDescriptorSetLayout" ) ); 13419 vkDestroyDescriptorSetLayout = 13420 PFN_vkDestroyDescriptorSetLayout( vkGetDeviceProcAddr( device, "vkDestroyDescriptorSetLayout" ) ); 13421 vkCreateDescriptorPool = PFN_vkCreateDescriptorPool( vkGetDeviceProcAddr( device, "vkCreateDescriptorPool" ) ); 13422 vkDestroyDescriptorPool = PFN_vkDestroyDescriptorPool( vkGetDeviceProcAddr( device, "vkDestroyDescriptorPool" ) ); 13423 vkResetDescriptorPool = PFN_vkResetDescriptorPool( vkGetDeviceProcAddr( device, "vkResetDescriptorPool" ) ); 13424 vkAllocateDescriptorSets = 13425 PFN_vkAllocateDescriptorSets( vkGetDeviceProcAddr( device, "vkAllocateDescriptorSets" ) ); 13426 vkFreeDescriptorSets = PFN_vkFreeDescriptorSets( vkGetDeviceProcAddr( device, "vkFreeDescriptorSets" ) ); 13427 vkUpdateDescriptorSets = PFN_vkUpdateDescriptorSets( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSets" ) ); 13428 vkCreateFramebuffer = PFN_vkCreateFramebuffer( vkGetDeviceProcAddr( device, "vkCreateFramebuffer" ) ); 13429 vkDestroyFramebuffer = PFN_vkDestroyFramebuffer( vkGetDeviceProcAddr( device, "vkDestroyFramebuffer" ) ); 13430 vkCreateRenderPass = PFN_vkCreateRenderPass( vkGetDeviceProcAddr( device, "vkCreateRenderPass" ) ); 13431 vkDestroyRenderPass = PFN_vkDestroyRenderPass( vkGetDeviceProcAddr( device, "vkDestroyRenderPass" ) ); 13432 vkGetRenderAreaGranularity = 13433 PFN_vkGetRenderAreaGranularity( vkGetDeviceProcAddr( device, "vkGetRenderAreaGranularity" ) ); 13434 vkCreateCommandPool = PFN_vkCreateCommandPool( vkGetDeviceProcAddr( device, "vkCreateCommandPool" ) ); 13435 vkDestroyCommandPool = PFN_vkDestroyCommandPool( vkGetDeviceProcAddr( device, "vkDestroyCommandPool" ) ); 13436 vkResetCommandPool = PFN_vkResetCommandPool( vkGetDeviceProcAddr( device, "vkResetCommandPool" ) ); 13437 vkAllocateCommandBuffers = 13438 PFN_vkAllocateCommandBuffers( vkGetDeviceProcAddr( device, "vkAllocateCommandBuffers" ) ); 13439 vkFreeCommandBuffers = PFN_vkFreeCommandBuffers( vkGetDeviceProcAddr( device, "vkFreeCommandBuffers" ) ); 13440 vkBeginCommandBuffer = PFN_vkBeginCommandBuffer( vkGetDeviceProcAddr( device, "vkBeginCommandBuffer" ) ); 13441 vkEndCommandBuffer = PFN_vkEndCommandBuffer( vkGetDeviceProcAddr( device, "vkEndCommandBuffer" ) ); 13442 vkResetCommandBuffer = PFN_vkResetCommandBuffer( vkGetDeviceProcAddr( device, "vkResetCommandBuffer" ) ); 13443 vkCmdBindPipeline = PFN_vkCmdBindPipeline( vkGetDeviceProcAddr( device, "vkCmdBindPipeline" ) ); 13444 vkCmdSetViewport = PFN_vkCmdSetViewport( vkGetDeviceProcAddr( device, "vkCmdSetViewport" ) ); 13445 vkCmdSetScissor = PFN_vkCmdSetScissor( vkGetDeviceProcAddr( device, "vkCmdSetScissor" ) ); 13446 vkCmdSetLineWidth = PFN_vkCmdSetLineWidth( vkGetDeviceProcAddr( device, "vkCmdSetLineWidth" ) ); 13447 vkCmdSetDepthBias = PFN_vkCmdSetDepthBias( vkGetDeviceProcAddr( device, "vkCmdSetDepthBias" ) ); 13448 vkCmdSetBlendConstants = PFN_vkCmdSetBlendConstants( vkGetDeviceProcAddr( device, "vkCmdSetBlendConstants" ) ); 13449 vkCmdSetDepthBounds = PFN_vkCmdSetDepthBounds( vkGetDeviceProcAddr( device, "vkCmdSetDepthBounds" ) ); 13450 vkCmdSetStencilCompareMask = 13451 PFN_vkCmdSetStencilCompareMask( vkGetDeviceProcAddr( device, "vkCmdSetStencilCompareMask" ) ); 13452 vkCmdSetStencilWriteMask = 13453 PFN_vkCmdSetStencilWriteMask( vkGetDeviceProcAddr( device, "vkCmdSetStencilWriteMask" ) ); 13454 vkCmdSetStencilReference = 13455 PFN_vkCmdSetStencilReference( vkGetDeviceProcAddr( device, "vkCmdSetStencilReference" ) ); 13456 vkCmdBindDescriptorSets = PFN_vkCmdBindDescriptorSets( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorSets" ) ); 13457 vkCmdBindIndexBuffer = PFN_vkCmdBindIndexBuffer( vkGetDeviceProcAddr( device, "vkCmdBindIndexBuffer" ) ); 13458 vkCmdBindVertexBuffers = PFN_vkCmdBindVertexBuffers( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers" ) ); 13459 vkCmdDraw = PFN_vkCmdDraw( vkGetDeviceProcAddr( device, "vkCmdDraw" ) ); 13460 vkCmdDrawIndexed = PFN_vkCmdDrawIndexed( vkGetDeviceProcAddr( device, "vkCmdDrawIndexed" ) ); 13461 vkCmdDrawIndirect = PFN_vkCmdDrawIndirect( vkGetDeviceProcAddr( device, "vkCmdDrawIndirect" ) ); 13462 vkCmdDrawIndexedIndirect = 13463 PFN_vkCmdDrawIndexedIndirect( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirect" ) ); 13464 vkCmdDispatch = PFN_vkCmdDispatch( vkGetDeviceProcAddr( device, "vkCmdDispatch" ) ); 13465 vkCmdDispatchIndirect = PFN_vkCmdDispatchIndirect( vkGetDeviceProcAddr( device, "vkCmdDispatchIndirect" ) ); 13466 vkCmdCopyBuffer = PFN_vkCmdCopyBuffer( vkGetDeviceProcAddr( device, "vkCmdCopyBuffer" ) ); 13467 vkCmdCopyImage = PFN_vkCmdCopyImage( vkGetDeviceProcAddr( device, "vkCmdCopyImage" ) ); 13468 vkCmdBlitImage = PFN_vkCmdBlitImage( vkGetDeviceProcAddr( device, "vkCmdBlitImage" ) ); 13469 vkCmdCopyBufferToImage = PFN_vkCmdCopyBufferToImage( vkGetDeviceProcAddr( device, "vkCmdCopyBufferToImage" ) ); 13470 vkCmdCopyImageToBuffer = PFN_vkCmdCopyImageToBuffer( vkGetDeviceProcAddr( device, "vkCmdCopyImageToBuffer" ) ); 13471 vkCmdUpdateBuffer = PFN_vkCmdUpdateBuffer( vkGetDeviceProcAddr( device, "vkCmdUpdateBuffer" ) ); 13472 vkCmdFillBuffer = PFN_vkCmdFillBuffer( vkGetDeviceProcAddr( device, "vkCmdFillBuffer" ) ); 13473 vkCmdClearColorImage = PFN_vkCmdClearColorImage( vkGetDeviceProcAddr( device, "vkCmdClearColorImage" ) ); 13474 vkCmdClearDepthStencilImage = 13475 PFN_vkCmdClearDepthStencilImage( vkGetDeviceProcAddr( device, "vkCmdClearDepthStencilImage" ) ); 13476 vkCmdClearAttachments = PFN_vkCmdClearAttachments( vkGetDeviceProcAddr( device, "vkCmdClearAttachments" ) ); 13477 vkCmdResolveImage = PFN_vkCmdResolveImage( vkGetDeviceProcAddr( device, "vkCmdResolveImage" ) ); 13478 vkCmdSetEvent = PFN_vkCmdSetEvent( vkGetDeviceProcAddr( device, "vkCmdSetEvent" ) ); 13479 vkCmdResetEvent = PFN_vkCmdResetEvent( vkGetDeviceProcAddr( device, "vkCmdResetEvent" ) ); 13480 vkCmdWaitEvents = PFN_vkCmdWaitEvents( vkGetDeviceProcAddr( device, "vkCmdWaitEvents" ) ); 13481 vkCmdPipelineBarrier = PFN_vkCmdPipelineBarrier( vkGetDeviceProcAddr( device, "vkCmdPipelineBarrier" ) ); 13482 vkCmdBeginQuery = PFN_vkCmdBeginQuery( vkGetDeviceProcAddr( device, "vkCmdBeginQuery" ) ); 13483 vkCmdEndQuery = PFN_vkCmdEndQuery( vkGetDeviceProcAddr( device, "vkCmdEndQuery" ) ); 13484 vkCmdResetQueryPool = PFN_vkCmdResetQueryPool( vkGetDeviceProcAddr( device, "vkCmdResetQueryPool" ) ); 13485 vkCmdWriteTimestamp = PFN_vkCmdWriteTimestamp( vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp" ) ); 13486 vkCmdCopyQueryPoolResults = 13487 PFN_vkCmdCopyQueryPoolResults( vkGetDeviceProcAddr( device, "vkCmdCopyQueryPoolResults" ) ); 13488 vkCmdPushConstants = PFN_vkCmdPushConstants( vkGetDeviceProcAddr( device, "vkCmdPushConstants" ) ); 13489 vkCmdBeginRenderPass = PFN_vkCmdBeginRenderPass( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass" ) ); 13490 vkCmdNextSubpass = PFN_vkCmdNextSubpass( vkGetDeviceProcAddr( device, "vkCmdNextSubpass" ) ); 13491 vkCmdEndRenderPass = PFN_vkCmdEndRenderPass( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass" ) ); 13492 vkCmdExecuteCommands = PFN_vkCmdExecuteCommands( vkGetDeviceProcAddr( device, "vkCmdExecuteCommands" ) ); 13493 13494 //=== VK_VERSION_1_1 === 13495 vkBindBufferMemory2 = PFN_vkBindBufferMemory2( vkGetDeviceProcAddr( device, "vkBindBufferMemory2" ) ); 13496 vkBindImageMemory2 = PFN_vkBindImageMemory2( vkGetDeviceProcAddr( device, "vkBindImageMemory2" ) ); 13497 vkGetDeviceGroupPeerMemoryFeatures = 13498 PFN_vkGetDeviceGroupPeerMemoryFeatures( vkGetDeviceProcAddr( device, "vkGetDeviceGroupPeerMemoryFeatures" ) ); 13499 vkCmdSetDeviceMask = PFN_vkCmdSetDeviceMask( vkGetDeviceProcAddr( device, "vkCmdSetDeviceMask" ) ); 13500 vkCmdDispatchBase = PFN_vkCmdDispatchBase( vkGetDeviceProcAddr( device, "vkCmdDispatchBase" ) ); 13501 vkGetImageMemoryRequirements2 = 13502 PFN_vkGetImageMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements2" ) ); 13503 vkGetBufferMemoryRequirements2 = 13504 PFN_vkGetBufferMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements2" ) ); 13505 vkGetImageSparseMemoryRequirements2 = 13506 PFN_vkGetImageSparseMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements2" ) ); 13507 vkTrimCommandPool = PFN_vkTrimCommandPool( vkGetDeviceProcAddr( device, "vkTrimCommandPool" ) ); 13508 vkGetDeviceQueue2 = PFN_vkGetDeviceQueue2( vkGetDeviceProcAddr( device, "vkGetDeviceQueue2" ) ); 13509 vkCreateSamplerYcbcrConversion = 13510 PFN_vkCreateSamplerYcbcrConversion( vkGetDeviceProcAddr( device, "vkCreateSamplerYcbcrConversion" ) ); 13511 vkDestroySamplerYcbcrConversion = 13512 PFN_vkDestroySamplerYcbcrConversion( vkGetDeviceProcAddr( device, "vkDestroySamplerYcbcrConversion" ) ); 13513 vkCreateDescriptorUpdateTemplate = 13514 PFN_vkCreateDescriptorUpdateTemplate( vkGetDeviceProcAddr( device, "vkCreateDescriptorUpdateTemplate" ) ); 13515 vkDestroyDescriptorUpdateTemplate = 13516 PFN_vkDestroyDescriptorUpdateTemplate( vkGetDeviceProcAddr( device, "vkDestroyDescriptorUpdateTemplate" ) ); 13517 vkUpdateDescriptorSetWithTemplate = 13518 PFN_vkUpdateDescriptorSetWithTemplate( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSetWithTemplate" ) ); 13519 vkGetDescriptorSetLayoutSupport = 13520 PFN_vkGetDescriptorSetLayoutSupport( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSupport" ) ); 13521 13522 //=== VK_VERSION_1_2 === 13523 vkCmdDrawIndirectCount = PFN_vkCmdDrawIndirectCount( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCount" ) ); 13524 vkCmdDrawIndexedIndirectCount = 13525 PFN_vkCmdDrawIndexedIndirectCount( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCount" ) ); 13526 vkCreateRenderPass2 = PFN_vkCreateRenderPass2( vkGetDeviceProcAddr( device, "vkCreateRenderPass2" ) ); 13527 vkCmdBeginRenderPass2 = PFN_vkCmdBeginRenderPass2( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass2" ) ); 13528 vkCmdNextSubpass2 = PFN_vkCmdNextSubpass2( vkGetDeviceProcAddr( device, "vkCmdNextSubpass2" ) ); 13529 vkCmdEndRenderPass2 = PFN_vkCmdEndRenderPass2( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass2" ) ); 13530 vkResetQueryPool = PFN_vkResetQueryPool( vkGetDeviceProcAddr( device, "vkResetQueryPool" ) ); 13531 vkGetSemaphoreCounterValue = 13532 PFN_vkGetSemaphoreCounterValue( vkGetDeviceProcAddr( device, "vkGetSemaphoreCounterValue" ) ); 13533 vkWaitSemaphores = PFN_vkWaitSemaphores( vkGetDeviceProcAddr( device, "vkWaitSemaphores" ) ); 13534 vkSignalSemaphore = PFN_vkSignalSemaphore( vkGetDeviceProcAddr( device, "vkSignalSemaphore" ) ); 13535 vkGetBufferDeviceAddress = 13536 PFN_vkGetBufferDeviceAddress( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddress" ) ); 13537 vkGetBufferOpaqueCaptureAddress = 13538 PFN_vkGetBufferOpaqueCaptureAddress( vkGetDeviceProcAddr( device, "vkGetBufferOpaqueCaptureAddress" ) ); 13539 vkGetDeviceMemoryOpaqueCaptureAddress = PFN_vkGetDeviceMemoryOpaqueCaptureAddress( 13540 vkGetDeviceProcAddr( device, "vkGetDeviceMemoryOpaqueCaptureAddress" ) ); 13541 13542 //=== VK_KHR_swapchain === 13543 vkCreateSwapchainKHR = PFN_vkCreateSwapchainKHR( vkGetDeviceProcAddr( device, "vkCreateSwapchainKHR" ) ); 13544 vkDestroySwapchainKHR = PFN_vkDestroySwapchainKHR( vkGetDeviceProcAddr( device, "vkDestroySwapchainKHR" ) ); 13545 vkGetSwapchainImagesKHR = PFN_vkGetSwapchainImagesKHR( vkGetDeviceProcAddr( device, "vkGetSwapchainImagesKHR" ) ); 13546 vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR( vkGetDeviceProcAddr( device, "vkAcquireNextImageKHR" ) ); 13547 vkQueuePresentKHR = PFN_vkQueuePresentKHR( vkGetDeviceProcAddr( device, "vkQueuePresentKHR" ) ); 13548 vkGetDeviceGroupPresentCapabilitiesKHR = PFN_vkGetDeviceGroupPresentCapabilitiesKHR( 13549 vkGetDeviceProcAddr( device, "vkGetDeviceGroupPresentCapabilitiesKHR" ) ); 13550 vkGetDeviceGroupSurfacePresentModesKHR = PFN_vkGetDeviceGroupSurfacePresentModesKHR( 13551 vkGetDeviceProcAddr( device, "vkGetDeviceGroupSurfacePresentModesKHR" ) ); 13552 vkAcquireNextImage2KHR = PFN_vkAcquireNextImage2KHR( vkGetDeviceProcAddr( device, "vkAcquireNextImage2KHR" ) ); 13553 13554 //=== VK_KHR_display_swapchain === 13555 vkCreateSharedSwapchainsKHR = 13556 PFN_vkCreateSharedSwapchainsKHR( vkGetDeviceProcAddr( device, "vkCreateSharedSwapchainsKHR" ) ); 13557 13558 //=== VK_EXT_debug_marker === 13559 vkDebugMarkerSetObjectTagEXT = 13560 PFN_vkDebugMarkerSetObjectTagEXT( vkGetDeviceProcAddr( device, "vkDebugMarkerSetObjectTagEXT" ) ); 13561 vkDebugMarkerSetObjectNameEXT = 13562 PFN_vkDebugMarkerSetObjectNameEXT( vkGetDeviceProcAddr( device, "vkDebugMarkerSetObjectNameEXT" ) ); 13563 vkCmdDebugMarkerBeginEXT = 13564 PFN_vkCmdDebugMarkerBeginEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerBeginEXT" ) ); 13565 vkCmdDebugMarkerEndEXT = PFN_vkCmdDebugMarkerEndEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerEndEXT" ) ); 13566 vkCmdDebugMarkerInsertEXT = 13567 PFN_vkCmdDebugMarkerInsertEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerInsertEXT" ) ); 13568 13569 #if defined( VK_ENABLE_BETA_EXTENSIONS ) 13570 //=== VK_KHR_video_queue === 13571 vkCreateVideoSessionKHR = PFN_vkCreateVideoSessionKHR( vkGetDeviceProcAddr( device, "vkCreateVideoSessionKHR" ) ); 13572 vkDestroyVideoSessionKHR = 13573 PFN_vkDestroyVideoSessionKHR( vkGetDeviceProcAddr( device, "vkDestroyVideoSessionKHR" ) ); 13574 vkGetVideoSessionMemoryRequirementsKHR = PFN_vkGetVideoSessionMemoryRequirementsKHR( 13575 vkGetDeviceProcAddr( device, "vkGetVideoSessionMemoryRequirementsKHR" ) ); 13576 vkBindVideoSessionMemoryKHR = 13577 PFN_vkBindVideoSessionMemoryKHR( vkGetDeviceProcAddr( device, "vkBindVideoSessionMemoryKHR" ) ); 13578 vkCreateVideoSessionParametersKHR = 13579 PFN_vkCreateVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkCreateVideoSessionParametersKHR" ) ); 13580 vkUpdateVideoSessionParametersKHR = 13581 PFN_vkUpdateVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkUpdateVideoSessionParametersKHR" ) ); 13582 vkDestroyVideoSessionParametersKHR = 13583 PFN_vkDestroyVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkDestroyVideoSessionParametersKHR" ) ); 13584 vkCmdBeginVideoCodingKHR = 13585 PFN_vkCmdBeginVideoCodingKHR( vkGetDeviceProcAddr( device, "vkCmdBeginVideoCodingKHR" ) ); 13586 vkCmdEndVideoCodingKHR = PFN_vkCmdEndVideoCodingKHR( vkGetDeviceProcAddr( device, "vkCmdEndVideoCodingKHR" ) ); 13587 vkCmdControlVideoCodingKHR = 13588 PFN_vkCmdControlVideoCodingKHR( vkGetDeviceProcAddr( device, "vkCmdControlVideoCodingKHR" ) ); 13589 #endif /*VK_ENABLE_BETA_EXTENSIONS*/ 13590 13591 #if defined( VK_ENABLE_BETA_EXTENSIONS ) 13592 //=== VK_KHR_video_decode_queue === 13593 vkCmdDecodeVideoKHR = PFN_vkCmdDecodeVideoKHR( vkGetDeviceProcAddr( device, "vkCmdDecodeVideoKHR" ) ); 13594 #endif /*VK_ENABLE_BETA_EXTENSIONS*/ 13595 13596 //=== VK_EXT_transform_feedback === 13597 vkCmdBindTransformFeedbackBuffersEXT = PFN_vkCmdBindTransformFeedbackBuffersEXT( 13598 vkGetDeviceProcAddr( device, "vkCmdBindTransformFeedbackBuffersEXT" ) ); 13599 vkCmdBeginTransformFeedbackEXT = 13600 PFN_vkCmdBeginTransformFeedbackEXT( vkGetDeviceProcAddr( device, "vkCmdBeginTransformFeedbackEXT" ) ); 13601 vkCmdEndTransformFeedbackEXT = 13602 PFN_vkCmdEndTransformFeedbackEXT( vkGetDeviceProcAddr( device, "vkCmdEndTransformFeedbackEXT" ) ); 13603 vkCmdBeginQueryIndexedEXT = 13604 PFN_vkCmdBeginQueryIndexedEXT( vkGetDeviceProcAddr( device, "vkCmdBeginQueryIndexedEXT" ) ); 13605 vkCmdEndQueryIndexedEXT = PFN_vkCmdEndQueryIndexedEXT( vkGetDeviceProcAddr( device, "vkCmdEndQueryIndexedEXT" ) ); 13606 vkCmdDrawIndirectByteCountEXT = 13607 PFN_vkCmdDrawIndirectByteCountEXT( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectByteCountEXT" ) ); 13608 13609 //=== VK_NVX_binary_import === 13610 vkCreateCuModuleNVX = PFN_vkCreateCuModuleNVX( vkGetDeviceProcAddr( device, "vkCreateCuModuleNVX" ) ); 13611 vkCreateCuFunctionNVX = PFN_vkCreateCuFunctionNVX( vkGetDeviceProcAddr( device, "vkCreateCuFunctionNVX" ) ); 13612 vkDestroyCuModuleNVX = PFN_vkDestroyCuModuleNVX( vkGetDeviceProcAddr( device, "vkDestroyCuModuleNVX" ) ); 13613 vkDestroyCuFunctionNVX = PFN_vkDestroyCuFunctionNVX( vkGetDeviceProcAddr( device, "vkDestroyCuFunctionNVX" ) ); 13614 vkCmdCuLaunchKernelNVX = PFN_vkCmdCuLaunchKernelNVX( vkGetDeviceProcAddr( device, "vkCmdCuLaunchKernelNVX" ) ); 13615 13616 //=== VK_NVX_image_view_handle === 13617 vkGetImageViewHandleNVX = PFN_vkGetImageViewHandleNVX( vkGetDeviceProcAddr( device, "vkGetImageViewHandleNVX" ) ); 13618 vkGetImageViewAddressNVX = 13619 PFN_vkGetImageViewAddressNVX( vkGetDeviceProcAddr( device, "vkGetImageViewAddressNVX" ) ); 13620 13621 //=== VK_AMD_draw_indirect_count === 13622 vkCmdDrawIndirectCountAMD = 13623 PFN_vkCmdDrawIndirectCountAMD( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCountAMD" ) ); 13624 if ( !vkCmdDrawIndirectCount ) 13625 vkCmdDrawIndirectCount = vkCmdDrawIndirectCountAMD; 13626 vkCmdDrawIndexedIndirectCountAMD = 13627 PFN_vkCmdDrawIndexedIndirectCountAMD( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCountAMD" ) ); 13628 if ( !vkCmdDrawIndexedIndirectCount ) 13629 vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountAMD; 13630 13631 //=== VK_AMD_shader_info === 13632 vkGetShaderInfoAMD = PFN_vkGetShaderInfoAMD( vkGetDeviceProcAddr( device, "vkGetShaderInfoAMD" ) ); 13633 13634 //=== VK_KHR_dynamic_rendering === 13635 vkCmdBeginRenderingKHR = PFN_vkCmdBeginRenderingKHR( vkGetDeviceProcAddr( device, "vkCmdBeginRenderingKHR" ) ); 13636 vkCmdEndRenderingKHR = PFN_vkCmdEndRenderingKHR( vkGetDeviceProcAddr( device, "vkCmdEndRenderingKHR" ) ); 13637 13638 #if defined( VK_USE_PLATFORM_WIN32_KHR ) 13639 //=== VK_NV_external_memory_win32 === 13640 vkGetMemoryWin32HandleNV = 13641 PFN_vkGetMemoryWin32HandleNV( vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleNV" ) ); 13642 #endif /*VK_USE_PLATFORM_WIN32_KHR*/ 13643 13644 //=== VK_KHR_device_group === 13645 vkGetDeviceGroupPeerMemoryFeaturesKHR = PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR( 13646 vkGetDeviceProcAddr( device, "vkGetDeviceGroupPeerMemoryFeaturesKHR" ) ); 13647 if ( !vkGetDeviceGroupPeerMemoryFeatures ) 13648 vkGetDeviceGroupPeerMemoryFeatures = vkGetDeviceGroupPeerMemoryFeaturesKHR; 13649 vkCmdSetDeviceMaskKHR = PFN_vkCmdSetDeviceMaskKHR( vkGetDeviceProcAddr( device, "vkCmdSetDeviceMaskKHR" ) ); 13650 if ( !vkCmdSetDeviceMask ) 13651 vkCmdSetDeviceMask = vkCmdSetDeviceMaskKHR; 13652 vkCmdDispatchBaseKHR = PFN_vkCmdDispatchBaseKHR( vkGetDeviceProcAddr( device, "vkCmdDispatchBaseKHR" ) ); 13653 if ( !vkCmdDispatchBase ) 13654 vkCmdDispatchBase = vkCmdDispatchBaseKHR; 13655 13656 //=== VK_KHR_maintenance1 === 13657 vkTrimCommandPoolKHR = PFN_vkTrimCommandPoolKHR( vkGetDeviceProcAddr( device, "vkTrimCommandPoolKHR" ) ); 13658 if ( !vkTrimCommandPool ) 13659 vkTrimCommandPool = vkTrimCommandPoolKHR; 13660 13661 #if defined( VK_USE_PLATFORM_WIN32_KHR ) 13662 //=== VK_KHR_external_memory_win32 === 13663 vkGetMemoryWin32HandleKHR = 13664 PFN_vkGetMemoryWin32HandleKHR( vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleKHR" ) ); 13665 vkGetMemoryWin32HandlePropertiesKHR = 13666 PFN_vkGetMemoryWin32HandlePropertiesKHR( vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandlePropertiesKHR" ) ); 13667 #endif /*VK_USE_PLATFORM_WIN32_KHR*/ 13668 13669 //=== VK_KHR_external_memory_fd === 13670 vkGetMemoryFdKHR = PFN_vkGetMemoryFdKHR( vkGetDeviceProcAddr( device, "vkGetMemoryFdKHR" ) ); 13671 vkGetMemoryFdPropertiesKHR = 13672 PFN_vkGetMemoryFdPropertiesKHR( vkGetDeviceProcAddr( device, "vkGetMemoryFdPropertiesKHR" ) ); 13673 13674 #if defined( VK_USE_PLATFORM_WIN32_KHR ) 13675 //=== VK_KHR_external_semaphore_win32 === 13676 vkImportSemaphoreWin32HandleKHR = 13677 PFN_vkImportSemaphoreWin32HandleKHR( vkGetDeviceProcAddr( device, "vkImportSemaphoreWin32HandleKHR" ) ); 13678 vkGetSemaphoreWin32HandleKHR = 13679 PFN_vkGetSemaphoreWin32HandleKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreWin32HandleKHR" ) ); 13680 #endif /*VK_USE_PLATFORM_WIN32_KHR*/ 13681 13682 //=== VK_KHR_external_semaphore_fd === 13683 vkImportSemaphoreFdKHR = PFN_vkImportSemaphoreFdKHR( vkGetDeviceProcAddr( device, "vkImportSemaphoreFdKHR" ) ); 13684 vkGetSemaphoreFdKHR = PFN_vkGetSemaphoreFdKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreFdKHR" ) ); 13685 13686 //=== VK_KHR_push_descriptor === 13687 vkCmdPushDescriptorSetKHR = 13688 PFN_vkCmdPushDescriptorSetKHR( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetKHR" ) ); 13689 vkCmdPushDescriptorSetWithTemplateKHR = PFN_vkCmdPushDescriptorSetWithTemplateKHR( 13690 vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetWithTemplateKHR" ) ); 13691 13692 //=== VK_EXT_conditional_rendering === 13693 vkCmdBeginConditionalRenderingEXT = 13694 PFN_vkCmdBeginConditionalRenderingEXT( vkGetDeviceProcAddr( device, "vkCmdBeginConditionalRenderingEXT" ) ); 13695 vkCmdEndConditionalRenderingEXT = 13696 PFN_vkCmdEndConditionalRenderingEXT( vkGetDeviceProcAddr( device, "vkCmdEndConditionalRenderingEXT" ) ); 13697 13698 //=== VK_KHR_descriptor_update_template === 13699 vkCreateDescriptorUpdateTemplateKHR = 13700 PFN_vkCreateDescriptorUpdateTemplateKHR( vkGetDeviceProcAddr( device, "vkCreateDescriptorUpdateTemplateKHR" ) ); 13701 if ( !vkCreateDescriptorUpdateTemplate ) 13702 vkCreateDescriptorUpdateTemplate = vkCreateDescriptorUpdateTemplateKHR; 13703 vkDestroyDescriptorUpdateTemplateKHR = PFN_vkDestroyDescriptorUpdateTemplateKHR( 13704 vkGetDeviceProcAddr( device, "vkDestroyDescriptorUpdateTemplateKHR" ) ); 13705 if ( !vkDestroyDescriptorUpdateTemplate ) 13706 vkDestroyDescriptorUpdateTemplate = vkDestroyDescriptorUpdateTemplateKHR; 13707 vkUpdateDescriptorSetWithTemplateKHR = PFN_vkUpdateDescriptorSetWithTemplateKHR( 13708 vkGetDeviceProcAddr( device, "vkUpdateDescriptorSetWithTemplateKHR" ) ); 13709 if ( !vkUpdateDescriptorSetWithTemplate ) 13710 vkUpdateDescriptorSetWithTemplate = vkUpdateDescriptorSetWithTemplateKHR; 13711 13712 //=== VK_NV_clip_space_w_scaling === 13713 vkCmdSetViewportWScalingNV = 13714 PFN_vkCmdSetViewportWScalingNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportWScalingNV" ) ); 13715 13716 //=== VK_EXT_display_control === 13717 vkDisplayPowerControlEXT = 13718 PFN_vkDisplayPowerControlEXT( vkGetDeviceProcAddr( device, "vkDisplayPowerControlEXT" ) ); 13719 vkRegisterDeviceEventEXT = 13720 PFN_vkRegisterDeviceEventEXT( vkGetDeviceProcAddr( device, "vkRegisterDeviceEventEXT" ) ); 13721 vkRegisterDisplayEventEXT = 13722 PFN_vkRegisterDisplayEventEXT( vkGetDeviceProcAddr( device, "vkRegisterDisplayEventEXT" ) ); 13723 vkGetSwapchainCounterEXT = 13724 PFN_vkGetSwapchainCounterEXT( vkGetDeviceProcAddr( device, "vkGetSwapchainCounterEXT" ) ); 13725 13726 //=== VK_GOOGLE_display_timing === 13727 vkGetRefreshCycleDurationGOOGLE = 13728 PFN_vkGetRefreshCycleDurationGOOGLE( vkGetDeviceProcAddr( device, "vkGetRefreshCycleDurationGOOGLE" ) ); 13729 vkGetPastPresentationTimingGOOGLE = 13730 PFN_vkGetPastPresentationTimingGOOGLE( vkGetDeviceProcAddr( device, "vkGetPastPresentationTimingGOOGLE" ) ); 13731 13732 //=== VK_EXT_discard_rectangles === 13733 vkCmdSetDiscardRectangleEXT = 13734 PFN_vkCmdSetDiscardRectangleEXT( vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleEXT" ) ); 13735 13736 //=== VK_EXT_hdr_metadata === 13737 vkSetHdrMetadataEXT = PFN_vkSetHdrMetadataEXT( vkGetDeviceProcAddr( device, "vkSetHdrMetadataEXT" ) ); 13738 13739 //=== VK_KHR_create_renderpass2 === 13740 vkCreateRenderPass2KHR = PFN_vkCreateRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCreateRenderPass2KHR" ) ); 13741 if ( !vkCreateRenderPass2 ) 13742 vkCreateRenderPass2 = vkCreateRenderPass2KHR; 13743 vkCmdBeginRenderPass2KHR = 13744 PFN_vkCmdBeginRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass2KHR" ) ); 13745 if ( !vkCmdBeginRenderPass2 ) 13746 vkCmdBeginRenderPass2 = vkCmdBeginRenderPass2KHR; 13747 vkCmdNextSubpass2KHR = PFN_vkCmdNextSubpass2KHR( vkGetDeviceProcAddr( device, "vkCmdNextSubpass2KHR" ) ); 13748 if ( !vkCmdNextSubpass2 ) 13749 vkCmdNextSubpass2 = vkCmdNextSubpass2KHR; 13750 vkCmdEndRenderPass2KHR = PFN_vkCmdEndRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass2KHR" ) ); 13751 if ( !vkCmdEndRenderPass2 ) 13752 vkCmdEndRenderPass2 = vkCmdEndRenderPass2KHR; 13753 13754 //=== VK_KHR_shared_presentable_image === 13755 vkGetSwapchainStatusKHR = PFN_vkGetSwapchainStatusKHR( vkGetDeviceProcAddr( device, "vkGetSwapchainStatusKHR" ) ); 13756 13757 #if defined( VK_USE_PLATFORM_WIN32_KHR ) 13758 //=== VK_KHR_external_fence_win32 === 13759 vkImportFenceWin32HandleKHR = 13760 PFN_vkImportFenceWin32HandleKHR( vkGetDeviceProcAddr( device, "vkImportFenceWin32HandleKHR" ) ); 13761 vkGetFenceWin32HandleKHR = 13762 PFN_vkGetFenceWin32HandleKHR( vkGetDeviceProcAddr( device, "vkGetFenceWin32HandleKHR" ) ); 13763 #endif /*VK_USE_PLATFORM_WIN32_KHR*/ 13764 13765 //=== VK_KHR_external_fence_fd === 13766 vkImportFenceFdKHR = PFN_vkImportFenceFdKHR( vkGetDeviceProcAddr( device, "vkImportFenceFdKHR" ) ); 13767 vkGetFenceFdKHR = PFN_vkGetFenceFdKHR( vkGetDeviceProcAddr( device, "vkGetFenceFdKHR" ) ); 13768 13769 //=== VK_KHR_performance_query === 13770 vkAcquireProfilingLockKHR = 13771 PFN_vkAcquireProfilingLockKHR( vkGetDeviceProcAddr( device, "vkAcquireProfilingLockKHR" ) ); 13772 vkReleaseProfilingLockKHR = 13773 PFN_vkReleaseProfilingLockKHR( vkGetDeviceProcAddr( device, "vkReleaseProfilingLockKHR" ) ); 13774 13775 //=== VK_EXT_debug_utils === 13776 vkSetDebugUtilsObjectNameEXT = 13777 PFN_vkSetDebugUtilsObjectNameEXT( vkGetDeviceProcAddr( device, "vkSetDebugUtilsObjectNameEXT" ) ); 13778 vkSetDebugUtilsObjectTagEXT = 13779 PFN_vkSetDebugUtilsObjectTagEXT( vkGetDeviceProcAddr( device, "vkSetDebugUtilsObjectTagEXT" ) ); 13780 vkQueueBeginDebugUtilsLabelEXT = 13781 PFN_vkQueueBeginDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueBeginDebugUtilsLabelEXT" ) ); 13782 vkQueueEndDebugUtilsLabelEXT = 13783 PFN_vkQueueEndDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueEndDebugUtilsLabelEXT" ) ); 13784 vkQueueInsertDebugUtilsLabelEXT = 13785 PFN_vkQueueInsertDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueInsertDebugUtilsLabelEXT" ) ); 13786 vkCmdBeginDebugUtilsLabelEXT = 13787 PFN_vkCmdBeginDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdBeginDebugUtilsLabelEXT" ) ); 13788 vkCmdEndDebugUtilsLabelEXT = 13789 PFN_vkCmdEndDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdEndDebugUtilsLabelEXT" ) ); 13790 vkCmdInsertDebugUtilsLabelEXT = 13791 PFN_vkCmdInsertDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdInsertDebugUtilsLabelEXT" ) ); 13792 13793 #if defined( VK_USE_PLATFORM_ANDROID_KHR ) 13794 //=== VK_ANDROID_external_memory_android_hardware_buffer === 13795 vkGetAndroidHardwareBufferPropertiesANDROID = PFN_vkGetAndroidHardwareBufferPropertiesANDROID( 13796 vkGetDeviceProcAddr( device, "vkGetAndroidHardwareBufferPropertiesANDROID" ) ); 13797 vkGetMemoryAndroidHardwareBufferANDROID = PFN_vkGetMemoryAndroidHardwareBufferANDROID( 13798 vkGetDeviceProcAddr( device, "vkGetMemoryAndroidHardwareBufferANDROID" ) ); 13799 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ 13800 13801 //=== VK_EXT_sample_locations === 13802 vkCmdSetSampleLocationsEXT = 13803 PFN_vkCmdSetSampleLocationsEXT( vkGetDeviceProcAddr( device, "vkCmdSetSampleLocationsEXT" ) ); 13804 13805 //=== VK_KHR_get_memory_requirements2 === 13806 vkGetImageMemoryRequirements2KHR = 13807 PFN_vkGetImageMemoryRequirements2KHR( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements2KHR" ) ); 13808 if ( !vkGetImageMemoryRequirements2 ) 13809 vkGetImageMemoryRequirements2 = vkGetImageMemoryRequirements2KHR; 13810 vkGetBufferMemoryRequirements2KHR = 13811 PFN_vkGetBufferMemoryRequirements2KHR( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements2KHR" ) ); 13812 if ( !vkGetBufferMemoryRequirements2 ) 13813 vkGetBufferMemoryRequirements2 = vkGetBufferMemoryRequirements2KHR; 13814 vkGetImageSparseMemoryRequirements2KHR = PFN_vkGetImageSparseMemoryRequirements2KHR( 13815 vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements2KHR" ) ); 13816 if ( !vkGetImageSparseMemoryRequirements2 ) 13817 vkGetImageSparseMemoryRequirements2 = vkGetImageSparseMemoryRequirements2KHR; 13818 13819 //=== VK_KHR_acceleration_structure === 13820 vkCreateAccelerationStructureKHR = 13821 PFN_vkCreateAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCreateAccelerationStructureKHR" ) ); 13822 vkDestroyAccelerationStructureKHR = 13823 PFN_vkDestroyAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkDestroyAccelerationStructureKHR" ) ); 13824 vkCmdBuildAccelerationStructuresKHR = 13825 PFN_vkCmdBuildAccelerationStructuresKHR( vkGetDeviceProcAddr( device, "vkCmdBuildAccelerationStructuresKHR" ) ); 13826 vkCmdBuildAccelerationStructuresIndirectKHR = PFN_vkCmdBuildAccelerationStructuresIndirectKHR( 13827 vkGetDeviceProcAddr( device, "vkCmdBuildAccelerationStructuresIndirectKHR" ) ); 13828 vkBuildAccelerationStructuresKHR = 13829 PFN_vkBuildAccelerationStructuresKHR( vkGetDeviceProcAddr( device, "vkBuildAccelerationStructuresKHR" ) ); 13830 vkCopyAccelerationStructureKHR = 13831 PFN_vkCopyAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCopyAccelerationStructureKHR" ) ); 13832 vkCopyAccelerationStructureToMemoryKHR = PFN_vkCopyAccelerationStructureToMemoryKHR( 13833 vkGetDeviceProcAddr( device, "vkCopyAccelerationStructureToMemoryKHR" ) ); 13834 vkCopyMemoryToAccelerationStructureKHR = PFN_vkCopyMemoryToAccelerationStructureKHR( 13835 vkGetDeviceProcAddr( device, "vkCopyMemoryToAccelerationStructureKHR" ) ); 13836 vkWriteAccelerationStructuresPropertiesKHR = PFN_vkWriteAccelerationStructuresPropertiesKHR( 13837 vkGetDeviceProcAddr( device, "vkWriteAccelerationStructuresPropertiesKHR" ) ); 13838 vkCmdCopyAccelerationStructureKHR = 13839 PFN_vkCmdCopyAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCmdCopyAccelerationStructureKHR" ) ); 13840 vkCmdCopyAccelerationStructureToMemoryKHR = PFN_vkCmdCopyAccelerationStructureToMemoryKHR( 13841 vkGetDeviceProcAddr( device, "vkCmdCopyAccelerationStructureToMemoryKHR" ) ); 13842 vkCmdCopyMemoryToAccelerationStructureKHR = PFN_vkCmdCopyMemoryToAccelerationStructureKHR( 13843 vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToAccelerationStructureKHR" ) ); 13844 vkGetAccelerationStructureDeviceAddressKHR = PFN_vkGetAccelerationStructureDeviceAddressKHR( 13845 vkGetDeviceProcAddr( device, "vkGetAccelerationStructureDeviceAddressKHR" ) ); 13846 vkCmdWriteAccelerationStructuresPropertiesKHR = PFN_vkCmdWriteAccelerationStructuresPropertiesKHR( 13847 vkGetDeviceProcAddr( device, "vkCmdWriteAccelerationStructuresPropertiesKHR" ) ); 13848 vkGetDeviceAccelerationStructureCompatibilityKHR = PFN_vkGetDeviceAccelerationStructureCompatibilityKHR( 13849 vkGetDeviceProcAddr( device, "vkGetDeviceAccelerationStructureCompatibilityKHR" ) ); 13850 vkGetAccelerationStructureBuildSizesKHR = PFN_vkGetAccelerationStructureBuildSizesKHR( 13851 vkGetDeviceProcAddr( device, "vkGetAccelerationStructureBuildSizesKHR" ) ); 13852 13853 //=== VK_KHR_sampler_ycbcr_conversion === 13854 vkCreateSamplerYcbcrConversionKHR = 13855 PFN_vkCreateSamplerYcbcrConversionKHR( vkGetDeviceProcAddr( device, "vkCreateSamplerYcbcrConversionKHR" ) ); 13856 if ( !vkCreateSamplerYcbcrConversion ) 13857 vkCreateSamplerYcbcrConversion = vkCreateSamplerYcbcrConversionKHR; 13858 vkDestroySamplerYcbcrConversionKHR = 13859 PFN_vkDestroySamplerYcbcrConversionKHR( vkGetDeviceProcAddr( device, "vkDestroySamplerYcbcrConversionKHR" ) ); 13860 if ( !vkDestroySamplerYcbcrConversion ) 13861 vkDestroySamplerYcbcrConversion = vkDestroySamplerYcbcrConversionKHR; 13862 13863 //=== VK_KHR_bind_memory2 === 13864 vkBindBufferMemory2KHR = PFN_vkBindBufferMemory2KHR( vkGetDeviceProcAddr( device, "vkBindBufferMemory2KHR" ) ); 13865 if ( !vkBindBufferMemory2 ) 13866 vkBindBufferMemory2 = vkBindBufferMemory2KHR; 13867 vkBindImageMemory2KHR = PFN_vkBindImageMemory2KHR( vkGetDeviceProcAddr( device, "vkBindImageMemory2KHR" ) ); 13868 if ( !vkBindImageMemory2 ) 13869 vkBindImageMemory2 = vkBindImageMemory2KHR; 13870 13871 //=== VK_EXT_image_drm_format_modifier === 13872 vkGetImageDrmFormatModifierPropertiesEXT = PFN_vkGetImageDrmFormatModifierPropertiesEXT( 13873 vkGetDeviceProcAddr( device, "vkGetImageDrmFormatModifierPropertiesEXT" ) ); 13874 13875 //=== VK_EXT_validation_cache === 13876 vkCreateValidationCacheEXT = 13877 PFN_vkCreateValidationCacheEXT( vkGetDeviceProcAddr( device, "vkCreateValidationCacheEXT" ) ); 13878 vkDestroyValidationCacheEXT = 13879 PFN_vkDestroyValidationCacheEXT( vkGetDeviceProcAddr( device, "vkDestroyValidationCacheEXT" ) ); 13880 vkMergeValidationCachesEXT = 13881 PFN_vkMergeValidationCachesEXT( vkGetDeviceProcAddr( device, "vkMergeValidationCachesEXT" ) ); 13882 vkGetValidationCacheDataEXT = 13883 PFN_vkGetValidationCacheDataEXT( vkGetDeviceProcAddr( device, "vkGetValidationCacheDataEXT" ) ); 13884 13885 //=== VK_NV_shading_rate_image === 13886 vkCmdBindShadingRateImageNV = 13887 PFN_vkCmdBindShadingRateImageNV( vkGetDeviceProcAddr( device, "vkCmdBindShadingRateImageNV" ) ); 13888 vkCmdSetViewportShadingRatePaletteNV = PFN_vkCmdSetViewportShadingRatePaletteNV( 13889 vkGetDeviceProcAddr( device, "vkCmdSetViewportShadingRatePaletteNV" ) ); 13890 vkCmdSetCoarseSampleOrderNV = 13891 PFN_vkCmdSetCoarseSampleOrderNV( vkGetDeviceProcAddr( device, "vkCmdSetCoarseSampleOrderNV" ) ); 13892 13893 //=== VK_NV_ray_tracing === 13894 vkCreateAccelerationStructureNV = 13895 PFN_vkCreateAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkCreateAccelerationStructureNV" ) ); 13896 vkDestroyAccelerationStructureNV = 13897 PFN_vkDestroyAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkDestroyAccelerationStructureNV" ) ); 13898 vkGetAccelerationStructureMemoryRequirementsNV = PFN_vkGetAccelerationStructureMemoryRequirementsNV( 13899 vkGetDeviceProcAddr( device, "vkGetAccelerationStructureMemoryRequirementsNV" ) ); 13900 vkBindAccelerationStructureMemoryNV = 13901 PFN_vkBindAccelerationStructureMemoryNV( vkGetDeviceProcAddr( device, "vkBindAccelerationStructureMemoryNV" ) ); 13902 vkCmdBuildAccelerationStructureNV = 13903 PFN_vkCmdBuildAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkCmdBuildAccelerationStructureNV" ) ); 13904 vkCmdCopyAccelerationStructureNV = 13905 PFN_vkCmdCopyAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkCmdCopyAccelerationStructureNV" ) ); 13906 vkCmdTraceRaysNV = PFN_vkCmdTraceRaysNV( vkGetDeviceProcAddr( device, "vkCmdTraceRaysNV" ) ); 13907 vkCreateRayTracingPipelinesNV = 13908 PFN_vkCreateRayTracingPipelinesNV( vkGetDeviceProcAddr( device, "vkCreateRayTracingPipelinesNV" ) ); 13909 vkGetRayTracingShaderGroupHandlesNV = 13910 PFN_vkGetRayTracingShaderGroupHandlesNV( vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupHandlesNV" ) ); 13911 if ( !vkGetRayTracingShaderGroupHandlesKHR ) 13912 vkGetRayTracingShaderGroupHandlesKHR = vkGetRayTracingShaderGroupHandlesNV; 13913 vkGetAccelerationStructureHandleNV = 13914 PFN_vkGetAccelerationStructureHandleNV( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureHandleNV" ) ); 13915 vkCmdWriteAccelerationStructuresPropertiesNV = PFN_vkCmdWriteAccelerationStructuresPropertiesNV( 13916 vkGetDeviceProcAddr( device, "vkCmdWriteAccelerationStructuresPropertiesNV" ) ); 13917 vkCompileDeferredNV = PFN_vkCompileDeferredNV( vkGetDeviceProcAddr( device, "vkCompileDeferredNV" ) ); 13918 13919 //=== VK_KHR_maintenance3 === 13920 vkGetDescriptorSetLayoutSupportKHR = 13921 PFN_vkGetDescriptorSetLayoutSupportKHR( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSupportKHR" ) ); 13922 if ( !vkGetDescriptorSetLayoutSupport ) 13923 vkGetDescriptorSetLayoutSupport = vkGetDescriptorSetLayoutSupportKHR; 13924 13925 //=== VK_KHR_draw_indirect_count === 13926 vkCmdDrawIndirectCountKHR = 13927 PFN_vkCmdDrawIndirectCountKHR( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCountKHR" ) ); 13928 if ( !vkCmdDrawIndirectCount ) 13929 vkCmdDrawIndirectCount = vkCmdDrawIndirectCountKHR; 13930 vkCmdDrawIndexedIndirectCountKHR = 13931 PFN_vkCmdDrawIndexedIndirectCountKHR( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCountKHR" ) ); 13932 if ( !vkCmdDrawIndexedIndirectCount ) 13933 vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountKHR; 13934 13935 //=== VK_EXT_external_memory_host === 13936 vkGetMemoryHostPointerPropertiesEXT = 13937 PFN_vkGetMemoryHostPointerPropertiesEXT( vkGetDeviceProcAddr( device, "vkGetMemoryHostPointerPropertiesEXT" ) ); 13938 13939 //=== VK_AMD_buffer_marker === 13940 vkCmdWriteBufferMarkerAMD = 13941 PFN_vkCmdWriteBufferMarkerAMD( vkGetDeviceProcAddr( device, "vkCmdWriteBufferMarkerAMD" ) ); 13942 13943 //=== VK_EXT_calibrated_timestamps === 13944 vkGetCalibratedTimestampsEXT = 13945 PFN_vkGetCalibratedTimestampsEXT( vkGetDeviceProcAddr( device, "vkGetCalibratedTimestampsEXT" ) ); 13946 13947 //=== VK_NV_mesh_shader === 13948 vkCmdDrawMeshTasksNV = PFN_vkCmdDrawMeshTasksNV( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksNV" ) ); 13949 vkCmdDrawMeshTasksIndirectNV = 13950 PFN_vkCmdDrawMeshTasksIndirectNV( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectNV" ) ); 13951 vkCmdDrawMeshTasksIndirectCountNV = 13952 PFN_vkCmdDrawMeshTasksIndirectCountNV( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectCountNV" ) ); 13953 13954 //=== VK_NV_scissor_exclusive === 13955 vkCmdSetExclusiveScissorNV = 13956 PFN_vkCmdSetExclusiveScissorNV( vkGetDeviceProcAddr( device, "vkCmdSetExclusiveScissorNV" ) ); 13957 13958 //=== VK_NV_device_diagnostic_checkpoints === 13959 vkCmdSetCheckpointNV = PFN_vkCmdSetCheckpointNV( vkGetDeviceProcAddr( device, "vkCmdSetCheckpointNV" ) ); 13960 vkGetQueueCheckpointDataNV = 13961 PFN_vkGetQueueCheckpointDataNV( vkGetDeviceProcAddr( device, "vkGetQueueCheckpointDataNV" ) ); 13962 13963 //=== VK_KHR_timeline_semaphore === 13964 vkGetSemaphoreCounterValueKHR = 13965 PFN_vkGetSemaphoreCounterValueKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreCounterValueKHR" ) ); 13966 if ( !vkGetSemaphoreCounterValue ) 13967 vkGetSemaphoreCounterValue = vkGetSemaphoreCounterValueKHR; 13968 vkWaitSemaphoresKHR = PFN_vkWaitSemaphoresKHR( vkGetDeviceProcAddr( device, "vkWaitSemaphoresKHR" ) ); 13969 if ( !vkWaitSemaphores ) 13970 vkWaitSemaphores = vkWaitSemaphoresKHR; 13971 vkSignalSemaphoreKHR = PFN_vkSignalSemaphoreKHR( vkGetDeviceProcAddr( device, "vkSignalSemaphoreKHR" ) ); 13972 if ( !vkSignalSemaphore ) 13973 vkSignalSemaphore = vkSignalSemaphoreKHR; 13974 13975 //=== VK_INTEL_performance_query === 13976 vkInitializePerformanceApiINTEL = 13977 PFN_vkInitializePerformanceApiINTEL( vkGetDeviceProcAddr( device, "vkInitializePerformanceApiINTEL" ) ); 13978 vkUninitializePerformanceApiINTEL = 13979 PFN_vkUninitializePerformanceApiINTEL( vkGetDeviceProcAddr( device, "vkUninitializePerformanceApiINTEL" ) ); 13980 vkCmdSetPerformanceMarkerINTEL = 13981 PFN_vkCmdSetPerformanceMarkerINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceMarkerINTEL" ) ); 13982 vkCmdSetPerformanceStreamMarkerINTEL = PFN_vkCmdSetPerformanceStreamMarkerINTEL( 13983 vkGetDeviceProcAddr( device, "vkCmdSetPerformanceStreamMarkerINTEL" ) ); 13984 vkCmdSetPerformanceOverrideINTEL = 13985 PFN_vkCmdSetPerformanceOverrideINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceOverrideINTEL" ) ); 13986 vkAcquirePerformanceConfigurationINTEL = PFN_vkAcquirePerformanceConfigurationINTEL( 13987 vkGetDeviceProcAddr( device, "vkAcquirePerformanceConfigurationINTEL" ) ); 13988 vkReleasePerformanceConfigurationINTEL = PFN_vkReleasePerformanceConfigurationINTEL( 13989 vkGetDeviceProcAddr( device, "vkReleasePerformanceConfigurationINTEL" ) ); 13990 vkQueueSetPerformanceConfigurationINTEL = PFN_vkQueueSetPerformanceConfigurationINTEL( 13991 vkGetDeviceProcAddr( device, "vkQueueSetPerformanceConfigurationINTEL" ) ); 13992 vkGetPerformanceParameterINTEL = 13993 PFN_vkGetPerformanceParameterINTEL( vkGetDeviceProcAddr( device, "vkGetPerformanceParameterINTEL" ) ); 13994 13995 //=== VK_AMD_display_native_hdr === 13996 vkSetLocalDimmingAMD = PFN_vkSetLocalDimmingAMD( vkGetDeviceProcAddr( device, "vkSetLocalDimmingAMD" ) ); 13997 13998 //=== VK_KHR_fragment_shading_rate === 13999 vkCmdSetFragmentShadingRateKHR = 14000 PFN_vkCmdSetFragmentShadingRateKHR( vkGetDeviceProcAddr( device, "vkCmdSetFragmentShadingRateKHR" ) ); 14001 14002 //=== VK_EXT_buffer_device_address === 14003 vkGetBufferDeviceAddressEXT = 14004 PFN_vkGetBufferDeviceAddressEXT( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddressEXT" ) ); 14005 if ( !vkGetBufferDeviceAddress ) 14006 vkGetBufferDeviceAddress = vkGetBufferDeviceAddressEXT; 14007 14008 //=== VK_KHR_present_wait === 14009 vkWaitForPresentKHR = PFN_vkWaitForPresentKHR( vkGetDeviceProcAddr( device, "vkWaitForPresentKHR" ) ); 14010 14011 #if defined( VK_USE_PLATFORM_WIN32_KHR ) 14012 //=== VK_EXT_full_screen_exclusive === 14013 vkAcquireFullScreenExclusiveModeEXT = 14014 PFN_vkAcquireFullScreenExclusiveModeEXT( vkGetDeviceProcAddr( device, "vkAcquireFullScreenExclusiveModeEXT" ) ); 14015 vkReleaseFullScreenExclusiveModeEXT = 14016 PFN_vkReleaseFullScreenExclusiveModeEXT( vkGetDeviceProcAddr( device, "vkReleaseFullScreenExclusiveModeEXT" ) ); 14017 vkGetDeviceGroupSurfacePresentModes2EXT = PFN_vkGetDeviceGroupSurfacePresentModes2EXT( 14018 vkGetDeviceProcAddr( device, "vkGetDeviceGroupSurfacePresentModes2EXT" ) ); 14019 #endif /*VK_USE_PLATFORM_WIN32_KHR*/ 14020 14021 //=== VK_KHR_buffer_device_address === 14022 vkGetBufferDeviceAddressKHR = 14023 PFN_vkGetBufferDeviceAddressKHR( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddressKHR" ) ); 14024 if ( !vkGetBufferDeviceAddress ) 14025 vkGetBufferDeviceAddress = vkGetBufferDeviceAddressKHR; 14026 vkGetBufferOpaqueCaptureAddressKHR = 14027 PFN_vkGetBufferOpaqueCaptureAddressKHR( vkGetDeviceProcAddr( device, "vkGetBufferOpaqueCaptureAddressKHR" ) ); 14028 if ( !vkGetBufferOpaqueCaptureAddress ) 14029 vkGetBufferOpaqueCaptureAddress = vkGetBufferOpaqueCaptureAddressKHR; 14030 vkGetDeviceMemoryOpaqueCaptureAddressKHR = PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR( 14031 vkGetDeviceProcAddr( device, "vkGetDeviceMemoryOpaqueCaptureAddressKHR" ) ); 14032 if ( !vkGetDeviceMemoryOpaqueCaptureAddress ) 14033 vkGetDeviceMemoryOpaqueCaptureAddress = vkGetDeviceMemoryOpaqueCaptureAddressKHR; 14034 14035 //=== VK_EXT_line_rasterization === 14036 vkCmdSetLineStippleEXT = PFN_vkCmdSetLineStippleEXT( vkGetDeviceProcAddr( device, "vkCmdSetLineStippleEXT" ) ); 14037 14038 //=== VK_EXT_host_query_reset === 14039 vkResetQueryPoolEXT = PFN_vkResetQueryPoolEXT( vkGetDeviceProcAddr( device, "vkResetQueryPoolEXT" ) ); 14040 if ( !vkResetQueryPool ) 14041 vkResetQueryPool = vkResetQueryPoolEXT; 14042 14043 //=== VK_EXT_extended_dynamic_state === 14044 vkCmdSetCullModeEXT = PFN_vkCmdSetCullModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetCullModeEXT" ) ); 14045 vkCmdSetFrontFaceEXT = PFN_vkCmdSetFrontFaceEXT( vkGetDeviceProcAddr( device, "vkCmdSetFrontFaceEXT" ) ); 14046 vkCmdSetPrimitiveTopologyEXT = 14047 PFN_vkCmdSetPrimitiveTopologyEXT( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveTopologyEXT" ) ); 14048 vkCmdSetViewportWithCountEXT = 14049 PFN_vkCmdSetViewportWithCountEXT( vkGetDeviceProcAddr( device, "vkCmdSetViewportWithCountEXT" ) ); 14050 vkCmdSetScissorWithCountEXT = 14051 PFN_vkCmdSetScissorWithCountEXT( vkGetDeviceProcAddr( device, "vkCmdSetScissorWithCountEXT" ) ); 14052 vkCmdBindVertexBuffers2EXT = 14053 PFN_vkCmdBindVertexBuffers2EXT( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers2EXT" ) ); 14054 vkCmdSetDepthTestEnableEXT = 14055 PFN_vkCmdSetDepthTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthTestEnableEXT" ) ); 14056 vkCmdSetDepthWriteEnableEXT = 14057 PFN_vkCmdSetDepthWriteEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthWriteEnableEXT" ) ); 14058 vkCmdSetDepthCompareOpEXT = 14059 PFN_vkCmdSetDepthCompareOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthCompareOpEXT" ) ); 14060 vkCmdSetDepthBoundsTestEnableEXT = 14061 PFN_vkCmdSetDepthBoundsTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthBoundsTestEnableEXT" ) ); 14062 vkCmdSetStencilTestEnableEXT = 14063 PFN_vkCmdSetStencilTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetStencilTestEnableEXT" ) ); 14064 vkCmdSetStencilOpEXT = PFN_vkCmdSetStencilOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetStencilOpEXT" ) ); 14065 14066 //=== VK_KHR_deferred_host_operations === 14067 vkCreateDeferredOperationKHR = 14068 PFN_vkCreateDeferredOperationKHR( vkGetDeviceProcAddr( device, "vkCreateDeferredOperationKHR" ) ); 14069 vkDestroyDeferredOperationKHR = 14070 PFN_vkDestroyDeferredOperationKHR( vkGetDeviceProcAddr( device, "vkDestroyDeferredOperationKHR" ) ); 14071 vkGetDeferredOperationMaxConcurrencyKHR = PFN_vkGetDeferredOperationMaxConcurrencyKHR( 14072 vkGetDeviceProcAddr( device, "vkGetDeferredOperationMaxConcurrencyKHR" ) ); 14073 vkGetDeferredOperationResultKHR = 14074 PFN_vkGetDeferredOperationResultKHR( vkGetDeviceProcAddr( device, "vkGetDeferredOperationResultKHR" ) ); 14075 vkDeferredOperationJoinKHR = 14076 PFN_vkDeferredOperationJoinKHR( vkGetDeviceProcAddr( device, "vkDeferredOperationJoinKHR" ) ); 14077 14078 //=== VK_KHR_pipeline_executable_properties === 14079 vkGetPipelineExecutablePropertiesKHR = PFN_vkGetPipelineExecutablePropertiesKHR( 14080 vkGetDeviceProcAddr( device, "vkGetPipelineExecutablePropertiesKHR" ) ); 14081 vkGetPipelineExecutableStatisticsKHR = PFN_vkGetPipelineExecutableStatisticsKHR( 14082 vkGetDeviceProcAddr( device, "vkGetPipelineExecutableStatisticsKHR" ) ); 14083 vkGetPipelineExecutableInternalRepresentationsKHR = PFN_vkGetPipelineExecutableInternalRepresentationsKHR( 14084 vkGetDeviceProcAddr( device, "vkGetPipelineExecutableInternalRepresentationsKHR" ) ); 14085 14086 //=== VK_NV_device_generated_commands === 14087 vkGetGeneratedCommandsMemoryRequirementsNV = PFN_vkGetGeneratedCommandsMemoryRequirementsNV( 14088 vkGetDeviceProcAddr( device, "vkGetGeneratedCommandsMemoryRequirementsNV" ) ); 14089 vkCmdPreprocessGeneratedCommandsNV = 14090 PFN_vkCmdPreprocessGeneratedCommandsNV( vkGetDeviceProcAddr( device, "vkCmdPreprocessGeneratedCommandsNV" ) ); 14091 vkCmdExecuteGeneratedCommandsNV = 14092 PFN_vkCmdExecuteGeneratedCommandsNV( vkGetDeviceProcAddr( device, "vkCmdExecuteGeneratedCommandsNV" ) ); 14093 vkCmdBindPipelineShaderGroupNV = 14094 PFN_vkCmdBindPipelineShaderGroupNV( vkGetDeviceProcAddr( device, "vkCmdBindPipelineShaderGroupNV" ) ); 14095 vkCreateIndirectCommandsLayoutNV = 14096 PFN_vkCreateIndirectCommandsLayoutNV( vkGetDeviceProcAddr( device, "vkCreateIndirectCommandsLayoutNV" ) ); 14097 vkDestroyIndirectCommandsLayoutNV = 14098 PFN_vkDestroyIndirectCommandsLayoutNV( vkGetDeviceProcAddr( device, "vkDestroyIndirectCommandsLayoutNV" ) ); 14099 14100 //=== VK_EXT_private_data === 14101 vkCreatePrivateDataSlotEXT = 14102 PFN_vkCreatePrivateDataSlotEXT( vkGetDeviceProcAddr( device, "vkCreatePrivateDataSlotEXT" ) ); 14103 vkDestroyPrivateDataSlotEXT = 14104 PFN_vkDestroyPrivateDataSlotEXT( vkGetDeviceProcAddr( device, "vkDestroyPrivateDataSlotEXT" ) ); 14105 vkSetPrivateDataEXT = PFN_vkSetPrivateDataEXT( vkGetDeviceProcAddr( device, "vkSetPrivateDataEXT" ) ); 14106 vkGetPrivateDataEXT = PFN_vkGetPrivateDataEXT( vkGetDeviceProcAddr( device, "vkGetPrivateDataEXT" ) ); 14107 14108 #if defined( VK_ENABLE_BETA_EXTENSIONS ) 14109 //=== VK_KHR_video_encode_queue === 14110 vkCmdEncodeVideoKHR = PFN_vkCmdEncodeVideoKHR( vkGetDeviceProcAddr( device, "vkCmdEncodeVideoKHR" ) ); 14111 #endif /*VK_ENABLE_BETA_EXTENSIONS*/ 14112 14113 //=== VK_KHR_synchronization2 === 14114 vkCmdSetEvent2KHR = PFN_vkCmdSetEvent2KHR( vkGetDeviceProcAddr( device, "vkCmdSetEvent2KHR" ) ); 14115 vkCmdResetEvent2KHR = PFN_vkCmdResetEvent2KHR( vkGetDeviceProcAddr( device, "vkCmdResetEvent2KHR" ) ); 14116 vkCmdWaitEvents2KHR = PFN_vkCmdWaitEvents2KHR( vkGetDeviceProcAddr( device, "vkCmdWaitEvents2KHR" ) ); 14117 vkCmdPipelineBarrier2KHR = 14118 PFN_vkCmdPipelineBarrier2KHR( vkGetDeviceProcAddr( device, "vkCmdPipelineBarrier2KHR" ) ); 14119 vkCmdWriteTimestamp2KHR = PFN_vkCmdWriteTimestamp2KHR( vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp2KHR" ) ); 14120 vkQueueSubmit2KHR = PFN_vkQueueSubmit2KHR( vkGetDeviceProcAddr( device, "vkQueueSubmit2KHR" ) ); 14121 vkCmdWriteBufferMarker2AMD = 14122 PFN_vkCmdWriteBufferMarker2AMD( vkGetDeviceProcAddr( device, "vkCmdWriteBufferMarker2AMD" ) ); 14123 vkGetQueueCheckpointData2NV = 14124 PFN_vkGetQueueCheckpointData2NV( vkGetDeviceProcAddr( device, "vkGetQueueCheckpointData2NV" ) ); 14125 14126 //=== VK_NV_fragment_shading_rate_enums === 14127 vkCmdSetFragmentShadingRateEnumNV = 14128 PFN_vkCmdSetFragmentShadingRateEnumNV( vkGetDeviceProcAddr( device, "vkCmdSetFragmentShadingRateEnumNV" ) ); 14129 14130 //=== VK_KHR_copy_commands2 === 14131 vkCmdCopyBuffer2KHR = PFN_vkCmdCopyBuffer2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyBuffer2KHR" ) ); 14132 vkCmdCopyImage2KHR = PFN_vkCmdCopyImage2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyImage2KHR" ) ); 14133 vkCmdCopyBufferToImage2KHR = 14134 PFN_vkCmdCopyBufferToImage2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyBufferToImage2KHR" ) ); 14135 vkCmdCopyImageToBuffer2KHR = 14136 PFN_vkCmdCopyImageToBuffer2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyImageToBuffer2KHR" ) ); 14137 vkCmdBlitImage2KHR = PFN_vkCmdBlitImage2KHR( vkGetDeviceProcAddr( device, "vkCmdBlitImage2KHR" ) ); 14138 vkCmdResolveImage2KHR = PFN_vkCmdResolveImage2KHR( vkGetDeviceProcAddr( device, "vkCmdResolveImage2KHR" ) ); 14139 14140 //=== VK_KHR_ray_tracing_pipeline === 14141 vkCmdTraceRaysKHR = PFN_vkCmdTraceRaysKHR( vkGetDeviceProcAddr( device, "vkCmdTraceRaysKHR" ) ); 14142 vkCreateRayTracingPipelinesKHR = 14143 PFN_vkCreateRayTracingPipelinesKHR( vkGetDeviceProcAddr( device, "vkCreateRayTracingPipelinesKHR" ) ); 14144 vkGetRayTracingShaderGroupHandlesKHR = PFN_vkGetRayTracingShaderGroupHandlesKHR( 14145 vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupHandlesKHR" ) ); 14146 vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( 14147 vkGetDeviceProcAddr( device, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR" ) ); 14148 vkCmdTraceRaysIndirectKHR = 14149 PFN_vkCmdTraceRaysIndirectKHR( vkGetDeviceProcAddr( device, "vkCmdTraceRaysIndirectKHR" ) ); 14150 vkGetRayTracingShaderGroupStackSizeKHR = PFN_vkGetRayTracingShaderGroupStackSizeKHR( 14151 vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupStackSizeKHR" ) ); 14152 vkCmdSetRayTracingPipelineStackSizeKHR = PFN_vkCmdSetRayTracingPipelineStackSizeKHR( 14153 vkGetDeviceProcAddr( device, "vkCmdSetRayTracingPipelineStackSizeKHR" ) ); 14154 14155 //=== VK_EXT_vertex_input_dynamic_state === 14156 vkCmdSetVertexInputEXT = PFN_vkCmdSetVertexInputEXT( vkGetDeviceProcAddr( device, "vkCmdSetVertexInputEXT" ) ); 14157 14158 #if defined( VK_USE_PLATFORM_FUCHSIA ) 14159 //=== VK_FUCHSIA_external_memory === 14160 vkGetMemoryZirconHandleFUCHSIA = 14161 PFN_vkGetMemoryZirconHandleFUCHSIA( vkGetDeviceProcAddr( device, "vkGetMemoryZirconHandleFUCHSIA" ) ); 14162 vkGetMemoryZirconHandlePropertiesFUCHSIA = PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA( 14163 vkGetDeviceProcAddr( device, "vkGetMemoryZirconHandlePropertiesFUCHSIA" ) ); 14164 #endif /*VK_USE_PLATFORM_FUCHSIA*/ 14165 14166 #if defined( VK_USE_PLATFORM_FUCHSIA ) 14167 //=== VK_FUCHSIA_external_semaphore === 14168 vkImportSemaphoreZirconHandleFUCHSIA = PFN_vkImportSemaphoreZirconHandleFUCHSIA( 14169 vkGetDeviceProcAddr( device, "vkImportSemaphoreZirconHandleFUCHSIA" ) ); 14170 vkGetSemaphoreZirconHandleFUCHSIA = 14171 PFN_vkGetSemaphoreZirconHandleFUCHSIA( vkGetDeviceProcAddr( device, "vkGetSemaphoreZirconHandleFUCHSIA" ) ); 14172 #endif /*VK_USE_PLATFORM_FUCHSIA*/ 14173 14174 #if defined( VK_USE_PLATFORM_FUCHSIA ) 14175 //=== VK_FUCHSIA_buffer_collection === 14176 vkCreateBufferCollectionFUCHSIA = 14177 PFN_vkCreateBufferCollectionFUCHSIA( vkGetDeviceProcAddr( device, "vkCreateBufferCollectionFUCHSIA" ) ); 14178 vkSetBufferCollectionImageConstraintsFUCHSIA = PFN_vkSetBufferCollectionImageConstraintsFUCHSIA( 14179 vkGetDeviceProcAddr( device, "vkSetBufferCollectionImageConstraintsFUCHSIA" ) ); 14180 vkSetBufferCollectionBufferConstraintsFUCHSIA = PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA( 14181 vkGetDeviceProcAddr( device, "vkSetBufferCollectionBufferConstraintsFUCHSIA" ) ); 14182 vkDestroyBufferCollectionFUCHSIA = 14183 PFN_vkDestroyBufferCollectionFUCHSIA( vkGetDeviceProcAddr( device, "vkDestroyBufferCollectionFUCHSIA" ) ); 14184 vkGetBufferCollectionPropertiesFUCHSIA = PFN_vkGetBufferCollectionPropertiesFUCHSIA( 14185 vkGetDeviceProcAddr( device, "vkGetBufferCollectionPropertiesFUCHSIA" ) ); 14186 #endif /*VK_USE_PLATFORM_FUCHSIA*/ 14187 14188 //=== VK_HUAWEI_subpass_shading === 14189 vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( 14190 vkGetDeviceProcAddr( device, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI" ) ); 14191 vkCmdSubpassShadingHUAWEI = 14192 PFN_vkCmdSubpassShadingHUAWEI( vkGetDeviceProcAddr( device, "vkCmdSubpassShadingHUAWEI" ) ); 14193 14194 //=== VK_HUAWEI_invocation_mask === 14195 vkCmdBindInvocationMaskHUAWEI = 14196 PFN_vkCmdBindInvocationMaskHUAWEI( vkGetDeviceProcAddr( device, "vkCmdBindInvocationMaskHUAWEI" ) ); 14197 14198 //=== VK_NV_external_memory_rdma === 14199 vkGetMemoryRemoteAddressNV = 14200 PFN_vkGetMemoryRemoteAddressNV( vkGetDeviceProcAddr( device, "vkGetMemoryRemoteAddressNV" ) ); 14201 14202 //=== VK_EXT_extended_dynamic_state2 === 14203 vkCmdSetPatchControlPointsEXT = 14204 PFN_vkCmdSetPatchControlPointsEXT( vkGetDeviceProcAddr( device, "vkCmdSetPatchControlPointsEXT" ) ); 14205 vkCmdSetRasterizerDiscardEnableEXT = 14206 PFN_vkCmdSetRasterizerDiscardEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetRasterizerDiscardEnableEXT" ) ); 14207 vkCmdSetDepthBiasEnableEXT = 14208 PFN_vkCmdSetDepthBiasEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthBiasEnableEXT" ) ); 14209 vkCmdSetLogicOpEXT = PFN_vkCmdSetLogicOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetLogicOpEXT" ) ); 14210 vkCmdSetPrimitiveRestartEnableEXT = 14211 PFN_vkCmdSetPrimitiveRestartEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveRestartEnableEXT" ) ); 14212 14213 //=== VK_EXT_color_write_enable === 14214 vkCmdSetColorWriteEnableEXT = 14215 PFN_vkCmdSetColorWriteEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorWriteEnableEXT" ) ); 14216 14217 //=== VK_EXT_multi_draw === 14218 vkCmdDrawMultiEXT = PFN_vkCmdDrawMultiEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMultiEXT" ) ); 14219 vkCmdDrawMultiIndexedEXT = 14220 PFN_vkCmdDrawMultiIndexedEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMultiIndexedEXT" ) ); 14221 14222 //=== VK_EXT_pageable_device_local_memory === 14223 vkSetDeviceMemoryPriorityEXT = 14224 PFN_vkSetDeviceMemoryPriorityEXT( vkGetDeviceProcAddr( device, "vkSetDeviceMemoryPriorityEXT" ) ); 14225 14226 //=== VK_KHR_maintenance4 === 14227 vkGetDeviceBufferMemoryRequirementsKHR = PFN_vkGetDeviceBufferMemoryRequirementsKHR( 14228 vkGetDeviceProcAddr( device, "vkGetDeviceBufferMemoryRequirementsKHR" ) ); 14229 vkGetDeviceImageMemoryRequirementsKHR = PFN_vkGetDeviceImageMemoryRequirementsKHR( 14230 vkGetDeviceProcAddr( device, "vkGetDeviceImageMemoryRequirementsKHR" ) ); 14231 vkGetDeviceImageSparseMemoryRequirementsKHR = PFN_vkGetDeviceImageSparseMemoryRequirementsKHR( 14232 vkGetDeviceProcAddr( device, "vkGetDeviceImageSparseMemoryRequirementsKHR" ) ); 14233 } 14234 }; 14235 } // namespace VULKAN_HPP_NAMESPACE 14236 14237 namespace std 14238 { 14239 //======================= 14240 //=== HASH structures === 14241 //======================= 14242 14243 template <typename BitType> 14244 struct hash<VULKAN_HPP_NAMESPACE::Flags<BitType>> 14245 { operator ()std::hash14246 std::size_t operator()( VULKAN_HPP_NAMESPACE::Flags<BitType> const & flags ) const VULKAN_HPP_NOEXCEPT 14247 { 14248 return std::hash<typename std::underlying_type<BitType>::type>{}( 14249 static_cast<typename std::underlying_type<BitType>::type>( flags ) ); 14250 } 14251 }; 14252 14253 //=== VK_VERSION_1_0 === 14254 14255 template <> 14256 struct hash<VULKAN_HPP_NAMESPACE::Instance> 14257 { operator ()std::hash14258 std::size_t operator()( VULKAN_HPP_NAMESPACE::Instance const & instance ) const VULKAN_HPP_NOEXCEPT 14259 { 14260 return std::hash<VkInstance>{}( static_cast<VkInstance>( instance ) ); 14261 } 14262 }; 14263 14264 template <> 14265 struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevice> 14266 { operator ()std::hash14267 std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice const & physicalDevice ) const VULKAN_HPP_NOEXCEPT 14268 { 14269 return std::hash<VkPhysicalDevice>{}( static_cast<VkPhysicalDevice>( physicalDevice ) ); 14270 } 14271 }; 14272 14273 template <> 14274 struct hash<VULKAN_HPP_NAMESPACE::Device> 14275 { operator ()std::hash14276 std::size_t operator()( VULKAN_HPP_NAMESPACE::Device const & device ) const VULKAN_HPP_NOEXCEPT 14277 { 14278 return std::hash<VkDevice>{}( static_cast<VkDevice>( device ) ); 14279 } 14280 }; 14281 14282 template <> 14283 struct hash<VULKAN_HPP_NAMESPACE::Queue> 14284 { operator ()std::hash14285 std::size_t operator()( VULKAN_HPP_NAMESPACE::Queue const & queue ) const VULKAN_HPP_NOEXCEPT 14286 { 14287 return std::hash<VkQueue>{}( static_cast<VkQueue>( queue ) ); 14288 } 14289 }; 14290 14291 template <> 14292 struct hash<VULKAN_HPP_NAMESPACE::DeviceMemory> 14293 { operator ()std::hash14294 std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemory const & deviceMemory ) const VULKAN_HPP_NOEXCEPT 14295 { 14296 return std::hash<VkDeviceMemory>{}( static_cast<VkDeviceMemory>( deviceMemory ) ); 14297 } 14298 }; 14299 14300 template <> 14301 struct hash<VULKAN_HPP_NAMESPACE::Fence> 14302 { operator ()std::hash14303 std::size_t operator()( VULKAN_HPP_NAMESPACE::Fence const & fence ) const VULKAN_HPP_NOEXCEPT 14304 { 14305 return std::hash<VkFence>{}( static_cast<VkFence>( fence ) ); 14306 } 14307 }; 14308 14309 template <> 14310 struct hash<VULKAN_HPP_NAMESPACE::Semaphore> 14311 { operator ()std::hash14312 std::size_t operator()( VULKAN_HPP_NAMESPACE::Semaphore const & semaphore ) const VULKAN_HPP_NOEXCEPT 14313 { 14314 return std::hash<VkSemaphore>{}( static_cast<VkSemaphore>( semaphore ) ); 14315 } 14316 }; 14317 14318 template <> 14319 struct hash<VULKAN_HPP_NAMESPACE::Event> 14320 { operator ()std::hash14321 std::size_t operator()( VULKAN_HPP_NAMESPACE::Event const & event ) const VULKAN_HPP_NOEXCEPT 14322 { 14323 return std::hash<VkEvent>{}( static_cast<VkEvent>( event ) ); 14324 } 14325 }; 14326 14327 template <> 14328 struct hash<VULKAN_HPP_NAMESPACE::QueryPool> 14329 { operator ()std::hash14330 std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryPool const & queryPool ) const VULKAN_HPP_NOEXCEPT 14331 { 14332 return std::hash<VkQueryPool>{}( static_cast<VkQueryPool>( queryPool ) ); 14333 } 14334 }; 14335 14336 template <> 14337 struct hash<VULKAN_HPP_NAMESPACE::Buffer> 14338 { operator ()std::hash14339 std::size_t operator()( VULKAN_HPP_NAMESPACE::Buffer const & buffer ) const VULKAN_HPP_NOEXCEPT 14340 { 14341 return std::hash<VkBuffer>{}( static_cast<VkBuffer>( buffer ) ); 14342 } 14343 }; 14344 14345 template <> 14346 struct hash<VULKAN_HPP_NAMESPACE::BufferView> 14347 { operator ()std::hash14348 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferView const & bufferView ) const VULKAN_HPP_NOEXCEPT 14349 { 14350 return std::hash<VkBufferView>{}( static_cast<VkBufferView>( bufferView ) ); 14351 } 14352 }; 14353 14354 template <> 14355 struct hash<VULKAN_HPP_NAMESPACE::Image> 14356 { operator ()std::hash14357 std::size_t operator()( VULKAN_HPP_NAMESPACE::Image const & image ) const VULKAN_HPP_NOEXCEPT 14358 { 14359 return std::hash<VkImage>{}( static_cast<VkImage>( image ) ); 14360 } 14361 }; 14362 14363 template <> 14364 struct hash<VULKAN_HPP_NAMESPACE::ImageView> 14365 { operator ()std::hash14366 std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageView const & imageView ) const VULKAN_HPP_NOEXCEPT 14367 { 14368 return std::hash<VkImageView>{}( static_cast<VkImageView>( imageView ) ); 14369 } 14370 }; 14371 14372 template <> 14373 struct hash<VULKAN_HPP_NAMESPACE::ShaderModule> 14374 { operator ()std::hash14375 std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderModule const & shaderModule ) const VULKAN_HPP_NOEXCEPT 14376 { 14377 return std::hash<VkShaderModule>{}( static_cast<VkShaderModule>( shaderModule ) ); 14378 } 14379 }; 14380 14381 template <> 14382 struct hash<VULKAN_HPP_NAMESPACE::PipelineCache> 14383 { operator ()std::hash14384 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCache const & pipelineCache ) const VULKAN_HPP_NOEXCEPT 14385 { 14386 return std::hash<VkPipelineCache>{}( static_cast<VkPipelineCache>( pipelineCache ) ); 14387 } 14388 }; 14389 14390 template <> 14391 struct hash<VULKAN_HPP_NAMESPACE::Pipeline> 14392 { operator ()std::hash14393 std::size_t operator()( VULKAN_HPP_NAMESPACE::Pipeline const & pipeline ) const VULKAN_HPP_NOEXCEPT 14394 { 14395 return std::hash<VkPipeline>{}( static_cast<VkPipeline>( pipeline ) ); 14396 } 14397 }; 14398 14399 template <> 14400 struct hash<VULKAN_HPP_NAMESPACE::PipelineLayout> 14401 { operator ()std::hash14402 std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineLayout const & pipelineLayout ) const VULKAN_HPP_NOEXCEPT 14403 { 14404 return std::hash<VkPipelineLayout>{}( static_cast<VkPipelineLayout>( pipelineLayout ) ); 14405 } 14406 }; 14407 14408 template <> 14409 struct hash<VULKAN_HPP_NAMESPACE::Sampler> 14410 { operator ()std::hash14411 std::size_t operator()( VULKAN_HPP_NAMESPACE::Sampler const & sampler ) const VULKAN_HPP_NOEXCEPT 14412 { 14413 return std::hash<VkSampler>{}( static_cast<VkSampler>( sampler ) ); 14414 } 14415 }; 14416 14417 template <> 14418 struct hash<VULKAN_HPP_NAMESPACE::DescriptorPool> 14419 { operator ()std::hash14420 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPool const & descriptorPool ) const VULKAN_HPP_NOEXCEPT 14421 { 14422 return std::hash<VkDescriptorPool>{}( static_cast<VkDescriptorPool>( descriptorPool ) ); 14423 } 14424 }; 14425 14426 template <> 14427 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSet> 14428 { operator ()std::hash14429 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSet const & descriptorSet ) const VULKAN_HPP_NOEXCEPT 14430 { 14431 return std::hash<VkDescriptorSet>{}( static_cast<VkDescriptorSet>( descriptorSet ) ); 14432 } 14433 }; 14434 14435 template <> 14436 struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayout> 14437 { 14438 std::size_t operator ()std::hash14439 operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayout const & descriptorSetLayout ) const VULKAN_HPP_NOEXCEPT 14440 { 14441 return std::hash<VkDescriptorSetLayout>{}( static_cast<VkDescriptorSetLayout>( descriptorSetLayout ) ); 14442 } 14443 }; 14444 14445 template <> 14446 struct hash<VULKAN_HPP_NAMESPACE::Framebuffer> 14447 { operator ()std::hash14448 std::size_t operator()( VULKAN_HPP_NAMESPACE::Framebuffer const & framebuffer ) const VULKAN_HPP_NOEXCEPT 14449 { 14450 return std::hash<VkFramebuffer>{}( static_cast<VkFramebuffer>( framebuffer ) ); 14451 } 14452 }; 14453 14454 template <> 14455 struct hash<VULKAN_HPP_NAMESPACE::RenderPass> 14456 { operator ()std::hash14457 std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPass const & renderPass ) const VULKAN_HPP_NOEXCEPT 14458 { 14459 return std::hash<VkRenderPass>{}( static_cast<VkRenderPass>( renderPass ) ); 14460 } 14461 }; 14462 14463 template <> 14464 struct hash<VULKAN_HPP_NAMESPACE::CommandPool> 14465 { operator ()std::hash14466 std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandPool const & commandPool ) const VULKAN_HPP_NOEXCEPT 14467 { 14468 return std::hash<VkCommandPool>{}( static_cast<VkCommandPool>( commandPool ) ); 14469 } 14470 }; 14471 14472 template <> 14473 struct hash<VULKAN_HPP_NAMESPACE::CommandBuffer> 14474 { operator ()std::hash14475 std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBuffer const & commandBuffer ) const VULKAN_HPP_NOEXCEPT 14476 { 14477 return std::hash<VkCommandBuffer>{}( static_cast<VkCommandBuffer>( commandBuffer ) ); 14478 } 14479 }; 14480 14481 //=== VK_VERSION_1_1 === 14482 14483 template <> 14484 struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion> 14485 { operator ()std::hash14486 std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion const & samplerYcbcrConversion ) const 14487 VULKAN_HPP_NOEXCEPT 14488 { 14489 return std::hash<VkSamplerYcbcrConversion>{}( static_cast<VkSamplerYcbcrConversion>( samplerYcbcrConversion ) ); 14490 } 14491 }; 14492 14493 template <> 14494 struct hash<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate> 14495 { operator ()std::hash14496 std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate const & descriptorUpdateTemplate ) const 14497 VULKAN_HPP_NOEXCEPT 14498 { 14499 return std::hash<VkDescriptorUpdateTemplate>{}( 14500 static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ) ); 14501 } 14502 }; 14503 14504 //=== VK_KHR_surface === 14505 14506 template <> 14507 struct hash<VULKAN_HPP_NAMESPACE::SurfaceKHR> 14508 { operator ()std::hash14509 std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceKHR const & surfaceKHR ) const VULKAN_HPP_NOEXCEPT 14510 { 14511 return std::hash<VkSurfaceKHR>{}( static_cast<VkSurfaceKHR>( surfaceKHR ) ); 14512 } 14513 }; 14514 14515 //=== VK_KHR_swapchain === 14516 14517 template <> 14518 struct hash<VULKAN_HPP_NAMESPACE::SwapchainKHR> 14519 { operator ()std::hash14520 std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainKHR const & swapchainKHR ) const VULKAN_HPP_NOEXCEPT 14521 { 14522 return std::hash<VkSwapchainKHR>{}( static_cast<VkSwapchainKHR>( swapchainKHR ) ); 14523 } 14524 }; 14525 14526 //=== VK_KHR_display === 14527 14528 template <> 14529 struct hash<VULKAN_HPP_NAMESPACE::DisplayKHR> 14530 { operator ()std::hash14531 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayKHR const & displayKHR ) const VULKAN_HPP_NOEXCEPT 14532 { 14533 return std::hash<VkDisplayKHR>{}( static_cast<VkDisplayKHR>( displayKHR ) ); 14534 } 14535 }; 14536 14537 template <> 14538 struct hash<VULKAN_HPP_NAMESPACE::DisplayModeKHR> 14539 { operator ()std::hash14540 std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeKHR const & displayModeKHR ) const VULKAN_HPP_NOEXCEPT 14541 { 14542 return std::hash<VkDisplayModeKHR>{}( static_cast<VkDisplayModeKHR>( displayModeKHR ) ); 14543 } 14544 }; 14545 14546 //=== VK_EXT_debug_report === 14547 14548 template <> 14549 struct hash<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT> 14550 { operator ()std::hash14551 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT const & debugReportCallbackEXT ) const 14552 VULKAN_HPP_NOEXCEPT 14553 { 14554 return std::hash<VkDebugReportCallbackEXT>{}( static_cast<VkDebugReportCallbackEXT>( debugReportCallbackEXT ) ); 14555 } 14556 }; 14557 14558 #if defined( VK_ENABLE_BETA_EXTENSIONS ) 14559 //=== VK_KHR_video_queue === 14560 14561 template <> 14562 struct hash<VULKAN_HPP_NAMESPACE::VideoSessionKHR> 14563 { operator ()std::hash14564 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionKHR const & videoSessionKHR ) const VULKAN_HPP_NOEXCEPT 14565 { 14566 return std::hash<VkVideoSessionKHR>{}( static_cast<VkVideoSessionKHR>( videoSessionKHR ) ); 14567 } 14568 }; 14569 14570 template <> 14571 struct hash<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR> 14572 { operator ()std::hash14573 std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR const & videoSessionParametersKHR ) const 14574 VULKAN_HPP_NOEXCEPT 14575 { 14576 return std::hash<VkVideoSessionParametersKHR>{}( 14577 static_cast<VkVideoSessionParametersKHR>( videoSessionParametersKHR ) ); 14578 } 14579 }; 14580 #endif /*VK_ENABLE_BETA_EXTENSIONS*/ 14581 14582 //=== VK_NVX_binary_import === 14583 14584 template <> 14585 struct hash<VULKAN_HPP_NAMESPACE::CuModuleNVX> 14586 { operator ()std::hash14587 std::size_t operator()( VULKAN_HPP_NAMESPACE::CuModuleNVX const & cuModuleNVX ) const VULKAN_HPP_NOEXCEPT 14588 { 14589 return std::hash<VkCuModuleNVX>{}( static_cast<VkCuModuleNVX>( cuModuleNVX ) ); 14590 } 14591 }; 14592 14593 template <> 14594 struct hash<VULKAN_HPP_NAMESPACE::CuFunctionNVX> 14595 { operator ()std::hash14596 std::size_t operator()( VULKAN_HPP_NAMESPACE::CuFunctionNVX const & cuFunctionNVX ) const VULKAN_HPP_NOEXCEPT 14597 { 14598 return std::hash<VkCuFunctionNVX>{}( static_cast<VkCuFunctionNVX>( cuFunctionNVX ) ); 14599 } 14600 }; 14601 14602 //=== VK_EXT_debug_utils === 14603 14604 template <> 14605 struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT> 14606 { operator ()std::hash14607 std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT const & debugUtilsMessengerEXT ) const 14608 VULKAN_HPP_NOEXCEPT 14609 { 14610 return std::hash<VkDebugUtilsMessengerEXT>{}( static_cast<VkDebugUtilsMessengerEXT>( debugUtilsMessengerEXT ) ); 14611 } 14612 }; 14613 14614 //=== VK_KHR_acceleration_structure === 14615 14616 template <> 14617 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> 14618 { operator ()std::hash14619 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const & accelerationStructureKHR ) const 14620 VULKAN_HPP_NOEXCEPT 14621 { 14622 return std::hash<VkAccelerationStructureKHR>{}( 14623 static_cast<VkAccelerationStructureKHR>( accelerationStructureKHR ) ); 14624 } 14625 }; 14626 14627 //=== VK_EXT_validation_cache === 14628 14629 template <> 14630 struct hash<VULKAN_HPP_NAMESPACE::ValidationCacheEXT> 14631 { 14632 std::size_t operator ()std::hash14633 operator()( VULKAN_HPP_NAMESPACE::ValidationCacheEXT const & validationCacheEXT ) const VULKAN_HPP_NOEXCEPT 14634 { 14635 return std::hash<VkValidationCacheEXT>{}( static_cast<VkValidationCacheEXT>( validationCacheEXT ) ); 14636 } 14637 }; 14638 14639 //=== VK_NV_ray_tracing === 14640 14641 template <> 14642 struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureNV> 14643 { operator ()std::hash14644 std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureNV const & accelerationStructureNV ) const 14645 VULKAN_HPP_NOEXCEPT 14646 { 14647 return std::hash<VkAccelerationStructureNV>{}( 14648 static_cast<VkAccelerationStructureNV>( accelerationStructureNV ) ); 14649 } 14650 }; 14651 14652 //=== VK_INTEL_performance_query === 14653 14654 template <> 14655 struct hash<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL> 14656 { operator ()std::hash14657 std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL const & performanceConfigurationINTEL ) 14658 const VULKAN_HPP_NOEXCEPT 14659 { 14660 return std::hash<VkPerformanceConfigurationINTEL>{}( 14661 static_cast<VkPerformanceConfigurationINTEL>( performanceConfigurationINTEL ) ); 14662 } 14663 }; 14664 14665 //=== VK_KHR_deferred_host_operations === 14666 14667 template <> 14668 struct hash<VULKAN_HPP_NAMESPACE::DeferredOperationKHR> 14669 { 14670 std::size_t operator ()std::hash14671 operator()( VULKAN_HPP_NAMESPACE::DeferredOperationKHR const & deferredOperationKHR ) const VULKAN_HPP_NOEXCEPT 14672 { 14673 return std::hash<VkDeferredOperationKHR>{}( static_cast<VkDeferredOperationKHR>( deferredOperationKHR ) ); 14674 } 14675 }; 14676 14677 //=== VK_NV_device_generated_commands === 14678 14679 template <> 14680 struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV> 14681 { operator ()std::hash14682 std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV const & indirectCommandsLayoutNV ) const 14683 VULKAN_HPP_NOEXCEPT 14684 { 14685 return std::hash<VkIndirectCommandsLayoutNV>{}( 14686 static_cast<VkIndirectCommandsLayoutNV>( indirectCommandsLayoutNV ) ); 14687 } 14688 }; 14689 14690 //=== VK_EXT_private_data === 14691 14692 template <> 14693 struct hash<VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT> 14694 { 14695 std::size_t operator ()std::hash14696 operator()( VULKAN_HPP_NAMESPACE::PrivateDataSlotEXT const & privateDataSlotEXT ) const VULKAN_HPP_NOEXCEPT 14697 { 14698 return std::hash<VkPrivateDataSlotEXT>{}( static_cast<VkPrivateDataSlotEXT>( privateDataSlotEXT ) ); 14699 } 14700 }; 14701 14702 #if defined( VK_USE_PLATFORM_FUCHSIA ) 14703 //=== VK_FUCHSIA_buffer_collection === 14704 14705 template <> 14706 struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA> 14707 { operator ()std::hash14708 std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA const & bufferCollectionFUCHSIA ) const 14709 VULKAN_HPP_NOEXCEPT 14710 { 14711 return std::hash<VkBufferCollectionFUCHSIA>{}( 14712 static_cast<VkBufferCollectionFUCHSIA>( bufferCollectionFUCHSIA ) ); 14713 } 14714 }; 14715 #endif /*VK_USE_PLATFORM_FUCHSIA*/ 14716 14717 } // namespace std 14718 #endif 14719