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