Update Vulkan headers to version 1.3.224
https://github.com/KhronosGroup/Vulkan-Headers
revision 2b55157592bf4c639b76cc16d64acaef565cc4b5
tag v1.3.224
Bug: b/202964266
Change-Id: I7cdca7b4b25af3fa230713684e292eea55c1d4d5
Reviewed-on: https://swiftshader-review.googlesource.com/c/SwiftShader/+/67348
Reviewed-by: Nicolas Capens <nicolascapens@google.com>
Presubmit-Ready: Alexis Hétu <sugoi@google.com>
Commit-Queue: Alexis Hétu <sugoi@google.com>
Tested-by: Alexis Hétu <sugoi@google.com>
diff --git a/include/vulkan/vulkan.hpp b/include/vulkan/vulkan.hpp
index c20a0af..aa38181 100644
--- a/include/vulkan/vulkan.hpp
+++ b/include/vulkan/vulkan.hpp
@@ -8,6238 +8,6183 @@
#ifndef VULKAN_HPP
#define VULKAN_HPP
-#if defined(_MSVC_LANG)
-# define VULKAN_HPP_CPLUSPLUS _MSVC_LANG
+#if defined( _MSVC_LANG )
+# define VULKAN_HPP_CPLUSPLUS _MSVC_LANG
#else
-# define VULKAN_HPP_CPLUSPLUS __cplusplus
+# define VULKAN_HPP_CPLUSPLUS __cplusplus
#endif
#if 201703L < VULKAN_HPP_CPLUSPLUS
-# define VULKAN_HPP_CPP_VERSION 20
+# define VULKAN_HPP_CPP_VERSION 20
#elif 201402L < VULKAN_HPP_CPLUSPLUS
-# define VULKAN_HPP_CPP_VERSION 17
+# define VULKAN_HPP_CPP_VERSION 17
#elif 201103L < VULKAN_HPP_CPLUSPLUS
-# define VULKAN_HPP_CPP_VERSION 14
+# define VULKAN_HPP_CPP_VERSION 14
#elif 199711L < VULKAN_HPP_CPLUSPLUS
-# define VULKAN_HPP_CPP_VERSION 11
+# define VULKAN_HPP_CPP_VERSION 11
#else
-# error "vulkan.hpp needs at least c++ standard version 11"
+# error "vulkan.hpp needs at least c++ standard version 11"
#endif
+#include <array> // ArrayWrapperND
+#include <string> // std::string
#include <vulkan/vulkan.h>
-#include <algorithm>
-#include <array>
-#include <cstddef>
-#include <cstdint>
-#include <cstring>
-#include <functional>
-#include <initializer_list>
-#include <sstream>
-#include <string>
-#include <system_error>
-#include <tuple>
-#include <type_traits>
#if 17 <= VULKAN_HPP_CPP_VERSION
-# include <string_view>
+# include <string_view> // std::string_view
#endif
-#if defined(VULKAN_HPP_DISABLE_ENHANCED_MODE)
-# if !defined(VULKAN_HPP_NO_SMART_HANDLE)
-# define VULKAN_HPP_NO_SMART_HANDLE
-# endif
+#if defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+# if !defined( VULKAN_HPP_NO_SMART_HANDLE )
+# define VULKAN_HPP_NO_SMART_HANDLE
+# endif
#else
-# include <memory>
-# include <vector>
+# include <tuple> // std::tie
+# include <vector> // std::vector
#endif
-#if defined(VULKAN_HPP_NO_CONSTRUCTORS)
-# if !defined(VULKAN_HPP_NO_STRUCT_CONSTRUCTORS)
-# define VULKAN_HPP_NO_STRUCT_CONSTRUCTORS
-# endif
-# if !defined(VULKAN_HPP_NO_UNION_CONSTRUCTORS)
-# define VULKAN_HPP_NO_UNION_CONSTRUCTORS
-# endif
+#if !defined( VULKAN_HPP_NO_EXCEPTIONS )
+# include <system_error> // std::is_error_code_enum
#endif
-#if defined(VULKAN_HPP_NO_SETTERS)
-# if !defined(VULKAN_HPP_NO_STRUCT_SETTERS)
-# define VULKAN_HPP_NO_STRUCT_SETTERS
-# endif
-# if !defined(VULKAN_HPP_NO_UNION_SETTERS)
-# define VULKAN_HPP_NO_UNION_SETTERS
-# endif
+#if !defined( VULKAN_HPP_NO_SMART_HANDLE )
+# include <algorithm> // std::transform
#endif
-#if !defined(VULKAN_HPP_ASSERT)
-# include <cassert>
-# define VULKAN_HPP_ASSERT assert
+#if defined( VULKAN_HPP_NO_CONSTRUCTORS )
+# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
+# define VULKAN_HPP_NO_STRUCT_CONSTRUCTORS
+# endif
+# if !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS )
+# define VULKAN_HPP_NO_UNION_CONSTRUCTORS
+# endif
#endif
-#if !defined(VULKAN_HPP_ASSERT_ON_RESULT)
-# define VULKAN_HPP_ASSERT_ON_RESULT VULKAN_HPP_ASSERT
+#if defined( VULKAN_HPP_NO_SETTERS )
+# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
+# define VULKAN_HPP_NO_STRUCT_SETTERS
+# endif
+# if !defined( VULKAN_HPP_NO_UNION_SETTERS )
+# define VULKAN_HPP_NO_UNION_SETTERS
+# endif
#endif
-#if !defined(VULKAN_HPP_STATIC_ASSERT)
-# define VULKAN_HPP_STATIC_ASSERT static_assert
+#if !defined( VULKAN_HPP_ASSERT )
+# include <cassert>
+# define VULKAN_HPP_ASSERT assert
#endif
-#if !defined(VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL)
-# define VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL 1
+#if !defined( VULKAN_HPP_ASSERT_ON_RESULT )
+# define VULKAN_HPP_ASSERT_ON_RESULT VULKAN_HPP_ASSERT
+#endif
+
+#if !defined( VULKAN_HPP_STATIC_ASSERT )
+# define VULKAN_HPP_STATIC_ASSERT static_assert
+#endif
+
+#if !defined( VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL )
+# define VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL 1
#endif
#if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL == 1
-# if defined(__unix__) || defined(__APPLE__) || defined(__QNXNTO__) || defined(__Fuchsia__)
-# include <dlfcn.h>
-# elif defined(_WIN32)
-typedef struct HINSTANCE__ *HINSTANCE;
-# if defined(_WIN64)
-typedef int64_t(__stdcall *FARPROC)();
-# else
-typedef int(__stdcall *FARPROC)();
-# endif
-extern "C" __declspec(dllimport) HINSTANCE __stdcall LoadLibraryA(char const *lpLibFileName);
-extern "C" __declspec(dllimport) int __stdcall FreeLibrary(HINSTANCE hLibModule);
-extern "C" __declspec(dllimport) FARPROC __stdcall GetProcAddress(HINSTANCE hModule, const char *lpProcName);
-# endif
+# if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNXNTO__ ) || defined( __Fuchsia__ )
+# include <dlfcn.h>
+# elif defined( _WIN32 )
+typedef struct HINSTANCE__ * HINSTANCE;
+# if defined( _WIN64 )
+typedef int64_t( __stdcall * FARPROC )();
+# else
+typedef int( __stdcall * FARPROC )();
+# endif
+extern "C" __declspec( dllimport ) HINSTANCE __stdcall LoadLibraryA( char const * lpLibFileName );
+extern "C" __declspec( dllimport ) int __stdcall FreeLibrary( HINSTANCE hLibModule );
+extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE hModule, const char * lpProcName );
+# endif
#endif
-#if !defined(__has_include)
-# define __has_include(x) false
+#if !defined( __has_include )
+# define __has_include( x ) false
#endif
-#if(201711 <= __cpp_impl_three_way_comparison) && __has_include(<compare> ) && !defined( VULKAN_HPP_NO_SPACESHIP_OPERATOR )
-# define VULKAN_HPP_HAS_SPACESHIP_OPERATOR
+#if ( 201907 <= __cpp_lib_three_way_comparison ) && __has_include( <compare> ) && !defined( VULKAN_HPP_NO_SPACESHIP_OPERATOR )
+# define VULKAN_HPP_HAS_SPACESHIP_OPERATOR
#endif
-#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
-# include <compare>
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+# include <compare>
#endif
-#if(201803 <= __cpp_lib_span)
-# define VULKAN_HPP_SUPPORT_SPAN
-# include <span>
+#if ( 201803 <= __cpp_lib_span )
+# define VULKAN_HPP_SUPPORT_SPAN
+# include <span>
#endif
-static_assert(VK_HEADER_VERSION == 211, "Wrong VK_HEADER_VERSION!");
+static_assert( VK_HEADER_VERSION == 224, "Wrong VK_HEADER_VERSION!" );
-// 32-bit vulkan is not typesafe for handles, so don't allow copy constructors on this platform by default.
+// 32-bit vulkan is not typesafe for non-dispatchable handles, so don't allow copy constructors on this platform by default.
// To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION
-#if(VK_USE_64_BIT_PTR_DEFINES == 1)
-# if !defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-# define VULKAN_HPP_TYPESAFE_CONVERSION
-# endif
+#if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
+# if !defined( VULKAN_HPP_TYPESAFE_CONVERSION )
+# define VULKAN_HPP_TYPESAFE_CONVERSION
+# endif
#endif
// <tuple> includes <sys/sysmacros.h> through some other header
// this results in major(x) being resolved to gnu_dev_major(x)
// which is an expression in a constructor initializer list.
-#if defined(major)
-# undef major
+#if defined( major )
+# undef major
#endif
-#if defined(minor)
-# undef minor
+#if defined( minor )
+# undef minor
#endif
// Windows defines MemoryBarrier which is deprecated and collides
// with the VULKAN_HPP_NAMESPACE::MemoryBarrier struct.
-#if defined(MemoryBarrier)
-# undef MemoryBarrier
+#if defined( MemoryBarrier )
+# undef MemoryBarrier
#endif
-#if !defined(VULKAN_HPP_HAS_UNRESTRICTED_UNIONS)
-# if defined(__clang__)
-# if __has_feature(cxx_unrestricted_unions)
-# define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
-# endif
-# elif defined(__GNUC__)
-# define GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
-# if 40600 <= GCC_VERSION
-# define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
-# endif
-# elif defined(_MSC_VER)
-# if 1900 <= _MSC_VER
-# define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
-# endif
-# endif
+#if !defined( VULKAN_HPP_HAS_UNRESTRICTED_UNIONS )
+# if defined( __clang__ )
+# if __has_feature( cxx_unrestricted_unions )
+# define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
+# endif
+# elif defined( __GNUC__ )
+# define GCC_VERSION ( __GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__ )
+# if 40600 <= GCC_VERSION
+# define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
+# endif
+# elif defined( _MSC_VER )
+# if 1900 <= _MSC_VER
+# define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
+# endif
+# endif
#endif
-#if !defined(VULKAN_HPP_INLINE)
-# if defined(__clang__)
-# if __has_attribute(always_inline)
-# define VULKAN_HPP_INLINE __attribute__((always_inline)) __inline__
-# else
-# define VULKAN_HPP_INLINE inline
-# endif
-# elif defined(__GNUC__)
-# define VULKAN_HPP_INLINE __attribute__((always_inline)) __inline__
-# elif defined(_MSC_VER)
-# define VULKAN_HPP_INLINE inline
-# else
-# define VULKAN_HPP_INLINE inline
-# endif
+#if !defined( VULKAN_HPP_INLINE )
+# if defined( __clang__ )
+# if __has_attribute( always_inline )
+# define VULKAN_HPP_INLINE __attribute__( ( always_inline ) ) __inline__
+# else
+# define VULKAN_HPP_INLINE inline
+# endif
+# elif defined( __GNUC__ )
+# define VULKAN_HPP_INLINE __attribute__( ( always_inline ) ) __inline__
+# elif defined( _MSC_VER )
+# define VULKAN_HPP_INLINE inline
+# else
+# define VULKAN_HPP_INLINE inline
+# endif
#endif
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-# define VULKAN_HPP_TYPESAFE_EXPLICIT
+#if defined( VULKAN_HPP_TYPESAFE_CONVERSION )
+# define VULKAN_HPP_TYPESAFE_EXPLICIT
#else
-# define VULKAN_HPP_TYPESAFE_EXPLICIT explicit
+# define VULKAN_HPP_TYPESAFE_EXPLICIT explicit
#endif
-#if defined(__cpp_constexpr)
-# define VULKAN_HPP_CONSTEXPR constexpr
-# if __cpp_constexpr >= 201304
-# define VULKAN_HPP_CONSTEXPR_14 constexpr
-# else
-# define VULKAN_HPP_CONSTEXPR_14
-# endif
-# define VULKAN_HPP_CONST_OR_CONSTEXPR constexpr
+#if defined( __cpp_constexpr )
+# define VULKAN_HPP_CONSTEXPR constexpr
+# if __cpp_constexpr >= 201304
+# define VULKAN_HPP_CONSTEXPR_14 constexpr
+# else
+# define VULKAN_HPP_CONSTEXPR_14
+# endif
+# define VULKAN_HPP_CONST_OR_CONSTEXPR constexpr
#else
-# define VULKAN_HPP_CONSTEXPR
-# define VULKAN_HPP_CONSTEXPR_14
-# define VULKAN_HPP_CONST_OR_CONSTEXPR const
+# define VULKAN_HPP_CONSTEXPR
+# define VULKAN_HPP_CONSTEXPR_14
+# define VULKAN_HPP_CONST_OR_CONSTEXPR const
#endif
-#if !defined(VULKAN_HPP_NOEXCEPT)
-# if defined(_MSC_VER) && (_MSC_VER <= 1800)
-# define VULKAN_HPP_NOEXCEPT
-# else
-# define VULKAN_HPP_NOEXCEPT noexcept
-# define VULKAN_HPP_HAS_NOEXCEPT 1
-# if defined(VULKAN_HPP_NO_EXCEPTIONS)
-# define VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS noexcept
-# else
-# define VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
-# endif
-# endif
+#if !defined( VULKAN_HPP_NOEXCEPT )
+# if defined( _MSC_VER ) && ( _MSC_VER <= 1800 )
+# define VULKAN_HPP_NOEXCEPT
+# else
+# define VULKAN_HPP_NOEXCEPT noexcept
+# define VULKAN_HPP_HAS_NOEXCEPT 1
+# if defined( VULKAN_HPP_NO_EXCEPTIONS )
+# define VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS noexcept
+# else
+# define VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS
+# endif
+# endif
#endif
#if 14 <= VULKAN_HPP_CPP_VERSION
-# define VULKAN_HPP_DEPRECATED(msg) [[deprecated(msg)]]
+# define VULKAN_HPP_DEPRECATED( msg ) [[deprecated( msg )]]
#else
-# define VULKAN_HPP_DEPRECATED(msg)
+# define VULKAN_HPP_DEPRECATED( msg )
#endif
-#if(17 <= VULKAN_HPP_CPP_VERSION) && !defined(VULKAN_HPP_NO_NODISCARD_WARNINGS)
-# define VULKAN_HPP_NODISCARD [[nodiscard]]
-# if defined(VULKAN_HPP_NO_EXCEPTIONS)
-# define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS [[nodiscard]]
-# else
-# define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
-# endif
+#if ( 17 <= VULKAN_HPP_CPP_VERSION ) && !defined( VULKAN_HPP_NO_NODISCARD_WARNINGS )
+# define VULKAN_HPP_NODISCARD [[nodiscard]]
+# if defined( VULKAN_HPP_NO_EXCEPTIONS )
+# define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS [[nodiscard]]
+# else
+# define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
+# endif
#else
-# define VULKAN_HPP_NODISCARD
-# define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
+# define VULKAN_HPP_NODISCARD
+# define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
#endif
-#if !defined(VULKAN_HPP_NAMESPACE)
-# define VULKAN_HPP_NAMESPACE vk
+#if !defined( VULKAN_HPP_NAMESPACE )
+# define VULKAN_HPP_NAMESPACE vk
#endif
-#define VULKAN_HPP_STRINGIFY2(text) #text
-#define VULKAN_HPP_STRINGIFY(text) VULKAN_HPP_STRINGIFY2(text)
-#define VULKAN_HPP_NAMESPACE_STRING VULKAN_HPP_STRINGIFY(VULKAN_HPP_NAMESPACE)
+#define VULKAN_HPP_STRINGIFY2( text ) #text
+#define VULKAN_HPP_STRINGIFY( text ) VULKAN_HPP_STRINGIFY2( text )
+#define VULKAN_HPP_NAMESPACE_STRING VULKAN_HPP_STRINGIFY( VULKAN_HPP_NAMESPACE )
-namespace VULKAN_HPP_NAMESPACE {
-#if !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE)
-template<typename T>
-class ArrayProxy
+namespace VULKAN_HPP_NAMESPACE
{
-public:
- VULKAN_HPP_CONSTEXPR ArrayProxy() VULKAN_HPP_NOEXCEPT
- : m_count(0),
- m_ptr(nullptr)
- {
- }
+ template <typename T, size_t N>
+ class ArrayWrapper1D : public std::array<T, N>
+ {
+ public:
+ VULKAN_HPP_CONSTEXPR ArrayWrapper1D() VULKAN_HPP_NOEXCEPT : std::array<T, N>() {}
- VULKAN_HPP_CONSTEXPR ArrayProxy(std::nullptr_t) VULKAN_HPP_NOEXCEPT
- : m_count(0),
- m_ptr(nullptr)
- {
- }
+ VULKAN_HPP_CONSTEXPR ArrayWrapper1D( std::array<T, N> const & data ) VULKAN_HPP_NOEXCEPT : std::array<T, N>( data ) {}
- ArrayProxy(T &value) VULKAN_HPP_NOEXCEPT
- : m_count(1),
- m_ptr(&value)
- {
- }
+#if ( VK_USE_64_BIT_PTR_DEFINES == 0 )
+ // on 32 bit compiles, needs overloads on index type int to resolve ambiguities
+ VULKAN_HPP_CONSTEXPR T const & operator[]( int index ) const VULKAN_HPP_NOEXCEPT
+ {
+ return std::array<T, N>::operator[]( index );
+ }
- template<typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
- ArrayProxy(typename std::remove_const<T>::type &value) VULKAN_HPP_NOEXCEPT
- : m_count(1),
- m_ptr(&value)
- {
- }
-
- ArrayProxy(uint32_t count, T *ptr) VULKAN_HPP_NOEXCEPT
- : m_count(count),
- m_ptr(ptr)
- {
- }
-
- template<typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
- ArrayProxy(uint32_t count, typename std::remove_const<T>::type *ptr) VULKAN_HPP_NOEXCEPT
- : m_count(count),
- m_ptr(ptr)
- {
- }
-
-# if __GNUC__ >= 9
-# pragma GCC diagnostic push
-# pragma GCC diagnostic ignored "-Winit-list-lifetime"
-# endif
-
- ArrayProxy(std::initializer_list<T> const &list) VULKAN_HPP_NOEXCEPT
- : m_count(static_cast<uint32_t>(list.size())),
- m_ptr(list.begin())
- {
- }
-
- template<typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
- ArrayProxy(std::initializer_list<typename std::remove_const<T>::type> const &list) VULKAN_HPP_NOEXCEPT
- : m_count(static_cast<uint32_t>(list.size())),
- m_ptr(list.begin())
- {
- }
-
- ArrayProxy(std::initializer_list<T> &list) VULKAN_HPP_NOEXCEPT
- : m_count(static_cast<uint32_t>(list.size())),
- m_ptr(list.begin())
- {
- }
-
- template<typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
- ArrayProxy(std::initializer_list<typename std::remove_const<T>::type> &list) VULKAN_HPP_NOEXCEPT
- : m_count(static_cast<uint32_t>(list.size())),
- m_ptr(list.begin())
- {
- }
-
-# if __GNUC__ >= 9
-# pragma GCC diagnostic pop
-# endif
-
- // Any type with a .data() return type implicitly convertible to T*, and a .size() return type implicitly
- // convertible to size_t. The const version can capture temporaries, with lifetime ending at end of statement.
- template<typename V,
- typename std::enable_if<std::is_convertible<decltype(std::declval<V>().data()), T *>::value &&
- std::is_convertible<decltype(std::declval<V>().size()), std::size_t>::value>::type * = nullptr>
- ArrayProxy(V const &v) VULKAN_HPP_NOEXCEPT
- : m_count(static_cast<uint32_t>(v.size())),
- m_ptr(v.data())
- {
- }
-
- template<typename V,
- typename std::enable_if<std::is_convertible<decltype(std::declval<V>().data()), T *>::value &&
- std::is_convertible<decltype(std::declval<V>().size()), std::size_t>::value>::type * = nullptr>
- ArrayProxy(V &v) VULKAN_HPP_NOEXCEPT
- : m_count(static_cast<uint32_t>(v.size())),
- m_ptr(v.data())
- {
- }
-
- const T *begin() const VULKAN_HPP_NOEXCEPT
- {
- return m_ptr;
- }
-
- const T *end() const VULKAN_HPP_NOEXCEPT
- {
- return m_ptr + m_count;
- }
-
- const T &front() const VULKAN_HPP_NOEXCEPT
- {
- VULKAN_HPP_ASSERT(m_count && m_ptr);
- return *m_ptr;
- }
-
- const T &back() const VULKAN_HPP_NOEXCEPT
- {
- VULKAN_HPP_ASSERT(m_count && m_ptr);
- return *(m_ptr + m_count - 1);
- }
-
- bool empty() const VULKAN_HPP_NOEXCEPT
- {
- return (m_count == 0);
- }
-
- uint32_t size() const VULKAN_HPP_NOEXCEPT
- {
- return m_count;
- }
-
- T *data() const VULKAN_HPP_NOEXCEPT
- {
- return m_ptr;
- }
-
-private:
- uint32_t m_count;
- T *m_ptr;
-};
-
-template<typename T>
-class ArrayProxyNoTemporaries
-{
-public:
- VULKAN_HPP_CONSTEXPR ArrayProxyNoTemporaries() VULKAN_HPP_NOEXCEPT
- : m_count(0),
- m_ptr(nullptr)
- {
- }
-
- VULKAN_HPP_CONSTEXPR ArrayProxyNoTemporaries(std::nullptr_t) VULKAN_HPP_NOEXCEPT
- : m_count(0),
- m_ptr(nullptr)
- {
- }
-
- ArrayProxyNoTemporaries(T &value) VULKAN_HPP_NOEXCEPT
- : m_count(1),
- m_ptr(&value)
- {
- }
-
- template<typename V>
- ArrayProxyNoTemporaries(V &&value) = delete;
-
- template<typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
- ArrayProxyNoTemporaries(typename std::remove_const<T>::type &value) VULKAN_HPP_NOEXCEPT
- : m_count(1),
- m_ptr(&value)
- {
- }
-
- template<typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
- ArrayProxyNoTemporaries(typename std::remove_const<T>::type &&value) = delete;
-
- ArrayProxyNoTemporaries(uint32_t count, T *ptr) VULKAN_HPP_NOEXCEPT
- : m_count(count),
- m_ptr(ptr)
- {
- }
-
- template<typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
- ArrayProxyNoTemporaries(uint32_t count, typename std::remove_const<T>::type *ptr) VULKAN_HPP_NOEXCEPT
- : m_count(count),
- m_ptr(ptr)
- {
- }
-
- ArrayProxyNoTemporaries(std::initializer_list<T> const &list) VULKAN_HPP_NOEXCEPT
- : m_count(static_cast<uint32_t>(list.size())),
- m_ptr(list.begin())
- {
- }
-
- ArrayProxyNoTemporaries(std::initializer_list<T> const &&list) = delete;
-
- template<typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
- ArrayProxyNoTemporaries(std::initializer_list<typename std::remove_const<T>::type> const &list) VULKAN_HPP_NOEXCEPT
- : m_count(static_cast<uint32_t>(list.size())),
- m_ptr(list.begin())
- {
- }
-
- template<typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
- ArrayProxyNoTemporaries(std::initializer_list<typename std::remove_const<T>::type> const &&list) = delete;
-
- ArrayProxyNoTemporaries(std::initializer_list<T> &list) VULKAN_HPP_NOEXCEPT
- : m_count(static_cast<uint32_t>(list.size())),
- m_ptr(list.begin())
- {
- }
-
- ArrayProxyNoTemporaries(std::initializer_list<T> &&list) = delete;
-
- template<typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
- ArrayProxyNoTemporaries(std::initializer_list<typename std::remove_const<T>::type> &list) VULKAN_HPP_NOEXCEPT
- : m_count(static_cast<uint32_t>(list.size())),
- m_ptr(list.begin())
- {
- }
-
- template<typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
- ArrayProxyNoTemporaries(std::initializer_list<typename std::remove_const<T>::type> &&list) = delete;
-
- // Any type with a .data() return type implicitly convertible to T*, and a // .size() return type implicitly
- // convertible to size_t.
- template<typename V,
- typename std::enable_if<std::is_convertible<decltype(std::declval<V>().data()), T *>::value &&
- std::is_convertible<decltype(std::declval<V>().size()), std::size_t>::value>::type * = nullptr>
- ArrayProxyNoTemporaries(V &v) VULKAN_HPP_NOEXCEPT
- : m_count(static_cast<uint32_t>(v.size())),
- m_ptr(v.data())
- {
- }
-
- const T *begin() const VULKAN_HPP_NOEXCEPT
- {
- return m_ptr;
- }
-
- const T *end() const VULKAN_HPP_NOEXCEPT
- {
- return m_ptr + m_count;
- }
-
- const T &front() const VULKAN_HPP_NOEXCEPT
- {
- VULKAN_HPP_ASSERT(m_count && m_ptr);
- return *m_ptr;
- }
-
- const T &back() const VULKAN_HPP_NOEXCEPT
- {
- VULKAN_HPP_ASSERT(m_count && m_ptr);
- return *(m_ptr + m_count - 1);
- }
-
- bool empty() const VULKAN_HPP_NOEXCEPT
- {
- return (m_count == 0);
- }
-
- uint32_t size() const VULKAN_HPP_NOEXCEPT
- {
- return m_count;
- }
-
- T *data() const VULKAN_HPP_NOEXCEPT
- {
- return m_ptr;
- }
-
-private:
- uint32_t m_count;
- T *m_ptr;
-};
+ T & operator[]( int index ) VULKAN_HPP_NOEXCEPT
+ {
+ return std::array<T, N>::operator[]( index );
+ }
#endif
-template<typename T, size_t N>
-class ArrayWrapper1D : public std::array<T, N>
-{
-public:
- VULKAN_HPP_CONSTEXPR ArrayWrapper1D() VULKAN_HPP_NOEXCEPT : std::array<T, N>() {}
+ operator T const *() const VULKAN_HPP_NOEXCEPT
+ {
+ return this->data();
+ }
- VULKAN_HPP_CONSTEXPR ArrayWrapper1D(std::array<T, N> const &data) VULKAN_HPP_NOEXCEPT : std::array<T, N>(data) {}
+ operator T *() VULKAN_HPP_NOEXCEPT
+ {
+ return this->data();
+ }
-#if(VK_USE_64_BIT_PTR_DEFINES == 0)
- // on 32 bit compiles, needs overloads on index type int to resolve ambiguities
- VULKAN_HPP_CONSTEXPR T const &operator[](int index) const VULKAN_HPP_NOEXCEPT
- {
- return std::array<T, N>::operator[](index);
- }
-
- T &operator[](int index) VULKAN_HPP_NOEXCEPT
- {
- return std::array<T, N>::operator[](index);
- }
-#endif
-
- operator T const *() const VULKAN_HPP_NOEXCEPT
- {
- return this->data();
- }
-
- operator T *() VULKAN_HPP_NOEXCEPT
- {
- return this->data();
- }
-
- template<typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
- operator std::string() const
- {
- return std::string(this->data());
- }
+ template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
+ operator std::string() const
+ {
+ return std::string( this->data() );
+ }
#if 17 <= VULKAN_HPP_CPP_VERSION
- template<typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
- operator std::string_view() const
- {
- return std::string_view(this->data());
- }
+ template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
+ operator std::string_view() const
+ {
+ return std::string_view( this->data() );
+ }
#endif
-#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
- template<typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
- std::strong_ordering operator<=>(ArrayWrapper1D<char, N> const &rhs) const VULKAN_HPP_NOEXCEPT
- {
- return *static_cast<std::array<char, N> const *>(this) <=> *static_cast<std::array<char, N> const *>(&rhs);
- }
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
+ std::strong_ordering operator<=>( ArrayWrapper1D<char, N> const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return *static_cast<std::array<char, N> const *>( this ) <=> *static_cast<std::array<char, N> const *>( &rhs );
+ }
#else
- template<typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
- bool operator<(ArrayWrapper1D<char, N> const &rhs) const VULKAN_HPP_NOEXCEPT
- {
- return *static_cast<std::array<char, N> const *>(this) < *static_cast<std::array<char, N> const *>(&rhs);
- }
+ template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
+ bool operator<( ArrayWrapper1D<char, N> const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return *static_cast<std::array<char, N> const *>( this ) < *static_cast<std::array<char, N> const *>( &rhs );
+ }
- template<typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
- bool operator<=(ArrayWrapper1D<char, N> const &rhs) const VULKAN_HPP_NOEXCEPT
- {
- return *static_cast<std::array<char, N> const *>(this) <= *static_cast<std::array<char, N> const *>(&rhs);
- }
+ template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
+ bool operator<=( ArrayWrapper1D<char, N> const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return *static_cast<std::array<char, N> const *>( this ) <= *static_cast<std::array<char, N> const *>( &rhs );
+ }
- template<typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
- bool operator>(ArrayWrapper1D<char, N> const &rhs) const VULKAN_HPP_NOEXCEPT
- {
- return *static_cast<std::array<char, N> const *>(this) > *static_cast<std::array<char, N> const *>(&rhs);
- }
+ template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
+ bool operator>( ArrayWrapper1D<char, N> const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return *static_cast<std::array<char, N> const *>( this ) > *static_cast<std::array<char, N> const *>( &rhs );
+ }
- template<typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
- bool operator>=(ArrayWrapper1D<char, N> const &rhs) const VULKAN_HPP_NOEXCEPT
- {
- return *static_cast<std::array<char, N> const *>(this) >= *static_cast<std::array<char, N> const *>(&rhs);
- }
+ template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
+ bool operator>=( ArrayWrapper1D<char, N> const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return *static_cast<std::array<char, N> const *>( this ) >= *static_cast<std::array<char, N> const *>( &rhs );
+ }
#endif
- template<typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
- bool operator==(ArrayWrapper1D<char, N> const &rhs) const VULKAN_HPP_NOEXCEPT
- {
- return *static_cast<std::array<char, N> const *>(this) == *static_cast<std::array<char, N> const *>(&rhs);
- }
+ template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
+ bool operator==( ArrayWrapper1D<char, N> const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return *static_cast<std::array<char, N> const *>( this ) == *static_cast<std::array<char, N> const *>( &rhs );
+ }
- template<typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
- bool operator!=(ArrayWrapper1D<char, N> const &rhs) const VULKAN_HPP_NOEXCEPT
- {
- return *static_cast<std::array<char, N> const *>(this) != *static_cast<std::array<char, N> const *>(&rhs);
- }
-};
+ template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
+ bool operator!=( ArrayWrapper1D<char, N> const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return *static_cast<std::array<char, N> const *>( this ) != *static_cast<std::array<char, N> const *>( &rhs );
+ }
+ };
-// specialization of relational operators between std::string and arrays of chars
-template<size_t N>
-bool operator<(std::string const &lhs, ArrayWrapper1D<char, N> const &rhs) VULKAN_HPP_NOEXCEPT
-{
- return lhs < rhs.data();
-}
+ // specialization of relational operators between std::string and arrays of chars
+ template <size_t N>
+ bool operator<( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ return lhs < rhs.data();
+ }
-template<size_t N>
-bool operator<=(std::string const &lhs, ArrayWrapper1D<char, N> const &rhs) VULKAN_HPP_NOEXCEPT
-{
- return lhs <= rhs.data();
-}
+ template <size_t N>
+ bool operator<=( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ return lhs <= rhs.data();
+ }
-template<size_t N>
-bool operator>(std::string const &lhs, ArrayWrapper1D<char, N> const &rhs) VULKAN_HPP_NOEXCEPT
-{
- return lhs > rhs.data();
-}
+ template <size_t N>
+ bool operator>( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ return lhs > rhs.data();
+ }
-template<size_t N>
-bool operator>=(std::string const &lhs, ArrayWrapper1D<char, N> const &rhs) VULKAN_HPP_NOEXCEPT
-{
- return lhs >= rhs.data();
-}
+ template <size_t N>
+ bool operator>=( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ return lhs >= rhs.data();
+ }
-template<size_t N>
-bool operator==(std::string const &lhs, ArrayWrapper1D<char, N> const &rhs) VULKAN_HPP_NOEXCEPT
-{
- return lhs == rhs.data();
-}
+ template <size_t N>
+ bool operator==( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ return lhs == rhs.data();
+ }
-template<size_t N>
-bool operator!=(std::string const &lhs, ArrayWrapper1D<char, N> const &rhs) VULKAN_HPP_NOEXCEPT
-{
- return lhs != rhs.data();
-}
+ template <size_t N>
+ bool operator!=( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ return lhs != rhs.data();
+ }
-template<typename T, size_t N, size_t M>
-class ArrayWrapper2D : public std::array<ArrayWrapper1D<T, M>, N>
-{
-public:
- VULKAN_HPP_CONSTEXPR ArrayWrapper2D() VULKAN_HPP_NOEXCEPT : std::array<ArrayWrapper1D<T, M>, N>() {}
+ template <typename T, size_t N, size_t M>
+ class ArrayWrapper2D : public std::array<ArrayWrapper1D<T, M>, N>
+ {
+ public:
+ VULKAN_HPP_CONSTEXPR ArrayWrapper2D() VULKAN_HPP_NOEXCEPT : std::array<ArrayWrapper1D<T, M>, N>() {}
- VULKAN_HPP_CONSTEXPR ArrayWrapper2D(std::array<std::array<T, M>, N> const &data) VULKAN_HPP_NOEXCEPT
- : std::array<ArrayWrapper1D<T, M>, N>(*reinterpret_cast<std::array<ArrayWrapper1D<T, M>, N> const *>(&data))
- {
- }
-};
+ VULKAN_HPP_CONSTEXPR ArrayWrapper2D( std::array<std::array<T, M>, N> const & data ) VULKAN_HPP_NOEXCEPT
+ : std::array<ArrayWrapper1D<T, M>, N>( *reinterpret_cast<std::array<ArrayWrapper1D<T, M>, N> const *>( &data ) )
+ {
+ }
+ };
-template<typename FlagBitsType>
-struct FlagTraits
-{
-};
+ template <typename FlagBitsType>
+ struct FlagTraits
+ {
+ };
-template<typename BitType>
-class Flags
-{
-public:
- using MaskType = typename std::underlying_type<BitType>::type;
+ template <typename BitType>
+ class Flags
+ {
+ public:
+ using MaskType = typename std::underlying_type<BitType>::type;
- // constructors
- VULKAN_HPP_CONSTEXPR Flags() VULKAN_HPP_NOEXCEPT : m_mask(0) {}
+ // constructors
+ VULKAN_HPP_CONSTEXPR Flags() VULKAN_HPP_NOEXCEPT : m_mask( 0 ) {}
- VULKAN_HPP_CONSTEXPR Flags(BitType bit) VULKAN_HPP_NOEXCEPT : m_mask(static_cast<MaskType>(bit)) {}
+ VULKAN_HPP_CONSTEXPR Flags( BitType bit ) VULKAN_HPP_NOEXCEPT : m_mask( static_cast<MaskType>( bit ) ) {}
- VULKAN_HPP_CONSTEXPR Flags(Flags<BitType> const &rhs) VULKAN_HPP_NOEXCEPT = default;
+ VULKAN_HPP_CONSTEXPR Flags( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT = default;
- VULKAN_HPP_CONSTEXPR explicit Flags(MaskType flags) VULKAN_HPP_NOEXCEPT : m_mask(flags) {}
+ VULKAN_HPP_CONSTEXPR explicit Flags( MaskType flags ) VULKAN_HPP_NOEXCEPT : m_mask( flags ) {}
- // relational operators
-#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
- auto operator<=>(Flags<BitType> const &) const = default;
+ // relational operators
+#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ auto operator<=>( Flags<BitType> const & ) const = default;
#else
- VULKAN_HPP_CONSTEXPR bool operator<(Flags<BitType> const &rhs) const VULKAN_HPP_NOEXCEPT
- {
- return m_mask < rhs.m_mask;
- }
+ VULKAN_HPP_CONSTEXPR bool operator<( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return m_mask < rhs.m_mask;
+ }
- VULKAN_HPP_CONSTEXPR bool operator<=(Flags<BitType> const &rhs) const VULKAN_HPP_NOEXCEPT
- {
- return m_mask <= rhs.m_mask;
- }
+ VULKAN_HPP_CONSTEXPR bool operator<=( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return m_mask <= rhs.m_mask;
+ }
- VULKAN_HPP_CONSTEXPR bool operator>(Flags<BitType> const &rhs) const VULKAN_HPP_NOEXCEPT
- {
- return m_mask > rhs.m_mask;
- }
+ VULKAN_HPP_CONSTEXPR bool operator>( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return m_mask > rhs.m_mask;
+ }
- VULKAN_HPP_CONSTEXPR bool operator>=(Flags<BitType> const &rhs) const VULKAN_HPP_NOEXCEPT
- {
- return m_mask >= rhs.m_mask;
- }
+ VULKAN_HPP_CONSTEXPR bool operator>=( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return m_mask >= rhs.m_mask;
+ }
- VULKAN_HPP_CONSTEXPR bool operator==(Flags<BitType> const &rhs) const VULKAN_HPP_NOEXCEPT
- {
- return m_mask == rhs.m_mask;
- }
+ VULKAN_HPP_CONSTEXPR bool operator==( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return m_mask == rhs.m_mask;
+ }
- VULKAN_HPP_CONSTEXPR bool operator!=(Flags<BitType> const &rhs) const VULKAN_HPP_NOEXCEPT
- {
- return m_mask != rhs.m_mask;
- }
+ VULKAN_HPP_CONSTEXPR bool operator!=( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return m_mask != rhs.m_mask;
+ }
#endif
- // logical operator
- VULKAN_HPP_CONSTEXPR bool operator!() const VULKAN_HPP_NOEXCEPT
- {
- return !m_mask;
- }
+ // logical operator
+ VULKAN_HPP_CONSTEXPR bool operator!() const VULKAN_HPP_NOEXCEPT
+ {
+ return !m_mask;
+ }
- // bitwise operators
- VULKAN_HPP_CONSTEXPR Flags<BitType> operator&(Flags<BitType> const &rhs) const VULKAN_HPP_NOEXCEPT
- {
- return Flags<BitType>(m_mask & rhs.m_mask);
- }
+ // bitwise operators
+ VULKAN_HPP_CONSTEXPR Flags<BitType> operator&( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return Flags<BitType>( m_mask & rhs.m_mask );
+ }
- VULKAN_HPP_CONSTEXPR Flags<BitType> operator|(Flags<BitType> const &rhs) const VULKAN_HPP_NOEXCEPT
- {
- return Flags<BitType>(m_mask | rhs.m_mask);
- }
+ VULKAN_HPP_CONSTEXPR Flags<BitType> operator|( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return Flags<BitType>( m_mask | rhs.m_mask );
+ }
- VULKAN_HPP_CONSTEXPR Flags<BitType> operator^(Flags<BitType> const &rhs) const VULKAN_HPP_NOEXCEPT
- {
- return Flags<BitType>(m_mask ^ rhs.m_mask);
- }
+ VULKAN_HPP_CONSTEXPR Flags<BitType> operator^( Flags<BitType> const & rhs ) const VULKAN_HPP_NOEXCEPT
+ {
+ return Flags<BitType>( m_mask ^ rhs.m_mask );
+ }
- VULKAN_HPP_CONSTEXPR Flags<BitType> operator~() const VULKAN_HPP_NOEXCEPT
- {
- return Flags<BitType>(m_mask ^ FlagTraits<BitType>::allFlags);
- }
+ VULKAN_HPP_CONSTEXPR Flags<BitType> operator~() const VULKAN_HPP_NOEXCEPT
+ {
+ return Flags<BitType>( m_mask ^ FlagTraits<BitType>::allFlags );
+ }
- // assignment operators
- VULKAN_HPP_CONSTEXPR_14 Flags<BitType> &operator=(Flags<BitType> const &rhs) VULKAN_HPP_NOEXCEPT = default;
+ // assignment operators
+ VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT = default;
- VULKAN_HPP_CONSTEXPR_14 Flags<BitType> &operator|=(Flags<BitType> const &rhs) VULKAN_HPP_NOEXCEPT
- {
- m_mask |= rhs.m_mask;
- return *this;
- }
+ VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator|=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ m_mask |= rhs.m_mask;
+ return *this;
+ }
- VULKAN_HPP_CONSTEXPR_14 Flags<BitType> &operator&=(Flags<BitType> const &rhs) VULKAN_HPP_NOEXCEPT
- {
- m_mask &= rhs.m_mask;
- return *this;
- }
+ VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator&=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ m_mask &= rhs.m_mask;
+ return *this;
+ }
- VULKAN_HPP_CONSTEXPR_14 Flags<BitType> &operator^=(Flags<BitType> const &rhs) VULKAN_HPP_NOEXCEPT
- {
- m_mask ^= rhs.m_mask;
- return *this;
- }
+ VULKAN_HPP_CONSTEXPR_14 Flags<BitType> & operator^=( Flags<BitType> const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ m_mask ^= rhs.m_mask;
+ return *this;
+ }
- // cast operators
- explicit VULKAN_HPP_CONSTEXPR operator bool() const VULKAN_HPP_NOEXCEPT
- {
- return !!m_mask;
- }
+ // cast operators
+ explicit VULKAN_HPP_CONSTEXPR operator bool() const VULKAN_HPP_NOEXCEPT
+ {
+ return !!m_mask;
+ }
- explicit VULKAN_HPP_CONSTEXPR operator MaskType() const VULKAN_HPP_NOEXCEPT
- {
- return m_mask;
- }
+ explicit VULKAN_HPP_CONSTEXPR operator MaskType() const VULKAN_HPP_NOEXCEPT
+ {
+ return m_mask;
+ }
-#if defined(VULKAN_HPP_FLAGS_MASK_TYPE_AS_PUBLIC)
-public:
+#if defined( VULKAN_HPP_FLAGS_MASK_TYPE_AS_PUBLIC )
+ public:
#else
-private:
+ private:
#endif
- MaskType m_mask;
-};
+ MaskType m_mask;
+ };
-#if !defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR)
-// relational operators only needed for pre C++20
-template<typename BitType>
-VULKAN_HPP_CONSTEXPR bool operator<(BitType bit, Flags<BitType> const &flags) VULKAN_HPP_NOEXCEPT
-{
- return flags.operator>(bit);
-}
+#if !defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
+ // relational operators only needed for pre C++20
+ template <typename BitType>
+ VULKAN_HPP_CONSTEXPR bool operator<( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+ {
+ return flags.operator>( bit );
+ }
-template<typename BitType>
-VULKAN_HPP_CONSTEXPR bool operator<=(BitType bit, Flags<BitType> const &flags) VULKAN_HPP_NOEXCEPT
-{
- return flags.operator>=(bit);
-}
+ template <typename BitType>
+ VULKAN_HPP_CONSTEXPR bool operator<=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+ {
+ return flags.operator>=( bit );
+ }
-template<typename BitType>
-VULKAN_HPP_CONSTEXPR bool operator>(BitType bit, Flags<BitType> const &flags) VULKAN_HPP_NOEXCEPT
-{
- return flags.operator<(bit);
-}
+ template <typename BitType>
+ VULKAN_HPP_CONSTEXPR bool operator>( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+ {
+ return flags.operator<( bit );
+ }
-template<typename BitType>
-VULKAN_HPP_CONSTEXPR bool operator>=(BitType bit, Flags<BitType> const &flags) VULKAN_HPP_NOEXCEPT
-{
- return flags.operator<=(bit);
-}
+ template <typename BitType>
+ VULKAN_HPP_CONSTEXPR bool operator>=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+ {
+ return flags.operator<=( bit );
+ }
-template<typename BitType>
-VULKAN_HPP_CONSTEXPR bool operator==(BitType bit, Flags<BitType> const &flags) VULKAN_HPP_NOEXCEPT
-{
- return flags.operator==(bit);
-}
+ template <typename BitType>
+ VULKAN_HPP_CONSTEXPR bool operator==( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+ {
+ return flags.operator==( bit );
+ }
-template<typename BitType>
-VULKAN_HPP_CONSTEXPR bool operator!=(BitType bit, Flags<BitType> const &flags) VULKAN_HPP_NOEXCEPT
-{
- return flags.operator!=(bit);
-}
+ template <typename BitType>
+ VULKAN_HPP_CONSTEXPR bool operator!=( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+ {
+ return flags.operator!=( bit );
+ }
#endif
-// bitwise operators
-template<typename BitType>
-VULKAN_HPP_CONSTEXPR Flags<BitType> operator&(BitType bit, Flags<BitType> const &flags) VULKAN_HPP_NOEXCEPT
-{
- return flags.operator&(bit);
-}
+ // bitwise operators
+ template <typename BitType>
+ VULKAN_HPP_CONSTEXPR Flags<BitType> operator&( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+ {
+ return flags.operator&( bit );
+ }
-template<typename BitType>
-VULKAN_HPP_CONSTEXPR Flags<BitType> operator|(BitType bit, Flags<BitType> const &flags) VULKAN_HPP_NOEXCEPT
-{
- return flags.operator|(bit);
-}
+ template <typename BitType>
+ VULKAN_HPP_CONSTEXPR Flags<BitType> operator|( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+ {
+ return flags.operator|( bit );
+ }
-template<typename BitType>
-VULKAN_HPP_CONSTEXPR Flags<BitType> operator^(BitType bit, Flags<BitType> const &flags) VULKAN_HPP_NOEXCEPT
-{
- return flags.operator^(bit);
-}
+ template <typename BitType>
+ VULKAN_HPP_CONSTEXPR Flags<BitType> operator^( BitType bit, Flags<BitType> const & flags ) VULKAN_HPP_NOEXCEPT
+ {
+ return flags.operator^( bit );
+ }
-template<typename RefType>
-class Optional
-{
-public:
- Optional(RefType &reference) VULKAN_HPP_NOEXCEPT
- {
- m_ptr = &reference;
- }
- Optional(RefType *ptr) VULKAN_HPP_NOEXCEPT
- {
- m_ptr = ptr;
- }
- Optional(std::nullptr_t) VULKAN_HPP_NOEXCEPT
- {
- m_ptr = nullptr;
- }
+#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
+ template <typename T>
+ class ArrayProxy
+ {
+ public:
+ VULKAN_HPP_CONSTEXPR ArrayProxy() VULKAN_HPP_NOEXCEPT
+ : m_count( 0 )
+ , m_ptr( nullptr )
+ {
+ }
- operator RefType *() const VULKAN_HPP_NOEXCEPT
- {
- return m_ptr;
- }
- RefType const *operator->() const VULKAN_HPP_NOEXCEPT
- {
- return m_ptr;
- }
- explicit operator bool() const VULKAN_HPP_NOEXCEPT
- {
- return !!m_ptr;
- }
+ VULKAN_HPP_CONSTEXPR ArrayProxy( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
+ : m_count( 0 )
+ , m_ptr( nullptr )
+ {
+ }
-private:
- RefType *m_ptr;
-};
+ ArrayProxy( T & value ) VULKAN_HPP_NOEXCEPT
+ : m_count( 1 )
+ , m_ptr( &value )
+ {
+ }
-template<typename X, typename Y>
-struct StructExtends
-{
- enum
- {
- value = false
- };
-};
+ template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
+ ArrayProxy( typename std::remove_const<T>::type & value ) VULKAN_HPP_NOEXCEPT
+ : m_count( 1 )
+ , m_ptr( &value )
+ {
+ }
-template<typename Type, class...>
-struct IsPartOfStructureChain
-{
- static const bool valid = false;
-};
+ ArrayProxy( uint32_t count, T * ptr ) VULKAN_HPP_NOEXCEPT
+ : m_count( count )
+ , m_ptr( ptr )
+ {
+ }
-template<typename Type, typename Head, typename... Tail>
-struct IsPartOfStructureChain<Type, Head, Tail...>
-{
- static const bool valid = std::is_same<Type, Head>::value || IsPartOfStructureChain<Type, Tail...>::valid;
-};
+ template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
+ ArrayProxy( uint32_t count, typename std::remove_const<T>::type * ptr ) VULKAN_HPP_NOEXCEPT
+ : m_count( count )
+ , m_ptr( ptr )
+ {
+ }
-template<size_t Index, typename T, typename... ChainElements>
-struct StructureChainContains
-{
- static const bool value = std::is_same<T, typename std::tuple_element<Index, std::tuple<ChainElements...>>::type>::value ||
- StructureChainContains<Index - 1, T, ChainElements...>::value;
-};
+ template <std::size_t C>
+ ArrayProxy( T ( &ptr )[C] ) VULKAN_HPP_NOEXCEPT
+ : m_count( C )
+ , m_ptr( ptr )
+ {
+ }
-template<typename T, typename... ChainElements>
-struct StructureChainContains<0, T, ChainElements...>
-{
- static const bool value = std::is_same<T, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value;
-};
+ template <std::size_t C, typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
+ ArrayProxy( typename std::remove_const<T>::type ( &ptr )[C] ) VULKAN_HPP_NOEXCEPT
+ : m_count( C )
+ , m_ptr( ptr )
+ {
+ }
-template<size_t Index, typename... ChainElements>
-struct StructureChainValidation
-{
- using TestType = typename std::tuple_element<Index, std::tuple<ChainElements...>>::type;
- static const bool valid = StructExtends<TestType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value &&
- (TestType::allowDuplicate || !StructureChainContains<Index - 1, TestType, ChainElements...>::value) &&
- StructureChainValidation<Index - 1, ChainElements...>::valid;
-};
+# if __GNUC__ >= 9
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Winit-list-lifetime"
+# endif
-template<typename... ChainElements>
-struct StructureChainValidation<0, ChainElements...>
-{
- static const bool valid = true;
-};
+ ArrayProxy( std::initializer_list<T> const & list ) VULKAN_HPP_NOEXCEPT
+ : m_count( static_cast<uint32_t>( list.size() ) )
+ , m_ptr( list.begin() )
+ {
+ }
-template<typename... ChainElements>
-class StructureChain : public std::tuple<ChainElements...>
-{
-public:
- StructureChain() VULKAN_HPP_NOEXCEPT
- {
- static_assert(StructureChainValidation<sizeof...(ChainElements) - 1, ChainElements...>::valid, "The structure chain is not valid!");
- link<sizeof...(ChainElements) - 1>();
- }
+ template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
+ ArrayProxy( std::initializer_list<typename std::remove_const<T>::type> const & list ) VULKAN_HPP_NOEXCEPT
+ : m_count( static_cast<uint32_t>( list.size() ) )
+ , m_ptr( list.begin() )
+ {
+ }
- StructureChain(StructureChain const &rhs) VULKAN_HPP_NOEXCEPT : std::tuple<ChainElements...>(rhs)
- {
- static_assert(StructureChainValidation<sizeof...(ChainElements) - 1, ChainElements...>::valid, "The structure chain is not valid!");
- link(&std::get<0>(*this),
- &std::get<0>(rhs),
- reinterpret_cast<VkBaseOutStructure *>(&std::get<0>(*this)),
- reinterpret_cast<VkBaseInStructure const *>(&std::get<0>(rhs)));
- }
+ ArrayProxy( std::initializer_list<T> & list ) VULKAN_HPP_NOEXCEPT
+ : m_count( static_cast<uint32_t>( list.size() ) )
+ , m_ptr( list.begin() )
+ {
+ }
- StructureChain(StructureChain &&rhs) VULKAN_HPP_NOEXCEPT : std::tuple<ChainElements...>(std::forward<std::tuple<ChainElements...>>(rhs))
- {
- static_assert(StructureChainValidation<sizeof...(ChainElements) - 1, ChainElements...>::valid, "The structure chain is not valid!");
- link(&std::get<0>(*this),
- &std::get<0>(rhs),
- reinterpret_cast<VkBaseOutStructure *>(&std::get<0>(*this)),
- reinterpret_cast<VkBaseInStructure const *>(&std::get<0>(rhs)));
- }
+ template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
+ ArrayProxy( std::initializer_list<typename std::remove_const<T>::type> & list ) VULKAN_HPP_NOEXCEPT
+ : m_count( static_cast<uint32_t>( list.size() ) )
+ , m_ptr( list.begin() )
+ {
+ }
- StructureChain(ChainElements const &... elems) VULKAN_HPP_NOEXCEPT : std::tuple<ChainElements...>(elems...)
- {
- static_assert(StructureChainValidation<sizeof...(ChainElements) - 1, ChainElements...>::valid, "The structure chain is not valid!");
- link<sizeof...(ChainElements) - 1>();
- }
+# if __GNUC__ >= 9
+# pragma GCC diagnostic pop
+# endif
- StructureChain &operator=(StructureChain const &rhs) VULKAN_HPP_NOEXCEPT
- {
- std::tuple<ChainElements...>::operator=(rhs);
- link(&std::get<0>(*this),
- &std::get<0>(rhs),
- reinterpret_cast<VkBaseOutStructure *>(&std::get<0>(*this)),
- reinterpret_cast<VkBaseInStructure const *>(&std::get<0>(rhs)));
- return *this;
- }
+ // Any type with a .data() return type implicitly convertible to T*, and a .size() return type implicitly
+ // convertible to size_t. The const version can capture temporaries, with lifetime ending at end of statement.
+ template <typename V,
+ typename std::enable_if<std::is_convertible<decltype( std::declval<V>().data() ), T *>::value &&
+ std::is_convertible<decltype( std::declval<V>().size() ), std::size_t>::value>::type * = nullptr>
+ ArrayProxy( V const & v ) VULKAN_HPP_NOEXCEPT
+ : m_count( static_cast<uint32_t>( v.size() ) )
+ , m_ptr( v.data() )
+ {
+ }
- StructureChain &operator=(StructureChain &&rhs) = delete;
+ template <typename V,
+ typename std::enable_if<std::is_convertible<decltype( std::declval<V>().data() ), T *>::value &&
+ std::is_convertible<decltype( std::declval<V>().size() ), std::size_t>::value>::type * = nullptr>
+ ArrayProxy( V & v ) VULKAN_HPP_NOEXCEPT
+ : m_count( static_cast<uint32_t>( v.size() ) )
+ , m_ptr( v.data() )
+ {
+ }
- template<typename T = typename std::tuple_element<0, std::tuple<ChainElements...>>::type, size_t Which = 0>
- T &get() VULKAN_HPP_NOEXCEPT
- {
- return std::get<ChainElementIndex<0, T, Which, void, ChainElements...>::value>(static_cast<std::tuple<ChainElements...> &>(*this));
- }
+ const T * begin() const VULKAN_HPP_NOEXCEPT
+ {
+ return m_ptr;
+ }
- template<typename T = typename std::tuple_element<0, std::tuple<ChainElements...>>::type, size_t Which = 0>
- T const &get() const VULKAN_HPP_NOEXCEPT
- {
- return std::get<ChainElementIndex<0, T, Which, void, ChainElements...>::value>(static_cast<std::tuple<ChainElements...> const &>(*this));
- }
+ const T * end() const VULKAN_HPP_NOEXCEPT
+ {
+ return m_ptr + m_count;
+ }
- template<typename T0, typename T1, typename... Ts>
- std::tuple<T0 &, T1 &, Ts &...> get() VULKAN_HPP_NOEXCEPT
- {
- return std::tie(get<T0>(), get<T1>(), get<Ts>()...);
- }
+ const T & front() const VULKAN_HPP_NOEXCEPT
+ {
+ VULKAN_HPP_ASSERT( m_count && m_ptr );
+ return *m_ptr;
+ }
- template<typename T0, typename T1, typename... Ts>
- std::tuple<T0 const &, T1 const &, Ts const &...> get() const VULKAN_HPP_NOEXCEPT
- {
- return std::tie(get<T0>(), get<T1>(), get<Ts>()...);
- }
+ const T & back() const VULKAN_HPP_NOEXCEPT
+ {
+ VULKAN_HPP_ASSERT( m_count && m_ptr );
+ return *( m_ptr + m_count - 1 );
+ }
- template<typename ClassType, size_t Which = 0>
- typename std::enable_if<std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value && (Which == 0), bool>::type
- isLinked() const VULKAN_HPP_NOEXCEPT
- {
- return true;
- }
+ bool empty() const VULKAN_HPP_NOEXCEPT
+ {
+ return ( m_count == 0 );
+ }
- template<typename ClassType, size_t Which = 0>
- typename std::enable_if<!std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value || (Which != 0), bool>::type
- isLinked() const VULKAN_HPP_NOEXCEPT
- {
- static_assert(IsPartOfStructureChain<ClassType, ChainElements...>::valid, "Can't unlink Structure that's not part of this StructureChain!");
- return isLinked(reinterpret_cast<VkBaseInStructure const *>(&get<ClassType, Which>()));
- }
+ uint32_t size() const VULKAN_HPP_NOEXCEPT
+ {
+ return m_count;
+ }
- template<typename ClassType, size_t Which = 0>
- typename std::enable_if<!std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value || (Which != 0), void>::type
- relink() VULKAN_HPP_NOEXCEPT
- {
- static_assert(IsPartOfStructureChain<ClassType, ChainElements...>::valid, "Can't relink Structure that's not part of this StructureChain!");
- auto pNext = reinterpret_cast<VkBaseInStructure *>(&get<ClassType, Which>());
- VULKAN_HPP_ASSERT(!isLinked(pNext));
- auto &headElement = std::get<0>(static_cast<std::tuple<ChainElements...> &>(*this));
- pNext->pNext = reinterpret_cast<VkBaseInStructure const *>(headElement.pNext);
- headElement.pNext = pNext;
- }
+ T * data() const VULKAN_HPP_NOEXCEPT
+ {
+ return m_ptr;
+ }
- template<typename ClassType, size_t Which = 0>
- typename std::enable_if<!std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value || (Which != 0), void>::type
- unlink() VULKAN_HPP_NOEXCEPT
- {
- static_assert(IsPartOfStructureChain<ClassType, ChainElements...>::valid, "Can't unlink Structure that's not part of this StructureChain!");
- unlink(reinterpret_cast<VkBaseOutStructure const *>(&get<ClassType, Which>()));
- }
+ private:
+ uint32_t m_count;
+ T * m_ptr;
+ };
-private:
- template<int Index, typename T, int Which, typename, class First, class... Types>
- struct ChainElementIndex : ChainElementIndex<Index + 1, T, Which, void, Types...>
- {
- };
+ template <typename T>
+ class ArrayProxyNoTemporaries
+ {
+ public:
+ VULKAN_HPP_CONSTEXPR ArrayProxyNoTemporaries() VULKAN_HPP_NOEXCEPT
+ : m_count( 0 )
+ , m_ptr( nullptr )
+ {
+ }
- template<int Index, typename T, int Which, class First, class... Types>
- struct ChainElementIndex<Index, T, Which, typename std::enable_if<!std::is_same<T, First>::value, void>::type, First, Types...>
- : ChainElementIndex<Index + 1, T, Which, void, Types...>
- {
- };
+ VULKAN_HPP_CONSTEXPR ArrayProxyNoTemporaries( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
+ : m_count( 0 )
+ , m_ptr( nullptr )
+ {
+ }
- template<int Index, typename T, int Which, class First, class... Types>
- struct ChainElementIndex<Index, T, Which, typename std::enable_if<std::is_same<T, First>::value, void>::type, First, Types...>
- : ChainElementIndex<Index + 1, T, Which - 1, void, Types...>
- {
- };
+ ArrayProxyNoTemporaries( T & value ) VULKAN_HPP_NOEXCEPT
+ : m_count( 1 )
+ , m_ptr( &value )
+ {
+ }
- template<int Index, typename T, class First, class... Types>
- struct ChainElementIndex<Index, T, 0, typename std::enable_if<std::is_same<T, First>::value, void>::type, First, Types...>
- : std::integral_constant<int, Index>
- {
- };
+ template <typename V>
+ ArrayProxyNoTemporaries( V && value ) = delete;
- bool isLinked(VkBaseInStructure const *pNext) const VULKAN_HPP_NOEXCEPT
- {
- VkBaseInStructure const *elementPtr =
- reinterpret_cast<VkBaseInStructure const *>(&std::get<0>(static_cast<std::tuple<ChainElements...> const &>(*this)));
- while(elementPtr)
- {
- if(elementPtr->pNext == pNext)
- {
- return true;
- }
- elementPtr = elementPtr->pNext;
- }
- return false;
- }
+ template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
+ ArrayProxyNoTemporaries( typename std::remove_const<T>::type & value ) VULKAN_HPP_NOEXCEPT
+ : m_count( 1 )
+ , m_ptr( &value )
+ {
+ }
- template<size_t Index>
- typename std::enable_if<Index != 0, void>::type link() VULKAN_HPP_NOEXCEPT
- {
- auto &x = std::get<Index - 1>(static_cast<std::tuple<ChainElements...> &>(*this));
- x.pNext = &std::get<Index>(static_cast<std::tuple<ChainElements...> &>(*this));
- link<Index - 1>();
- }
+ template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
+ ArrayProxyNoTemporaries( typename std::remove_const<T>::type && value ) = delete;
- template<size_t Index>
- typename std::enable_if<Index == 0, void>::type link() VULKAN_HPP_NOEXCEPT
- {
- }
+ ArrayProxyNoTemporaries( uint32_t count, T * ptr ) VULKAN_HPP_NOEXCEPT
+ : m_count( count )
+ , m_ptr( ptr )
+ {
+ }
- void link(void *dstBase, void const *srcBase, VkBaseOutStructure *dst, VkBaseInStructure const *src)
- {
- while(src->pNext)
- {
- std::ptrdiff_t offset = reinterpret_cast<char const *>(src->pNext) - reinterpret_cast<char const *>(srcBase);
- dst->pNext = reinterpret_cast<VkBaseOutStructure *>(reinterpret_cast<char *>(dstBase) + offset);
- dst = dst->pNext;
- src = src->pNext;
- }
- dst->pNext = nullptr;
- }
+ template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
+ ArrayProxyNoTemporaries( uint32_t count, typename std::remove_const<T>::type * ptr ) VULKAN_HPP_NOEXCEPT
+ : m_count( count )
+ , m_ptr( ptr )
+ {
+ }
- void unlink(VkBaseOutStructure const *pNext) VULKAN_HPP_NOEXCEPT
- {
- VkBaseOutStructure *elementPtr = reinterpret_cast<VkBaseOutStructure *>(&std::get<0>(static_cast<std::tuple<ChainElements...> &>(*this)));
- while(elementPtr && (elementPtr->pNext != pNext))
- {
- elementPtr = elementPtr->pNext;
- }
- if(elementPtr)
- {
- elementPtr->pNext = pNext->pNext;
- }
- else
- {
- VULKAN_HPP_ASSERT(false); // fires, if the ClassType member has already been unlinked !
- }
- }
-};
+ template <std::size_t C>
+ ArrayProxyNoTemporaries( T ( &ptr )[C] ) VULKAN_HPP_NOEXCEPT
+ : m_count( C )
+ , m_ptr( ptr )
+ {
+ }
-#if !defined(VULKAN_HPP_NO_SMART_HANDLE)
-template<typename Type, typename Dispatch>
-class UniqueHandleTraits;
+ template <std::size_t C>
+ ArrayProxyNoTemporaries( T( &&ptr )[C] ) = delete;
-template<typename Type, typename Dispatch>
-class UniqueHandle : public UniqueHandleTraits<Type, Dispatch>::deleter
-{
-private:
- using Deleter = typename UniqueHandleTraits<Type, Dispatch>::deleter;
+ template <std::size_t C, typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
+ ArrayProxyNoTemporaries( typename std::remove_const<T>::type ( &ptr )[C] ) VULKAN_HPP_NOEXCEPT
+ : m_count( C )
+ , m_ptr( ptr )
+ {
+ }
-public:
- using element_type = Type;
+ template <std::size_t C, typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
+ ArrayProxyNoTemporaries( typename std::remove_const<T>::type( &&ptr )[C] ) = delete;
- UniqueHandle()
- : Deleter()
- , m_value()
- {}
+ ArrayProxyNoTemporaries( std::initializer_list<T> const & list ) VULKAN_HPP_NOEXCEPT
+ : m_count( static_cast<uint32_t>( list.size() ) )
+ , m_ptr( list.begin() )
+ {
+ }
- explicit UniqueHandle(Type const &value, Deleter const &deleter = Deleter()) VULKAN_HPP_NOEXCEPT
- : Deleter(deleter),
- m_value(value)
- {
- }
+ ArrayProxyNoTemporaries( std::initializer_list<T> const && list ) = delete;
- UniqueHandle(UniqueHandle const &) = delete;
+ template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
+ ArrayProxyNoTemporaries( std::initializer_list<typename std::remove_const<T>::type> const & list ) VULKAN_HPP_NOEXCEPT
+ : m_count( static_cast<uint32_t>( list.size() ) )
+ , m_ptr( list.begin() )
+ {
+ }
- UniqueHandle(UniqueHandle &&other) VULKAN_HPP_NOEXCEPT
- : Deleter(std::move(static_cast<Deleter &>(other))),
- m_value(other.release())
- {
- }
+ template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
+ ArrayProxyNoTemporaries( std::initializer_list<typename std::remove_const<T>::type> const && list ) = delete;
- ~UniqueHandle() VULKAN_HPP_NOEXCEPT
- {
- if(m_value)
- {
- this->destroy(m_value);
- }
- }
+ ArrayProxyNoTemporaries( std::initializer_list<T> & list ) VULKAN_HPP_NOEXCEPT
+ : m_count( static_cast<uint32_t>( list.size() ) )
+ , m_ptr( list.begin() )
+ {
+ }
- UniqueHandle &operator=(UniqueHandle const &) = delete;
+ ArrayProxyNoTemporaries( std::initializer_list<T> && list ) = delete;
- UniqueHandle &operator=(UniqueHandle &&other) VULKAN_HPP_NOEXCEPT
- {
- reset(other.release());
- *static_cast<Deleter *>(this) = std::move(static_cast<Deleter &>(other));
- return *this;
- }
+ template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
+ ArrayProxyNoTemporaries( std::initializer_list<typename std::remove_const<T>::type> & list ) VULKAN_HPP_NOEXCEPT
+ : m_count( static_cast<uint32_t>( list.size() ) )
+ , m_ptr( list.begin() )
+ {
+ }
- explicit operator bool() const VULKAN_HPP_NOEXCEPT
- {
- return m_value.operator bool();
- }
+ template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
+ ArrayProxyNoTemporaries( std::initializer_list<typename std::remove_const<T>::type> && list ) = delete;
- Type const *operator->() const VULKAN_HPP_NOEXCEPT
- {
- return &m_value;
- }
+ // Any type with a .data() return type implicitly convertible to T*, and a // .size() return type implicitly
+ // convertible to size_t.
+ template <typename V,
+ typename std::enable_if<std::is_convertible<decltype( std::declval<V>().data() ), T *>::value &&
+ std::is_convertible<decltype( std::declval<V>().size() ), std::size_t>::value>::type * = nullptr>
+ ArrayProxyNoTemporaries( V & v ) VULKAN_HPP_NOEXCEPT
+ : m_count( static_cast<uint32_t>( v.size() ) )
+ , m_ptr( v.data() )
+ {
+ }
- Type *operator->() VULKAN_HPP_NOEXCEPT
- {
- return &m_value;
- }
+ const T * begin() const VULKAN_HPP_NOEXCEPT
+ {
+ return m_ptr;
+ }
- Type const &operator*() const VULKAN_HPP_NOEXCEPT
- {
- return m_value;
- }
+ const T * end() const VULKAN_HPP_NOEXCEPT
+ {
+ return m_ptr + m_count;
+ }
- Type &operator*() VULKAN_HPP_NOEXCEPT
- {
- return m_value;
- }
+ const T & front() const VULKAN_HPP_NOEXCEPT
+ {
+ VULKAN_HPP_ASSERT( m_count && m_ptr );
+ return *m_ptr;
+ }
- const Type &get() const VULKAN_HPP_NOEXCEPT
- {
- return m_value;
- }
+ const T & back() const VULKAN_HPP_NOEXCEPT
+ {
+ VULKAN_HPP_ASSERT( m_count && m_ptr );
+ return *( m_ptr + m_count - 1 );
+ }
- Type &get() VULKAN_HPP_NOEXCEPT
- {
- return m_value;
- }
+ bool empty() const VULKAN_HPP_NOEXCEPT
+ {
+ return ( m_count == 0 );
+ }
- void reset(Type const &value = Type()) VULKAN_HPP_NOEXCEPT
- {
- if(m_value != value)
- {
- if(m_value)
- {
- this->destroy(m_value);
- }
- m_value = value;
- }
- }
+ uint32_t size() const VULKAN_HPP_NOEXCEPT
+ {
+ return m_count;
+ }
- Type release() VULKAN_HPP_NOEXCEPT
- {
- Type value = m_value;
- m_value = nullptr;
- return value;
- }
+ T * data() const VULKAN_HPP_NOEXCEPT
+ {
+ return m_ptr;
+ }
- void swap(UniqueHandle<Type, Dispatch> &rhs) VULKAN_HPP_NOEXCEPT
- {
- std::swap(m_value, rhs.m_value);
- std::swap(static_cast<Deleter &>(*this), static_cast<Deleter &>(rhs));
- }
+ private:
+ uint32_t m_count;
+ T * m_ptr;
+ };
-private:
- Type m_value;
-};
+ template <typename RefType>
+ class Optional
+ {
+ public:
+ Optional( RefType & reference ) VULKAN_HPP_NOEXCEPT
+ {
+ m_ptr = &reference;
+ }
+ Optional( RefType * ptr ) VULKAN_HPP_NOEXCEPT
+ {
+ m_ptr = ptr;
+ }
+ Optional( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
+ {
+ m_ptr = nullptr;
+ }
-template<typename UniqueType>
-VULKAN_HPP_INLINE std::vector<typename UniqueType::element_type> uniqueToRaw(std::vector<UniqueType> const &handles)
-{
- std::vector<typename UniqueType::element_type> newBuffer(handles.size());
- std::transform(handles.begin(), handles.end(), newBuffer.begin(), [](UniqueType const &handle) { return handle.get(); });
- return newBuffer;
-}
+ operator RefType *() const VULKAN_HPP_NOEXCEPT
+ {
+ return m_ptr;
+ }
+ RefType const * operator->() const VULKAN_HPP_NOEXCEPT
+ {
+ return m_ptr;
+ }
+ explicit operator bool() const VULKAN_HPP_NOEXCEPT
+ {
+ return !!m_ptr;
+ }
-template<typename Type, typename Dispatch>
-VULKAN_HPP_INLINE void swap(UniqueHandle<Type, Dispatch> &lhs, UniqueHandle<Type, Dispatch> &rhs) VULKAN_HPP_NOEXCEPT
-{
- lhs.swap(rhs);
-}
+ private:
+ RefType * m_ptr;
+ };
+
+ template <typename X, typename Y>
+ struct StructExtends
+ {
+ enum
+ {
+ value = false
+ };
+ };
+
+ template <typename Type, class...>
+ struct IsPartOfStructureChain
+ {
+ static const bool valid = false;
+ };
+
+ template <typename Type, typename Head, typename... Tail>
+ struct IsPartOfStructureChain<Type, Head, Tail...>
+ {
+ static const bool valid = std::is_same<Type, Head>::value || IsPartOfStructureChain<Type, Tail...>::valid;
+ };
+
+ template <size_t Index, typename T, typename... ChainElements>
+ struct StructureChainContains
+ {
+ static const bool value = std::is_same<T, typename std::tuple_element<Index, std::tuple<ChainElements...>>::type>::value ||
+ StructureChainContains<Index - 1, T, ChainElements...>::value;
+ };
+
+ template <typename T, typename... ChainElements>
+ struct StructureChainContains<0, T, ChainElements...>
+ {
+ static const bool value = std::is_same<T, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value;
+ };
+
+ template <size_t Index, typename... ChainElements>
+ struct StructureChainValidation
+ {
+ using TestType = typename std::tuple_element<Index, std::tuple<ChainElements...>>::type;
+ static const bool valid = StructExtends<TestType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value &&
+ ( TestType::allowDuplicate || !StructureChainContains<Index - 1, TestType, ChainElements...>::value ) &&
+ StructureChainValidation<Index - 1, ChainElements...>::valid;
+ };
+
+ template <typename... ChainElements>
+ struct StructureChainValidation<0, ChainElements...>
+ {
+ static const bool valid = true;
+ };
+
+ template <typename... ChainElements>
+ class StructureChain : public std::tuple<ChainElements...>
+ {
+ public:
+ StructureChain() VULKAN_HPP_NOEXCEPT
+ {
+ static_assert( StructureChainValidation<sizeof...( ChainElements ) - 1, ChainElements...>::valid, "The structure chain is not valid!" );
+ link<sizeof...( ChainElements ) - 1>();
+ }
+
+ StructureChain( StructureChain const & rhs ) VULKAN_HPP_NOEXCEPT : std::tuple<ChainElements...>( rhs )
+ {
+ static_assert( StructureChainValidation<sizeof...( ChainElements ) - 1, ChainElements...>::valid, "The structure chain is not valid!" );
+ link( &std::get<0>( *this ),
+ &std::get<0>( rhs ),
+ reinterpret_cast<VkBaseOutStructure *>( &std::get<0>( *this ) ),
+ reinterpret_cast<VkBaseInStructure const *>( &std::get<0>( rhs ) ) );
+ }
+
+ StructureChain( StructureChain && rhs ) VULKAN_HPP_NOEXCEPT : std::tuple<ChainElements...>( std::forward<std::tuple<ChainElements...>>( rhs ) )
+ {
+ static_assert( StructureChainValidation<sizeof...( ChainElements ) - 1, ChainElements...>::valid, "The structure chain is not valid!" );
+ link( &std::get<0>( *this ),
+ &std::get<0>( rhs ),
+ reinterpret_cast<VkBaseOutStructure *>( &std::get<0>( *this ) ),
+ reinterpret_cast<VkBaseInStructure const *>( &std::get<0>( rhs ) ) );
+ }
+
+ StructureChain( ChainElements const &... elems ) VULKAN_HPP_NOEXCEPT : std::tuple<ChainElements...>( elems... )
+ {
+ static_assert( StructureChainValidation<sizeof...( ChainElements ) - 1, ChainElements...>::valid, "The structure chain is not valid!" );
+ link<sizeof...( ChainElements ) - 1>();
+ }
+
+ StructureChain & operator=( StructureChain const & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ std::tuple<ChainElements...>::operator=( rhs );
+ link( &std::get<0>( *this ),
+ &std::get<0>( rhs ),
+ reinterpret_cast<VkBaseOutStructure *>( &std::get<0>( *this ) ),
+ reinterpret_cast<VkBaseInStructure const *>( &std::get<0>( rhs ) ) );
+ return *this;
+ }
+
+ StructureChain & operator=( StructureChain && rhs ) = delete;
+
+ template <typename T = typename std::tuple_element<0, std::tuple<ChainElements...>>::type, size_t Which = 0>
+ T & get() VULKAN_HPP_NOEXCEPT
+ {
+ return std::get<ChainElementIndex<0, T, Which, void, ChainElements...>::value>( static_cast<std::tuple<ChainElements...> &>( *this ) );
+ }
+
+ template <typename T = typename std::tuple_element<0, std::tuple<ChainElements...>>::type, size_t Which = 0>
+ T const & get() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::get<ChainElementIndex<0, T, Which, void, ChainElements...>::value>( static_cast<std::tuple<ChainElements...> const &>( *this ) );
+ }
+
+ template <typename T0, typename T1, typename... Ts>
+ std::tuple<T0 &, T1 &, Ts &...> get() VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( get<T0>(), get<T1>(), get<Ts>()... );
+ }
+
+ template <typename T0, typename T1, typename... Ts>
+ std::tuple<T0 const &, T1 const &, Ts const &...> get() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::tie( get<T0>(), get<T1>(), get<Ts>()... );
+ }
+
+ template <typename ClassType, size_t Which = 0>
+ typename std::enable_if<std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value && ( Which == 0 ), bool>::type
+ isLinked() const VULKAN_HPP_NOEXCEPT
+ {
+ return true;
+ }
+
+ template <typename ClassType, size_t Which = 0>
+ typename std::enable_if<!std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value || ( Which != 0 ), bool>::type
+ isLinked() const VULKAN_HPP_NOEXCEPT
+ {
+ static_assert( IsPartOfStructureChain<ClassType, ChainElements...>::valid, "Can't unlink Structure that's not part of this StructureChain!" );
+ return isLinked( reinterpret_cast<VkBaseInStructure const *>( &get<ClassType, Which>() ) );
+ }
+
+ template <typename ClassType, size_t Which = 0>
+ typename std::enable_if<!std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value || ( Which != 0 ), void>::type
+ relink() VULKAN_HPP_NOEXCEPT
+ {
+ static_assert( IsPartOfStructureChain<ClassType, ChainElements...>::valid, "Can't relink Structure that's not part of this StructureChain!" );
+ auto pNext = reinterpret_cast<VkBaseInStructure *>( &get<ClassType, Which>() );
+ VULKAN_HPP_ASSERT( !isLinked( pNext ) );
+ auto & headElement = std::get<0>( static_cast<std::tuple<ChainElements...> &>( *this ) );
+ pNext->pNext = reinterpret_cast<VkBaseInStructure const *>( headElement.pNext );
+ headElement.pNext = pNext;
+ }
+
+ template <typename ClassType, size_t Which = 0>
+ typename std::enable_if<!std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value || ( Which != 0 ), void>::type
+ unlink() VULKAN_HPP_NOEXCEPT
+ {
+ static_assert( IsPartOfStructureChain<ClassType, ChainElements...>::valid, "Can't unlink Structure that's not part of this StructureChain!" );
+ unlink( reinterpret_cast<VkBaseOutStructure const *>( &get<ClassType, Which>() ) );
+ }
+
+ private:
+ template <int Index, typename T, int Which, typename, class First, class... Types>
+ struct ChainElementIndex : ChainElementIndex<Index + 1, T, Which, void, Types...>
+ {
+ };
+
+ template <int Index, typename T, int Which, class First, class... Types>
+ struct ChainElementIndex<Index, T, Which, typename std::enable_if<!std::is_same<T, First>::value, void>::type, First, Types...>
+ : ChainElementIndex<Index + 1, T, Which, void, Types...>
+ {
+ };
+
+ template <int Index, typename T, int Which, class First, class... Types>
+ struct ChainElementIndex<Index, T, Which, typename std::enable_if<std::is_same<T, First>::value, void>::type, First, Types...>
+ : ChainElementIndex<Index + 1, T, Which - 1, void, Types...>
+ {
+ };
+
+ template <int Index, typename T, class First, class... Types>
+ struct ChainElementIndex<Index, T, 0, typename std::enable_if<std::is_same<T, First>::value, void>::type, First, Types...>
+ : std::integral_constant<int, Index>
+ {
+ };
+
+ bool isLinked( VkBaseInStructure const * pNext ) const VULKAN_HPP_NOEXCEPT
+ {
+ VkBaseInStructure const * elementPtr =
+ reinterpret_cast<VkBaseInStructure const *>( &std::get<0>( static_cast<std::tuple<ChainElements...> const &>( *this ) ) );
+ while ( elementPtr )
+ {
+ if ( elementPtr->pNext == pNext )
+ {
+ return true;
+ }
+ elementPtr = elementPtr->pNext;
+ }
+ return false;
+ }
+
+ template <size_t Index>
+ typename std::enable_if<Index != 0, void>::type link() VULKAN_HPP_NOEXCEPT
+ {
+ auto & x = std::get<Index - 1>( static_cast<std::tuple<ChainElements...> &>( *this ) );
+ x.pNext = &std::get<Index>( static_cast<std::tuple<ChainElements...> &>( *this ) );
+ link<Index - 1>();
+ }
+
+ template <size_t Index>
+ typename std::enable_if<Index == 0, void>::type link() VULKAN_HPP_NOEXCEPT
+ {
+ }
+
+ void link( void * dstBase, void const * srcBase, VkBaseOutStructure * dst, VkBaseInStructure const * src )
+ {
+ while ( src->pNext )
+ {
+ std::ptrdiff_t offset = reinterpret_cast<char const *>( src->pNext ) - reinterpret_cast<char const *>( srcBase );
+ dst->pNext = reinterpret_cast<VkBaseOutStructure *>( reinterpret_cast<char *>( dstBase ) + offset );
+ dst = dst->pNext;
+ src = src->pNext;
+ }
+ dst->pNext = nullptr;
+ }
+
+ void unlink( VkBaseOutStructure const * pNext ) VULKAN_HPP_NOEXCEPT
+ {
+ VkBaseOutStructure * elementPtr = reinterpret_cast<VkBaseOutStructure *>( &std::get<0>( static_cast<std::tuple<ChainElements...> &>( *this ) ) );
+ while ( elementPtr && ( elementPtr->pNext != pNext ) )
+ {
+ elementPtr = elementPtr->pNext;
+ }
+ if ( elementPtr )
+ {
+ elementPtr->pNext = pNext->pNext;
+ }
+ else
+ {
+ VULKAN_HPP_ASSERT( false ); // fires, if the ClassType member has already been unlinked !
+ }
+ }
+ };
+
+# if !defined( VULKAN_HPP_NO_SMART_HANDLE )
+ template <typename Type, typename Dispatch>
+ class UniqueHandleTraits;
+
+ template <typename Type, typename Dispatch>
+ class UniqueHandle : public UniqueHandleTraits<Type, Dispatch>::deleter
+ {
+ private:
+ using Deleter = typename UniqueHandleTraits<Type, Dispatch>::deleter;
+
+ public:
+ using element_type = Type;
+
+ UniqueHandle() : Deleter(), m_value() {}
+
+ explicit UniqueHandle( Type const & value, Deleter const & deleter = Deleter() ) VULKAN_HPP_NOEXCEPT
+ : Deleter( deleter )
+ , m_value( value )
+ {
+ }
+
+ UniqueHandle( UniqueHandle const & ) = delete;
+
+ UniqueHandle( UniqueHandle && other ) VULKAN_HPP_NOEXCEPT
+ : Deleter( std::move( static_cast<Deleter &>( other ) ) )
+ , m_value( other.release() )
+ {
+ }
+
+ ~UniqueHandle() VULKAN_HPP_NOEXCEPT
+ {
+ if ( m_value )
+ {
+ this->destroy( m_value );
+ }
+ }
+
+ UniqueHandle & operator=( UniqueHandle const & ) = delete;
+
+ UniqueHandle & operator=( UniqueHandle && other ) VULKAN_HPP_NOEXCEPT
+ {
+ reset( other.release() );
+ *static_cast<Deleter *>( this ) = std::move( static_cast<Deleter &>( other ) );
+ return *this;
+ }
+
+ explicit operator bool() const VULKAN_HPP_NOEXCEPT
+ {
+ return m_value.operator bool();
+ }
+
+ Type const * operator->() const VULKAN_HPP_NOEXCEPT
+ {
+ return &m_value;
+ }
+
+ Type * operator->() VULKAN_HPP_NOEXCEPT
+ {
+ return &m_value;
+ }
+
+ Type const & operator*() const VULKAN_HPP_NOEXCEPT
+ {
+ return m_value;
+ }
+
+ Type & operator*() VULKAN_HPP_NOEXCEPT
+ {
+ return m_value;
+ }
+
+ const Type & get() const VULKAN_HPP_NOEXCEPT
+ {
+ return m_value;
+ }
+
+ Type & get() VULKAN_HPP_NOEXCEPT
+ {
+ return m_value;
+ }
+
+ void reset( Type const & value = Type() ) VULKAN_HPP_NOEXCEPT
+ {
+ if ( m_value != value )
+ {
+ if ( m_value )
+ {
+ this->destroy( m_value );
+ }
+ m_value = value;
+ }
+ }
+
+ Type release() VULKAN_HPP_NOEXCEPT
+ {
+ Type value = m_value;
+ m_value = nullptr;
+ return value;
+ }
+
+ void swap( UniqueHandle<Type, Dispatch> & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ std::swap( m_value, rhs.m_value );
+ std::swap( static_cast<Deleter &>( *this ), static_cast<Deleter &>( rhs ) );
+ }
+
+ private:
+ Type m_value;
+ };
+
+ template <typename UniqueType>
+ VULKAN_HPP_INLINE std::vector<typename UniqueType::element_type> uniqueToRaw( std::vector<UniqueType> const & handles )
+ {
+ std::vector<typename UniqueType::element_type> newBuffer( handles.size() );
+ std::transform( handles.begin(), handles.end(), newBuffer.begin(), []( UniqueType const & handle ) { return handle.get(); } );
+ return newBuffer;
+ }
+
+ template <typename Type, typename Dispatch>
+ VULKAN_HPP_INLINE void swap( UniqueHandle<Type, Dispatch> & lhs, UniqueHandle<Type, Dispatch> & rhs ) VULKAN_HPP_NOEXCEPT
+ {
+ lhs.swap( rhs );
+ }
+# endif
+#endif // VULKAN_HPP_DISABLE_ENHANCED_MODE
+
+ class DispatchLoaderBase
+ {
+ public:
+ DispatchLoaderBase() = default;
+ DispatchLoaderBase( std::nullptr_t )
+#if !defined( NDEBUG )
+ : m_valid( false )
+#endif
+ {
+ }
+
+#if !defined( NDEBUG )
+ size_t getVkHeaderVersion() const
+ {
+ VULKAN_HPP_ASSERT( m_valid );
+ return vkHeaderVersion;
+ }
+
+ private:
+ size_t vkHeaderVersion = VK_HEADER_VERSION;
+ bool m_valid = true;
+#endif
+ };
+
+#if !defined( VK_NO_PROTOTYPES )
+ class DispatchLoaderStatic : public DispatchLoaderBase
+ {
+ public:
+ //=== VK_VERSION_1_0 ===
+
+ VkResult
+ vkCreateInstance( const VkInstanceCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkInstance * pInstance ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateInstance( pCreateInfo, pAllocator, pInstance );
+ }
+
+ void vkDestroyInstance( VkInstance instance, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDestroyInstance( instance, pAllocator );
+ }
+
+ VkResult vkEnumeratePhysicalDevices( VkInstance instance, uint32_t * pPhysicalDeviceCount, VkPhysicalDevice * pPhysicalDevices ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkEnumeratePhysicalDevices( instance, pPhysicalDeviceCount, pPhysicalDevices );
+ }
+
+ void vkGetPhysicalDeviceFeatures( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures * pFeatures ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceFeatures( physicalDevice, pFeatures );
+ }
+
+ void
+ vkGetPhysicalDeviceFormatProperties( VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties * pFormatProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceFormatProperties( physicalDevice, format, pFormatProperties );
+ }
+
+ VkResult vkGetPhysicalDeviceImageFormatProperties( VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkImageType type,
+ VkImageTiling tiling,
+ VkImageUsageFlags usage,
+ VkImageCreateFlags flags,
+ VkImageFormatProperties * pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceImageFormatProperties( physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties );
+ }
+
+ void vkGetPhysicalDeviceProperties( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceProperties( physicalDevice, pProperties );
+ }
+
+ void vkGetPhysicalDeviceQueueFamilyProperties( VkPhysicalDevice physicalDevice,
+ uint32_t * pQueueFamilyPropertyCount,
+ VkQueueFamilyProperties * pQueueFamilyProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceQueueFamilyProperties( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties );
+ }
+
+ void vkGetPhysicalDeviceMemoryProperties( VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties * pMemoryProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceMemoryProperties( physicalDevice, pMemoryProperties );
+ }
+
+ PFN_vkVoidFunction vkGetInstanceProcAddr( VkInstance instance, const char * pName ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetInstanceProcAddr( instance, pName );
+ }
+
+ PFN_vkVoidFunction vkGetDeviceProcAddr( VkDevice device, const char * pName ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetDeviceProcAddr( device, pName );
+ }
+
+ VkResult vkCreateDevice( VkPhysicalDevice physicalDevice,
+ const VkDeviceCreateInfo * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkDevice * pDevice ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateDevice( physicalDevice, pCreateInfo, pAllocator, pDevice );
+ }
+
+ void vkDestroyDevice( VkDevice device, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDestroyDevice( device, pAllocator );
+ }
+
+ VkResult vkEnumerateInstanceExtensionProperties( const char * pLayerName,
+ uint32_t * pPropertyCount,
+ VkExtensionProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkEnumerateInstanceExtensionProperties( pLayerName, pPropertyCount, pProperties );
+ }
+
+ VkResult vkEnumerateDeviceExtensionProperties( VkPhysicalDevice physicalDevice,
+ const char * pLayerName,
+ uint32_t * pPropertyCount,
+ VkExtensionProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkEnumerateDeviceExtensionProperties( physicalDevice, pLayerName, pPropertyCount, pProperties );
+ }
+
+ VkResult vkEnumerateInstanceLayerProperties( uint32_t * pPropertyCount, VkLayerProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkEnumerateInstanceLayerProperties( pPropertyCount, pProperties );
+ }
+
+ VkResult
+ vkEnumerateDeviceLayerProperties( VkPhysicalDevice physicalDevice, uint32_t * pPropertyCount, VkLayerProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkEnumerateDeviceLayerProperties( physicalDevice, pPropertyCount, pProperties );
+ }
+
+ void vkGetDeviceQueue( VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue * pQueue ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetDeviceQueue( device, queueFamilyIndex, queueIndex, pQueue );
+ }
+
+ VkResult vkQueueSubmit( VkQueue queue, uint32_t submitCount, const VkSubmitInfo * pSubmits, VkFence fence ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkQueueSubmit( queue, submitCount, pSubmits, fence );
+ }
+
+ VkResult vkQueueWaitIdle( VkQueue queue ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkQueueWaitIdle( queue );
+ }
+
+ VkResult vkDeviceWaitIdle( VkDevice device ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDeviceWaitIdle( device );
+ }
+
+ VkResult vkAllocateMemory( VkDevice device,
+ const VkMemoryAllocateInfo * pAllocateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkDeviceMemory * pMemory ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkAllocateMemory( device, pAllocateInfo, pAllocator, pMemory );
+ }
+
+ void vkFreeMemory( VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkFreeMemory( device, memory, pAllocator );
+ }
+
+ VkResult vkMapMemory( VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void ** ppData ) const
+ VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkMapMemory( device, memory, offset, size, flags, ppData );
+ }
+
+ void vkUnmapMemory( VkDevice device, VkDeviceMemory memory ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkUnmapMemory( device, memory );
+ }
+
+ VkResult vkFlushMappedMemoryRanges( VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange * pMemoryRanges ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkFlushMappedMemoryRanges( device, memoryRangeCount, pMemoryRanges );
+ }
+
+ VkResult vkInvalidateMappedMemoryRanges( VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange * pMemoryRanges ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkInvalidateMappedMemoryRanges( device, memoryRangeCount, pMemoryRanges );
+ }
+
+ void vkGetDeviceMemoryCommitment( VkDevice device, VkDeviceMemory memory, VkDeviceSize * pCommittedMemoryInBytes ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetDeviceMemoryCommitment( device, memory, pCommittedMemoryInBytes );
+ }
+
+ VkResult vkBindBufferMemory( VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkBindBufferMemory( device, buffer, memory, memoryOffset );
+ }
+
+ VkResult vkBindImageMemory( VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkBindImageMemory( device, image, memory, memoryOffset );
+ }
+
+ void vkGetBufferMemoryRequirements( VkDevice device, VkBuffer buffer, VkMemoryRequirements * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetBufferMemoryRequirements( device, buffer, pMemoryRequirements );
+ }
+
+ void vkGetImageMemoryRequirements( VkDevice device, VkImage image, VkMemoryRequirements * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetImageMemoryRequirements( device, image, pMemoryRequirements );
+ }
+
+ void vkGetImageSparseMemoryRequirements( VkDevice device,
+ VkImage image,
+ uint32_t * pSparseMemoryRequirementCount,
+ VkSparseImageMemoryRequirements * pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetImageSparseMemoryRequirements( device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
+ }
+
+ void vkGetPhysicalDeviceSparseImageFormatProperties( VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkImageType type,
+ VkSampleCountFlagBits samples,
+ VkImageUsageFlags usage,
+ VkImageTiling tiling,
+ uint32_t * pPropertyCount,
+ VkSparseImageFormatProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceSparseImageFormatProperties( physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties );
+ }
+
+ VkResult vkQueueBindSparse( VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo * pBindInfo, VkFence fence ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkQueueBindSparse( queue, bindInfoCount, pBindInfo, fence );
+ }
+
+ VkResult vkCreateFence( VkDevice device,
+ const VkFenceCreateInfo * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkFence * pFence ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateFence( device, pCreateInfo, pAllocator, pFence );
+ }
+
+ void vkDestroyFence( VkDevice device, VkFence fence, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDestroyFence( device, fence, pAllocator );
+ }
+
+ VkResult vkResetFences( VkDevice device, uint32_t fenceCount, const VkFence * pFences ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkResetFences( device, fenceCount, pFences );
+ }
+
+ VkResult vkGetFenceStatus( VkDevice device, VkFence fence ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetFenceStatus( device, fence );
+ }
+
+ VkResult vkWaitForFences( VkDevice device, uint32_t fenceCount, const VkFence * pFences, VkBool32 waitAll, uint64_t timeout ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkWaitForFences( device, fenceCount, pFences, waitAll, timeout );
+ }
+
+ VkResult vkCreateSemaphore( VkDevice device,
+ const VkSemaphoreCreateInfo * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkSemaphore * pSemaphore ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateSemaphore( device, pCreateInfo, pAllocator, pSemaphore );
+ }
+
+ void vkDestroySemaphore( VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDestroySemaphore( device, semaphore, pAllocator );
+ }
+
+ VkResult vkCreateEvent( VkDevice device,
+ const VkEventCreateInfo * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkEvent * pEvent ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateEvent( device, pCreateInfo, pAllocator, pEvent );
+ }
+
+ void vkDestroyEvent( VkDevice device, VkEvent event, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDestroyEvent( device, event, pAllocator );
+ }
+
+ VkResult vkGetEventStatus( VkDevice device, VkEvent event ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetEventStatus( device, event );
+ }
+
+ VkResult vkSetEvent( VkDevice device, VkEvent event ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkSetEvent( device, event );
+ }
+
+ VkResult vkResetEvent( VkDevice device, VkEvent event ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkResetEvent( device, event );
+ }
+
+ VkResult vkCreateQueryPool( VkDevice device,
+ const VkQueryPoolCreateInfo * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkQueryPool * pQueryPool ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateQueryPool( device, pCreateInfo, pAllocator, pQueryPool );
+ }
+
+ void vkDestroyQueryPool( VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDestroyQueryPool( device, queryPool, pAllocator );
+ }
+
+ VkResult vkGetQueryPoolResults( VkDevice device,
+ VkQueryPool queryPool,
+ uint32_t firstQuery,
+ uint32_t queryCount,
+ size_t dataSize,
+ void * pData,
+ VkDeviceSize stride,
+ VkQueryResultFlags flags ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetQueryPoolResults( device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags );
+ }
+
+ VkResult vkCreateBuffer( VkDevice device,
+ const VkBufferCreateInfo * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkBuffer * pBuffer ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateBuffer( device, pCreateInfo, pAllocator, pBuffer );
+ }
+
+ void vkDestroyBuffer( VkDevice device, VkBuffer buffer, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDestroyBuffer( device, buffer, pAllocator );
+ }
+
+ VkResult vkCreateBufferView( VkDevice device,
+ const VkBufferViewCreateInfo * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkBufferView * pView ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateBufferView( device, pCreateInfo, pAllocator, pView );
+ }
+
+ void vkDestroyBufferView( VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDestroyBufferView( device, bufferView, pAllocator );
+ }
+
+ VkResult vkCreateImage( VkDevice device,
+ const VkImageCreateInfo * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkImage * pImage ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateImage( device, pCreateInfo, pAllocator, pImage );
+ }
+
+ void vkDestroyImage( VkDevice device, VkImage image, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDestroyImage( device, image, pAllocator );
+ }
+
+ void vkGetImageSubresourceLayout( VkDevice device,
+ VkImage image,
+ const VkImageSubresource * pSubresource,
+ VkSubresourceLayout * pLayout ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetImageSubresourceLayout( device, image, pSubresource, pLayout );
+ }
+
+ VkResult vkCreateImageView( VkDevice device,
+ const VkImageViewCreateInfo * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkImageView * pView ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateImageView( device, pCreateInfo, pAllocator, pView );
+ }
+
+ void vkDestroyImageView( VkDevice device, VkImageView imageView, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDestroyImageView( device, imageView, pAllocator );
+ }
+
+ VkResult vkCreateShaderModule( VkDevice device,
+ const VkShaderModuleCreateInfo * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkShaderModule * pShaderModule ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateShaderModule( device, pCreateInfo, pAllocator, pShaderModule );
+ }
+
+ void vkDestroyShaderModule( VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDestroyShaderModule( device, shaderModule, pAllocator );
+ }
+
+ VkResult vkCreatePipelineCache( VkDevice device,
+ const VkPipelineCacheCreateInfo * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkPipelineCache * pPipelineCache ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreatePipelineCache( device, pCreateInfo, pAllocator, pPipelineCache );
+ }
+
+ void vkDestroyPipelineCache( VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDestroyPipelineCache( device, pipelineCache, pAllocator );
+ }
+
+ VkResult vkGetPipelineCacheData( VkDevice device, VkPipelineCache pipelineCache, size_t * pDataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPipelineCacheData( device, pipelineCache, pDataSize, pData );
+ }
+
+ VkResult
+ vkMergePipelineCaches( VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache * pSrcCaches ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkMergePipelineCaches( device, dstCache, srcCacheCount, pSrcCaches );
+ }
+
+ VkResult vkCreateGraphicsPipelines( VkDevice device,
+ VkPipelineCache pipelineCache,
+ uint32_t createInfoCount,
+ const VkGraphicsPipelineCreateInfo * pCreateInfos,
+ const VkAllocationCallbacks * pAllocator,
+ VkPipeline * pPipelines ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateGraphicsPipelines( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
+ }
+
+ VkResult vkCreateComputePipelines( VkDevice device,
+ VkPipelineCache pipelineCache,
+ uint32_t createInfoCount,
+ const VkComputePipelineCreateInfo * pCreateInfos,
+ const VkAllocationCallbacks * pAllocator,
+ VkPipeline * pPipelines ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateComputePipelines( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
+ }
+
+ void vkDestroyPipeline( VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDestroyPipeline( device, pipeline, pAllocator );
+ }
+
+ VkResult vkCreatePipelineLayout( VkDevice device,
+ const VkPipelineLayoutCreateInfo * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkPipelineLayout * pPipelineLayout ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreatePipelineLayout( device, pCreateInfo, pAllocator, pPipelineLayout );
+ }
+
+ void vkDestroyPipelineLayout( VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDestroyPipelineLayout( device, pipelineLayout, pAllocator );
+ }
+
+ VkResult vkCreateSampler( VkDevice device,
+ const VkSamplerCreateInfo * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkSampler * pSampler ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateSampler( device, pCreateInfo, pAllocator, pSampler );
+ }
+
+ void vkDestroySampler( VkDevice device, VkSampler sampler, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDestroySampler( device, sampler, pAllocator );
+ }
+
+ VkResult vkCreateDescriptorSetLayout( VkDevice device,
+ const VkDescriptorSetLayoutCreateInfo * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkDescriptorSetLayout * pSetLayout ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateDescriptorSetLayout( device, pCreateInfo, pAllocator, pSetLayout );
+ }
+
+ void vkDestroyDescriptorSetLayout( VkDevice device,
+ VkDescriptorSetLayout descriptorSetLayout,
+ const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDestroyDescriptorSetLayout( device, descriptorSetLayout, pAllocator );
+ }
+
+ VkResult vkCreateDescriptorPool( VkDevice device,
+ const VkDescriptorPoolCreateInfo * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkDescriptorPool * pDescriptorPool ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateDescriptorPool( device, pCreateInfo, pAllocator, pDescriptorPool );
+ }
+
+ void vkDestroyDescriptorPool( VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDestroyDescriptorPool( device, descriptorPool, pAllocator );
+ }
+
+ VkResult vkResetDescriptorPool( VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkResetDescriptorPool( device, descriptorPool, flags );
+ }
+
+ VkResult vkAllocateDescriptorSets( VkDevice device,
+ const VkDescriptorSetAllocateInfo * pAllocateInfo,
+ VkDescriptorSet * pDescriptorSets ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkAllocateDescriptorSets( device, pAllocateInfo, pDescriptorSets );
+ }
+
+ VkResult vkFreeDescriptorSets( VkDevice device,
+ VkDescriptorPool descriptorPool,
+ uint32_t descriptorSetCount,
+ const VkDescriptorSet * pDescriptorSets ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkFreeDescriptorSets( device, descriptorPool, descriptorSetCount, pDescriptorSets );
+ }
+
+ void vkUpdateDescriptorSets( VkDevice device,
+ uint32_t descriptorWriteCount,
+ const VkWriteDescriptorSet * pDescriptorWrites,
+ uint32_t descriptorCopyCount,
+ const VkCopyDescriptorSet * pDescriptorCopies ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkUpdateDescriptorSets( device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies );
+ }
+
+ VkResult vkCreateFramebuffer( VkDevice device,
+ const VkFramebufferCreateInfo * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkFramebuffer * pFramebuffer ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateFramebuffer( device, pCreateInfo, pAllocator, pFramebuffer );
+ }
+
+ void vkDestroyFramebuffer( VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDestroyFramebuffer( device, framebuffer, pAllocator );
+ }
+
+ VkResult vkCreateRenderPass( VkDevice device,
+ const VkRenderPassCreateInfo * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkRenderPass * pRenderPass ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateRenderPass( device, pCreateInfo, pAllocator, pRenderPass );
+ }
+
+ void vkDestroyRenderPass( VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDestroyRenderPass( device, renderPass, pAllocator );
+ }
+
+ void vkGetRenderAreaGranularity( VkDevice device, VkRenderPass renderPass, VkExtent2D * pGranularity ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetRenderAreaGranularity( device, renderPass, pGranularity );
+ }
+
+ VkResult vkCreateCommandPool( VkDevice device,
+ const VkCommandPoolCreateInfo * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkCommandPool * pCommandPool ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateCommandPool( device, pCreateInfo, pAllocator, pCommandPool );
+ }
+
+ void vkDestroyCommandPool( VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDestroyCommandPool( device, commandPool, pAllocator );
+ }
+
+ VkResult vkResetCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkResetCommandPool( device, commandPool, flags );
+ }
+
+ VkResult vkAllocateCommandBuffers( VkDevice device,
+ const VkCommandBufferAllocateInfo * pAllocateInfo,
+ VkCommandBuffer * pCommandBuffers ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkAllocateCommandBuffers( device, pAllocateInfo, pCommandBuffers );
+ }
+
+ void vkFreeCommandBuffers( VkDevice device,
+ VkCommandPool commandPool,
+ uint32_t commandBufferCount,
+ const VkCommandBuffer * pCommandBuffers ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkFreeCommandBuffers( device, commandPool, commandBufferCount, pCommandBuffers );
+ }
+
+ VkResult vkBeginCommandBuffer( VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo * pBeginInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkBeginCommandBuffer( commandBuffer, pBeginInfo );
+ }
+
+ VkResult vkEndCommandBuffer( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkEndCommandBuffer( commandBuffer );
+ }
+
+ VkResult vkResetCommandBuffer( VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkResetCommandBuffer( commandBuffer, flags );
+ }
+
+ void vkCmdBindPipeline( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdBindPipeline( commandBuffer, pipelineBindPoint, pipeline );
+ }
+
+ void
+ vkCmdSetViewport( VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport * pViewports ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetViewport( commandBuffer, firstViewport, viewportCount, pViewports );
+ }
+
+ void vkCmdSetScissor( VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D * pScissors ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetScissor( commandBuffer, firstScissor, scissorCount, pScissors );
+ }
+
+ void vkCmdSetLineWidth( VkCommandBuffer commandBuffer, float lineWidth ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetLineWidth( commandBuffer, lineWidth );
+ }
+
+ void vkCmdSetDepthBias( VkCommandBuffer commandBuffer,
+ float depthBiasConstantFactor,
+ float depthBiasClamp,
+ float depthBiasSlopeFactor ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetDepthBias( commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor );
+ }
+
+ void vkCmdSetBlendConstants( VkCommandBuffer commandBuffer, const float blendConstants[4] ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetBlendConstants( commandBuffer, blendConstants );
+ }
+
+ void vkCmdSetDepthBounds( VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetDepthBounds( commandBuffer, minDepthBounds, maxDepthBounds );
+ }
+
+ void vkCmdSetStencilCompareMask( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetStencilCompareMask( commandBuffer, faceMask, compareMask );
+ }
+
+ void vkCmdSetStencilWriteMask( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetStencilWriteMask( commandBuffer, faceMask, writeMask );
+ }
+
+ void vkCmdSetStencilReference( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetStencilReference( commandBuffer, faceMask, reference );
+ }
+
+ void vkCmdBindDescriptorSets( VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipelineLayout layout,
+ uint32_t firstSet,
+ uint32_t descriptorSetCount,
+ const VkDescriptorSet * pDescriptorSets,
+ uint32_t dynamicOffsetCount,
+ const uint32_t * pDynamicOffsets ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdBindDescriptorSets(
+ commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets );
+ }
+
+ void vkCmdBindIndexBuffer( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdBindIndexBuffer( commandBuffer, buffer, offset, indexType );
+ }
+
+ void vkCmdBindVertexBuffers( VkCommandBuffer commandBuffer,
+ uint32_t firstBinding,
+ uint32_t bindingCount,
+ const VkBuffer * pBuffers,
+ const VkDeviceSize * pOffsets ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdBindVertexBuffers( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets );
+ }
+
+ void vkCmdDraw( VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance ) const
+ VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdDraw( commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance );
+ }
+
+ void vkCmdDrawIndexed( VkCommandBuffer commandBuffer,
+ uint32_t indexCount,
+ uint32_t instanceCount,
+ uint32_t firstIndex,
+ int32_t vertexOffset,
+ uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdDrawIndexed( commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance );
+ }
+
+ void vkCmdDrawIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdDrawIndirect( commandBuffer, buffer, offset, drawCount, stride );
+ }
+
+ void vkCmdDrawIndexedIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const
+ VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdDrawIndexedIndirect( commandBuffer, buffer, offset, drawCount, stride );
+ }
+
+ void vkCmdDispatch( VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdDispatch( commandBuffer, groupCountX, groupCountY, groupCountZ );
+ }
+
+ void vkCmdDispatchIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdDispatchIndirect( commandBuffer, buffer, offset );
+ }
+
+ void vkCmdCopyBuffer( VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy * pRegions ) const
+ VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdCopyBuffer( commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions );
+ }
+
+ void vkCmdCopyImage( VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkImageCopy * pRegions ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdCopyImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions );
+ }
+
+ void vkCmdBlitImage( VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkImageBlit * pRegions,
+ VkFilter filter ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdBlitImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter );
+ }
+
+ void vkCmdCopyBufferToImage( VkCommandBuffer commandBuffer,
+ VkBuffer srcBuffer,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkBufferImageCopy * pRegions ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdCopyBufferToImage( commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions );
+ }
+
+ void vkCmdCopyImageToBuffer( VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+ VkBuffer dstBuffer,
+ uint32_t regionCount,
+ const VkBufferImageCopy * pRegions ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdCopyImageToBuffer( commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions );
+ }
+
+ void vkCmdUpdateBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void * pData ) const
+ VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdUpdateBuffer( commandBuffer, dstBuffer, dstOffset, dataSize, pData );
+ }
+
+ void
+ vkCmdFillBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdFillBuffer( commandBuffer, dstBuffer, dstOffset, size, data );
+ }
+
+ void vkCmdClearColorImage( VkCommandBuffer commandBuffer,
+ VkImage image,
+ VkImageLayout imageLayout,
+ const VkClearColorValue * pColor,
+ uint32_t rangeCount,
+ const VkImageSubresourceRange * pRanges ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdClearColorImage( commandBuffer, image, imageLayout, pColor, rangeCount, pRanges );
+ }
+
+ void vkCmdClearDepthStencilImage( VkCommandBuffer commandBuffer,
+ VkImage image,
+ VkImageLayout imageLayout,
+ const VkClearDepthStencilValue * pDepthStencil,
+ uint32_t rangeCount,
+ const VkImageSubresourceRange * pRanges ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdClearDepthStencilImage( commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges );
+ }
+
+ void vkCmdClearAttachments( VkCommandBuffer commandBuffer,
+ uint32_t attachmentCount,
+ const VkClearAttachment * pAttachments,
+ uint32_t rectCount,
+ const VkClearRect * pRects ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdClearAttachments( commandBuffer, attachmentCount, pAttachments, rectCount, pRects );
+ }
+
+ void vkCmdResolveImage( VkCommandBuffer commandBuffer,
+ VkImage srcImage,
+ VkImageLayout srcImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
+ uint32_t regionCount,
+ const VkImageResolve * pRegions ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdResolveImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions );
+ }
+
+ void vkCmdSetEvent( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetEvent( commandBuffer, event, stageMask );
+ }
+
+ void vkCmdResetEvent( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdResetEvent( commandBuffer, event, stageMask );
+ }
+
+ void vkCmdWaitEvents( VkCommandBuffer commandBuffer,
+ uint32_t eventCount,
+ const VkEvent * pEvents,
+ VkPipelineStageFlags srcStageMask,
+ VkPipelineStageFlags dstStageMask,
+ uint32_t memoryBarrierCount,
+ const VkMemoryBarrier * pMemoryBarriers,
+ uint32_t bufferMemoryBarrierCount,
+ const VkBufferMemoryBarrier * pBufferMemoryBarriers,
+ uint32_t imageMemoryBarrierCount,
+ const VkImageMemoryBarrier * pImageMemoryBarriers ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdWaitEvents( commandBuffer,
+ eventCount,
+ pEvents,
+ srcStageMask,
+ dstStageMask,
+ memoryBarrierCount,
+ pMemoryBarriers,
+ bufferMemoryBarrierCount,
+ pBufferMemoryBarriers,
+ imageMemoryBarrierCount,
+ pImageMemoryBarriers );
+ }
+
+ void vkCmdPipelineBarrier( VkCommandBuffer commandBuffer,
+ VkPipelineStageFlags srcStageMask,
+ VkPipelineStageFlags dstStageMask,
+ VkDependencyFlags dependencyFlags,
+ uint32_t memoryBarrierCount,
+ const VkMemoryBarrier * pMemoryBarriers,
+ uint32_t bufferMemoryBarrierCount,
+ const VkBufferMemoryBarrier * pBufferMemoryBarriers,
+ uint32_t imageMemoryBarrierCount,
+ const VkImageMemoryBarrier * pImageMemoryBarriers ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdPipelineBarrier( commandBuffer,
+ srcStageMask,
+ dstStageMask,
+ dependencyFlags,
+ memoryBarrierCount,
+ pMemoryBarriers,
+ bufferMemoryBarrierCount,
+ pBufferMemoryBarriers,
+ imageMemoryBarrierCount,
+ pImageMemoryBarriers );
+ }
+
+ void vkCmdBeginQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdBeginQuery( commandBuffer, queryPool, query, flags );
+ }
+
+ void vkCmdEndQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdEndQuery( commandBuffer, queryPool, query );
+ }
+
+ void vkCmdResetQueryPool( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdResetQueryPool( commandBuffer, queryPool, firstQuery, queryCount );
+ }
+
+ void vkCmdWriteTimestamp( VkCommandBuffer commandBuffer,
+ VkPipelineStageFlagBits pipelineStage,
+ VkQueryPool queryPool,
+ uint32_t query ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdWriteTimestamp( commandBuffer, pipelineStage, queryPool, query );
+ }
+
+ void vkCmdCopyQueryPoolResults( VkCommandBuffer commandBuffer,
+ VkQueryPool queryPool,
+ uint32_t firstQuery,
+ uint32_t queryCount,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
+ VkDeviceSize stride,
+ VkQueryResultFlags flags ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdCopyQueryPoolResults( commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags );
+ }
+
+ void vkCmdPushConstants( VkCommandBuffer commandBuffer,
+ VkPipelineLayout layout,
+ VkShaderStageFlags stageFlags,
+ uint32_t offset,
+ uint32_t size,
+ const void * pValues ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdPushConstants( commandBuffer, layout, stageFlags, offset, size, pValues );
+ }
+
+ void vkCmdBeginRenderPass( VkCommandBuffer commandBuffer,
+ const VkRenderPassBeginInfo * pRenderPassBegin,
+ VkSubpassContents contents ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdBeginRenderPass( commandBuffer, pRenderPassBegin, contents );
+ }
+
+ void vkCmdNextSubpass( VkCommandBuffer commandBuffer, VkSubpassContents contents ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdNextSubpass( commandBuffer, contents );
+ }
+
+ void vkCmdEndRenderPass( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdEndRenderPass( commandBuffer );
+ }
+
+ void vkCmdExecuteCommands( VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer * pCommandBuffers ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdExecuteCommands( commandBuffer, commandBufferCount, pCommandBuffers );
+ }
+
+ //=== VK_VERSION_1_1 ===
+
+ VkResult vkEnumerateInstanceVersion( uint32_t * pApiVersion ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkEnumerateInstanceVersion( pApiVersion );
+ }
+
+ VkResult vkBindBufferMemory2( VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkBindBufferMemory2( device, bindInfoCount, pBindInfos );
+ }
+
+ VkResult vkBindImageMemory2( VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkBindImageMemory2( device, bindInfoCount, pBindInfos );
+ }
+
+ void vkGetDeviceGroupPeerMemoryFeatures( VkDevice device,
+ uint32_t heapIndex,
+ uint32_t localDeviceIndex,
+ uint32_t remoteDeviceIndex,
+ VkPeerMemoryFeatureFlags * pPeerMemoryFeatures ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetDeviceGroupPeerMemoryFeatures( device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures );
+ }
+
+ void vkCmdSetDeviceMask( VkCommandBuffer commandBuffer, uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetDeviceMask( commandBuffer, deviceMask );
+ }
+
+ void vkCmdDispatchBase( VkCommandBuffer commandBuffer,
+ uint32_t baseGroupX,
+ uint32_t baseGroupY,
+ uint32_t baseGroupZ,
+ uint32_t groupCountX,
+ uint32_t groupCountY,
+ uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdDispatchBase( commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
+ }
+
+ VkResult vkEnumeratePhysicalDeviceGroups( VkInstance instance,
+ uint32_t * pPhysicalDeviceGroupCount,
+ VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkEnumeratePhysicalDeviceGroups( instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties );
+ }
+
+ void vkGetImageMemoryRequirements2( VkDevice device,
+ const VkImageMemoryRequirementsInfo2 * pInfo,
+ VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetImageMemoryRequirements2( device, pInfo, pMemoryRequirements );
+ }
+
+ void vkGetBufferMemoryRequirements2( VkDevice device,
+ const VkBufferMemoryRequirementsInfo2 * pInfo,
+ VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetBufferMemoryRequirements2( device, pInfo, pMemoryRequirements );
+ }
+
+ void vkGetImageSparseMemoryRequirements2( VkDevice device,
+ const VkImageSparseMemoryRequirementsInfo2 * pInfo,
+ uint32_t * pSparseMemoryRequirementCount,
+ VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetImageSparseMemoryRequirements2( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
+ }
+
+ void vkGetPhysicalDeviceFeatures2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 * pFeatures ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceFeatures2( physicalDevice, pFeatures );
+ }
+
+ void vkGetPhysicalDeviceProperties2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 * pProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceProperties2( physicalDevice, pProperties );
+ }
+
+ void vkGetPhysicalDeviceFormatProperties2( VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkFormatProperties2 * pFormatProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceFormatProperties2( physicalDevice, format, pFormatProperties );
+ }
+
+ VkResult vkGetPhysicalDeviceImageFormatProperties2( VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,
+ VkImageFormatProperties2 * pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceImageFormatProperties2( physicalDevice, pImageFormatInfo, pImageFormatProperties );
+ }
+
+ void vkGetPhysicalDeviceQueueFamilyProperties2( VkPhysicalDevice physicalDevice,
+ uint32_t * pQueueFamilyPropertyCount,
+ VkQueueFamilyProperties2 * pQueueFamilyProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceQueueFamilyProperties2( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties );
+ }
+
+ void vkGetPhysicalDeviceMemoryProperties2( VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceMemoryProperties2 * pMemoryProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceMemoryProperties2( physicalDevice, pMemoryProperties );
+ }
+
+ void vkGetPhysicalDeviceSparseImageFormatProperties2( VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
+ uint32_t * pPropertyCount,
+ VkSparseImageFormatProperties2 * pProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceSparseImageFormatProperties2( physicalDevice, pFormatInfo, pPropertyCount, pProperties );
+ }
+
+ void vkTrimCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkTrimCommandPool( device, commandPool, flags );
+ }
+
+ void vkGetDeviceQueue2( VkDevice device, const VkDeviceQueueInfo2 * pQueueInfo, VkQueue * pQueue ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetDeviceQueue2( device, pQueueInfo, pQueue );
+ }
+
+ VkResult vkCreateSamplerYcbcrConversion( VkDevice device,
+ const VkSamplerYcbcrConversionCreateInfo * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkSamplerYcbcrConversion * pYcbcrConversion ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateSamplerYcbcrConversion( device, pCreateInfo, pAllocator, pYcbcrConversion );
+ }
+
+ void vkDestroySamplerYcbcrConversion( VkDevice device,
+ VkSamplerYcbcrConversion ycbcrConversion,
+ const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDestroySamplerYcbcrConversion( device, ycbcrConversion, pAllocator );
+ }
+
+ VkResult vkCreateDescriptorUpdateTemplate( VkDevice device,
+ const VkDescriptorUpdateTemplateCreateInfo * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkDescriptorUpdateTemplate * pDescriptorUpdateTemplate ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateDescriptorUpdateTemplate( device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate );
+ }
+
+ void vkDestroyDescriptorUpdateTemplate( VkDevice device,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDestroyDescriptorUpdateTemplate( device, descriptorUpdateTemplate, pAllocator );
+ }
+
+ void vkUpdateDescriptorSetWithTemplate( VkDevice device,
+ VkDescriptorSet descriptorSet,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ const void * pData ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkUpdateDescriptorSetWithTemplate( device, descriptorSet, descriptorUpdateTemplate, pData );
+ }
+
+ void vkGetPhysicalDeviceExternalBufferProperties( VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
+ VkExternalBufferProperties * pExternalBufferProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceExternalBufferProperties( physicalDevice, pExternalBufferInfo, pExternalBufferProperties );
+ }
+
+ void vkGetPhysicalDeviceExternalFenceProperties( VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,
+ VkExternalFenceProperties * pExternalFenceProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceExternalFenceProperties( physicalDevice, pExternalFenceInfo, pExternalFenceProperties );
+ }
+
+ void vkGetPhysicalDeviceExternalSemaphoreProperties( VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,
+ VkExternalSemaphoreProperties * pExternalSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceExternalSemaphoreProperties( physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties );
+ }
+
+ void vkGetDescriptorSetLayoutSupport( VkDevice device,
+ const VkDescriptorSetLayoutCreateInfo * pCreateInfo,
+ VkDescriptorSetLayoutSupport * pSupport ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetDescriptorSetLayoutSupport( device, pCreateInfo, pSupport );
+ }
+
+ //=== VK_VERSION_1_2 ===
+
+ void vkCmdDrawIndirectCount( VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount,
+ uint32_t stride ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdDrawIndirectCount( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
+ }
+
+ void vkCmdDrawIndexedIndirectCount( VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount,
+ uint32_t stride ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdDrawIndexedIndirectCount( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
+ }
+
+ VkResult vkCreateRenderPass2( VkDevice device,
+ const VkRenderPassCreateInfo2 * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkRenderPass * pRenderPass ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateRenderPass2( device, pCreateInfo, pAllocator, pRenderPass );
+ }
+
+ void vkCmdBeginRenderPass2( VkCommandBuffer commandBuffer,
+ const VkRenderPassBeginInfo * pRenderPassBegin,
+ const VkSubpassBeginInfo * pSubpassBeginInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdBeginRenderPass2( commandBuffer, pRenderPassBegin, pSubpassBeginInfo );
+ }
+
+ void vkCmdNextSubpass2( VkCommandBuffer commandBuffer,
+ const VkSubpassBeginInfo * pSubpassBeginInfo,
+ const VkSubpassEndInfo * pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdNextSubpass2( commandBuffer, pSubpassBeginInfo, pSubpassEndInfo );
+ }
+
+ void vkCmdEndRenderPass2( VkCommandBuffer commandBuffer, const VkSubpassEndInfo * pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdEndRenderPass2( commandBuffer, pSubpassEndInfo );
+ }
+
+ void vkResetQueryPool( VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkResetQueryPool( device, queryPool, firstQuery, queryCount );
+ }
+
+ VkResult vkGetSemaphoreCounterValue( VkDevice device, VkSemaphore semaphore, uint64_t * pValue ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetSemaphoreCounterValue( device, semaphore, pValue );
+ }
+
+ VkResult vkWaitSemaphores( VkDevice device, const VkSemaphoreWaitInfo * pWaitInfo, uint64_t timeout ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkWaitSemaphores( device, pWaitInfo, timeout );
+ }
+
+ VkResult vkSignalSemaphore( VkDevice device, const VkSemaphoreSignalInfo * pSignalInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkSignalSemaphore( device, pSignalInfo );
+ }
+
+ VkDeviceAddress vkGetBufferDeviceAddress( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetBufferDeviceAddress( device, pInfo );
+ }
+
+ uint64_t vkGetBufferOpaqueCaptureAddress( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetBufferOpaqueCaptureAddress( device, pInfo );
+ }
+
+ uint64_t vkGetDeviceMemoryOpaqueCaptureAddress( VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetDeviceMemoryOpaqueCaptureAddress( device, pInfo );
+ }
+
+ //=== VK_VERSION_1_3 ===
+
+ VkResult vkGetPhysicalDeviceToolProperties( VkPhysicalDevice physicalDevice,
+ uint32_t * pToolCount,
+ VkPhysicalDeviceToolProperties * pToolProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceToolProperties( physicalDevice, pToolCount, pToolProperties );
+ }
+
+ VkResult vkCreatePrivateDataSlot( VkDevice device,
+ const VkPrivateDataSlotCreateInfo * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkPrivateDataSlot * pPrivateDataSlot ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreatePrivateDataSlot( device, pCreateInfo, pAllocator, pPrivateDataSlot );
+ }
+
+ void vkDestroyPrivateDataSlot( VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDestroyPrivateDataSlot( device, privateDataSlot, pAllocator );
+ }
+
+ VkResult vkSetPrivateData( VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data ) const
+ VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkSetPrivateData( device, objectType, objectHandle, privateDataSlot, data );
+ }
+
+ void vkGetPrivateData( VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t * pData ) const
+ VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPrivateData( device, objectType, objectHandle, privateDataSlot, pData );
+ }
+
+ void vkCmdSetEvent2( VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetEvent2( commandBuffer, event, pDependencyInfo );
+ }
+
+ void vkCmdResetEvent2( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdResetEvent2( commandBuffer, event, stageMask );
+ }
+
+ void vkCmdWaitEvents2( VkCommandBuffer commandBuffer,
+ uint32_t eventCount,
+ const VkEvent * pEvents,
+ const VkDependencyInfo * pDependencyInfos ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdWaitEvents2( commandBuffer, eventCount, pEvents, pDependencyInfos );
+ }
+
+ void vkCmdPipelineBarrier2( VkCommandBuffer commandBuffer, const VkDependencyInfo * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdPipelineBarrier2( commandBuffer, pDependencyInfo );
+ }
+
+ void vkCmdWriteTimestamp2( VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdWriteTimestamp2( commandBuffer, stage, queryPool, query );
+ }
+
+ VkResult vkQueueSubmit2( VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 * pSubmits, VkFence fence ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkQueueSubmit2( queue, submitCount, pSubmits, fence );
+ }
+
+ void vkCmdCopyBuffer2( VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 * pCopyBufferInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdCopyBuffer2( commandBuffer, pCopyBufferInfo );
+ }
+
+ void vkCmdCopyImage2( VkCommandBuffer commandBuffer, const VkCopyImageInfo2 * pCopyImageInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdCopyImage2( commandBuffer, pCopyImageInfo );
+ }
+
+ void vkCmdCopyBufferToImage2( VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 * pCopyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdCopyBufferToImage2( commandBuffer, pCopyBufferToImageInfo );
+ }
+
+ void vkCmdCopyImageToBuffer2( VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 * pCopyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdCopyImageToBuffer2( commandBuffer, pCopyImageToBufferInfo );
+ }
+
+ void vkCmdBlitImage2( VkCommandBuffer commandBuffer, const VkBlitImageInfo2 * pBlitImageInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdBlitImage2( commandBuffer, pBlitImageInfo );
+ }
+
+ void vkCmdResolveImage2( VkCommandBuffer commandBuffer, const VkResolveImageInfo2 * pResolveImageInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdResolveImage2( commandBuffer, pResolveImageInfo );
+ }
+
+ void vkCmdBeginRendering( VkCommandBuffer commandBuffer, const VkRenderingInfo * pRenderingInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdBeginRendering( commandBuffer, pRenderingInfo );
+ }
+
+ void vkCmdEndRendering( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdEndRendering( commandBuffer );
+ }
+
+ void vkCmdSetCullMode( VkCommandBuffer commandBuffer, VkCullModeFlags cullMode ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetCullMode( commandBuffer, cullMode );
+ }
+
+ void vkCmdSetFrontFace( VkCommandBuffer commandBuffer, VkFrontFace frontFace ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetFrontFace( commandBuffer, frontFace );
+ }
+
+ void vkCmdSetPrimitiveTopology( VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetPrimitiveTopology( commandBuffer, primitiveTopology );
+ }
+
+ void vkCmdSetViewportWithCount( VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport * pViewports ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetViewportWithCount( commandBuffer, viewportCount, pViewports );
+ }
+
+ void vkCmdSetScissorWithCount( VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D * pScissors ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetScissorWithCount( commandBuffer, scissorCount, pScissors );
+ }
+
+ void vkCmdBindVertexBuffers2( VkCommandBuffer commandBuffer,
+ uint32_t firstBinding,
+ uint32_t bindingCount,
+ const VkBuffer * pBuffers,
+ const VkDeviceSize * pOffsets,
+ const VkDeviceSize * pSizes,
+ const VkDeviceSize * pStrides ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdBindVertexBuffers2( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides );
+ }
+
+ void vkCmdSetDepthTestEnable( VkCommandBuffer commandBuffer, VkBool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetDepthTestEnable( commandBuffer, depthTestEnable );
+ }
+
+ void vkCmdSetDepthWriteEnable( VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetDepthWriteEnable( commandBuffer, depthWriteEnable );
+ }
+
+ void vkCmdSetDepthCompareOp( VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetDepthCompareOp( commandBuffer, depthCompareOp );
+ }
+
+ void vkCmdSetDepthBoundsTestEnable( VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetDepthBoundsTestEnable( commandBuffer, depthBoundsTestEnable );
+ }
+
+ void vkCmdSetStencilTestEnable( VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetStencilTestEnable( commandBuffer, stencilTestEnable );
+ }
+
+ void vkCmdSetStencilOp( VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask,
+ VkStencilOp failOp,
+ VkStencilOp passOp,
+ VkStencilOp depthFailOp,
+ VkCompareOp compareOp ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetStencilOp( commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp );
+ }
+
+ void vkCmdSetRasterizerDiscardEnable( VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetRasterizerDiscardEnable( commandBuffer, rasterizerDiscardEnable );
+ }
+
+ void vkCmdSetDepthBiasEnable( VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetDepthBiasEnable( commandBuffer, depthBiasEnable );
+ }
+
+ void vkCmdSetPrimitiveRestartEnable( VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetPrimitiveRestartEnable( commandBuffer, primitiveRestartEnable );
+ }
+
+ void vkGetDeviceBufferMemoryRequirements( VkDevice device,
+ const VkDeviceBufferMemoryRequirements * pInfo,
+ VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetDeviceBufferMemoryRequirements( device, pInfo, pMemoryRequirements );
+ }
+
+ void vkGetDeviceImageMemoryRequirements( VkDevice device,
+ const VkDeviceImageMemoryRequirements * pInfo,
+ VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetDeviceImageMemoryRequirements( device, pInfo, pMemoryRequirements );
+ }
+
+ void vkGetDeviceImageSparseMemoryRequirements( VkDevice device,
+ const VkDeviceImageMemoryRequirements * pInfo,
+ uint32_t * pSparseMemoryRequirementCount,
+ VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetDeviceImageSparseMemoryRequirements( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
+ }
+
+ //=== VK_KHR_surface ===
+
+ void vkDestroySurfaceKHR( VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDestroySurfaceKHR( instance, surface, pAllocator );
+ }
+
+ VkResult vkGetPhysicalDeviceSurfaceSupportKHR( VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ VkSurfaceKHR surface,
+ VkBool32 * pSupported ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceSurfaceSupportKHR( physicalDevice, queueFamilyIndex, surface, pSupported );
+ }
+
+ VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR( VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ VkSurfaceCapabilitiesKHR * pSurfaceCapabilities ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceSurfaceCapabilitiesKHR( physicalDevice, surface, pSurfaceCapabilities );
+ }
+
+ VkResult vkGetPhysicalDeviceSurfaceFormatsKHR( VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ uint32_t * pSurfaceFormatCount,
+ VkSurfaceFormatKHR * pSurfaceFormats ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceSurfaceFormatsKHR( physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats );
+ }
+
+ VkResult vkGetPhysicalDeviceSurfacePresentModesKHR( VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ uint32_t * pPresentModeCount,
+ VkPresentModeKHR * pPresentModes ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceSurfacePresentModesKHR( physicalDevice, surface, pPresentModeCount, pPresentModes );
+ }
+
+ //=== VK_KHR_swapchain ===
+
+ VkResult vkCreateSwapchainKHR( VkDevice device,
+ const VkSwapchainCreateInfoKHR * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkSwapchainKHR * pSwapchain ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateSwapchainKHR( device, pCreateInfo, pAllocator, pSwapchain );
+ }
+
+ void vkDestroySwapchainKHR( VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDestroySwapchainKHR( device, swapchain, pAllocator );
+ }
+
+ VkResult vkGetSwapchainImagesKHR( VkDevice device,
+ VkSwapchainKHR swapchain,
+ uint32_t * pSwapchainImageCount,
+ VkImage * pSwapchainImages ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetSwapchainImagesKHR( device, swapchain, pSwapchainImageCount, pSwapchainImages );
+ }
+
+ VkResult vkAcquireNextImageKHR(
+ VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t * pImageIndex ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkAcquireNextImageKHR( device, swapchain, timeout, semaphore, fence, pImageIndex );
+ }
+
+ VkResult vkQueuePresentKHR( VkQueue queue, const VkPresentInfoKHR * pPresentInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkQueuePresentKHR( queue, pPresentInfo );
+ }
+
+ VkResult vkGetDeviceGroupPresentCapabilitiesKHR( VkDevice device,
+ VkDeviceGroupPresentCapabilitiesKHR * pDeviceGroupPresentCapabilities ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetDeviceGroupPresentCapabilitiesKHR( device, pDeviceGroupPresentCapabilities );
+ }
+
+ VkResult
+ vkGetDeviceGroupSurfacePresentModesKHR( VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR * pModes ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetDeviceGroupSurfacePresentModesKHR( device, surface, pModes );
+ }
+
+ VkResult vkGetPhysicalDevicePresentRectanglesKHR( VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ uint32_t * pRectCount,
+ VkRect2D * pRects ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDevicePresentRectanglesKHR( physicalDevice, surface, pRectCount, pRects );
+ }
+
+ VkResult vkAcquireNextImage2KHR( VkDevice device, const VkAcquireNextImageInfoKHR * pAcquireInfo, uint32_t * pImageIndex ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkAcquireNextImage2KHR( device, pAcquireInfo, pImageIndex );
+ }
+
+ //=== VK_KHR_display ===
+
+ VkResult vkGetPhysicalDeviceDisplayPropertiesKHR( VkPhysicalDevice physicalDevice,
+ uint32_t * pPropertyCount,
+ VkDisplayPropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceDisplayPropertiesKHR( physicalDevice, pPropertyCount, pProperties );
+ }
+
+ VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR( VkPhysicalDevice physicalDevice,
+ uint32_t * pPropertyCount,
+ VkDisplayPlanePropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceDisplayPlanePropertiesKHR( physicalDevice, pPropertyCount, pProperties );
+ }
+
+ VkResult vkGetDisplayPlaneSupportedDisplaysKHR( VkPhysicalDevice physicalDevice,
+ uint32_t planeIndex,
+ uint32_t * pDisplayCount,
+ VkDisplayKHR * pDisplays ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetDisplayPlaneSupportedDisplaysKHR( physicalDevice, planeIndex, pDisplayCount, pDisplays );
+ }
+
+ VkResult vkGetDisplayModePropertiesKHR( VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display,
+ uint32_t * pPropertyCount,
+ VkDisplayModePropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetDisplayModePropertiesKHR( physicalDevice, display, pPropertyCount, pProperties );
+ }
+
+ VkResult vkCreateDisplayModeKHR( VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display,
+ const VkDisplayModeCreateInfoKHR * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkDisplayModeKHR * pMode ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateDisplayModeKHR( physicalDevice, display, pCreateInfo, pAllocator, pMode );
+ }
+
+ VkResult vkGetDisplayPlaneCapabilitiesKHR( VkPhysicalDevice physicalDevice,
+ VkDisplayModeKHR mode,
+ uint32_t planeIndex,
+ VkDisplayPlaneCapabilitiesKHR * pCapabilities ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetDisplayPlaneCapabilitiesKHR( physicalDevice, mode, planeIndex, pCapabilities );
+ }
+
+ VkResult vkCreateDisplayPlaneSurfaceKHR( VkInstance instance,
+ const VkDisplaySurfaceCreateInfoKHR * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateDisplayPlaneSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
+ }
+
+ //=== VK_KHR_display_swapchain ===
+
+ VkResult vkCreateSharedSwapchainsKHR( VkDevice device,
+ uint32_t swapchainCount,
+ const VkSwapchainCreateInfoKHR * pCreateInfos,
+ const VkAllocationCallbacks * pAllocator,
+ VkSwapchainKHR * pSwapchains ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateSharedSwapchainsKHR( device, swapchainCount, pCreateInfos, pAllocator, pSwapchains );
+ }
+
+# if defined( VK_USE_PLATFORM_XLIB_KHR )
+ //=== VK_KHR_xlib_surface ===
+
+ VkResult vkCreateXlibSurfaceKHR( VkInstance instance,
+ const VkXlibSurfaceCreateInfoKHR * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateXlibSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
+ }
+
+ VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR( VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ Display * dpy,
+ VisualID visualID ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceXlibPresentationSupportKHR( physicalDevice, queueFamilyIndex, dpy, visualID );
+ }
+# endif /*VK_USE_PLATFORM_XLIB_KHR*/
+
+# if defined( VK_USE_PLATFORM_XCB_KHR )
+ //=== VK_KHR_xcb_surface ===
+
+ VkResult vkCreateXcbSurfaceKHR( VkInstance instance,
+ const VkXcbSurfaceCreateInfoKHR * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateXcbSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
+ }
+
+ VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR( VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ xcb_connection_t * connection,
+ xcb_visualid_t visual_id ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceXcbPresentationSupportKHR( physicalDevice, queueFamilyIndex, connection, visual_id );
+ }
+# endif /*VK_USE_PLATFORM_XCB_KHR*/
+
+# if defined( VK_USE_PLATFORM_WAYLAND_KHR )
+ //=== VK_KHR_wayland_surface ===
+
+ VkResult vkCreateWaylandSurfaceKHR( VkInstance instance,
+ const VkWaylandSurfaceCreateInfoKHR * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateWaylandSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
+ }
+
+ VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR( VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ struct wl_display * display ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceWaylandPresentationSupportKHR( physicalDevice, queueFamilyIndex, display );
+ }
+# endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
+
+# if defined( VK_USE_PLATFORM_ANDROID_KHR )
+ //=== VK_KHR_android_surface ===
+
+ VkResult vkCreateAndroidSurfaceKHR( VkInstance instance,
+ const VkAndroidSurfaceCreateInfoKHR * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateAndroidSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
+ }
+# endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+
+# if defined( VK_USE_PLATFORM_WIN32_KHR )
+ //=== VK_KHR_win32_surface ===
+
+ VkResult vkCreateWin32SurfaceKHR( VkInstance instance,
+ const VkWin32SurfaceCreateInfoKHR * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateWin32SurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
+ }
+
+ VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceWin32PresentationSupportKHR( physicalDevice, queueFamilyIndex );
+ }
+# endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+ //=== VK_EXT_debug_report ===
+
+ VkResult vkCreateDebugReportCallbackEXT( VkInstance instance,
+ const VkDebugReportCallbackCreateInfoEXT * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkDebugReportCallbackEXT * pCallback ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateDebugReportCallbackEXT( instance, pCreateInfo, pAllocator, pCallback );
+ }
+
+ void vkDestroyDebugReportCallbackEXT( VkInstance instance,
+ VkDebugReportCallbackEXT callback,
+ const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDestroyDebugReportCallbackEXT( instance, callback, pAllocator );
+ }
+
+ void vkDebugReportMessageEXT( VkInstance instance,
+ VkDebugReportFlagsEXT flags,
+ VkDebugReportObjectTypeEXT objectType,
+ uint64_t object,
+ size_t location,
+ int32_t messageCode,
+ const char * pLayerPrefix,
+ const char * pMessage ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDebugReportMessageEXT( instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage );
+ }
+
+ //=== VK_EXT_debug_marker ===
+
+ VkResult vkDebugMarkerSetObjectTagEXT( VkDevice device, const VkDebugMarkerObjectTagInfoEXT * pTagInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDebugMarkerSetObjectTagEXT( device, pTagInfo );
+ }
+
+ VkResult vkDebugMarkerSetObjectNameEXT( VkDevice device, const VkDebugMarkerObjectNameInfoEXT * pNameInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDebugMarkerSetObjectNameEXT( device, pNameInfo );
+ }
+
+ void vkCmdDebugMarkerBeginEXT( VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdDebugMarkerBeginEXT( commandBuffer, pMarkerInfo );
+ }
+
+ void vkCmdDebugMarkerEndEXT( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdDebugMarkerEndEXT( commandBuffer );
+ }
+
+ void vkCmdDebugMarkerInsertEXT( VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdDebugMarkerInsertEXT( commandBuffer, pMarkerInfo );
+ }
+
+# if defined( VK_ENABLE_BETA_EXTENSIONS )
+ //=== VK_KHR_video_queue ===
+
+ VkResult vkGetPhysicalDeviceVideoCapabilitiesKHR( VkPhysicalDevice physicalDevice,
+ const VkVideoProfileKHR * pVideoProfile,
+ VkVideoCapabilitiesKHR * pCapabilities ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceVideoCapabilitiesKHR( physicalDevice, pVideoProfile, pCapabilities );
+ }
+
+ VkResult vkGetPhysicalDeviceVideoFormatPropertiesKHR( VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceVideoFormatInfoKHR * pVideoFormatInfo,
+ uint32_t * pVideoFormatPropertyCount,
+ VkVideoFormatPropertiesKHR * pVideoFormatProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceVideoFormatPropertiesKHR( physicalDevice, pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties );
+ }
+
+ VkResult vkCreateVideoSessionKHR( VkDevice device,
+ const VkVideoSessionCreateInfoKHR * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkVideoSessionKHR * pVideoSession ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateVideoSessionKHR( device, pCreateInfo, pAllocator, pVideoSession );
+ }
+
+ void vkDestroyVideoSessionKHR( VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDestroyVideoSessionKHR( device, videoSession, pAllocator );
+ }
+
+ VkResult vkGetVideoSessionMemoryRequirementsKHR( VkDevice device,
+ VkVideoSessionKHR videoSession,
+ uint32_t * pVideoSessionMemoryRequirementsCount,
+ VkVideoGetMemoryPropertiesKHR * pVideoSessionMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetVideoSessionMemoryRequirementsKHR( device, videoSession, pVideoSessionMemoryRequirementsCount, pVideoSessionMemoryRequirements );
+ }
+
+ VkResult vkBindVideoSessionMemoryKHR( VkDevice device,
+ VkVideoSessionKHR videoSession,
+ uint32_t videoSessionBindMemoryCount,
+ const VkVideoBindMemoryKHR * pVideoSessionBindMemories ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkBindVideoSessionMemoryKHR( device, videoSession, videoSessionBindMemoryCount, pVideoSessionBindMemories );
+ }
+
+ VkResult vkCreateVideoSessionParametersKHR( VkDevice device,
+ const VkVideoSessionParametersCreateInfoKHR * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkVideoSessionParametersKHR * pVideoSessionParameters ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateVideoSessionParametersKHR( device, pCreateInfo, pAllocator, pVideoSessionParameters );
+ }
+
+ VkResult vkUpdateVideoSessionParametersKHR( VkDevice device,
+ VkVideoSessionParametersKHR videoSessionParameters,
+ const VkVideoSessionParametersUpdateInfoKHR * pUpdateInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkUpdateVideoSessionParametersKHR( device, videoSessionParameters, pUpdateInfo );
+ }
+
+ void vkDestroyVideoSessionParametersKHR( VkDevice device,
+ VkVideoSessionParametersKHR videoSessionParameters,
+ const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDestroyVideoSessionParametersKHR( device, videoSessionParameters, pAllocator );
+ }
+
+ void vkCmdBeginVideoCodingKHR( VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR * pBeginInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdBeginVideoCodingKHR( commandBuffer, pBeginInfo );
+ }
+
+ void vkCmdEndVideoCodingKHR( VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR * pEndCodingInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdEndVideoCodingKHR( commandBuffer, pEndCodingInfo );
+ }
+
+ void vkCmdControlVideoCodingKHR( VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR * pCodingControlInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdControlVideoCodingKHR( commandBuffer, pCodingControlInfo );
+ }
+# endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+# if defined( VK_ENABLE_BETA_EXTENSIONS )
+ //=== VK_KHR_video_decode_queue ===
+
+ void vkCmdDecodeVideoKHR( VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR * pFrameInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdDecodeVideoKHR( commandBuffer, pFrameInfo );
+ }
+# endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+ //=== VK_EXT_transform_feedback ===
+
+ void vkCmdBindTransformFeedbackBuffersEXT( VkCommandBuffer commandBuffer,
+ uint32_t firstBinding,
+ uint32_t bindingCount,
+ const VkBuffer * pBuffers,
+ const VkDeviceSize * pOffsets,
+ const VkDeviceSize * pSizes ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdBindTransformFeedbackBuffersEXT( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes );
+ }
+
+ void vkCmdBeginTransformFeedbackEXT( VkCommandBuffer commandBuffer,
+ uint32_t firstCounterBuffer,
+ uint32_t counterBufferCount,
+ const VkBuffer * pCounterBuffers,
+ const VkDeviceSize * pCounterBufferOffsets ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdBeginTransformFeedbackEXT( commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets );
+ }
+
+ void vkCmdEndTransformFeedbackEXT( VkCommandBuffer commandBuffer,
+ uint32_t firstCounterBuffer,
+ uint32_t counterBufferCount,
+ const VkBuffer * pCounterBuffers,
+ const VkDeviceSize * pCounterBufferOffsets ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdEndTransformFeedbackEXT( commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets );
+ }
+
+ void vkCmdBeginQueryIndexedEXT( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index ) const
+ VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdBeginQueryIndexedEXT( commandBuffer, queryPool, query, flags, index );
+ }
+
+ void vkCmdEndQueryIndexedEXT( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdEndQueryIndexedEXT( commandBuffer, queryPool, query, index );
+ }
+
+ void vkCmdDrawIndirectByteCountEXT( VkCommandBuffer commandBuffer,
+ uint32_t instanceCount,
+ uint32_t firstInstance,
+ VkBuffer counterBuffer,
+ VkDeviceSize counterBufferOffset,
+ uint32_t counterOffset,
+ uint32_t vertexStride ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdDrawIndirectByteCountEXT( commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride );
+ }
+
+ //=== VK_NVX_binary_import ===
+
+ VkResult vkCreateCuModuleNVX( VkDevice device,
+ const VkCuModuleCreateInfoNVX * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkCuModuleNVX * pModule ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateCuModuleNVX( device, pCreateInfo, pAllocator, pModule );
+ }
+
+ VkResult vkCreateCuFunctionNVX( VkDevice device,
+ const VkCuFunctionCreateInfoNVX * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkCuFunctionNVX * pFunction ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateCuFunctionNVX( device, pCreateInfo, pAllocator, pFunction );
+ }
+
+ void vkDestroyCuModuleNVX( VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDestroyCuModuleNVX( device, module, pAllocator );
+ }
+
+ void vkDestroyCuFunctionNVX( VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDestroyCuFunctionNVX( device, function, pAllocator );
+ }
+
+ void vkCmdCuLaunchKernelNVX( VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX * pLaunchInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdCuLaunchKernelNVX( commandBuffer, pLaunchInfo );
+ }
+
+ //=== VK_NVX_image_view_handle ===
+
+ uint32_t vkGetImageViewHandleNVX( VkDevice device, const VkImageViewHandleInfoNVX * pInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetImageViewHandleNVX( device, pInfo );
+ }
+
+ VkResult vkGetImageViewAddressNVX( VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX * pProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetImageViewAddressNVX( device, imageView, pProperties );
+ }
+
+ //=== VK_AMD_draw_indirect_count ===
+
+ void vkCmdDrawIndirectCountAMD( VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount,
+ uint32_t stride ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdDrawIndirectCountAMD( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
+ }
+
+ void vkCmdDrawIndexedIndirectCountAMD( VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount,
+ uint32_t stride ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdDrawIndexedIndirectCountAMD( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
+ }
+
+ //=== VK_AMD_shader_info ===
+
+ VkResult vkGetShaderInfoAMD( VkDevice device,
+ VkPipeline pipeline,
+ VkShaderStageFlagBits shaderStage,
+ VkShaderInfoTypeAMD infoType,
+ size_t * pInfoSize,
+ void * pInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetShaderInfoAMD( device, pipeline, shaderStage, infoType, pInfoSize, pInfo );
+ }
+
+ //=== VK_KHR_dynamic_rendering ===
+
+ void vkCmdBeginRenderingKHR( VkCommandBuffer commandBuffer, const VkRenderingInfo * pRenderingInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdBeginRenderingKHR( commandBuffer, pRenderingInfo );
+ }
+
+ void vkCmdEndRenderingKHR( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdEndRenderingKHR( commandBuffer );
+ }
+
+# if defined( VK_USE_PLATFORM_GGP )
+ //=== VK_GGP_stream_descriptor_surface ===
+
+ VkResult vkCreateStreamDescriptorSurfaceGGP( VkInstance instance,
+ const VkStreamDescriptorSurfaceCreateInfoGGP * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateStreamDescriptorSurfaceGGP( instance, pCreateInfo, pAllocator, pSurface );
+ }
+# endif /*VK_USE_PLATFORM_GGP*/
+
+ //=== VK_NV_external_memory_capabilities ===
+
+ VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV( VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkImageType type,
+ VkImageTiling tiling,
+ VkImageUsageFlags usage,
+ VkImageCreateFlags flags,
+ VkExternalMemoryHandleTypeFlagsNV externalHandleType,
+ VkExternalImageFormatPropertiesNV * pExternalImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
+ physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties );
+ }
+
+# if defined( VK_USE_PLATFORM_WIN32_KHR )
+ //=== VK_NV_external_memory_win32 ===
+
+ VkResult vkGetMemoryWin32HandleNV( VkDevice device,
+ VkDeviceMemory memory,
+ VkExternalMemoryHandleTypeFlagsNV handleType,
+ HANDLE * pHandle ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetMemoryWin32HandleNV( device, memory, handleType, pHandle );
+ }
+# endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+ //=== VK_KHR_get_physical_device_properties2 ===
+
+ void vkGetPhysicalDeviceFeatures2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 * pFeatures ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceFeatures2KHR( physicalDevice, pFeatures );
+ }
+
+ void vkGetPhysicalDeviceProperties2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 * pProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceProperties2KHR( physicalDevice, pProperties );
+ }
+
+ void vkGetPhysicalDeviceFormatProperties2KHR( VkPhysicalDevice physicalDevice,
+ VkFormat format,
+ VkFormatProperties2 * pFormatProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceFormatProperties2KHR( physicalDevice, format, pFormatProperties );
+ }
+
+ VkResult vkGetPhysicalDeviceImageFormatProperties2KHR( VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,
+ VkImageFormatProperties2 * pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceImageFormatProperties2KHR( physicalDevice, pImageFormatInfo, pImageFormatProperties );
+ }
+
+ void vkGetPhysicalDeviceQueueFamilyProperties2KHR( VkPhysicalDevice physicalDevice,
+ uint32_t * pQueueFamilyPropertyCount,
+ VkQueueFamilyProperties2 * pQueueFamilyProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceQueueFamilyProperties2KHR( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties );
+ }
+
+ void vkGetPhysicalDeviceMemoryProperties2KHR( VkPhysicalDevice physicalDevice,
+ VkPhysicalDeviceMemoryProperties2 * pMemoryProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceMemoryProperties2KHR( physicalDevice, pMemoryProperties );
+ }
+
+ void vkGetPhysicalDeviceSparseImageFormatProperties2KHR( VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
+ uint32_t * pPropertyCount,
+ VkSparseImageFormatProperties2 * pProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceSparseImageFormatProperties2KHR( physicalDevice, pFormatInfo, pPropertyCount, pProperties );
+ }
+
+ //=== VK_KHR_device_group ===
+
+ void vkGetDeviceGroupPeerMemoryFeaturesKHR( VkDevice device,
+ uint32_t heapIndex,
+ uint32_t localDeviceIndex,
+ uint32_t remoteDeviceIndex,
+ VkPeerMemoryFeatureFlags * pPeerMemoryFeatures ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetDeviceGroupPeerMemoryFeaturesKHR( device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures );
+ }
+
+ void vkCmdSetDeviceMaskKHR( VkCommandBuffer commandBuffer, uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetDeviceMaskKHR( commandBuffer, deviceMask );
+ }
+
+ void vkCmdDispatchBaseKHR( VkCommandBuffer commandBuffer,
+ uint32_t baseGroupX,
+ uint32_t baseGroupY,
+ uint32_t baseGroupZ,
+ uint32_t groupCountX,
+ uint32_t groupCountY,
+ uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdDispatchBaseKHR( commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
+ }
+
+# if defined( VK_USE_PLATFORM_VI_NN )
+ //=== VK_NN_vi_surface ===
+
+ VkResult vkCreateViSurfaceNN( VkInstance instance,
+ const VkViSurfaceCreateInfoNN * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateViSurfaceNN( instance, pCreateInfo, pAllocator, pSurface );
+ }
+# endif /*VK_USE_PLATFORM_VI_NN*/
+
+ //=== VK_KHR_maintenance1 ===
+
+ void vkTrimCommandPoolKHR( VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkTrimCommandPoolKHR( device, commandPool, flags );
+ }
+
+ //=== VK_KHR_device_group_creation ===
+
+ VkResult vkEnumeratePhysicalDeviceGroupsKHR( VkInstance instance,
+ uint32_t * pPhysicalDeviceGroupCount,
+ VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkEnumeratePhysicalDeviceGroupsKHR( instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties );
+ }
+
+ //=== VK_KHR_external_memory_capabilities ===
+
+ void vkGetPhysicalDeviceExternalBufferPropertiesKHR( VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
+ VkExternalBufferProperties * pExternalBufferProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceExternalBufferPropertiesKHR( physicalDevice, pExternalBufferInfo, pExternalBufferProperties );
+ }
+
+# if defined( VK_USE_PLATFORM_WIN32_KHR )
+ //=== VK_KHR_external_memory_win32 ===
+
+ VkResult vkGetMemoryWin32HandleKHR( VkDevice device, const VkMemoryGetWin32HandleInfoKHR * pGetWin32HandleInfo, HANDLE * pHandle ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetMemoryWin32HandleKHR( device, pGetWin32HandleInfo, pHandle );
+ }
+
+ VkResult vkGetMemoryWin32HandlePropertiesKHR( VkDevice device,
+ VkExternalMemoryHandleTypeFlagBits handleType,
+ HANDLE handle,
+ VkMemoryWin32HandlePropertiesKHR * pMemoryWin32HandleProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetMemoryWin32HandlePropertiesKHR( device, handleType, handle, pMemoryWin32HandleProperties );
+ }
+# endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+ //=== VK_KHR_external_memory_fd ===
+
+ VkResult vkGetMemoryFdKHR( VkDevice device, const VkMemoryGetFdInfoKHR * pGetFdInfo, int * pFd ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetMemoryFdKHR( device, pGetFdInfo, pFd );
+ }
+
+ VkResult vkGetMemoryFdPropertiesKHR( VkDevice device,
+ VkExternalMemoryHandleTypeFlagBits handleType,
+ int fd,
+ VkMemoryFdPropertiesKHR * pMemoryFdProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetMemoryFdPropertiesKHR( device, handleType, fd, pMemoryFdProperties );
+ }
+
+ //=== VK_KHR_external_semaphore_capabilities ===
+
+ void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,
+ VkExternalSemaphoreProperties * pExternalSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties );
+ }
+
+# if defined( VK_USE_PLATFORM_WIN32_KHR )
+ //=== VK_KHR_external_semaphore_win32 ===
+
+ VkResult vkImportSemaphoreWin32HandleKHR( VkDevice device,
+ const VkImportSemaphoreWin32HandleInfoKHR * pImportSemaphoreWin32HandleInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkImportSemaphoreWin32HandleKHR( device, pImportSemaphoreWin32HandleInfo );
+ }
+
+ VkResult
+ vkGetSemaphoreWin32HandleKHR( VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR * pGetWin32HandleInfo, HANDLE * pHandle ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetSemaphoreWin32HandleKHR( device, pGetWin32HandleInfo, pHandle );
+ }
+# endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+ //=== VK_KHR_external_semaphore_fd ===
+
+ VkResult vkImportSemaphoreFdKHR( VkDevice device, const VkImportSemaphoreFdInfoKHR * pImportSemaphoreFdInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkImportSemaphoreFdKHR( device, pImportSemaphoreFdInfo );
+ }
+
+ VkResult vkGetSemaphoreFdKHR( VkDevice device, const VkSemaphoreGetFdInfoKHR * pGetFdInfo, int * pFd ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetSemaphoreFdKHR( device, pGetFdInfo, pFd );
+ }
+
+ //=== VK_KHR_push_descriptor ===
+
+ void vkCmdPushDescriptorSetKHR( VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipelineLayout layout,
+ uint32_t set,
+ uint32_t descriptorWriteCount,
+ const VkWriteDescriptorSet * pDescriptorWrites ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdPushDescriptorSetKHR( commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites );
+ }
+
+ void vkCmdPushDescriptorSetWithTemplateKHR( VkCommandBuffer commandBuffer,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ VkPipelineLayout layout,
+ uint32_t set,
+ const void * pData ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdPushDescriptorSetWithTemplateKHR( commandBuffer, descriptorUpdateTemplate, layout, set, pData );
+ }
+
+ //=== VK_EXT_conditional_rendering ===
+
+ void vkCmdBeginConditionalRenderingEXT( VkCommandBuffer commandBuffer,
+ const VkConditionalRenderingBeginInfoEXT * pConditionalRenderingBegin ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdBeginConditionalRenderingEXT( commandBuffer, pConditionalRenderingBegin );
+ }
+
+ void vkCmdEndConditionalRenderingEXT( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdEndConditionalRenderingEXT( commandBuffer );
+ }
+
+ //=== VK_KHR_descriptor_update_template ===
+
+ VkResult vkCreateDescriptorUpdateTemplateKHR( VkDevice device,
+ const VkDescriptorUpdateTemplateCreateInfo * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkDescriptorUpdateTemplate * pDescriptorUpdateTemplate ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateDescriptorUpdateTemplateKHR( device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate );
+ }
+
+ void vkDestroyDescriptorUpdateTemplateKHR( VkDevice device,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDestroyDescriptorUpdateTemplateKHR( device, descriptorUpdateTemplate, pAllocator );
+ }
+
+ void vkUpdateDescriptorSetWithTemplateKHR( VkDevice device,
+ VkDescriptorSet descriptorSet,
+ VkDescriptorUpdateTemplate descriptorUpdateTemplate,
+ const void * pData ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkUpdateDescriptorSetWithTemplateKHR( device, descriptorSet, descriptorUpdateTemplate, pData );
+ }
+
+ //=== VK_NV_clip_space_w_scaling ===
+
+ void vkCmdSetViewportWScalingNV( VkCommandBuffer commandBuffer,
+ uint32_t firstViewport,
+ uint32_t viewportCount,
+ const VkViewportWScalingNV * pViewportWScalings ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetViewportWScalingNV( commandBuffer, firstViewport, viewportCount, pViewportWScalings );
+ }
+
+ //=== VK_EXT_direct_mode_display ===
+
+ VkResult vkReleaseDisplayEXT( VkPhysicalDevice physicalDevice, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkReleaseDisplayEXT( physicalDevice, display );
+ }
+
+# if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
+ //=== VK_EXT_acquire_xlib_display ===
+
+ VkResult vkAcquireXlibDisplayEXT( VkPhysicalDevice physicalDevice, Display * dpy, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkAcquireXlibDisplayEXT( physicalDevice, dpy, display );
+ }
+
+ VkResult vkGetRandROutputDisplayEXT( VkPhysicalDevice physicalDevice, Display * dpy, RROutput rrOutput, VkDisplayKHR * pDisplay ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetRandROutputDisplayEXT( physicalDevice, dpy, rrOutput, pDisplay );
+ }
+# endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
+
+ //=== VK_EXT_display_surface_counter ===
+
+ VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT( VkPhysicalDevice physicalDevice,
+ VkSurfaceKHR surface,
+ VkSurfaceCapabilities2EXT * pSurfaceCapabilities ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceSurfaceCapabilities2EXT( physicalDevice, surface, pSurfaceCapabilities );
+ }
+
+ //=== VK_EXT_display_control ===
+
+ VkResult vkDisplayPowerControlEXT( VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT * pDisplayPowerInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDisplayPowerControlEXT( device, display, pDisplayPowerInfo );
+ }
+
+ VkResult vkRegisterDeviceEventEXT( VkDevice device,
+ const VkDeviceEventInfoEXT * pDeviceEventInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkFence * pFence ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkRegisterDeviceEventEXT( device, pDeviceEventInfo, pAllocator, pFence );
+ }
+
+ VkResult vkRegisterDisplayEventEXT( VkDevice device,
+ VkDisplayKHR display,
+ const VkDisplayEventInfoEXT * pDisplayEventInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkFence * pFence ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkRegisterDisplayEventEXT( device, display, pDisplayEventInfo, pAllocator, pFence );
+ }
+
+ VkResult vkGetSwapchainCounterEXT( VkDevice device,
+ VkSwapchainKHR swapchain,
+ VkSurfaceCounterFlagBitsEXT counter,
+ uint64_t * pCounterValue ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetSwapchainCounterEXT( device, swapchain, counter, pCounterValue );
+ }
+
+ //=== VK_GOOGLE_display_timing ===
+
+ VkResult vkGetRefreshCycleDurationGOOGLE( VkDevice device,
+ VkSwapchainKHR swapchain,
+ VkRefreshCycleDurationGOOGLE * pDisplayTimingProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetRefreshCycleDurationGOOGLE( device, swapchain, pDisplayTimingProperties );
+ }
+
+ VkResult vkGetPastPresentationTimingGOOGLE( VkDevice device,
+ VkSwapchainKHR swapchain,
+ uint32_t * pPresentationTimingCount,
+ VkPastPresentationTimingGOOGLE * pPresentationTimings ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPastPresentationTimingGOOGLE( device, swapchain, pPresentationTimingCount, pPresentationTimings );
+ }
+
+ //=== VK_EXT_discard_rectangles ===
+
+ void vkCmdSetDiscardRectangleEXT( VkCommandBuffer commandBuffer,
+ uint32_t firstDiscardRectangle,
+ uint32_t discardRectangleCount,
+ const VkRect2D * pDiscardRectangles ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetDiscardRectangleEXT( commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles );
+ }
+
+ //=== VK_EXT_hdr_metadata ===
+
+ void vkSetHdrMetadataEXT( VkDevice device,
+ uint32_t swapchainCount,
+ const VkSwapchainKHR * pSwapchains,
+ const VkHdrMetadataEXT * pMetadata ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkSetHdrMetadataEXT( device, swapchainCount, pSwapchains, pMetadata );
+ }
+
+ //=== VK_KHR_create_renderpass2 ===
+
+ VkResult vkCreateRenderPass2KHR( VkDevice device,
+ const VkRenderPassCreateInfo2 * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkRenderPass * pRenderPass ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateRenderPass2KHR( device, pCreateInfo, pAllocator, pRenderPass );
+ }
+
+ void vkCmdBeginRenderPass2KHR( VkCommandBuffer commandBuffer,
+ const VkRenderPassBeginInfo * pRenderPassBegin,
+ const VkSubpassBeginInfo * pSubpassBeginInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdBeginRenderPass2KHR( commandBuffer, pRenderPassBegin, pSubpassBeginInfo );
+ }
+
+ void vkCmdNextSubpass2KHR( VkCommandBuffer commandBuffer,
+ const VkSubpassBeginInfo * pSubpassBeginInfo,
+ const VkSubpassEndInfo * pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdNextSubpass2KHR( commandBuffer, pSubpassBeginInfo, pSubpassEndInfo );
+ }
+
+ void vkCmdEndRenderPass2KHR( VkCommandBuffer commandBuffer, const VkSubpassEndInfo * pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdEndRenderPass2KHR( commandBuffer, pSubpassEndInfo );
+ }
+
+ //=== VK_KHR_shared_presentable_image ===
+
+ VkResult vkGetSwapchainStatusKHR( VkDevice device, VkSwapchainKHR swapchain ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetSwapchainStatusKHR( device, swapchain );
+ }
+
+ //=== VK_KHR_external_fence_capabilities ===
+
+ void vkGetPhysicalDeviceExternalFencePropertiesKHR( VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,
+ VkExternalFenceProperties * pExternalFenceProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceExternalFencePropertiesKHR( physicalDevice, pExternalFenceInfo, pExternalFenceProperties );
+ }
+
+# if defined( VK_USE_PLATFORM_WIN32_KHR )
+ //=== VK_KHR_external_fence_win32 ===
+
+ VkResult vkImportFenceWin32HandleKHR( VkDevice device, const VkImportFenceWin32HandleInfoKHR * pImportFenceWin32HandleInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkImportFenceWin32HandleKHR( device, pImportFenceWin32HandleInfo );
+ }
+
+ VkResult vkGetFenceWin32HandleKHR( VkDevice device, const VkFenceGetWin32HandleInfoKHR * pGetWin32HandleInfo, HANDLE * pHandle ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetFenceWin32HandleKHR( device, pGetWin32HandleInfo, pHandle );
+ }
+# endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+ //=== VK_KHR_external_fence_fd ===
+
+ VkResult vkImportFenceFdKHR( VkDevice device, const VkImportFenceFdInfoKHR * pImportFenceFdInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkImportFenceFdKHR( device, pImportFenceFdInfo );
+ }
+
+ VkResult vkGetFenceFdKHR( VkDevice device, const VkFenceGetFdInfoKHR * pGetFdInfo, int * pFd ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetFenceFdKHR( device, pGetFdInfo, pFd );
+ }
+
+ //=== VK_KHR_performance_query ===
+
+ VkResult
+ vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ uint32_t * pCounterCount,
+ VkPerformanceCounterKHR * pCounters,
+ VkPerformanceCounterDescriptionKHR * pCounterDescriptions ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
+ physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions );
+ }
+
+ void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( VkPhysicalDevice physicalDevice,
+ const VkQueryPoolPerformanceCreateInfoKHR * pPerformanceQueryCreateInfo,
+ uint32_t * pNumPasses ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( physicalDevice, pPerformanceQueryCreateInfo, pNumPasses );
+ }
+
+ VkResult vkAcquireProfilingLockKHR( VkDevice device, const VkAcquireProfilingLockInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkAcquireProfilingLockKHR( device, pInfo );
+ }
+
+ void vkReleaseProfilingLockKHR( VkDevice device ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkReleaseProfilingLockKHR( device );
+ }
+
+ //=== VK_KHR_get_surface_capabilities2 ===
+
+ VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR( VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
+ VkSurfaceCapabilities2KHR * pSurfaceCapabilities ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceSurfaceCapabilities2KHR( physicalDevice, pSurfaceInfo, pSurfaceCapabilities );
+ }
+
+ VkResult vkGetPhysicalDeviceSurfaceFormats2KHR( VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
+ uint32_t * pSurfaceFormatCount,
+ VkSurfaceFormat2KHR * pSurfaceFormats ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceSurfaceFormats2KHR( physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats );
+ }
+
+ //=== VK_KHR_get_display_properties2 ===
+
+ VkResult vkGetPhysicalDeviceDisplayProperties2KHR( VkPhysicalDevice physicalDevice,
+ uint32_t * pPropertyCount,
+ VkDisplayProperties2KHR * pProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceDisplayProperties2KHR( physicalDevice, pPropertyCount, pProperties );
+ }
+
+ VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR( VkPhysicalDevice physicalDevice,
+ uint32_t * pPropertyCount,
+ VkDisplayPlaneProperties2KHR * pProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceDisplayPlaneProperties2KHR( physicalDevice, pPropertyCount, pProperties );
+ }
+
+ VkResult vkGetDisplayModeProperties2KHR( VkPhysicalDevice physicalDevice,
+ VkDisplayKHR display,
+ uint32_t * pPropertyCount,
+ VkDisplayModeProperties2KHR * pProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetDisplayModeProperties2KHR( physicalDevice, display, pPropertyCount, pProperties );
+ }
+
+ VkResult vkGetDisplayPlaneCapabilities2KHR( VkPhysicalDevice physicalDevice,
+ const VkDisplayPlaneInfo2KHR * pDisplayPlaneInfo,
+ VkDisplayPlaneCapabilities2KHR * pCapabilities ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetDisplayPlaneCapabilities2KHR( physicalDevice, pDisplayPlaneInfo, pCapabilities );
+ }
+
+# if defined( VK_USE_PLATFORM_IOS_MVK )
+ //=== VK_MVK_ios_surface ===
+
+ VkResult vkCreateIOSSurfaceMVK( VkInstance instance,
+ const VkIOSSurfaceCreateInfoMVK * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateIOSSurfaceMVK( instance, pCreateInfo, pAllocator, pSurface );
+ }
+# endif /*VK_USE_PLATFORM_IOS_MVK*/
+
+# if defined( VK_USE_PLATFORM_MACOS_MVK )
+ //=== VK_MVK_macos_surface ===
+
+ VkResult vkCreateMacOSSurfaceMVK( VkInstance instance,
+ const VkMacOSSurfaceCreateInfoMVK * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateMacOSSurfaceMVK( instance, pCreateInfo, pAllocator, pSurface );
+ }
+# endif /*VK_USE_PLATFORM_MACOS_MVK*/
+
+ //=== VK_EXT_debug_utils ===
+
+ VkResult vkSetDebugUtilsObjectNameEXT( VkDevice device, const VkDebugUtilsObjectNameInfoEXT * pNameInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkSetDebugUtilsObjectNameEXT( device, pNameInfo );
+ }
+
+ VkResult vkSetDebugUtilsObjectTagEXT( VkDevice device, const VkDebugUtilsObjectTagInfoEXT * pTagInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkSetDebugUtilsObjectTagEXT( device, pTagInfo );
+ }
+
+ void vkQueueBeginDebugUtilsLabelEXT( VkQueue queue, const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkQueueBeginDebugUtilsLabelEXT( queue, pLabelInfo );
+ }
+
+ void vkQueueEndDebugUtilsLabelEXT( VkQueue queue ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkQueueEndDebugUtilsLabelEXT( queue );
+ }
+
+ void vkQueueInsertDebugUtilsLabelEXT( VkQueue queue, const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkQueueInsertDebugUtilsLabelEXT( queue, pLabelInfo );
+ }
+
+ void vkCmdBeginDebugUtilsLabelEXT( VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdBeginDebugUtilsLabelEXT( commandBuffer, pLabelInfo );
+ }
+
+ void vkCmdEndDebugUtilsLabelEXT( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdEndDebugUtilsLabelEXT( commandBuffer );
+ }
+
+ void vkCmdInsertDebugUtilsLabelEXT( VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdInsertDebugUtilsLabelEXT( commandBuffer, pLabelInfo );
+ }
+
+ VkResult vkCreateDebugUtilsMessengerEXT( VkInstance instance,
+ const VkDebugUtilsMessengerCreateInfoEXT * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkDebugUtilsMessengerEXT * pMessenger ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateDebugUtilsMessengerEXT( instance, pCreateInfo, pAllocator, pMessenger );
+ }
+
+ void vkDestroyDebugUtilsMessengerEXT( VkInstance instance,
+ VkDebugUtilsMessengerEXT messenger,
+ const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDestroyDebugUtilsMessengerEXT( instance, messenger, pAllocator );
+ }
+
+ void vkSubmitDebugUtilsMessageEXT( VkInstance instance,
+ VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
+ VkDebugUtilsMessageTypeFlagsEXT messageTypes,
+ const VkDebugUtilsMessengerCallbackDataEXT * pCallbackData ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkSubmitDebugUtilsMessageEXT( instance, messageSeverity, messageTypes, pCallbackData );
+ }
+
+# if defined( VK_USE_PLATFORM_ANDROID_KHR )
+ //=== VK_ANDROID_external_memory_android_hardware_buffer ===
+
+ VkResult vkGetAndroidHardwareBufferPropertiesANDROID( VkDevice device,
+ const struct AHardwareBuffer * buffer,
+ VkAndroidHardwareBufferPropertiesANDROID * pProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetAndroidHardwareBufferPropertiesANDROID( device, buffer, pProperties );
+ }
+
+ VkResult vkGetMemoryAndroidHardwareBufferANDROID( VkDevice device,
+ const VkMemoryGetAndroidHardwareBufferInfoANDROID * pInfo,
+ struct AHardwareBuffer ** pBuffer ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetMemoryAndroidHardwareBufferANDROID( device, pInfo, pBuffer );
+ }
+# endif /*VK_USE_PLATFORM_ANDROID_KHR*/
+
+ //=== VK_EXT_sample_locations ===
+
+ void vkCmdSetSampleLocationsEXT( VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT * pSampleLocationsInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetSampleLocationsEXT( commandBuffer, pSampleLocationsInfo );
+ }
+
+ void vkGetPhysicalDeviceMultisamplePropertiesEXT( VkPhysicalDevice physicalDevice,
+ VkSampleCountFlagBits samples,
+ VkMultisamplePropertiesEXT * pMultisampleProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceMultisamplePropertiesEXT( physicalDevice, samples, pMultisampleProperties );
+ }
+
+ //=== VK_KHR_get_memory_requirements2 ===
+
+ void vkGetImageMemoryRequirements2KHR( VkDevice device,
+ const VkImageMemoryRequirementsInfo2 * pInfo,
+ VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetImageMemoryRequirements2KHR( device, pInfo, pMemoryRequirements );
+ }
+
+ void vkGetBufferMemoryRequirements2KHR( VkDevice device,
+ const VkBufferMemoryRequirementsInfo2 * pInfo,
+ VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetBufferMemoryRequirements2KHR( device, pInfo, pMemoryRequirements );
+ }
+
+ void vkGetImageSparseMemoryRequirements2KHR( VkDevice device,
+ const VkImageSparseMemoryRequirementsInfo2 * pInfo,
+ uint32_t * pSparseMemoryRequirementCount,
+ VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetImageSparseMemoryRequirements2KHR( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
+ }
+
+ //=== VK_KHR_acceleration_structure ===
+
+ VkResult vkCreateAccelerationStructureKHR( VkDevice device,
+ const VkAccelerationStructureCreateInfoKHR * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkAccelerationStructureKHR * pAccelerationStructure ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateAccelerationStructureKHR( device, pCreateInfo, pAllocator, pAccelerationStructure );
+ }
+
+ void vkDestroyAccelerationStructureKHR( VkDevice device,
+ VkAccelerationStructureKHR accelerationStructure,
+ const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDestroyAccelerationStructureKHR( device, accelerationStructure, pAllocator );
+ }
+
+ void vkCmdBuildAccelerationStructuresKHR( VkCommandBuffer commandBuffer,
+ uint32_t infoCount,
+ const VkAccelerationStructureBuildGeometryInfoKHR * pInfos,
+ const VkAccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdBuildAccelerationStructuresKHR( commandBuffer, infoCount, pInfos, ppBuildRangeInfos );
+ }
+
+ void vkCmdBuildAccelerationStructuresIndirectKHR( VkCommandBuffer commandBuffer,
+ uint32_t infoCount,
+ const VkAccelerationStructureBuildGeometryInfoKHR * pInfos,
+ const VkDeviceAddress * pIndirectDeviceAddresses,
+ const uint32_t * pIndirectStrides,
+ const uint32_t * const * ppMaxPrimitiveCounts ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdBuildAccelerationStructuresIndirectKHR(
+ commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts );
+ }
+
+ VkResult vkBuildAccelerationStructuresKHR( VkDevice device,
+ VkDeferredOperationKHR deferredOperation,
+ uint32_t infoCount,
+ const VkAccelerationStructureBuildGeometryInfoKHR * pInfos,
+ const VkAccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkBuildAccelerationStructuresKHR( device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos );
+ }
+
+ VkResult vkCopyAccelerationStructureKHR( VkDevice device,
+ VkDeferredOperationKHR deferredOperation,
+ const VkCopyAccelerationStructureInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCopyAccelerationStructureKHR( device, deferredOperation, pInfo );
+ }
+
+ VkResult vkCopyAccelerationStructureToMemoryKHR( VkDevice device,
+ VkDeferredOperationKHR deferredOperation,
+ const VkCopyAccelerationStructureToMemoryInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCopyAccelerationStructureToMemoryKHR( device, deferredOperation, pInfo );
+ }
+
+ VkResult vkCopyMemoryToAccelerationStructureKHR( VkDevice device,
+ VkDeferredOperationKHR deferredOperation,
+ const VkCopyMemoryToAccelerationStructureInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCopyMemoryToAccelerationStructureKHR( device, deferredOperation, pInfo );
+ }
+
+ VkResult vkWriteAccelerationStructuresPropertiesKHR( VkDevice device,
+ uint32_t accelerationStructureCount,
+ const VkAccelerationStructureKHR * pAccelerationStructures,
+ VkQueryType queryType,
+ size_t dataSize,
+ void * pData,
+ size_t stride ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkWriteAccelerationStructuresPropertiesKHR( device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride );
+ }
+
+ void vkCmdCopyAccelerationStructureKHR( VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdCopyAccelerationStructureKHR( commandBuffer, pInfo );
+ }
+
+ void vkCmdCopyAccelerationStructureToMemoryKHR( VkCommandBuffer commandBuffer,
+ const VkCopyAccelerationStructureToMemoryInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdCopyAccelerationStructureToMemoryKHR( commandBuffer, pInfo );
+ }
+
+ void vkCmdCopyMemoryToAccelerationStructureKHR( VkCommandBuffer commandBuffer,
+ const VkCopyMemoryToAccelerationStructureInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdCopyMemoryToAccelerationStructureKHR( commandBuffer, pInfo );
+ }
+
+ VkDeviceAddress vkGetAccelerationStructureDeviceAddressKHR( VkDevice device,
+ const VkAccelerationStructureDeviceAddressInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetAccelerationStructureDeviceAddressKHR( device, pInfo );
+ }
+
+ void vkCmdWriteAccelerationStructuresPropertiesKHR( VkCommandBuffer commandBuffer,
+ uint32_t accelerationStructureCount,
+ const VkAccelerationStructureKHR * pAccelerationStructures,
+ VkQueryType queryType,
+ VkQueryPool queryPool,
+ uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdWriteAccelerationStructuresPropertiesKHR(
+ commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery );
+ }
+
+ void vkGetDeviceAccelerationStructureCompatibilityKHR( VkDevice device,
+ const VkAccelerationStructureVersionInfoKHR * pVersionInfo,
+ VkAccelerationStructureCompatibilityKHR * pCompatibility ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetDeviceAccelerationStructureCompatibilityKHR( device, pVersionInfo, pCompatibility );
+ }
+
+ void vkGetAccelerationStructureBuildSizesKHR( VkDevice device,
+ VkAccelerationStructureBuildTypeKHR buildType,
+ const VkAccelerationStructureBuildGeometryInfoKHR * pBuildInfo,
+ const uint32_t * pMaxPrimitiveCounts,
+ VkAccelerationStructureBuildSizesInfoKHR * pSizeInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetAccelerationStructureBuildSizesKHR( device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo );
+ }
+
+ //=== VK_KHR_sampler_ycbcr_conversion ===
+
+ VkResult vkCreateSamplerYcbcrConversionKHR( VkDevice device,
+ const VkSamplerYcbcrConversionCreateInfo * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkSamplerYcbcrConversion * pYcbcrConversion ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateSamplerYcbcrConversionKHR( device, pCreateInfo, pAllocator, pYcbcrConversion );
+ }
+
+ void vkDestroySamplerYcbcrConversionKHR( VkDevice device,
+ VkSamplerYcbcrConversion ycbcrConversion,
+ const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDestroySamplerYcbcrConversionKHR( device, ycbcrConversion, pAllocator );
+ }
+
+ //=== VK_KHR_bind_memory2 ===
+
+ VkResult vkBindBufferMemory2KHR( VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkBindBufferMemory2KHR( device, bindInfoCount, pBindInfos );
+ }
+
+ VkResult vkBindImageMemory2KHR( VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkBindImageMemory2KHR( device, bindInfoCount, pBindInfos );
+ }
+
+ //=== VK_EXT_image_drm_format_modifier ===
+
+ VkResult
+ vkGetImageDrmFormatModifierPropertiesEXT( VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT * pProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetImageDrmFormatModifierPropertiesEXT( device, image, pProperties );
+ }
+
+ //=== VK_EXT_validation_cache ===
+
+ VkResult vkCreateValidationCacheEXT( VkDevice device,
+ const VkValidationCacheCreateInfoEXT * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkValidationCacheEXT * pValidationCache ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateValidationCacheEXT( device, pCreateInfo, pAllocator, pValidationCache );
+ }
+
+ void
+ vkDestroyValidationCacheEXT( VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDestroyValidationCacheEXT( device, validationCache, pAllocator );
+ }
+
+ VkResult vkMergeValidationCachesEXT( VkDevice device,
+ VkValidationCacheEXT dstCache,
+ uint32_t srcCacheCount,
+ const VkValidationCacheEXT * pSrcCaches ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkMergeValidationCachesEXT( device, dstCache, srcCacheCount, pSrcCaches );
+ }
+
+ VkResult vkGetValidationCacheDataEXT( VkDevice device, VkValidationCacheEXT validationCache, size_t * pDataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetValidationCacheDataEXT( device, validationCache, pDataSize, pData );
+ }
+
+ //=== VK_NV_shading_rate_image ===
+
+ void vkCmdBindShadingRateImageNV( VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdBindShadingRateImageNV( commandBuffer, imageView, imageLayout );
+ }
+
+ void vkCmdSetViewportShadingRatePaletteNV( VkCommandBuffer commandBuffer,
+ uint32_t firstViewport,
+ uint32_t viewportCount,
+ const VkShadingRatePaletteNV * pShadingRatePalettes ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetViewportShadingRatePaletteNV( commandBuffer, firstViewport, viewportCount, pShadingRatePalettes );
+ }
+
+ void vkCmdSetCoarseSampleOrderNV( VkCommandBuffer commandBuffer,
+ VkCoarseSampleOrderTypeNV sampleOrderType,
+ uint32_t customSampleOrderCount,
+ const VkCoarseSampleOrderCustomNV * pCustomSampleOrders ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetCoarseSampleOrderNV( commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders );
+ }
+
+ //=== VK_NV_ray_tracing ===
+
+ VkResult vkCreateAccelerationStructureNV( VkDevice device,
+ const VkAccelerationStructureCreateInfoNV * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkAccelerationStructureNV * pAccelerationStructure ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateAccelerationStructureNV( device, pCreateInfo, pAllocator, pAccelerationStructure );
+ }
+
+ void vkDestroyAccelerationStructureNV( VkDevice device,
+ VkAccelerationStructureNV accelerationStructure,
+ const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDestroyAccelerationStructureNV( device, accelerationStructure, pAllocator );
+ }
+
+ void vkGetAccelerationStructureMemoryRequirementsNV( VkDevice device,
+ const VkAccelerationStructureMemoryRequirementsInfoNV * pInfo,
+ VkMemoryRequirements2KHR * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetAccelerationStructureMemoryRequirementsNV( device, pInfo, pMemoryRequirements );
+ }
+
+ VkResult vkBindAccelerationStructureMemoryNV( VkDevice device,
+ uint32_t bindInfoCount,
+ const VkBindAccelerationStructureMemoryInfoNV * pBindInfos ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkBindAccelerationStructureMemoryNV( device, bindInfoCount, pBindInfos );
+ }
+
+ void vkCmdBuildAccelerationStructureNV( VkCommandBuffer commandBuffer,
+ const VkAccelerationStructureInfoNV * pInfo,
+ VkBuffer instanceData,
+ VkDeviceSize instanceOffset,
+ VkBool32 update,
+ VkAccelerationStructureNV dst,
+ VkAccelerationStructureNV src,
+ VkBuffer scratch,
+ VkDeviceSize scratchOffset ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdBuildAccelerationStructureNV( commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset );
+ }
+
+ void vkCmdCopyAccelerationStructureNV( VkCommandBuffer commandBuffer,
+ VkAccelerationStructureNV dst,
+ VkAccelerationStructureNV src,
+ VkCopyAccelerationStructureModeKHR mode ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdCopyAccelerationStructureNV( commandBuffer, dst, src, mode );
+ }
+
+ void vkCmdTraceRaysNV( VkCommandBuffer commandBuffer,
+ VkBuffer raygenShaderBindingTableBuffer,
+ VkDeviceSize raygenShaderBindingOffset,
+ VkBuffer missShaderBindingTableBuffer,
+ VkDeviceSize missShaderBindingOffset,
+ VkDeviceSize missShaderBindingStride,
+ VkBuffer hitShaderBindingTableBuffer,
+ VkDeviceSize hitShaderBindingOffset,
+ VkDeviceSize hitShaderBindingStride,
+ VkBuffer callableShaderBindingTableBuffer,
+ VkDeviceSize callableShaderBindingOffset,
+ VkDeviceSize callableShaderBindingStride,
+ uint32_t width,
+ uint32_t height,
+ uint32_t depth ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdTraceRaysNV( commandBuffer,
+ raygenShaderBindingTableBuffer,
+ raygenShaderBindingOffset,
+ missShaderBindingTableBuffer,
+ missShaderBindingOffset,
+ missShaderBindingStride,
+ hitShaderBindingTableBuffer,
+ hitShaderBindingOffset,
+ hitShaderBindingStride,
+ callableShaderBindingTableBuffer,
+ callableShaderBindingOffset,
+ callableShaderBindingStride,
+ width,
+ height,
+ depth );
+ }
+
+ VkResult vkCreateRayTracingPipelinesNV( VkDevice device,
+ VkPipelineCache pipelineCache,
+ uint32_t createInfoCount,
+ const VkRayTracingPipelineCreateInfoNV * pCreateInfos,
+ const VkAllocationCallbacks * pAllocator,
+ VkPipeline * pPipelines ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateRayTracingPipelinesNV( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
+ }
+
+ VkResult vkGetRayTracingShaderGroupHandlesNV(
+ VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetRayTracingShaderGroupHandlesNV( device, pipeline, firstGroup, groupCount, dataSize, pData );
+ }
+
+ VkResult vkGetAccelerationStructureHandleNV( VkDevice device,
+ VkAccelerationStructureNV accelerationStructure,
+ size_t dataSize,
+ void * pData ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetAccelerationStructureHandleNV( device, accelerationStructure, dataSize, pData );
+ }
+
+ void vkCmdWriteAccelerationStructuresPropertiesNV( VkCommandBuffer commandBuffer,
+ uint32_t accelerationStructureCount,
+ const VkAccelerationStructureNV * pAccelerationStructures,
+ VkQueryType queryType,
+ VkQueryPool queryPool,
+ uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdWriteAccelerationStructuresPropertiesNV(
+ commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery );
+ }
+
+ VkResult vkCompileDeferredNV( VkDevice device, VkPipeline pipeline, uint32_t shader ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCompileDeferredNV( device, pipeline, shader );
+ }
+
+ //=== VK_KHR_maintenance3 ===
+
+ void vkGetDescriptorSetLayoutSupportKHR( VkDevice device,
+ const VkDescriptorSetLayoutCreateInfo * pCreateInfo,
+ VkDescriptorSetLayoutSupport * pSupport ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetDescriptorSetLayoutSupportKHR( device, pCreateInfo, pSupport );
+ }
+
+ //=== VK_KHR_draw_indirect_count ===
+
+ void vkCmdDrawIndirectCountKHR( VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount,
+ uint32_t stride ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdDrawIndirectCountKHR( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
+ }
+
+ void vkCmdDrawIndexedIndirectCountKHR( VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount,
+ uint32_t stride ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdDrawIndexedIndirectCountKHR( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
+ }
+
+ //=== VK_EXT_external_memory_host ===
+
+ VkResult vkGetMemoryHostPointerPropertiesEXT( VkDevice device,
+ VkExternalMemoryHandleTypeFlagBits handleType,
+ const void * pHostPointer,
+ VkMemoryHostPointerPropertiesEXT * pMemoryHostPointerProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetMemoryHostPointerPropertiesEXT( device, handleType, pHostPointer, pMemoryHostPointerProperties );
+ }
+
+ //=== VK_AMD_buffer_marker ===
+
+ void vkCmdWriteBufferMarkerAMD( VkCommandBuffer commandBuffer,
+ VkPipelineStageFlagBits pipelineStage,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
+ uint32_t marker ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdWriteBufferMarkerAMD( commandBuffer, pipelineStage, dstBuffer, dstOffset, marker );
+ }
+
+ //=== VK_EXT_calibrated_timestamps ===
+
+ VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( VkPhysicalDevice physicalDevice,
+ uint32_t * pTimeDomainCount,
+ VkTimeDomainEXT * pTimeDomains ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( physicalDevice, pTimeDomainCount, pTimeDomains );
+ }
+
+ VkResult vkGetCalibratedTimestampsEXT( VkDevice device,
+ uint32_t timestampCount,
+ const VkCalibratedTimestampInfoEXT * pTimestampInfos,
+ uint64_t * pTimestamps,
+ uint64_t * pMaxDeviation ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetCalibratedTimestampsEXT( device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation );
+ }
+
+ //=== VK_NV_mesh_shader ===
+
+ void vkCmdDrawMeshTasksNV( VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdDrawMeshTasksNV( commandBuffer, taskCount, firstTask );
+ }
+
+ void vkCmdDrawMeshTasksIndirectNV( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const
+ VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdDrawMeshTasksIndirectNV( commandBuffer, buffer, offset, drawCount, stride );
+ }
+
+ void vkCmdDrawMeshTasksIndirectCountNV( VkCommandBuffer commandBuffer,
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkBuffer countBuffer,
+ VkDeviceSize countBufferOffset,
+ uint32_t maxDrawCount,
+ uint32_t stride ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdDrawMeshTasksIndirectCountNV( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
+ }
+
+ //=== VK_NV_scissor_exclusive ===
+
+ void vkCmdSetExclusiveScissorNV( VkCommandBuffer commandBuffer,
+ uint32_t firstExclusiveScissor,
+ uint32_t exclusiveScissorCount,
+ const VkRect2D * pExclusiveScissors ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetExclusiveScissorNV( commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors );
+ }
+
+ //=== VK_NV_device_diagnostic_checkpoints ===
+
+ void vkCmdSetCheckpointNV( VkCommandBuffer commandBuffer, const void * pCheckpointMarker ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetCheckpointNV( commandBuffer, pCheckpointMarker );
+ }
+
+ void vkGetQueueCheckpointDataNV( VkQueue queue, uint32_t * pCheckpointDataCount, VkCheckpointDataNV * pCheckpointData ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetQueueCheckpointDataNV( queue, pCheckpointDataCount, pCheckpointData );
+ }
+
+ //=== VK_KHR_timeline_semaphore ===
+
+ VkResult vkGetSemaphoreCounterValueKHR( VkDevice device, VkSemaphore semaphore, uint64_t * pValue ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetSemaphoreCounterValueKHR( device, semaphore, pValue );
+ }
+
+ VkResult vkWaitSemaphoresKHR( VkDevice device, const VkSemaphoreWaitInfo * pWaitInfo, uint64_t timeout ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkWaitSemaphoresKHR( device, pWaitInfo, timeout );
+ }
+
+ VkResult vkSignalSemaphoreKHR( VkDevice device, const VkSemaphoreSignalInfo * pSignalInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkSignalSemaphoreKHR( device, pSignalInfo );
+ }
+
+ //=== VK_INTEL_performance_query ===
+
+ VkResult vkInitializePerformanceApiINTEL( VkDevice device, const VkInitializePerformanceApiInfoINTEL * pInitializeInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkInitializePerformanceApiINTEL( device, pInitializeInfo );
+ }
+
+ void vkUninitializePerformanceApiINTEL( VkDevice device ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkUninitializePerformanceApiINTEL( device );
+ }
+
+ VkResult vkCmdSetPerformanceMarkerINTEL( VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetPerformanceMarkerINTEL( commandBuffer, pMarkerInfo );
+ }
+
+ VkResult vkCmdSetPerformanceStreamMarkerINTEL( VkCommandBuffer commandBuffer,
+ const VkPerformanceStreamMarkerInfoINTEL * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetPerformanceStreamMarkerINTEL( commandBuffer, pMarkerInfo );
+ }
+
+ VkResult vkCmdSetPerformanceOverrideINTEL( VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL * pOverrideInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetPerformanceOverrideINTEL( commandBuffer, pOverrideInfo );
+ }
+
+ VkResult vkAcquirePerformanceConfigurationINTEL( VkDevice device,
+ const VkPerformanceConfigurationAcquireInfoINTEL * pAcquireInfo,
+ VkPerformanceConfigurationINTEL * pConfiguration ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkAcquirePerformanceConfigurationINTEL( device, pAcquireInfo, pConfiguration );
+ }
+
+ VkResult vkReleasePerformanceConfigurationINTEL( VkDevice device, VkPerformanceConfigurationINTEL configuration ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkReleasePerformanceConfigurationINTEL( device, configuration );
+ }
+
+ VkResult vkQueueSetPerformanceConfigurationINTEL( VkQueue queue, VkPerformanceConfigurationINTEL configuration ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkQueueSetPerformanceConfigurationINTEL( queue, configuration );
+ }
+
+ VkResult
+ vkGetPerformanceParameterINTEL( VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL * pValue ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPerformanceParameterINTEL( device, parameter, pValue );
+ }
+
+ //=== VK_AMD_display_native_hdr ===
+
+ void vkSetLocalDimmingAMD( VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkSetLocalDimmingAMD( device, swapChain, localDimmingEnable );
+ }
+
+# if defined( VK_USE_PLATFORM_FUCHSIA )
+ //=== VK_FUCHSIA_imagepipe_surface ===
+
+ VkResult vkCreateImagePipeSurfaceFUCHSIA( VkInstance instance,
+ const VkImagePipeSurfaceCreateInfoFUCHSIA * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateImagePipeSurfaceFUCHSIA( instance, pCreateInfo, pAllocator, pSurface );
+ }
+# endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+# if defined( VK_USE_PLATFORM_METAL_EXT )
+ //=== VK_EXT_metal_surface ===
+
+ VkResult vkCreateMetalSurfaceEXT( VkInstance instance,
+ const VkMetalSurfaceCreateInfoEXT * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateMetalSurfaceEXT( instance, pCreateInfo, pAllocator, pSurface );
+ }
+# endif /*VK_USE_PLATFORM_METAL_EXT*/
+
+ //=== VK_KHR_fragment_shading_rate ===
+
+ VkResult vkGetPhysicalDeviceFragmentShadingRatesKHR( VkPhysicalDevice physicalDevice,
+ uint32_t * pFragmentShadingRateCount,
+ VkPhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceFragmentShadingRatesKHR( physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates );
+ }
+
+ void vkCmdSetFragmentShadingRateKHR( VkCommandBuffer commandBuffer,
+ const VkExtent2D * pFragmentSize,
+ const VkFragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetFragmentShadingRateKHR( commandBuffer, pFragmentSize, combinerOps );
+ }
+
+ //=== VK_EXT_buffer_device_address ===
+
+ VkDeviceAddress vkGetBufferDeviceAddressEXT( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetBufferDeviceAddressEXT( device, pInfo );
+ }
+
+ //=== VK_EXT_tooling_info ===
+
+ VkResult vkGetPhysicalDeviceToolPropertiesEXT( VkPhysicalDevice physicalDevice,
+ uint32_t * pToolCount,
+ VkPhysicalDeviceToolProperties * pToolProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceToolPropertiesEXT( physicalDevice, pToolCount, pToolProperties );
+ }
+
+ //=== VK_KHR_present_wait ===
+
+ VkResult vkWaitForPresentKHR( VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkWaitForPresentKHR( device, swapchain, presentId, timeout );
+ }
+
+ //=== VK_NV_cooperative_matrix ===
+
+ VkResult vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( VkPhysicalDevice physicalDevice,
+ uint32_t * pPropertyCount,
+ VkCooperativeMatrixPropertiesNV * pProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( physicalDevice, pPropertyCount, pProperties );
+ }
+
+ //=== VK_NV_coverage_reduction_mode ===
+
+ VkResult vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
+ VkPhysicalDevice physicalDevice, uint32_t * pCombinationCount, VkFramebufferMixedSamplesCombinationNV * pCombinations ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( physicalDevice, pCombinationCount, pCombinations );
+ }
+
+# if defined( VK_USE_PLATFORM_WIN32_KHR )
+ //=== VK_EXT_full_screen_exclusive ===
+
+ VkResult vkGetPhysicalDeviceSurfacePresentModes2EXT( VkPhysicalDevice physicalDevice,
+ const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
+ uint32_t * pPresentModeCount,
+ VkPresentModeKHR * pPresentModes ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceSurfacePresentModes2EXT( physicalDevice, pSurfaceInfo, pPresentModeCount, pPresentModes );
+ }
+
+ VkResult vkAcquireFullScreenExclusiveModeEXT( VkDevice device, VkSwapchainKHR swapchain ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkAcquireFullScreenExclusiveModeEXT( device, swapchain );
+ }
+
+ VkResult vkReleaseFullScreenExclusiveModeEXT( VkDevice device, VkSwapchainKHR swapchain ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkReleaseFullScreenExclusiveModeEXT( device, swapchain );
+ }
+
+ VkResult vkGetDeviceGroupSurfacePresentModes2EXT( VkDevice device,
+ const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
+ VkDeviceGroupPresentModeFlagsKHR * pModes ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetDeviceGroupSurfacePresentModes2EXT( device, pSurfaceInfo, pModes );
+ }
+# endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+ //=== VK_EXT_headless_surface ===
+
+ VkResult vkCreateHeadlessSurfaceEXT( VkInstance instance,
+ const VkHeadlessSurfaceCreateInfoEXT * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateHeadlessSurfaceEXT( instance, pCreateInfo, pAllocator, pSurface );
+ }
+
+ //=== VK_KHR_buffer_device_address ===
+
+ VkDeviceAddress vkGetBufferDeviceAddressKHR( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetBufferDeviceAddressKHR( device, pInfo );
+ }
+
+ uint64_t vkGetBufferOpaqueCaptureAddressKHR( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetBufferOpaqueCaptureAddressKHR( device, pInfo );
+ }
+
+ uint64_t vkGetDeviceMemoryOpaqueCaptureAddressKHR( VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetDeviceMemoryOpaqueCaptureAddressKHR( device, pInfo );
+ }
+
+ //=== VK_EXT_line_rasterization ===
+
+ void vkCmdSetLineStippleEXT( VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetLineStippleEXT( commandBuffer, lineStippleFactor, lineStipplePattern );
+ }
+
+ //=== VK_EXT_host_query_reset ===
+
+ void vkResetQueryPoolEXT( VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkResetQueryPoolEXT( device, queryPool, firstQuery, queryCount );
+ }
+
+ //=== VK_EXT_extended_dynamic_state ===
+
+ void vkCmdSetCullModeEXT( VkCommandBuffer commandBuffer, VkCullModeFlags cullMode ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetCullModeEXT( commandBuffer, cullMode );
+ }
+
+ void vkCmdSetFrontFaceEXT( VkCommandBuffer commandBuffer, VkFrontFace frontFace ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetFrontFaceEXT( commandBuffer, frontFace );
+ }
+
+ void vkCmdSetPrimitiveTopologyEXT( VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetPrimitiveTopologyEXT( commandBuffer, primitiveTopology );
+ }
+
+ void vkCmdSetViewportWithCountEXT( VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport * pViewports ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetViewportWithCountEXT( commandBuffer, viewportCount, pViewports );
+ }
+
+ void vkCmdSetScissorWithCountEXT( VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D * pScissors ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetScissorWithCountEXT( commandBuffer, scissorCount, pScissors );
+ }
+
+ void vkCmdBindVertexBuffers2EXT( VkCommandBuffer commandBuffer,
+ uint32_t firstBinding,
+ uint32_t bindingCount,
+ const VkBuffer * pBuffers,
+ const VkDeviceSize * pOffsets,
+ const VkDeviceSize * pSizes,
+ const VkDeviceSize * pStrides ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdBindVertexBuffers2EXT( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides );
+ }
+
+ void vkCmdSetDepthTestEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetDepthTestEnableEXT( commandBuffer, depthTestEnable );
+ }
+
+ void vkCmdSetDepthWriteEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetDepthWriteEnableEXT( commandBuffer, depthWriteEnable );
+ }
+
+ void vkCmdSetDepthCompareOpEXT( VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetDepthCompareOpEXT( commandBuffer, depthCompareOp );
+ }
+
+ void vkCmdSetDepthBoundsTestEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetDepthBoundsTestEnableEXT( commandBuffer, depthBoundsTestEnable );
+ }
+
+ void vkCmdSetStencilTestEnableEXT( VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetStencilTestEnableEXT( commandBuffer, stencilTestEnable );
+ }
+
+ void vkCmdSetStencilOpEXT( VkCommandBuffer commandBuffer,
+ VkStencilFaceFlags faceMask,
+ VkStencilOp failOp,
+ VkStencilOp passOp,
+ VkStencilOp depthFailOp,
+ VkCompareOp compareOp ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetStencilOpEXT( commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp );
+ }
+
+ //=== VK_KHR_deferred_host_operations ===
+
+ VkResult vkCreateDeferredOperationKHR( VkDevice device,
+ const VkAllocationCallbacks * pAllocator,
+ VkDeferredOperationKHR * pDeferredOperation ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateDeferredOperationKHR( device, pAllocator, pDeferredOperation );
+ }
+
+ void vkDestroyDeferredOperationKHR( VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDestroyDeferredOperationKHR( device, operation, pAllocator );
+ }
+
+ uint32_t vkGetDeferredOperationMaxConcurrencyKHR( VkDevice device, VkDeferredOperationKHR operation ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetDeferredOperationMaxConcurrencyKHR( device, operation );
+ }
+
+ VkResult vkGetDeferredOperationResultKHR( VkDevice device, VkDeferredOperationKHR operation ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetDeferredOperationResultKHR( device, operation );
+ }
+
+ VkResult vkDeferredOperationJoinKHR( VkDevice device, VkDeferredOperationKHR operation ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDeferredOperationJoinKHR( device, operation );
+ }
+
+ //=== VK_KHR_pipeline_executable_properties ===
+
+ VkResult vkGetPipelineExecutablePropertiesKHR( VkDevice device,
+ const VkPipelineInfoKHR * pPipelineInfo,
+ uint32_t * pExecutableCount,
+ VkPipelineExecutablePropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPipelineExecutablePropertiesKHR( device, pPipelineInfo, pExecutableCount, pProperties );
+ }
+
+ VkResult vkGetPipelineExecutableStatisticsKHR( VkDevice device,
+ const VkPipelineExecutableInfoKHR * pExecutableInfo,
+ uint32_t * pStatisticCount,
+ VkPipelineExecutableStatisticKHR * pStatistics ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPipelineExecutableStatisticsKHR( device, pExecutableInfo, pStatisticCount, pStatistics );
+ }
+
+ VkResult
+ vkGetPipelineExecutableInternalRepresentationsKHR( VkDevice device,
+ const VkPipelineExecutableInfoKHR * pExecutableInfo,
+ uint32_t * pInternalRepresentationCount,
+ VkPipelineExecutableInternalRepresentationKHR * pInternalRepresentations ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPipelineExecutableInternalRepresentationsKHR( device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations );
+ }
+
+ //=== VK_NV_device_generated_commands ===
+
+ void vkGetGeneratedCommandsMemoryRequirementsNV( VkDevice device,
+ const VkGeneratedCommandsMemoryRequirementsInfoNV * pInfo,
+ VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetGeneratedCommandsMemoryRequirementsNV( device, pInfo, pMemoryRequirements );
+ }
+
+ void vkCmdPreprocessGeneratedCommandsNV( VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV * pGeneratedCommandsInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdPreprocessGeneratedCommandsNV( commandBuffer, pGeneratedCommandsInfo );
+ }
+
+ void vkCmdExecuteGeneratedCommandsNV( VkCommandBuffer commandBuffer,
+ VkBool32 isPreprocessed,
+ const VkGeneratedCommandsInfoNV * pGeneratedCommandsInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdExecuteGeneratedCommandsNV( commandBuffer, isPreprocessed, pGeneratedCommandsInfo );
+ }
+
+ void vkCmdBindPipelineShaderGroupNV( VkCommandBuffer commandBuffer,
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipeline pipeline,
+ uint32_t groupIndex ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdBindPipelineShaderGroupNV( commandBuffer, pipelineBindPoint, pipeline, groupIndex );
+ }
+
+ VkResult vkCreateIndirectCommandsLayoutNV( VkDevice device,
+ const VkIndirectCommandsLayoutCreateInfoNV * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkIndirectCommandsLayoutNV * pIndirectCommandsLayout ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateIndirectCommandsLayoutNV( device, pCreateInfo, pAllocator, pIndirectCommandsLayout );
+ }
+
+ void vkDestroyIndirectCommandsLayoutNV( VkDevice device,
+ VkIndirectCommandsLayoutNV indirectCommandsLayout,
+ const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDestroyIndirectCommandsLayoutNV( device, indirectCommandsLayout, pAllocator );
+ }
+
+ //=== VK_EXT_acquire_drm_display ===
+
+ VkResult vkAcquireDrmDisplayEXT( VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkAcquireDrmDisplayEXT( physicalDevice, drmFd, display );
+ }
+
+ VkResult vkGetDrmDisplayEXT( VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR * display ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetDrmDisplayEXT( physicalDevice, drmFd, connectorId, display );
+ }
+
+ //=== VK_EXT_private_data ===
+
+ VkResult vkCreatePrivateDataSlotEXT( VkDevice device,
+ const VkPrivateDataSlotCreateInfo * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkPrivateDataSlot * pPrivateDataSlot ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreatePrivateDataSlotEXT( device, pCreateInfo, pAllocator, pPrivateDataSlot );
+ }
+
+ void vkDestroyPrivateDataSlotEXT( VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDestroyPrivateDataSlotEXT( device, privateDataSlot, pAllocator );
+ }
+
+ VkResult vkSetPrivateDataEXT( VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data ) const
+ VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkSetPrivateDataEXT( device, objectType, objectHandle, privateDataSlot, data );
+ }
+
+ void vkGetPrivateDataEXT( VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t * pData ) const
+ VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPrivateDataEXT( device, objectType, objectHandle, privateDataSlot, pData );
+ }
+
+# if defined( VK_ENABLE_BETA_EXTENSIONS )
+ //=== VK_KHR_video_encode_queue ===
+
+ void vkCmdEncodeVideoKHR( VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR * pEncodeInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdEncodeVideoKHR( commandBuffer, pEncodeInfo );
+ }
+# endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+# if defined( VK_USE_PLATFORM_METAL_EXT )
+ //=== VK_EXT_metal_objects ===
+
+ void vkExportMetalObjectsEXT( VkDevice device, VkExportMetalObjectsInfoEXT * pMetalObjectsInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkExportMetalObjectsEXT( device, pMetalObjectsInfo );
+ }
+# endif /*VK_USE_PLATFORM_METAL_EXT*/
+
+ //=== VK_KHR_synchronization2 ===
+
+ void vkCmdSetEvent2KHR( VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetEvent2KHR( commandBuffer, event, pDependencyInfo );
+ }
+
+ void vkCmdResetEvent2KHR( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdResetEvent2KHR( commandBuffer, event, stageMask );
+ }
+
+ void vkCmdWaitEvents2KHR( VkCommandBuffer commandBuffer,
+ uint32_t eventCount,
+ const VkEvent * pEvents,
+ const VkDependencyInfo * pDependencyInfos ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdWaitEvents2KHR( commandBuffer, eventCount, pEvents, pDependencyInfos );
+ }
+
+ void vkCmdPipelineBarrier2KHR( VkCommandBuffer commandBuffer, const VkDependencyInfo * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdPipelineBarrier2KHR( commandBuffer, pDependencyInfo );
+ }
+
+ void vkCmdWriteTimestamp2KHR( VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdWriteTimestamp2KHR( commandBuffer, stage, queryPool, query );
+ }
+
+ VkResult vkQueueSubmit2KHR( VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 * pSubmits, VkFence fence ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkQueueSubmit2KHR( queue, submitCount, pSubmits, fence );
+ }
+
+ void vkCmdWriteBufferMarker2AMD(
+ VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdWriteBufferMarker2AMD( commandBuffer, stage, dstBuffer, dstOffset, marker );
+ }
+
+ void vkGetQueueCheckpointData2NV( VkQueue queue, uint32_t * pCheckpointDataCount, VkCheckpointData2NV * pCheckpointData ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetQueueCheckpointData2NV( queue, pCheckpointDataCount, pCheckpointData );
+ }
+
+ //=== VK_NV_fragment_shading_rate_enums ===
+
+ void vkCmdSetFragmentShadingRateEnumNV( VkCommandBuffer commandBuffer,
+ VkFragmentShadingRateNV shadingRate,
+ const VkFragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetFragmentShadingRateEnumNV( commandBuffer, shadingRate, combinerOps );
+ }
+
+ //=== VK_KHR_copy_commands2 ===
+
+ void vkCmdCopyBuffer2KHR( VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 * pCopyBufferInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdCopyBuffer2KHR( commandBuffer, pCopyBufferInfo );
+ }
+
+ void vkCmdCopyImage2KHR( VkCommandBuffer commandBuffer, const VkCopyImageInfo2 * pCopyImageInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdCopyImage2KHR( commandBuffer, pCopyImageInfo );
+ }
+
+ void vkCmdCopyBufferToImage2KHR( VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 * pCopyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdCopyBufferToImage2KHR( commandBuffer, pCopyBufferToImageInfo );
+ }
+
+ void vkCmdCopyImageToBuffer2KHR( VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 * pCopyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdCopyImageToBuffer2KHR( commandBuffer, pCopyImageToBufferInfo );
+ }
+
+ void vkCmdBlitImage2KHR( VkCommandBuffer commandBuffer, const VkBlitImageInfo2 * pBlitImageInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdBlitImage2KHR( commandBuffer, pBlitImageInfo );
+ }
+
+ void vkCmdResolveImage2KHR( VkCommandBuffer commandBuffer, const VkResolveImageInfo2 * pResolveImageInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdResolveImage2KHR( commandBuffer, pResolveImageInfo );
+ }
+
+ //=== VK_EXT_image_compression_control ===
+
+ void vkGetImageSubresourceLayout2EXT( VkDevice device,
+ VkImage image,
+ const VkImageSubresource2EXT * pSubresource,
+ VkSubresourceLayout2EXT * pLayout ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetImageSubresourceLayout2EXT( device, image, pSubresource, pLayout );
+ }
+
+# if defined( VK_USE_PLATFORM_WIN32_KHR )
+ //=== VK_NV_acquire_winrt_display ===
+
+ VkResult vkAcquireWinrtDisplayNV( VkPhysicalDevice physicalDevice, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkAcquireWinrtDisplayNV( physicalDevice, display );
+ }
+
+ VkResult vkGetWinrtDisplayNV( VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR * pDisplay ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetWinrtDisplayNV( physicalDevice, deviceRelativeId, pDisplay );
+ }
+# endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+# if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
+ //=== VK_EXT_directfb_surface ===
+
+ VkResult vkCreateDirectFBSurfaceEXT( VkInstance instance,
+ const VkDirectFBSurfaceCreateInfoEXT * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateDirectFBSurfaceEXT( instance, pCreateInfo, pAllocator, pSurface );
+ }
+
+ VkBool32
+ vkGetPhysicalDeviceDirectFBPresentationSupportEXT( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, IDirectFB * dfb ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceDirectFBPresentationSupportEXT( physicalDevice, queueFamilyIndex, dfb );
+ }
+# endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
+
+ //=== VK_KHR_ray_tracing_pipeline ===
+
+ void vkCmdTraceRaysKHR( VkCommandBuffer commandBuffer,
+ const VkStridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
+ const VkStridedDeviceAddressRegionKHR * pMissShaderBindingTable,
+ const VkStridedDeviceAddressRegionKHR * pHitShaderBindingTable,
+ const VkStridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
+ uint32_t width,
+ uint32_t height,
+ uint32_t depth ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdTraceRaysKHR(
+ commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth );
+ }
+
+ VkResult vkCreateRayTracingPipelinesKHR( VkDevice device,
+ VkDeferredOperationKHR deferredOperation,
+ VkPipelineCache pipelineCache,
+ uint32_t createInfoCount,
+ const VkRayTracingPipelineCreateInfoKHR * pCreateInfos,
+ const VkAllocationCallbacks * pAllocator,
+ VkPipeline * pPipelines ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateRayTracingPipelinesKHR( device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
+ }
+
+ VkResult vkGetRayTracingShaderGroupHandlesKHR(
+ VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetRayTracingShaderGroupHandlesKHR( device, pipeline, firstGroup, groupCount, dataSize, pData );
+ }
+
+ VkResult vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(
+ VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( device, pipeline, firstGroup, groupCount, dataSize, pData );
+ }
+
+ void vkCmdTraceRaysIndirectKHR( VkCommandBuffer commandBuffer,
+ const VkStridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
+ const VkStridedDeviceAddressRegionKHR * pMissShaderBindingTable,
+ const VkStridedDeviceAddressRegionKHR * pHitShaderBindingTable,
+ const VkStridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
+ VkDeviceAddress indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdTraceRaysIndirectKHR(
+ commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress );
+ }
+
+ VkDeviceSize vkGetRayTracingShaderGroupStackSizeKHR( VkDevice device,
+ VkPipeline pipeline,
+ uint32_t group,
+ VkShaderGroupShaderKHR groupShader ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetRayTracingShaderGroupStackSizeKHR( device, pipeline, group, groupShader );
+ }
+
+ void vkCmdSetRayTracingPipelineStackSizeKHR( VkCommandBuffer commandBuffer, uint32_t pipelineStackSize ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetRayTracingPipelineStackSizeKHR( commandBuffer, pipelineStackSize );
+ }
+
+ //=== VK_EXT_vertex_input_dynamic_state ===
+
+ void vkCmdSetVertexInputEXT( VkCommandBuffer commandBuffer,
+ uint32_t vertexBindingDescriptionCount,
+ const VkVertexInputBindingDescription2EXT * pVertexBindingDescriptions,
+ uint32_t vertexAttributeDescriptionCount,
+ const VkVertexInputAttributeDescription2EXT * pVertexAttributeDescriptions ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetVertexInputEXT(
+ commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions );
+ }
+
+# if defined( VK_USE_PLATFORM_FUCHSIA )
+ //=== VK_FUCHSIA_external_memory ===
+
+ VkResult vkGetMemoryZirconHandleFUCHSIA( VkDevice device,
+ const VkMemoryGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
+ zx_handle_t * pZirconHandle ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetMemoryZirconHandleFUCHSIA( device, pGetZirconHandleInfo, pZirconHandle );
+ }
+
+ VkResult vkGetMemoryZirconHandlePropertiesFUCHSIA( VkDevice device,
+ VkExternalMemoryHandleTypeFlagBits handleType,
+ zx_handle_t zirconHandle,
+ VkMemoryZirconHandlePropertiesFUCHSIA * pMemoryZirconHandleProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetMemoryZirconHandlePropertiesFUCHSIA( device, handleType, zirconHandle, pMemoryZirconHandleProperties );
+ }
+# endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+# if defined( VK_USE_PLATFORM_FUCHSIA )
+ //=== VK_FUCHSIA_external_semaphore ===
+
+ VkResult vkImportSemaphoreZirconHandleFUCHSIA( VkDevice device,
+ const VkImportSemaphoreZirconHandleInfoFUCHSIA * pImportSemaphoreZirconHandleInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkImportSemaphoreZirconHandleFUCHSIA( device, pImportSemaphoreZirconHandleInfo );
+ }
+
+ VkResult vkGetSemaphoreZirconHandleFUCHSIA( VkDevice device,
+ const VkSemaphoreGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
+ zx_handle_t * pZirconHandle ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetSemaphoreZirconHandleFUCHSIA( device, pGetZirconHandleInfo, pZirconHandle );
+ }
+# endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+# if defined( VK_USE_PLATFORM_FUCHSIA )
+ //=== VK_FUCHSIA_buffer_collection ===
+
+ VkResult vkCreateBufferCollectionFUCHSIA( VkDevice device,
+ const VkBufferCollectionCreateInfoFUCHSIA * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkBufferCollectionFUCHSIA * pCollection ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateBufferCollectionFUCHSIA( device, pCreateInfo, pAllocator, pCollection );
+ }
+
+ VkResult vkSetBufferCollectionImageConstraintsFUCHSIA( VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkImageConstraintsInfoFUCHSIA * pImageConstraintsInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkSetBufferCollectionImageConstraintsFUCHSIA( device, collection, pImageConstraintsInfo );
+ }
+
+ VkResult vkSetBufferCollectionBufferConstraintsFUCHSIA( VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkBufferConstraintsInfoFUCHSIA * pBufferConstraintsInfo ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkSetBufferCollectionBufferConstraintsFUCHSIA( device, collection, pBufferConstraintsInfo );
+ }
+
+ void vkDestroyBufferCollectionFUCHSIA( VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkDestroyBufferCollectionFUCHSIA( device, collection, pAllocator );
+ }
+
+ VkResult vkGetBufferCollectionPropertiesFUCHSIA( VkDevice device,
+ VkBufferCollectionFUCHSIA collection,
+ VkBufferCollectionPropertiesFUCHSIA * pProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetBufferCollectionPropertiesFUCHSIA( device, collection, pProperties );
+ }
+# endif /*VK_USE_PLATFORM_FUCHSIA*/
+
+ //=== VK_HUAWEI_subpass_shading ===
+
+ VkResult
+ vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( VkDevice device, VkRenderPass renderpass, VkExtent2D * pMaxWorkgroupSize ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( device, renderpass, pMaxWorkgroupSize );
+ }
+
+ void vkCmdSubpassShadingHUAWEI( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSubpassShadingHUAWEI( commandBuffer );
+ }
+
+ //=== VK_HUAWEI_invocation_mask ===
+
+ void vkCmdBindInvocationMaskHUAWEI( VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdBindInvocationMaskHUAWEI( commandBuffer, imageView, imageLayout );
+ }
+
+ //=== VK_NV_external_memory_rdma ===
+
+ VkResult vkGetMemoryRemoteAddressNV( VkDevice device,
+ const VkMemoryGetRemoteAddressInfoNV * pMemoryGetRemoteAddressInfo,
+ VkRemoteAddressNV * pAddress ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetMemoryRemoteAddressNV( device, pMemoryGetRemoteAddressInfo, pAddress );
+ }
+
+ //=== VK_EXT_pipeline_properties ===
+
+ VkResult
+ vkGetPipelinePropertiesEXT( VkDevice device, const VkPipelineInfoEXT * pPipelineInfo, VkBaseOutStructure * pPipelineProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPipelinePropertiesEXT( device, pPipelineInfo, pPipelineProperties );
+ }
+
+ //=== VK_EXT_extended_dynamic_state2 ===
+
+ void vkCmdSetPatchControlPointsEXT( VkCommandBuffer commandBuffer, uint32_t patchControlPoints ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetPatchControlPointsEXT( commandBuffer, patchControlPoints );
+ }
+
+ void vkCmdSetRasterizerDiscardEnableEXT( VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetRasterizerDiscardEnableEXT( commandBuffer, rasterizerDiscardEnable );
+ }
+
+ void vkCmdSetDepthBiasEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetDepthBiasEnableEXT( commandBuffer, depthBiasEnable );
+ }
+
+ void vkCmdSetLogicOpEXT( VkCommandBuffer commandBuffer, VkLogicOp logicOp ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetLogicOpEXT( commandBuffer, logicOp );
+ }
+
+ void vkCmdSetPrimitiveRestartEnableEXT( VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetPrimitiveRestartEnableEXT( commandBuffer, primitiveRestartEnable );
+ }
+
+# if defined( VK_USE_PLATFORM_SCREEN_QNX )
+ //=== VK_QNX_screen_surface ===
+
+ VkResult vkCreateScreenSurfaceQNX( VkInstance instance,
+ const VkScreenSurfaceCreateInfoQNX * pCreateInfo,
+ const VkAllocationCallbacks * pAllocator,
+ VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCreateScreenSurfaceQNX( instance, pCreateInfo, pAllocator, pSurface );
+ }
+
+ VkBool32 vkGetPhysicalDeviceScreenPresentationSupportQNX( VkPhysicalDevice physicalDevice,
+ uint32_t queueFamilyIndex,
+ struct _screen_window * window ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetPhysicalDeviceScreenPresentationSupportQNX( physicalDevice, queueFamilyIndex, window );
+ }
+# endif /*VK_USE_PLATFORM_SCREEN_QNX*/
+
+ //=== VK_EXT_color_write_enable ===
+
+ void vkCmdSetColorWriteEnableEXT( VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32 * pColorWriteEnables ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdSetColorWriteEnableEXT( commandBuffer, attachmentCount, pColorWriteEnables );
+ }
+
+ //=== VK_KHR_ray_tracing_maintenance1 ===
+
+ void vkCmdTraceRaysIndirect2KHR( VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdTraceRaysIndirect2KHR( commandBuffer, indirectDeviceAddress );
+ }
+
+ //=== VK_EXT_multi_draw ===
+
+ void vkCmdDrawMultiEXT( VkCommandBuffer commandBuffer,
+ uint32_t drawCount,
+ const VkMultiDrawInfoEXT * pVertexInfo,
+ uint32_t instanceCount,
+ uint32_t firstInstance,
+ uint32_t stride ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdDrawMultiEXT( commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride );
+ }
+
+ void vkCmdDrawMultiIndexedEXT( VkCommandBuffer commandBuffer,
+ uint32_t drawCount,
+ const VkMultiDrawIndexedInfoEXT * pIndexInfo,
+ uint32_t instanceCount,
+ uint32_t firstInstance,
+ uint32_t stride,
+ const int32_t * pVertexOffset ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkCmdDrawMultiIndexedEXT( commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset );
+ }
+
+ //=== VK_EXT_pageable_device_local_memory ===
+
+ void vkSetDeviceMemoryPriorityEXT( VkDevice device, VkDeviceMemory memory, float priority ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkSetDeviceMemoryPriorityEXT( device, memory, priority );
+ }
+
+ //=== VK_KHR_maintenance4 ===
+
+ void vkGetDeviceBufferMemoryRequirementsKHR( VkDevice device,
+ const VkDeviceBufferMemoryRequirements * pInfo,
+ VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetDeviceBufferMemoryRequirementsKHR( device, pInfo, pMemoryRequirements );
+ }
+
+ void vkGetDeviceImageMemoryRequirementsKHR( VkDevice device,
+ const VkDeviceImageMemoryRequirements * pInfo,
+ VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetDeviceImageMemoryRequirementsKHR( device, pInfo, pMemoryRequirements );
+ }
+
+ void vkGetDeviceImageSparseMemoryRequirementsKHR( VkDevice device,
+ const VkDeviceImageMemoryRequirements * pInfo,
+ uint32_t * pSparseMemoryRequirementCount,
+ VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetDeviceImageSparseMemoryRequirementsKHR( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
+ }
+
+ //=== VK_VALVE_descriptor_set_host_mapping ===
+
+ void vkGetDescriptorSetLayoutHostMappingInfoVALVE( VkDevice device,
+ const VkDescriptorSetBindingReferenceVALVE * pBindingReference,
+ VkDescriptorSetLayoutHostMappingInfoVALVE * pHostMapping ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetDescriptorSetLayoutHostMappingInfoVALVE( device, pBindingReference, pHostMapping );
+ }
+
+ void vkGetDescriptorSetHostMappingVALVE( VkDevice device, VkDescriptorSet descriptorSet, void ** ppData ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetDescriptorSetHostMappingVALVE( device, descriptorSet, ppData );
+ }
+
+ //=== VK_EXT_shader_module_identifier ===
+
+ void vkGetShaderModuleIdentifierEXT( VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT * pIdentifier ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetShaderModuleIdentifierEXT( device, shaderModule, pIdentifier );
+ }
+
+ void vkGetShaderModuleCreateInfoIdentifierEXT( VkDevice device,
+ const VkShaderModuleCreateInfo * pCreateInfo,
+ VkShaderModuleIdentifierEXT * pIdentifier ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetShaderModuleCreateInfoIdentifierEXT( device, pCreateInfo, pIdentifier );
+ }
+
+ //=== VK_QCOM_tile_properties ===
+
+ VkResult vkGetFramebufferTilePropertiesQCOM( VkDevice device,
+ VkFramebuffer framebuffer,
+ uint32_t * pPropertiesCount,
+ VkTilePropertiesQCOM * pProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetFramebufferTilePropertiesQCOM( device, framebuffer, pPropertiesCount, pProperties );
+ }
+
+ VkResult vkGetDynamicRenderingTilePropertiesQCOM( VkDevice device,
+ const VkRenderingInfo * pRenderingInfo,
+ VkTilePropertiesQCOM * pProperties ) const VULKAN_HPP_NOEXCEPT
+ {
+ return ::vkGetDynamicRenderingTilePropertiesQCOM( device, pRenderingInfo, pProperties );
+ }
+ };
#endif
-class DispatchLoaderBase
-{
-public:
- DispatchLoaderBase() = default;
- DispatchLoaderBase(std::nullptr_t)
-#if !defined(NDEBUG)
- : m_valid(false)
-#endif
- {
- }
-
-#if !defined(NDEBUG)
- size_t getVkHeaderVersion() const
- {
- VULKAN_HPP_ASSERT(m_valid);
- return vkHeaderVersion;
- }
-
-private:
- size_t vkHeaderVersion = VK_HEADER_VERSION;
- bool m_valid = true;
-#endif
-};
-
-#if !defined(VK_NO_PROTOTYPES)
-class DispatchLoaderStatic : public DispatchLoaderBase
-{
-public:
- //=== VK_VERSION_1_0 ===
-
- VkResult
- vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkInstance *pInstance) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateInstance(pCreateInfo, pAllocator, pInstance);
- }
-
- void vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDestroyInstance(instance, pAllocator);
- }
-
- VkResult vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, VkPhysicalDevice *pPhysicalDevices) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkEnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices);
- }
-
- void vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceFeatures(physicalDevice, pFeatures);
- }
-
- void
- vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties *pFormatProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties);
- }
-
- VkResult vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice,
- VkFormat format,
- VkImageType type,
- VkImageTiling tiling,
- VkImageUsageFlags usage,
- VkImageCreateFlags flags,
- VkImageFormatProperties *pImageFormatProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
- }
-
- void vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceProperties(physicalDevice, pProperties);
- }
-
- void vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice,
- uint32_t *pQueueFamilyPropertyCount,
- VkQueueFamilyProperties *pQueueFamilyProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
- }
-
- void vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties *pMemoryProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
- }
-
- PFN_vkVoidFunction vkGetInstanceProcAddr(VkInstance instance, const char *pName) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetInstanceProcAddr(instance, pName);
- }
-
- PFN_vkVoidFunction vkGetDeviceProcAddr(VkDevice device, const char *pName) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetDeviceProcAddr(device, pName);
- }
-
- VkResult vkCreateDevice(VkPhysicalDevice physicalDevice,
- const VkDeviceCreateInfo *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkDevice *pDevice) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
- }
-
- void vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDestroyDevice(device, pAllocator);
- }
-
- VkResult vkEnumerateInstanceExtensionProperties(const char *pLayerName,
- uint32_t *pPropertyCount,
- VkExtensionProperties *pProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkEnumerateInstanceExtensionProperties(pLayerName, pPropertyCount, pProperties);
- }
-
- VkResult vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,
- const char *pLayerName,
- uint32_t *pPropertyCount,
- VkExtensionProperties *pProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkEnumerateDeviceExtensionProperties(physicalDevice, pLayerName, pPropertyCount, pProperties);
- }
-
- VkResult vkEnumerateInstanceLayerProperties(uint32_t *pPropertyCount, VkLayerProperties *pProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkEnumerateInstanceLayerProperties(pPropertyCount, pProperties);
- }
-
- VkResult
- vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkLayerProperties *pProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkEnumerateDeviceLayerProperties(physicalDevice, pPropertyCount, pProperties);
- }
-
- void vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
- }
-
- VkResult vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkQueueSubmit(queue, submitCount, pSubmits, fence);
- }
-
- VkResult vkQueueWaitIdle(VkQueue queue) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkQueueWaitIdle(queue);
- }
-
- VkResult vkDeviceWaitIdle(VkDevice device) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDeviceWaitIdle(device);
- }
-
- VkResult vkAllocateMemory(VkDevice device,
- const VkMemoryAllocateInfo *pAllocateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkDeviceMemory *pMemory) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkAllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
- }
-
- void vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkFreeMemory(device, memory, pAllocator);
- }
-
- VkResult vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void **ppData) const
- VULKAN_HPP_NOEXCEPT
- {
- return ::vkMapMemory(device, memory, offset, size, flags, ppData);
- }
-
- void vkUnmapMemory(VkDevice device, VkDeviceMemory memory) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkUnmapMemory(device, memory);
- }
-
- VkResult vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkFlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
- }
-
- VkResult vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkInvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
- }
-
- void vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize *pCommittedMemoryInBytes) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
- }
-
- VkResult vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkBindBufferMemory(device, buffer, memory, memoryOffset);
- }
-
- VkResult vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkBindImageMemory(device, image, memory, memoryOffset);
- }
-
- void vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
- }
-
- void vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetImageMemoryRequirements(device, image, pMemoryRequirements);
- }
-
- void vkGetImageSparseMemoryRequirements(VkDevice device,
- VkImage image,
- uint32_t *pSparseMemoryRequirementCount,
- VkSparseImageMemoryRequirements *pSparseMemoryRequirements) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
- }
-
- void vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice,
- VkFormat format,
- VkImageType type,
- VkSampleCountFlagBits samples,
- VkImageUsageFlags usage,
- VkImageTiling tiling,
- uint32_t *pPropertyCount,
- VkSparseImageFormatProperties *pProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
- }
-
- VkResult vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo *pBindInfo, VkFence fence) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkQueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
- }
-
- VkResult vkCreateFence(VkDevice device,
- const VkFenceCreateInfo *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkFence *pFence) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateFence(device, pCreateInfo, pAllocator, pFence);
- }
-
- void vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDestroyFence(device, fence, pAllocator);
- }
-
- VkResult vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkResetFences(device, fenceCount, pFences);
- }
-
- VkResult vkGetFenceStatus(VkDevice device, VkFence fence) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetFenceStatus(device, fence);
- }
-
- VkResult vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, uint64_t timeout) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkWaitForFences(device, fenceCount, pFences, waitAll, timeout);
- }
-
- VkResult vkCreateSemaphore(VkDevice device,
- const VkSemaphoreCreateInfo *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkSemaphore *pSemaphore) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
- }
-
- void vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDestroySemaphore(device, semaphore, pAllocator);
- }
-
- VkResult vkCreateEvent(VkDevice device,
- const VkEventCreateInfo *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkEvent *pEvent) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateEvent(device, pCreateInfo, pAllocator, pEvent);
- }
-
- void vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDestroyEvent(device, event, pAllocator);
- }
-
- VkResult vkGetEventStatus(VkDevice device, VkEvent event) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetEventStatus(device, event);
- }
-
- VkResult vkSetEvent(VkDevice device, VkEvent event) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkSetEvent(device, event);
- }
-
- VkResult vkResetEvent(VkDevice device, VkEvent event) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkResetEvent(device, event);
- }
-
- VkResult vkCreateQueryPool(VkDevice device,
- const VkQueryPoolCreateInfo *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkQueryPool *pQueryPool) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
- }
-
- void vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDestroyQueryPool(device, queryPool, pAllocator);
- }
-
- VkResult vkGetQueryPoolResults(VkDevice device,
- VkQueryPool queryPool,
- uint32_t firstQuery,
- uint32_t queryCount,
- size_t dataSize,
- void *pData,
- VkDeviceSize stride,
- VkQueryResultFlags flags) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
- }
-
- VkResult vkCreateBuffer(VkDevice device,
- const VkBufferCreateInfo *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkBuffer *pBuffer) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
- }
-
- void vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDestroyBuffer(device, buffer, pAllocator);
- }
-
- VkResult vkCreateBufferView(VkDevice device,
- const VkBufferViewCreateInfo *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkBufferView *pView) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateBufferView(device, pCreateInfo, pAllocator, pView);
- }
-
- void vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDestroyBufferView(device, bufferView, pAllocator);
- }
-
- VkResult vkCreateImage(VkDevice device,
- const VkImageCreateInfo *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkImage *pImage) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateImage(device, pCreateInfo, pAllocator, pImage);
- }
-
- void vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDestroyImage(device, image, pAllocator);
- }
-
- void vkGetImageSubresourceLayout(VkDevice device,
- VkImage image,
- const VkImageSubresource *pSubresource,
- VkSubresourceLayout *pLayout) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetImageSubresourceLayout(device, image, pSubresource, pLayout);
- }
-
- VkResult vkCreateImageView(VkDevice device,
- const VkImageViewCreateInfo *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkImageView *pView) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateImageView(device, pCreateInfo, pAllocator, pView);
- }
-
- void vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDestroyImageView(device, imageView, pAllocator);
- }
-
- VkResult vkCreateShaderModule(VkDevice device,
- const VkShaderModuleCreateInfo *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkShaderModule *pShaderModule) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
- }
-
- void vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDestroyShaderModule(device, shaderModule, pAllocator);
- }
-
- VkResult vkCreatePipelineCache(VkDevice device,
- const VkPipelineCacheCreateInfo *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkPipelineCache *pPipelineCache) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
- }
-
- void vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDestroyPipelineCache(device, pipelineCache, pAllocator);
- }
-
- VkResult vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t *pDataSize, void *pData) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPipelineCacheData(device, pipelineCache, pDataSize, pData);
- }
-
- VkResult
- vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache *pSrcCaches) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkMergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
- }
-
- VkResult vkCreateGraphicsPipelines(VkDevice device,
- VkPipelineCache pipelineCache,
- uint32_t createInfoCount,
- const VkGraphicsPipelineCreateInfo *pCreateInfos,
- const VkAllocationCallbacks *pAllocator,
- VkPipeline *pPipelines) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
- }
-
- VkResult vkCreateComputePipelines(VkDevice device,
- VkPipelineCache pipelineCache,
- uint32_t createInfoCount,
- const VkComputePipelineCreateInfo *pCreateInfos,
- const VkAllocationCallbacks *pAllocator,
- VkPipeline *pPipelines) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
- }
-
- void vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDestroyPipeline(device, pipeline, pAllocator);
- }
-
- VkResult vkCreatePipelineLayout(VkDevice device,
- const VkPipelineLayoutCreateInfo *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkPipelineLayout *pPipelineLayout) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
- }
-
- void vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDestroyPipelineLayout(device, pipelineLayout, pAllocator);
- }
-
- VkResult vkCreateSampler(VkDevice device,
- const VkSamplerCreateInfo *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkSampler *pSampler) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateSampler(device, pCreateInfo, pAllocator, pSampler);
- }
-
- void vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDestroySampler(device, sampler, pAllocator);
- }
-
- VkResult vkCreateDescriptorSetLayout(VkDevice device,
- const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkDescriptorSetLayout *pSetLayout) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
- }
-
- void vkDestroyDescriptorSetLayout(VkDevice device,
- VkDescriptorSetLayout descriptorSetLayout,
- const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
- }
-
- VkResult vkCreateDescriptorPool(VkDevice device,
- const VkDescriptorPoolCreateInfo *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkDescriptorPool *pDescriptorPool) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
- }
-
- void vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDestroyDescriptorPool(device, descriptorPool, pAllocator);
- }
-
- VkResult vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkResetDescriptorPool(device, descriptorPool, flags);
- }
-
- VkResult vkAllocateDescriptorSets(VkDevice device,
- const VkDescriptorSetAllocateInfo *pAllocateInfo,
- VkDescriptorSet *pDescriptorSets) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkAllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
- }
-
- VkResult vkFreeDescriptorSets(VkDevice device,
- VkDescriptorPool descriptorPool,
- uint32_t descriptorSetCount,
- const VkDescriptorSet *pDescriptorSets) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkFreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets);
- }
-
- void vkUpdateDescriptorSets(VkDevice device,
- uint32_t descriptorWriteCount,
- const VkWriteDescriptorSet *pDescriptorWrites,
- uint32_t descriptorCopyCount,
- const VkCopyDescriptorSet *pDescriptorCopies) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkUpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
- }
-
- VkResult vkCreateFramebuffer(VkDevice device,
- const VkFramebufferCreateInfo *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkFramebuffer *pFramebuffer) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
- }
-
- void vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDestroyFramebuffer(device, framebuffer, pAllocator);
- }
-
- VkResult vkCreateRenderPass(VkDevice device,
- const VkRenderPassCreateInfo *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkRenderPass *pRenderPass) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
- }
-
- void vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDestroyRenderPass(device, renderPass, pAllocator);
- }
-
- void vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D *pGranularity) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetRenderAreaGranularity(device, renderPass, pGranularity);
- }
-
- VkResult vkCreateCommandPool(VkDevice device,
- const VkCommandPoolCreateInfo *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkCommandPool *pCommandPool) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
- }
-
- void vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDestroyCommandPool(device, commandPool, pAllocator);
- }
-
- VkResult vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkResetCommandPool(device, commandPool, flags);
- }
-
- VkResult vkAllocateCommandBuffers(VkDevice device,
- const VkCommandBufferAllocateInfo *pAllocateInfo,
- VkCommandBuffer *pCommandBuffers) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkAllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers);
- }
-
- void vkFreeCommandBuffers(VkDevice device,
- VkCommandPool commandPool,
- uint32_t commandBufferCount,
- const VkCommandBuffer *pCommandBuffers) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkFreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers);
- }
-
- VkResult vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkBeginCommandBuffer(commandBuffer, pBeginInfo);
- }
-
- VkResult vkEndCommandBuffer(VkCommandBuffer commandBuffer) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkEndCommandBuffer(commandBuffer);
- }
-
- VkResult vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkResetCommandBuffer(commandBuffer, flags);
- }
-
- void vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
- }
-
- void
- vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport *pViewports) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports);
- }
-
- void vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D *pScissors) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors);
- }
-
- void vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetLineWidth(commandBuffer, lineWidth);
- }
-
- void vkCmdSetDepthBias(VkCommandBuffer commandBuffer,
- float depthBiasConstantFactor,
- float depthBiasClamp,
- float depthBiasSlopeFactor) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
- }
-
- void vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetBlendConstants(commandBuffer, blendConstants);
- }
-
- void vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
- }
-
- void vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
- }
-
- void vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
- }
-
- void vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetStencilReference(commandBuffer, faceMask, reference);
- }
-
- void vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer,
- VkPipelineBindPoint pipelineBindPoint,
- VkPipelineLayout layout,
- uint32_t firstSet,
- uint32_t descriptorSetCount,
- const VkDescriptorSet *pDescriptorSets,
- uint32_t dynamicOffsetCount,
- const uint32_t *pDynamicOffsets) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdBindDescriptorSets(
- commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
- }
-
- void vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
- }
-
- void vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer,
- uint32_t firstBinding,
- uint32_t bindingCount,
- const VkBuffer *pBuffers,
- const VkDeviceSize *pOffsets) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
- }
-
- void vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) const
- VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
- }
-
- void vkCmdDrawIndexed(VkCommandBuffer commandBuffer,
- uint32_t indexCount,
- uint32_t instanceCount,
- uint32_t firstIndex,
- int32_t vertexOffset,
- uint32_t firstInstance) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
- }
-
- void vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride);
- }
-
- void vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) const
- VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride);
- }
-
- void vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ);
- }
-
- void vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdDispatchIndirect(commandBuffer, buffer, offset);
- }
-
- void vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy *pRegions) const
- VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
- }
-
- void vkCmdCopyImage(VkCommandBuffer commandBuffer,
- VkImage srcImage,
- VkImageLayout srcImageLayout,
- VkImage dstImage,
- VkImageLayout dstImageLayout,
- uint32_t regionCount,
- const VkImageCopy *pRegions) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
- }
-
- void vkCmdBlitImage(VkCommandBuffer commandBuffer,
- VkImage srcImage,
- VkImageLayout srcImageLayout,
- VkImage dstImage,
- VkImageLayout dstImageLayout,
- uint32_t regionCount,
- const VkImageBlit *pRegions,
- VkFilter filter) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
- }
-
- void vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer,
- VkBuffer srcBuffer,
- VkImage dstImage,
- VkImageLayout dstImageLayout,
- uint32_t regionCount,
- const VkBufferImageCopy *pRegions) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
- }
-
- void vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer,
- VkImage srcImage,
- VkImageLayout srcImageLayout,
- VkBuffer dstBuffer,
- uint32_t regionCount,
- const VkBufferImageCopy *pRegions) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
- }
-
- void vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void *pData) const
- VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
- }
-
- void
- vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
- }
-
- void vkCmdClearColorImage(VkCommandBuffer commandBuffer,
- VkImage image,
- VkImageLayout imageLayout,
- const VkClearColorValue *pColor,
- uint32_t rangeCount,
- const VkImageSubresourceRange *pRanges) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
- }
-
- void vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer,
- VkImage image,
- VkImageLayout imageLayout,
- const VkClearDepthStencilValue *pDepthStencil,
- uint32_t rangeCount,
- const VkImageSubresourceRange *pRanges) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
- }
-
- void vkCmdClearAttachments(VkCommandBuffer commandBuffer,
- uint32_t attachmentCount,
- const VkClearAttachment *pAttachments,
- uint32_t rectCount,
- const VkClearRect *pRects) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
- }
-
- void vkCmdResolveImage(VkCommandBuffer commandBuffer,
- VkImage srcImage,
- VkImageLayout srcImageLayout,
- VkImage dstImage,
- VkImageLayout dstImageLayout,
- uint32_t regionCount,
- const VkImageResolve *pRegions) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
- }
-
- void vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetEvent(commandBuffer, event, stageMask);
- }
-
- void vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdResetEvent(commandBuffer, event, stageMask);
- }
-
- void vkCmdWaitEvents(VkCommandBuffer commandBuffer,
- uint32_t eventCount,
- const VkEvent *pEvents,
- VkPipelineStageFlags srcStageMask,
- VkPipelineStageFlags dstStageMask,
- uint32_t memoryBarrierCount,
- const VkMemoryBarrier *pMemoryBarriers,
- uint32_t bufferMemoryBarrierCount,
- const VkBufferMemoryBarrier *pBufferMemoryBarriers,
- uint32_t imageMemoryBarrierCount,
- const VkImageMemoryBarrier *pImageMemoryBarriers) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdWaitEvents(commandBuffer,
- eventCount,
- pEvents,
- srcStageMask,
- dstStageMask,
- memoryBarrierCount,
- pMemoryBarriers,
- bufferMemoryBarrierCount,
- pBufferMemoryBarriers,
- imageMemoryBarrierCount,
- pImageMemoryBarriers);
- }
-
- void vkCmdPipelineBarrier(VkCommandBuffer commandBuffer,
- VkPipelineStageFlags srcStageMask,
- VkPipelineStageFlags dstStageMask,
- VkDependencyFlags dependencyFlags,
- uint32_t memoryBarrierCount,
- const VkMemoryBarrier *pMemoryBarriers,
- uint32_t bufferMemoryBarrierCount,
- const VkBufferMemoryBarrier *pBufferMemoryBarriers,
- uint32_t imageMemoryBarrierCount,
- const VkImageMemoryBarrier *pImageMemoryBarriers) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdPipelineBarrier(commandBuffer,
- srcStageMask,
- dstStageMask,
- dependencyFlags,
- memoryBarrierCount,
- pMemoryBarriers,
- bufferMemoryBarrierCount,
- pBufferMemoryBarriers,
- imageMemoryBarrierCount,
- pImageMemoryBarriers);
- }
-
- void vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdBeginQuery(commandBuffer, queryPool, query, flags);
- }
-
- void vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdEndQuery(commandBuffer, queryPool, query);
- }
-
- void vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount);
- }
-
- void vkCmdWriteTimestamp(VkCommandBuffer commandBuffer,
- VkPipelineStageFlagBits pipelineStage,
- VkQueryPool queryPool,
- uint32_t query) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query);
- }
-
- void vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer,
- VkQueryPool queryPool,
- uint32_t firstQuery,
- uint32_t queryCount,
- VkBuffer dstBuffer,
- VkDeviceSize dstOffset,
- VkDeviceSize stride,
- VkQueryResultFlags flags) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
- }
-
- void vkCmdPushConstants(VkCommandBuffer commandBuffer,
- VkPipelineLayout layout,
- VkShaderStageFlags stageFlags,
- uint32_t offset,
- uint32_t size,
- const void *pValues) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues);
- }
-
- void vkCmdBeginRenderPass(VkCommandBuffer commandBuffer,
- const VkRenderPassBeginInfo *pRenderPassBegin,
- VkSubpassContents contents) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
- }
-
- void vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdNextSubpass(commandBuffer, contents);
- }
-
- void vkCmdEndRenderPass(VkCommandBuffer commandBuffer) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdEndRenderPass(commandBuffer);
- }
-
- void vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers);
- }
-
- //=== VK_VERSION_1_1 ===
-
- VkResult vkEnumerateInstanceVersion(uint32_t *pApiVersion) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkEnumerateInstanceVersion(pApiVersion);
- }
-
- VkResult vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkBindBufferMemory2(device, bindInfoCount, pBindInfos);
- }
-
- VkResult vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkBindImageMemory2(device, bindInfoCount, pBindInfos);
- }
-
- void vkGetDeviceGroupPeerMemoryFeatures(VkDevice device,
- uint32_t heapIndex,
- uint32_t localDeviceIndex,
- uint32_t remoteDeviceIndex,
- VkPeerMemoryFeatureFlags *pPeerMemoryFeatures) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
- }
-
- void vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetDeviceMask(commandBuffer, deviceMask);
- }
-
- void vkCmdDispatchBase(VkCommandBuffer commandBuffer,
- uint32_t baseGroupX,
- uint32_t baseGroupY,
- uint32_t baseGroupZ,
- uint32_t groupCountX,
- uint32_t groupCountY,
- uint32_t groupCountZ) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
- }
-
- VkResult vkEnumeratePhysicalDeviceGroups(VkInstance instance,
- uint32_t *pPhysicalDeviceGroupCount,
- VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkEnumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
- }
-
- void vkGetImageMemoryRequirements2(VkDevice device,
- const VkImageMemoryRequirementsInfo2 *pInfo,
- VkMemoryRequirements2 *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetImageMemoryRequirements2(device, pInfo, pMemoryRequirements);
- }
-
- void vkGetBufferMemoryRequirements2(VkDevice device,
- const VkBufferMemoryRequirementsInfo2 *pInfo,
- VkMemoryRequirements2 *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetBufferMemoryRequirements2(device, pInfo, pMemoryRequirements);
- }
-
- void vkGetImageSparseMemoryRequirements2(VkDevice device,
- const VkImageSparseMemoryRequirementsInfo2 *pInfo,
- uint32_t *pSparseMemoryRequirementCount,
- VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
- }
-
- void vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceFeatures2(physicalDevice, pFeatures);
- }
-
- void vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceProperties2(physicalDevice, pProperties);
- }
-
- void vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice,
- VkFormat format,
- VkFormatProperties2 *pFormatProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceFormatProperties2(physicalDevice, format, pFormatProperties);
- }
-
- VkResult vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo,
- VkImageFormatProperties2 *pImageFormatProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceImageFormatProperties2(physicalDevice, pImageFormatInfo, pImageFormatProperties);
- }
-
- void vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice,
- uint32_t *pQueueFamilyPropertyCount,
- VkQueueFamilyProperties2 *pQueueFamilyProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
- }
-
- void vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceMemoryProperties2 *pMemoryProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceMemoryProperties2(physicalDevice, pMemoryProperties);
- }
-
- void vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo,
- uint32_t *pPropertyCount,
- VkSparseImageFormatProperties2 *pProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice, pFormatInfo, pPropertyCount, pProperties);
- }
-
- void vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkTrimCommandPool(device, commandPool, flags);
- }
-
- void vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetDeviceQueue2(device, pQueueInfo, pQueue);
- }
-
- VkResult vkCreateSamplerYcbcrConversion(VkDevice device,
- const VkSamplerYcbcrConversionCreateInfo *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkSamplerYcbcrConversion *pYcbcrConversion) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateSamplerYcbcrConversion(device, pCreateInfo, pAllocator, pYcbcrConversion);
- }
-
- void vkDestroySamplerYcbcrConversion(VkDevice device,
- VkSamplerYcbcrConversion ycbcrConversion,
- const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDestroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator);
- }
-
- VkResult vkCreateDescriptorUpdateTemplate(VkDevice device,
- const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
- }
-
- void vkDestroyDescriptorUpdateTemplate(VkDevice device,
- VkDescriptorUpdateTemplate descriptorUpdateTemplate,
- const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator);
- }
-
- void vkUpdateDescriptorSetWithTemplate(VkDevice device,
- VkDescriptorSet descriptorSet,
- VkDescriptorUpdateTemplate descriptorUpdateTemplate,
- const void *pData) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkUpdateDescriptorSetWithTemplate(device, descriptorSet, descriptorUpdateTemplate, pData);
- }
-
- void vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo,
- VkExternalBufferProperties *pExternalBufferProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
- }
-
- void vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo,
- VkExternalFenceProperties *pExternalFenceProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
- }
-
- void vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo,
- VkExternalSemaphoreProperties *pExternalSemaphoreProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
- }
-
- void vkGetDescriptorSetLayoutSupport(VkDevice device,
- const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
- VkDescriptorSetLayoutSupport *pSupport) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport);
- }
-
- //=== VK_VERSION_1_2 ===
-
- void vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- VkBuffer countBuffer,
- VkDeviceSize countBufferOffset,
- uint32_t maxDrawCount,
- uint32_t stride) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdDrawIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
- }
-
- void vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- VkBuffer countBuffer,
- VkDeviceSize countBufferOffset,
- uint32_t maxDrawCount,
- uint32_t stride) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdDrawIndexedIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
- }
-
- VkResult vkCreateRenderPass2(VkDevice device,
- const VkRenderPassCreateInfo2 *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkRenderPass *pRenderPass) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateRenderPass2(device, pCreateInfo, pAllocator, pRenderPass);
- }
-
- void vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer,
- const VkRenderPassBeginInfo *pRenderPassBegin,
- const VkSubpassBeginInfo *pSubpassBeginInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdBeginRenderPass2(commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
- }
-
- void vkCmdNextSubpass2(VkCommandBuffer commandBuffer,
- const VkSubpassBeginInfo *pSubpassBeginInfo,
- const VkSubpassEndInfo *pSubpassEndInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdNextSubpass2(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
- }
-
- void vkCmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdEndRenderPass2(commandBuffer, pSubpassEndInfo);
- }
-
- void vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkResetQueryPool(device, queryPool, firstQuery, queryCount);
- }
-
- VkResult vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t *pValue) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetSemaphoreCounterValue(device, semaphore, pValue);
- }
-
- VkResult vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkWaitSemaphores(device, pWaitInfo, timeout);
- }
-
- VkResult vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkSignalSemaphore(device, pSignalInfo);
- }
-
- VkDeviceAddress vkGetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo *pInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetBufferDeviceAddress(device, pInfo);
- }
-
- uint64_t vkGetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo *pInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetBufferOpaqueCaptureAddress(device, pInfo);
- }
-
- uint64_t vkGetDeviceMemoryOpaqueCaptureAddress(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetDeviceMemoryOpaqueCaptureAddress(device, pInfo);
- }
-
- //=== VK_VERSION_1_3 ===
-
- VkResult vkGetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice,
- uint32_t *pToolCount,
- VkPhysicalDeviceToolProperties *pToolProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceToolProperties(physicalDevice, pToolCount, pToolProperties);
- }
-
- VkResult vkCreatePrivateDataSlot(VkDevice device,
- const VkPrivateDataSlotCreateInfo *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkPrivateDataSlot *pPrivateDataSlot) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreatePrivateDataSlot(device, pCreateInfo, pAllocator, pPrivateDataSlot);
- }
-
- void vkDestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDestroyPrivateDataSlot(device, privateDataSlot, pAllocator);
- }
-
- VkResult vkSetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) const
- VULKAN_HPP_NOEXCEPT
- {
- return ::vkSetPrivateData(device, objectType, objectHandle, privateDataSlot, data);
- }
-
- void vkGetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t *pData) const
- VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPrivateData(device, objectType, objectHandle, privateDataSlot, pData);
- }
-
- void vkCmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo *pDependencyInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetEvent2(commandBuffer, event, pDependencyInfo);
- }
-
- void vkCmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdResetEvent2(commandBuffer, event, stageMask);
- }
-
- void vkCmdWaitEvents2(VkCommandBuffer commandBuffer,
- uint32_t eventCount,
- const VkEvent *pEvents,
- const VkDependencyInfo *pDependencyInfos) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdWaitEvents2(commandBuffer, eventCount, pEvents, pDependencyInfos);
- }
-
- void vkCmdPipelineBarrier2(VkCommandBuffer commandBuffer, const VkDependencyInfo *pDependencyInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdPipelineBarrier2(commandBuffer, pDependencyInfo);
- }
-
- void vkCmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdWriteTimestamp2(commandBuffer, stage, queryPool, query);
- }
-
- VkResult vkQueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 *pSubmits, VkFence fence) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkQueueSubmit2(queue, submitCount, pSubmits, fence);
- }
-
- void vkCmdCopyBuffer2(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 *pCopyBufferInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdCopyBuffer2(commandBuffer, pCopyBufferInfo);
- }
-
- void vkCmdCopyImage2(VkCommandBuffer commandBuffer, const VkCopyImageInfo2 *pCopyImageInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdCopyImage2(commandBuffer, pCopyImageInfo);
- }
-
- void vkCmdCopyBufferToImage2(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 *pCopyBufferToImageInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdCopyBufferToImage2(commandBuffer, pCopyBufferToImageInfo);
- }
-
- void vkCmdCopyImageToBuffer2(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 *pCopyImageToBufferInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdCopyImageToBuffer2(commandBuffer, pCopyImageToBufferInfo);
- }
-
- void vkCmdBlitImage2(VkCommandBuffer commandBuffer, const VkBlitImageInfo2 *pBlitImageInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdBlitImage2(commandBuffer, pBlitImageInfo);
- }
-
- void vkCmdResolveImage2(VkCommandBuffer commandBuffer, const VkResolveImageInfo2 *pResolveImageInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdResolveImage2(commandBuffer, pResolveImageInfo);
- }
-
- void vkCmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfo *pRenderingInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdBeginRendering(commandBuffer, pRenderingInfo);
- }
-
- void vkCmdEndRendering(VkCommandBuffer commandBuffer) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdEndRendering(commandBuffer);
- }
-
- void vkCmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetCullMode(commandBuffer, cullMode);
- }
-
- void vkCmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetFrontFace(commandBuffer, frontFace);
- }
-
- void vkCmdSetPrimitiveTopology(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetPrimitiveTopology(commandBuffer, primitiveTopology);
- }
-
- void vkCmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport *pViewports) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetViewportWithCount(commandBuffer, viewportCount, pViewports);
- }
-
- void vkCmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D *pScissors) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetScissorWithCount(commandBuffer, scissorCount, pScissors);
- }
-
- void vkCmdBindVertexBuffers2(VkCommandBuffer commandBuffer,
- uint32_t firstBinding,
- uint32_t bindingCount,
- const VkBuffer *pBuffers,
- const VkDeviceSize *pOffsets,
- const VkDeviceSize *pSizes,
- const VkDeviceSize *pStrides) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdBindVertexBuffers2(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides);
- }
-
- void vkCmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetDepthTestEnable(commandBuffer, depthTestEnable);
- }
-
- void vkCmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetDepthWriteEnable(commandBuffer, depthWriteEnable);
- }
-
- void vkCmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetDepthCompareOp(commandBuffer, depthCompareOp);
- }
-
- void vkCmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetDepthBoundsTestEnable(commandBuffer, depthBoundsTestEnable);
- }
-
- void vkCmdSetStencilTestEnable(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetStencilTestEnable(commandBuffer, stencilTestEnable);
- }
-
- void vkCmdSetStencilOp(VkCommandBuffer commandBuffer,
- VkStencilFaceFlags faceMask,
- VkStencilOp failOp,
- VkStencilOp passOp,
- VkStencilOp depthFailOp,
- VkCompareOp compareOp) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetStencilOp(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp);
- }
-
- void vkCmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetRasterizerDiscardEnable(commandBuffer, rasterizerDiscardEnable);
- }
-
- void vkCmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetDepthBiasEnable(commandBuffer, depthBiasEnable);
- }
-
- void vkCmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetPrimitiveRestartEnable(commandBuffer, primitiveRestartEnable);
- }
-
- void vkGetDeviceBufferMemoryRequirements(VkDevice device,
- const VkDeviceBufferMemoryRequirements *pInfo,
- VkMemoryRequirements2 *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetDeviceBufferMemoryRequirements(device, pInfo, pMemoryRequirements);
- }
-
- void vkGetDeviceImageMemoryRequirements(VkDevice device,
- const VkDeviceImageMemoryRequirements *pInfo,
- VkMemoryRequirements2 *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetDeviceImageMemoryRequirements(device, pInfo, pMemoryRequirements);
- }
-
- void vkGetDeviceImageSparseMemoryRequirements(VkDevice device,
- const VkDeviceImageMemoryRequirements *pInfo,
- uint32_t *pSparseMemoryRequirementCount,
- VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetDeviceImageSparseMemoryRequirements(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
- }
-
- //=== VK_KHR_surface ===
-
- void vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDestroySurfaceKHR(instance, surface, pAllocator);
- }
-
- VkResult vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice,
- uint32_t queueFamilyIndex,
- VkSurfaceKHR surface,
- VkBool32 *pSupported) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported);
- }
-
- VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice,
- VkSurfaceKHR surface,
- VkSurfaceCapabilitiesKHR *pSurfaceCapabilities) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities);
- }
-
- VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice,
- VkSurfaceKHR surface,
- uint32_t *pSurfaceFormatCount,
- VkSurfaceFormatKHR *pSurfaceFormats) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
- }
-
- VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice,
- VkSurfaceKHR surface,
- uint32_t *pPresentModeCount,
- VkPresentModeKHR *pPresentModes) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes);
- }
-
- //=== VK_KHR_swapchain ===
-
- VkResult vkCreateSwapchainKHR(VkDevice device,
- const VkSwapchainCreateInfoKHR *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkSwapchainKHR *pSwapchain) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain);
- }
-
- void vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDestroySwapchainKHR(device, swapchain, pAllocator);
- }
-
- VkResult vkGetSwapchainImagesKHR(VkDevice device,
- VkSwapchainKHR swapchain,
- uint32_t *pSwapchainImageCount,
- VkImage *pSwapchainImages) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages);
- }
-
- VkResult vkAcquireNextImageKHR(
- VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkAcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex);
- }
-
- VkResult vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkQueuePresentKHR(queue, pPresentInfo);
- }
-
- VkResult vkGetDeviceGroupPresentCapabilitiesKHR(VkDevice device,
- VkDeviceGroupPresentCapabilitiesKHR *pDeviceGroupPresentCapabilities) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities);
- }
-
- VkResult
- vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR *pModes) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetDeviceGroupSurfacePresentModesKHR(device, surface, pModes);
- }
-
- VkResult vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice,
- VkSurfaceKHR surface,
- uint32_t *pRectCount,
- VkRect2D *pRects) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, pRectCount, pRects);
- }
-
- VkResult vkAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR *pAcquireInfo, uint32_t *pImageIndex) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkAcquireNextImage2KHR(device, pAcquireInfo, pImageIndex);
- }
-
- //=== VK_KHR_display ===
-
- VkResult vkGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice,
- uint32_t *pPropertyCount,
- VkDisplayPropertiesKHR *pProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, pPropertyCount, pProperties);
- }
-
- VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice,
- uint32_t *pPropertyCount,
- VkDisplayPlanePropertiesKHR *pProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, pPropertyCount, pProperties);
- }
-
- VkResult vkGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice,
- uint32_t planeIndex,
- uint32_t *pDisplayCount,
- VkDisplayKHR *pDisplays) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetDisplayPlaneSupportedDisplaysKHR(physicalDevice, planeIndex, pDisplayCount, pDisplays);
- }
-
- VkResult vkGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice,
- VkDisplayKHR display,
- uint32_t *pPropertyCount,
- VkDisplayModePropertiesKHR *pProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetDisplayModePropertiesKHR(physicalDevice, display, pPropertyCount, pProperties);
- }
-
- VkResult vkCreateDisplayModeKHR(VkPhysicalDevice physicalDevice,
- VkDisplayKHR display,
- const VkDisplayModeCreateInfoKHR *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkDisplayModeKHR *pMode) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateDisplayModeKHR(physicalDevice, display, pCreateInfo, pAllocator, pMode);
- }
-
- VkResult vkGetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice,
- VkDisplayModeKHR mode,
- uint32_t planeIndex,
- VkDisplayPlaneCapabilitiesKHR *pCapabilities) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetDisplayPlaneCapabilitiesKHR(physicalDevice, mode, planeIndex, pCapabilities);
- }
-
- VkResult vkCreateDisplayPlaneSurfaceKHR(VkInstance instance,
- const VkDisplaySurfaceCreateInfoKHR *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
- }
-
- //=== VK_KHR_display_swapchain ===
-
- VkResult vkCreateSharedSwapchainsKHR(VkDevice device,
- uint32_t swapchainCount,
- const VkSwapchainCreateInfoKHR *pCreateInfos,
- const VkAllocationCallbacks *pAllocator,
- VkSwapchainKHR *pSwapchains) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains);
- }
-
-# if defined(VK_USE_PLATFORM_XLIB_KHR)
- //=== VK_KHR_xlib_surface ===
-
- VkResult vkCreateXlibSurfaceKHR(VkInstance instance,
- const VkXlibSurfaceCreateInfoKHR *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateXlibSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
- }
-
- VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice,
- uint32_t queueFamilyIndex,
- Display *dpy,
- VisualID visualID) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceXlibPresentationSupportKHR(physicalDevice, queueFamilyIndex, dpy, visualID);
- }
-# endif /*VK_USE_PLATFORM_XLIB_KHR*/
-
-# if defined(VK_USE_PLATFORM_XCB_KHR)
- //=== VK_KHR_xcb_surface ===
-
- VkResult vkCreateXcbSurfaceKHR(VkInstance instance,
- const VkXcbSurfaceCreateInfoKHR *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateXcbSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
- }
-
- VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice,
- uint32_t queueFamilyIndex,
- xcb_connection_t *connection,
- xcb_visualid_t visual_id) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceXcbPresentationSupportKHR(physicalDevice, queueFamilyIndex, connection, visual_id);
- }
-# endif /*VK_USE_PLATFORM_XCB_KHR*/
-
-# if defined(VK_USE_PLATFORM_WAYLAND_KHR)
- //=== VK_KHR_wayland_surface ===
-
- VkResult vkCreateWaylandSurfaceKHR(VkInstance instance,
- const VkWaylandSurfaceCreateInfoKHR *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateWaylandSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
- }
-
- VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice,
- uint32_t queueFamilyIndex,
- struct wl_display *display) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceWaylandPresentationSupportKHR(physicalDevice, queueFamilyIndex, display);
- }
-# endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
-
-# if defined(VK_USE_PLATFORM_ANDROID_KHR)
- //=== VK_KHR_android_surface ===
-
- VkResult vkCreateAndroidSurfaceKHR(VkInstance instance,
- const VkAndroidSurfaceCreateInfoKHR *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
- }
-# endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-# if defined(VK_USE_PLATFORM_WIN32_KHR)
- //=== VK_KHR_win32_surface ===
-
- VkResult vkCreateWin32SurfaceKHR(VkInstance instance,
- const VkWin32SurfaceCreateInfoKHR *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateWin32SurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
- }
-
- VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice, queueFamilyIndex);
- }
-# endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
- //=== VK_EXT_debug_report ===
-
- VkResult vkCreateDebugReportCallbackEXT(VkInstance instance,
- const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkDebugReportCallbackEXT *pCallback) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback);
- }
-
- void vkDestroyDebugReportCallbackEXT(VkInstance instance,
- VkDebugReportCallbackEXT callback,
- const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDestroyDebugReportCallbackEXT(instance, callback, pAllocator);
- }
-
- void vkDebugReportMessageEXT(VkInstance instance,
- VkDebugReportFlagsEXT flags,
- VkDebugReportObjectTypeEXT objectType,
- uint64_t object,
- size_t location,
- int32_t messageCode,
- const char *pLayerPrefix,
- const char *pMessage) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDebugReportMessageEXT(instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage);
- }
-
- //=== VK_EXT_debug_marker ===
-
- VkResult vkDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT *pTagInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDebugMarkerSetObjectTagEXT(device, pTagInfo);
- }
-
- VkResult vkDebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT *pNameInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDebugMarkerSetObjectNameEXT(device, pNameInfo);
- }
-
- void vkCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdDebugMarkerBeginEXT(commandBuffer, pMarkerInfo);
- }
-
- void vkCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdDebugMarkerEndEXT(commandBuffer);
- }
-
- void vkCmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdDebugMarkerInsertEXT(commandBuffer, pMarkerInfo);
- }
-
-# if defined(VK_ENABLE_BETA_EXTENSIONS)
- //=== VK_KHR_video_queue ===
-
- VkResult vkGetPhysicalDeviceVideoCapabilitiesKHR(VkPhysicalDevice physicalDevice,
- const VkVideoProfileKHR *pVideoProfile,
- VkVideoCapabilitiesKHR *pCapabilities) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceVideoCapabilitiesKHR(physicalDevice, pVideoProfile, pCapabilities);
- }
-
- VkResult vkGetPhysicalDeviceVideoFormatPropertiesKHR(VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceVideoFormatInfoKHR *pVideoFormatInfo,
- uint32_t *pVideoFormatPropertyCount,
- VkVideoFormatPropertiesKHR *pVideoFormatProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceVideoFormatPropertiesKHR(physicalDevice, pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties);
- }
-
- VkResult vkCreateVideoSessionKHR(VkDevice device,
- const VkVideoSessionCreateInfoKHR *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkVideoSessionKHR *pVideoSession) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateVideoSessionKHR(device, pCreateInfo, pAllocator, pVideoSession);
- }
-
- void vkDestroyVideoSessionKHR(VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDestroyVideoSessionKHR(device, videoSession, pAllocator);
- }
-
- VkResult vkGetVideoSessionMemoryRequirementsKHR(VkDevice device,
- VkVideoSessionKHR videoSession,
- uint32_t *pVideoSessionMemoryRequirementsCount,
- VkVideoGetMemoryPropertiesKHR *pVideoSessionMemoryRequirements) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetVideoSessionMemoryRequirementsKHR(device, videoSession, pVideoSessionMemoryRequirementsCount, pVideoSessionMemoryRequirements);
- }
-
- VkResult vkBindVideoSessionMemoryKHR(VkDevice device,
- VkVideoSessionKHR videoSession,
- uint32_t videoSessionBindMemoryCount,
- const VkVideoBindMemoryKHR *pVideoSessionBindMemories) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkBindVideoSessionMemoryKHR(device, videoSession, videoSessionBindMemoryCount, pVideoSessionBindMemories);
- }
-
- VkResult vkCreateVideoSessionParametersKHR(VkDevice device,
- const VkVideoSessionParametersCreateInfoKHR *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkVideoSessionParametersKHR *pVideoSessionParameters) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateVideoSessionParametersKHR(device, pCreateInfo, pAllocator, pVideoSessionParameters);
- }
-
- VkResult vkUpdateVideoSessionParametersKHR(VkDevice device,
- VkVideoSessionParametersKHR videoSessionParameters,
- const VkVideoSessionParametersUpdateInfoKHR *pUpdateInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkUpdateVideoSessionParametersKHR(device, videoSessionParameters, pUpdateInfo);
- }
-
- void vkDestroyVideoSessionParametersKHR(VkDevice device,
- VkVideoSessionParametersKHR videoSessionParameters,
- const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDestroyVideoSessionParametersKHR(device, videoSessionParameters, pAllocator);
- }
-
- void vkCmdBeginVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR *pBeginInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdBeginVideoCodingKHR(commandBuffer, pBeginInfo);
- }
-
- void vkCmdEndVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR *pEndCodingInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdEndVideoCodingKHR(commandBuffer, pEndCodingInfo);
- }
-
- void vkCmdControlVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR *pCodingControlInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdControlVideoCodingKHR(commandBuffer, pCodingControlInfo);
- }
-# endif /*VK_ENABLE_BETA_EXTENSIONS*/
-
-# if defined(VK_ENABLE_BETA_EXTENSIONS)
- //=== VK_KHR_video_decode_queue ===
-
- void vkCmdDecodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR *pFrameInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdDecodeVideoKHR(commandBuffer, pFrameInfo);
- }
-# endif /*VK_ENABLE_BETA_EXTENSIONS*/
-
- //=== VK_EXT_transform_feedback ===
-
- void vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer,
- uint32_t firstBinding,
- uint32_t bindingCount,
- const VkBuffer *pBuffers,
- const VkDeviceSize *pOffsets,
- const VkDeviceSize *pSizes) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdBindTransformFeedbackBuffersEXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes);
- }
-
- void vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer,
- uint32_t firstCounterBuffer,
- uint32_t counterBufferCount,
- const VkBuffer *pCounterBuffers,
- const VkDeviceSize *pCounterBufferOffsets) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdBeginTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
- }
-
- void vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer,
- uint32_t firstCounterBuffer,
- uint32_t counterBufferCount,
- const VkBuffer *pCounterBuffers,
- const VkDeviceSize *pCounterBufferOffsets) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdEndTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
- }
-
- void vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index) const
- VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, index);
- }
-
- void vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdEndQueryIndexedEXT(commandBuffer, queryPool, query, index);
- }
-
- void vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer,
- uint32_t instanceCount,
- uint32_t firstInstance,
- VkBuffer counterBuffer,
- VkDeviceSize counterBufferOffset,
- uint32_t counterOffset,
- uint32_t vertexStride) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdDrawIndirectByteCountEXT(commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride);
- }
-
- //=== VK_NVX_binary_import ===
-
- VkResult vkCreateCuModuleNVX(VkDevice device,
- const VkCuModuleCreateInfoNVX *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkCuModuleNVX *pModule) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateCuModuleNVX(device, pCreateInfo, pAllocator, pModule);
- }
-
- VkResult vkCreateCuFunctionNVX(VkDevice device,
- const VkCuFunctionCreateInfoNVX *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkCuFunctionNVX *pFunction) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateCuFunctionNVX(device, pCreateInfo, pAllocator, pFunction);
- }
-
- void vkDestroyCuModuleNVX(VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDestroyCuModuleNVX(device, module, pAllocator);
- }
-
- void vkDestroyCuFunctionNVX(VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDestroyCuFunctionNVX(device, function, pAllocator);
- }
-
- void vkCmdCuLaunchKernelNVX(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX *pLaunchInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdCuLaunchKernelNVX(commandBuffer, pLaunchInfo);
- }
-
- //=== VK_NVX_image_view_handle ===
-
- uint32_t vkGetImageViewHandleNVX(VkDevice device, const VkImageViewHandleInfoNVX *pInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetImageViewHandleNVX(device, pInfo);
- }
-
- VkResult vkGetImageViewAddressNVX(VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX *pProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetImageViewAddressNVX(device, imageView, pProperties);
- }
-
- //=== VK_AMD_draw_indirect_count ===
-
- void vkCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- VkBuffer countBuffer,
- VkDeviceSize countBufferOffset,
- uint32_t maxDrawCount,
- uint32_t stride) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdDrawIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
- }
-
- void vkCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- VkBuffer countBuffer,
- VkDeviceSize countBufferOffset,
- uint32_t maxDrawCount,
- uint32_t stride) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdDrawIndexedIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
- }
-
- //=== VK_AMD_shader_info ===
-
- VkResult vkGetShaderInfoAMD(VkDevice device,
- VkPipeline pipeline,
- VkShaderStageFlagBits shaderStage,
- VkShaderInfoTypeAMD infoType,
- size_t *pInfoSize,
- void *pInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetShaderInfoAMD(device, pipeline, shaderStage, infoType, pInfoSize, pInfo);
- }
-
- //=== VK_KHR_dynamic_rendering ===
-
- void vkCmdBeginRenderingKHR(VkCommandBuffer commandBuffer, const VkRenderingInfo *pRenderingInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdBeginRenderingKHR(commandBuffer, pRenderingInfo);
- }
-
- void vkCmdEndRenderingKHR(VkCommandBuffer commandBuffer) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdEndRenderingKHR(commandBuffer);
- }
-
-# if defined(VK_USE_PLATFORM_GGP)
- //=== VK_GGP_stream_descriptor_surface ===
-
- VkResult vkCreateStreamDescriptorSurfaceGGP(VkInstance instance,
- const VkStreamDescriptorSurfaceCreateInfoGGP *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateStreamDescriptorSurfaceGGP(instance, pCreateInfo, pAllocator, pSurface);
- }
-# endif /*VK_USE_PLATFORM_GGP*/
-
- //=== VK_NV_external_memory_capabilities ===
-
- VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV(VkPhysicalDevice physicalDevice,
- VkFormat format,
- VkImageType type,
- VkImageTiling tiling,
- VkImageUsageFlags usage,
- VkImageCreateFlags flags,
- VkExternalMemoryHandleTypeFlagsNV externalHandleType,
- VkExternalImageFormatPropertiesNV *pExternalImageFormatProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
- physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties);
- }
-
-# if defined(VK_USE_PLATFORM_WIN32_KHR)
- //=== VK_NV_external_memory_win32 ===
-
- VkResult vkGetMemoryWin32HandleNV(VkDevice device,
- VkDeviceMemory memory,
- VkExternalMemoryHandleTypeFlagsNV handleType,
- HANDLE *pHandle) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetMemoryWin32HandleNV(device, memory, handleType, pHandle);
- }
-# endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
- //=== VK_KHR_get_physical_device_properties2 ===
-
- void vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceFeatures2KHR(physicalDevice, pFeatures);
- }
-
- void vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceProperties2KHR(physicalDevice, pProperties);
- }
-
- void vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice,
- VkFormat format,
- VkFormatProperties2 *pFormatProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceFormatProperties2KHR(physicalDevice, format, pFormatProperties);
- }
-
- VkResult vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo,
- VkImageFormatProperties2 *pImageFormatProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceImageFormatProperties2KHR(physicalDevice, pImageFormatInfo, pImageFormatProperties);
- }
-
- void vkGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice,
- uint32_t *pQueueFamilyPropertyCount,
- VkQueueFamilyProperties2 *pQueueFamilyProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
- }
-
- void vkGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice,
- VkPhysicalDeviceMemoryProperties2 *pMemoryProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceMemoryProperties2KHR(physicalDevice, pMemoryProperties);
- }
-
- void vkGetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo,
- uint32_t *pPropertyCount,
- VkSparseImageFormatProperties2 *pProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice, pFormatInfo, pPropertyCount, pProperties);
- }
-
- //=== VK_KHR_device_group ===
-
- void vkGetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device,
- uint32_t heapIndex,
- uint32_t localDeviceIndex,
- uint32_t remoteDeviceIndex,
- VkPeerMemoryFeatureFlags *pPeerMemoryFeatures) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetDeviceGroupPeerMemoryFeaturesKHR(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
- }
-
- void vkCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetDeviceMaskKHR(commandBuffer, deviceMask);
- }
-
- void vkCmdDispatchBaseKHR(VkCommandBuffer commandBuffer,
- uint32_t baseGroupX,
- uint32_t baseGroupY,
- uint32_t baseGroupZ,
- uint32_t groupCountX,
- uint32_t groupCountY,
- uint32_t groupCountZ) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdDispatchBaseKHR(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
- }
-
-# if defined(VK_USE_PLATFORM_VI_NN)
- //=== VK_NN_vi_surface ===
-
- VkResult vkCreateViSurfaceNN(VkInstance instance,
- const VkViSurfaceCreateInfoNN *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateViSurfaceNN(instance, pCreateInfo, pAllocator, pSurface);
- }
-# endif /*VK_USE_PLATFORM_VI_NN*/
-
- //=== VK_KHR_maintenance1 ===
-
- void vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkTrimCommandPoolKHR(device, commandPool, flags);
- }
-
- //=== VK_KHR_device_group_creation ===
-
- VkResult vkEnumeratePhysicalDeviceGroupsKHR(VkInstance instance,
- uint32_t *pPhysicalDeviceGroupCount,
- VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkEnumeratePhysicalDeviceGroupsKHR(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
- }
-
- //=== VK_KHR_external_memory_capabilities ===
-
- void vkGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo,
- VkExternalBufferProperties *pExternalBufferProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceExternalBufferPropertiesKHR(physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
- }
-
-# if defined(VK_USE_PLATFORM_WIN32_KHR)
- //=== VK_KHR_external_memory_win32 ===
-
- VkResult vkGetMemoryWin32HandleKHR(VkDevice device, const VkMemoryGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetMemoryWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
- }
-
- VkResult vkGetMemoryWin32HandlePropertiesKHR(VkDevice device,
- VkExternalMemoryHandleTypeFlagBits handleType,
- HANDLE handle,
- VkMemoryWin32HandlePropertiesKHR *pMemoryWin32HandleProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetMemoryWin32HandlePropertiesKHR(device, handleType, handle, pMemoryWin32HandleProperties);
- }
-# endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
- //=== VK_KHR_external_memory_fd ===
-
- VkResult vkGetMemoryFdKHR(VkDevice device, const VkMemoryGetFdInfoKHR *pGetFdInfo, int *pFd) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetMemoryFdKHR(device, pGetFdInfo, pFd);
- }
-
- VkResult vkGetMemoryFdPropertiesKHR(VkDevice device,
- VkExternalMemoryHandleTypeFlagBits handleType,
- int fd,
- VkMemoryFdPropertiesKHR *pMemoryFdProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetMemoryFdPropertiesKHR(device, handleType, fd, pMemoryFdProperties);
- }
-
- //=== VK_KHR_external_semaphore_capabilities ===
-
- void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo,
- VkExternalSemaphoreProperties *pExternalSemaphoreProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
- }
-
-# if defined(VK_USE_PLATFORM_WIN32_KHR)
- //=== VK_KHR_external_semaphore_win32 ===
-
- VkResult vkImportSemaphoreWin32HandleKHR(VkDevice device,
- const VkImportSemaphoreWin32HandleInfoKHR *pImportSemaphoreWin32HandleInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkImportSemaphoreWin32HandleKHR(device, pImportSemaphoreWin32HandleInfo);
- }
-
- VkResult
- vkGetSemaphoreWin32HandleKHR(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetSemaphoreWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
- }
-# endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
- //=== VK_KHR_external_semaphore_fd ===
-
- VkResult vkImportSemaphoreFdKHR(VkDevice device, const VkImportSemaphoreFdInfoKHR *pImportSemaphoreFdInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkImportSemaphoreFdKHR(device, pImportSemaphoreFdInfo);
- }
-
- VkResult vkGetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR *pGetFdInfo, int *pFd) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetSemaphoreFdKHR(device, pGetFdInfo, pFd);
- }
-
- //=== VK_KHR_push_descriptor ===
-
- void vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer,
- VkPipelineBindPoint pipelineBindPoint,
- VkPipelineLayout layout,
- uint32_t set,
- uint32_t descriptorWriteCount,
- const VkWriteDescriptorSet *pDescriptorWrites) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites);
- }
-
- void vkCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer,
- VkDescriptorUpdateTemplate descriptorUpdateTemplate,
- VkPipelineLayout layout,
- uint32_t set,
- const void *pData) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set, pData);
- }
-
- //=== VK_EXT_conditional_rendering ===
-
- void vkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer,
- const VkConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdBeginConditionalRenderingEXT(commandBuffer, pConditionalRenderingBegin);
- }
-
- void vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdEndConditionalRenderingEXT(commandBuffer);
- }
-
- //=== VK_KHR_descriptor_update_template ===
-
- VkResult vkCreateDescriptorUpdateTemplateKHR(VkDevice device,
- const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
- }
-
- void vkDestroyDescriptorUpdateTemplateKHR(VkDevice device,
- VkDescriptorUpdateTemplate descriptorUpdateTemplate,
- const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator);
- }
-
- void vkUpdateDescriptorSetWithTemplateKHR(VkDevice device,
- VkDescriptorSet descriptorSet,
- VkDescriptorUpdateTemplate descriptorUpdateTemplate,
- const void *pData) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkUpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate, pData);
- }
-
- //=== VK_NV_clip_space_w_scaling ===
-
- void vkCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer,
- uint32_t firstViewport,
- uint32_t viewportCount,
- const VkViewportWScalingNV *pViewportWScalings) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetViewportWScalingNV(commandBuffer, firstViewport, viewportCount, pViewportWScalings);
- }
-
- //=== VK_EXT_direct_mode_display ===
-
- VkResult vkReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkReleaseDisplayEXT(physicalDevice, display);
- }
-
-# if defined(VK_USE_PLATFORM_XLIB_XRANDR_EXT)
- //=== VK_EXT_acquire_xlib_display ===
-
- VkResult vkAcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display *dpy, VkDisplayKHR display) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkAcquireXlibDisplayEXT(physicalDevice, dpy, display);
- }
-
- VkResult vkGetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display *dpy, RROutput rrOutput, VkDisplayKHR *pDisplay) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetRandROutputDisplayEXT(physicalDevice, dpy, rrOutput, pDisplay);
- }
-# endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
-
- //=== VK_EXT_display_surface_counter ===
-
- VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice,
- VkSurfaceKHR surface,
- VkSurfaceCapabilities2EXT *pSurfaceCapabilities) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice, surface, pSurfaceCapabilities);
- }
-
- //=== VK_EXT_display_control ===
-
- VkResult vkDisplayPowerControlEXT(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT *pDisplayPowerInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDisplayPowerControlEXT(device, display, pDisplayPowerInfo);
- }
-
- VkResult vkRegisterDeviceEventEXT(VkDevice device,
- const VkDeviceEventInfoEXT *pDeviceEventInfo,
- const VkAllocationCallbacks *pAllocator,
- VkFence *pFence) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkRegisterDeviceEventEXT(device, pDeviceEventInfo, pAllocator, pFence);
- }
-
- VkResult vkRegisterDisplayEventEXT(VkDevice device,
- VkDisplayKHR display,
- const VkDisplayEventInfoEXT *pDisplayEventInfo,
- const VkAllocationCallbacks *pAllocator,
- VkFence *pFence) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkRegisterDisplayEventEXT(device, display, pDisplayEventInfo, pAllocator, pFence);
- }
-
- VkResult vkGetSwapchainCounterEXT(VkDevice device,
- VkSwapchainKHR swapchain,
- VkSurfaceCounterFlagBitsEXT counter,
- uint64_t *pCounterValue) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetSwapchainCounterEXT(device, swapchain, counter, pCounterValue);
- }
-
- //=== VK_GOOGLE_display_timing ===
-
- VkResult vkGetRefreshCycleDurationGOOGLE(VkDevice device,
- VkSwapchainKHR swapchain,
- VkRefreshCycleDurationGOOGLE *pDisplayTimingProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetRefreshCycleDurationGOOGLE(device, swapchain, pDisplayTimingProperties);
- }
-
- VkResult vkGetPastPresentationTimingGOOGLE(VkDevice device,
- VkSwapchainKHR swapchain,
- uint32_t *pPresentationTimingCount,
- VkPastPresentationTimingGOOGLE *pPresentationTimings) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPastPresentationTimingGOOGLE(device, swapchain, pPresentationTimingCount, pPresentationTimings);
- }
-
- //=== VK_EXT_discard_rectangles ===
-
- void vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer,
- uint32_t firstDiscardRectangle,
- uint32_t discardRectangleCount,
- const VkRect2D *pDiscardRectangles) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetDiscardRectangleEXT(commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles);
- }
-
- //=== VK_EXT_hdr_metadata ===
-
- void vkSetHdrMetadataEXT(VkDevice device,
- uint32_t swapchainCount,
- const VkSwapchainKHR *pSwapchains,
- const VkHdrMetadataEXT *pMetadata) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkSetHdrMetadataEXT(device, swapchainCount, pSwapchains, pMetadata);
- }
-
- //=== VK_KHR_create_renderpass2 ===
-
- VkResult vkCreateRenderPass2KHR(VkDevice device,
- const VkRenderPassCreateInfo2 *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkRenderPass *pRenderPass) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateRenderPass2KHR(device, pCreateInfo, pAllocator, pRenderPass);
- }
-
- void vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer,
- const VkRenderPassBeginInfo *pRenderPassBegin,
- const VkSubpassBeginInfo *pSubpassBeginInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdBeginRenderPass2KHR(commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
- }
-
- void vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer,
- const VkSubpassBeginInfo *pSubpassBeginInfo,
- const VkSubpassEndInfo *pSubpassEndInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdNextSubpass2KHR(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
- }
-
- void vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdEndRenderPass2KHR(commandBuffer, pSubpassEndInfo);
- }
-
- //=== VK_KHR_shared_presentable_image ===
-
- VkResult vkGetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetSwapchainStatusKHR(device, swapchain);
- }
-
- //=== VK_KHR_external_fence_capabilities ===
-
- void vkGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo,
- VkExternalFenceProperties *pExternalFenceProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceExternalFencePropertiesKHR(physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
- }
-
-# if defined(VK_USE_PLATFORM_WIN32_KHR)
- //=== VK_KHR_external_fence_win32 ===
-
- VkResult vkImportFenceWin32HandleKHR(VkDevice device, const VkImportFenceWin32HandleInfoKHR *pImportFenceWin32HandleInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkImportFenceWin32HandleKHR(device, pImportFenceWin32HandleInfo);
- }
-
- VkResult vkGetFenceWin32HandleKHR(VkDevice device, const VkFenceGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetFenceWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
- }
-# endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
- //=== VK_KHR_external_fence_fd ===
-
- VkResult vkImportFenceFdKHR(VkDevice device, const VkImportFenceFdInfoKHR *pImportFenceFdInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkImportFenceFdKHR(device, pImportFenceFdInfo);
- }
-
- VkResult vkGetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR *pGetFdInfo, int *pFd) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetFenceFdKHR(device, pGetFdInfo, pFd);
- }
-
- //=== VK_KHR_performance_query ===
-
- VkResult
- vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(VkPhysicalDevice physicalDevice,
- uint32_t queueFamilyIndex,
- uint32_t *pCounterCount,
- VkPerformanceCounterKHR *pCounters,
- VkPerformanceCounterDescriptionKHR *pCounterDescriptions) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
- physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions);
- }
-
- void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(VkPhysicalDevice physicalDevice,
- const VkQueryPoolPerformanceCreateInfoKHR *pPerformanceQueryCreateInfo,
- uint32_t *pNumPasses) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(physicalDevice, pPerformanceQueryCreateInfo, pNumPasses);
- }
-
- VkResult vkAcquireProfilingLockKHR(VkDevice device, const VkAcquireProfilingLockInfoKHR *pInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkAcquireProfilingLockKHR(device, pInfo);
- }
-
- void vkReleaseProfilingLockKHR(VkDevice device) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkReleaseProfilingLockKHR(device);
- }
-
- //=== VK_KHR_get_surface_capabilities2 ===
-
- VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo,
- VkSurfaceCapabilities2KHR *pSurfaceCapabilities) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice, pSurfaceInfo, pSurfaceCapabilities);
- }
-
- VkResult vkGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo,
- uint32_t *pSurfaceFormatCount,
- VkSurfaceFormat2KHR *pSurfaceFormats) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceSurfaceFormats2KHR(physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats);
- }
-
- //=== VK_KHR_get_display_properties2 ===
-
- VkResult vkGetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice,
- uint32_t *pPropertyCount,
- VkDisplayProperties2KHR *pProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceDisplayProperties2KHR(physicalDevice, pPropertyCount, pProperties);
- }
-
- VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice physicalDevice,
- uint32_t *pPropertyCount,
- VkDisplayPlaneProperties2KHR *pProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceDisplayPlaneProperties2KHR(physicalDevice, pPropertyCount, pProperties);
- }
-
- VkResult vkGetDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice,
- VkDisplayKHR display,
- uint32_t *pPropertyCount,
- VkDisplayModeProperties2KHR *pProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetDisplayModeProperties2KHR(physicalDevice, display, pPropertyCount, pProperties);
- }
-
- VkResult vkGetDisplayPlaneCapabilities2KHR(VkPhysicalDevice physicalDevice,
- const VkDisplayPlaneInfo2KHR *pDisplayPlaneInfo,
- VkDisplayPlaneCapabilities2KHR *pCapabilities) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetDisplayPlaneCapabilities2KHR(physicalDevice, pDisplayPlaneInfo, pCapabilities);
- }
-
-# if defined(VK_USE_PLATFORM_IOS_MVK)
- //=== VK_MVK_ios_surface ===
-
- VkResult vkCreateIOSSurfaceMVK(VkInstance instance,
- const VkIOSSurfaceCreateInfoMVK *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateIOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface);
- }
-# endif /*VK_USE_PLATFORM_IOS_MVK*/
-
-# if defined(VK_USE_PLATFORM_MACOS_MVK)
- //=== VK_MVK_macos_surface ===
-
- VkResult vkCreateMacOSSurfaceMVK(VkInstance instance,
- const VkMacOSSurfaceCreateInfoMVK *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateMacOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface);
- }
-# endif /*VK_USE_PLATFORM_MACOS_MVK*/
-
- //=== VK_EXT_debug_utils ===
-
- VkResult vkSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT *pNameInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkSetDebugUtilsObjectNameEXT(device, pNameInfo);
- }
-
- VkResult vkSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT *pTagInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkSetDebugUtilsObjectTagEXT(device, pTagInfo);
- }
-
- void vkQueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkQueueBeginDebugUtilsLabelEXT(queue, pLabelInfo);
- }
-
- void vkQueueEndDebugUtilsLabelEXT(VkQueue queue) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkQueueEndDebugUtilsLabelEXT(queue);
- }
-
- void vkQueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkQueueInsertDebugUtilsLabelEXT(queue, pLabelInfo);
- }
-
- void vkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdBeginDebugUtilsLabelEXT(commandBuffer, pLabelInfo);
- }
-
- void vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdEndDebugUtilsLabelEXT(commandBuffer);
- }
-
- void vkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdInsertDebugUtilsLabelEXT(commandBuffer, pLabelInfo);
- }
-
- VkResult vkCreateDebugUtilsMessengerEXT(VkInstance instance,
- const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkDebugUtilsMessengerEXT *pMessenger) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateDebugUtilsMessengerEXT(instance, pCreateInfo, pAllocator, pMessenger);
- }
-
- void vkDestroyDebugUtilsMessengerEXT(VkInstance instance,
- VkDebugUtilsMessengerEXT messenger,
- const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDestroyDebugUtilsMessengerEXT(instance, messenger, pAllocator);
- }
-
- void vkSubmitDebugUtilsMessageEXT(VkInstance instance,
- VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
- VkDebugUtilsMessageTypeFlagsEXT messageTypes,
- const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkSubmitDebugUtilsMessageEXT(instance, messageSeverity, messageTypes, pCallbackData);
- }
-
-# if defined(VK_USE_PLATFORM_ANDROID_KHR)
- //=== VK_ANDROID_external_memory_android_hardware_buffer ===
-
- VkResult vkGetAndroidHardwareBufferPropertiesANDROID(VkDevice device,
- const struct AHardwareBuffer *buffer,
- VkAndroidHardwareBufferPropertiesANDROID *pProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetAndroidHardwareBufferPropertiesANDROID(device, buffer, pProperties);
- }
-
- VkResult vkGetMemoryAndroidHardwareBufferANDROID(VkDevice device,
- const VkMemoryGetAndroidHardwareBufferInfoANDROID *pInfo,
- struct AHardwareBuffer **pBuffer) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetMemoryAndroidHardwareBufferANDROID(device, pInfo, pBuffer);
- }
-# endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-
- //=== VK_EXT_sample_locations ===
-
- void vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT *pSampleLocationsInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetSampleLocationsEXT(commandBuffer, pSampleLocationsInfo);
- }
-
- void vkGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice,
- VkSampleCountFlagBits samples,
- VkMultisamplePropertiesEXT *pMultisampleProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceMultisamplePropertiesEXT(physicalDevice, samples, pMultisampleProperties);
- }
-
- //=== VK_KHR_get_memory_requirements2 ===
-
- void vkGetImageMemoryRequirements2KHR(VkDevice device,
- const VkImageMemoryRequirementsInfo2 *pInfo,
- VkMemoryRequirements2 *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetImageMemoryRequirements2KHR(device, pInfo, pMemoryRequirements);
- }
-
- void vkGetBufferMemoryRequirements2KHR(VkDevice device,
- const VkBufferMemoryRequirementsInfo2 *pInfo,
- VkMemoryRequirements2 *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetBufferMemoryRequirements2KHR(device, pInfo, pMemoryRequirements);
- }
-
- void vkGetImageSparseMemoryRequirements2KHR(VkDevice device,
- const VkImageSparseMemoryRequirementsInfo2 *pInfo,
- uint32_t *pSparseMemoryRequirementCount,
- VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
- }
-
- //=== VK_KHR_acceleration_structure ===
-
- VkResult vkCreateAccelerationStructureKHR(VkDevice device,
- const VkAccelerationStructureCreateInfoKHR *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkAccelerationStructureKHR *pAccelerationStructure) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateAccelerationStructureKHR(device, pCreateInfo, pAllocator, pAccelerationStructure);
- }
-
- void vkDestroyAccelerationStructureKHR(VkDevice device,
- VkAccelerationStructureKHR accelerationStructure,
- const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDestroyAccelerationStructureKHR(device, accelerationStructure, pAllocator);
- }
-
- void vkCmdBuildAccelerationStructuresKHR(VkCommandBuffer commandBuffer,
- uint32_t infoCount,
- const VkAccelerationStructureBuildGeometryInfoKHR *pInfos,
- const VkAccelerationStructureBuildRangeInfoKHR *const *ppBuildRangeInfos) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdBuildAccelerationStructuresKHR(commandBuffer, infoCount, pInfos, ppBuildRangeInfos);
- }
-
- void vkCmdBuildAccelerationStructuresIndirectKHR(VkCommandBuffer commandBuffer,
- uint32_t infoCount,
- const VkAccelerationStructureBuildGeometryInfoKHR *pInfos,
- const VkDeviceAddress *pIndirectDeviceAddresses,
- const uint32_t *pIndirectStrides,
- const uint32_t *const *ppMaxPrimitiveCounts) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdBuildAccelerationStructuresIndirectKHR(
- commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts);
- }
-
- VkResult vkBuildAccelerationStructuresKHR(VkDevice device,
- VkDeferredOperationKHR deferredOperation,
- uint32_t infoCount,
- const VkAccelerationStructureBuildGeometryInfoKHR *pInfos,
- const VkAccelerationStructureBuildRangeInfoKHR *const *ppBuildRangeInfos) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkBuildAccelerationStructuresKHR(device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos);
- }
-
- VkResult vkCopyAccelerationStructureKHR(VkDevice device,
- VkDeferredOperationKHR deferredOperation,
- const VkCopyAccelerationStructureInfoKHR *pInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCopyAccelerationStructureKHR(device, deferredOperation, pInfo);
- }
-
- VkResult vkCopyAccelerationStructureToMemoryKHR(VkDevice device,
- VkDeferredOperationKHR deferredOperation,
- const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCopyAccelerationStructureToMemoryKHR(device, deferredOperation, pInfo);
- }
-
- VkResult vkCopyMemoryToAccelerationStructureKHR(VkDevice device,
- VkDeferredOperationKHR deferredOperation,
- const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCopyMemoryToAccelerationStructureKHR(device, deferredOperation, pInfo);
- }
-
- VkResult vkWriteAccelerationStructuresPropertiesKHR(VkDevice device,
- uint32_t accelerationStructureCount,
- const VkAccelerationStructureKHR *pAccelerationStructures,
- VkQueryType queryType,
- size_t dataSize,
- void *pData,
- size_t stride) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkWriteAccelerationStructuresPropertiesKHR(device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride);
- }
-
- void vkCmdCopyAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR *pInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdCopyAccelerationStructureKHR(commandBuffer, pInfo);
- }
-
- void vkCmdCopyAccelerationStructureToMemoryKHR(VkCommandBuffer commandBuffer,
- const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdCopyAccelerationStructureToMemoryKHR(commandBuffer, pInfo);
- }
-
- void vkCmdCopyMemoryToAccelerationStructureKHR(VkCommandBuffer commandBuffer,
- const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdCopyMemoryToAccelerationStructureKHR(commandBuffer, pInfo);
- }
-
- VkDeviceAddress vkGetAccelerationStructureDeviceAddressKHR(VkDevice device,
- const VkAccelerationStructureDeviceAddressInfoKHR *pInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetAccelerationStructureDeviceAddressKHR(device, pInfo);
- }
-
- void vkCmdWriteAccelerationStructuresPropertiesKHR(VkCommandBuffer commandBuffer,
- uint32_t accelerationStructureCount,
- const VkAccelerationStructureKHR *pAccelerationStructures,
- VkQueryType queryType,
- VkQueryPool queryPool,
- uint32_t firstQuery) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdWriteAccelerationStructuresPropertiesKHR(
- commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery);
- }
-
- void vkGetDeviceAccelerationStructureCompatibilityKHR(VkDevice device,
- const VkAccelerationStructureVersionInfoKHR *pVersionInfo,
- VkAccelerationStructureCompatibilityKHR *pCompatibility) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetDeviceAccelerationStructureCompatibilityKHR(device, pVersionInfo, pCompatibility);
- }
-
- void vkGetAccelerationStructureBuildSizesKHR(VkDevice device,
- VkAccelerationStructureBuildTypeKHR buildType,
- const VkAccelerationStructureBuildGeometryInfoKHR *pBuildInfo,
- const uint32_t *pMaxPrimitiveCounts,
- VkAccelerationStructureBuildSizesInfoKHR *pSizeInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetAccelerationStructureBuildSizesKHR(device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo);
- }
-
- //=== VK_KHR_sampler_ycbcr_conversion ===
-
- VkResult vkCreateSamplerYcbcrConversionKHR(VkDevice device,
- const VkSamplerYcbcrConversionCreateInfo *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkSamplerYcbcrConversion *pYcbcrConversion) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateSamplerYcbcrConversionKHR(device, pCreateInfo, pAllocator, pYcbcrConversion);
- }
-
- void vkDestroySamplerYcbcrConversionKHR(VkDevice device,
- VkSamplerYcbcrConversion ycbcrConversion,
- const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDestroySamplerYcbcrConversionKHR(device, ycbcrConversion, pAllocator);
- }
-
- //=== VK_KHR_bind_memory2 ===
-
- VkResult vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkBindBufferMemory2KHR(device, bindInfoCount, pBindInfos);
- }
-
- VkResult vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkBindImageMemory2KHR(device, bindInfoCount, pBindInfos);
- }
-
- //=== VK_EXT_image_drm_format_modifier ===
-
- VkResult
- vkGetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT *pProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetImageDrmFormatModifierPropertiesEXT(device, image, pProperties);
- }
-
- //=== VK_EXT_validation_cache ===
-
- VkResult vkCreateValidationCacheEXT(VkDevice device,
- const VkValidationCacheCreateInfoEXT *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkValidationCacheEXT *pValidationCache) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateValidationCacheEXT(device, pCreateInfo, pAllocator, pValidationCache);
- }
-
- void
- vkDestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDestroyValidationCacheEXT(device, validationCache, pAllocator);
- }
-
- VkResult vkMergeValidationCachesEXT(VkDevice device,
- VkValidationCacheEXT dstCache,
- uint32_t srcCacheCount,
- const VkValidationCacheEXT *pSrcCaches) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkMergeValidationCachesEXT(device, dstCache, srcCacheCount, pSrcCaches);
- }
-
- VkResult vkGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, size_t *pDataSize, void *pData) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetValidationCacheDataEXT(device, validationCache, pDataSize, pData);
- }
-
- //=== VK_NV_shading_rate_image ===
-
- void vkCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdBindShadingRateImageNV(commandBuffer, imageView, imageLayout);
- }
-
- void vkCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer,
- uint32_t firstViewport,
- uint32_t viewportCount,
- const VkShadingRatePaletteNV *pShadingRatePalettes) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetViewportShadingRatePaletteNV(commandBuffer, firstViewport, viewportCount, pShadingRatePalettes);
- }
-
- void vkCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer,
- VkCoarseSampleOrderTypeNV sampleOrderType,
- uint32_t customSampleOrderCount,
- const VkCoarseSampleOrderCustomNV *pCustomSampleOrders) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetCoarseSampleOrderNV(commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders);
- }
-
- //=== VK_NV_ray_tracing ===
-
- VkResult vkCreateAccelerationStructureNV(VkDevice device,
- const VkAccelerationStructureCreateInfoNV *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkAccelerationStructureNV *pAccelerationStructure) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateAccelerationStructureNV(device, pCreateInfo, pAllocator, pAccelerationStructure);
- }
-
- void vkDestroyAccelerationStructureNV(VkDevice device,
- VkAccelerationStructureNV accelerationStructure,
- const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDestroyAccelerationStructureNV(device, accelerationStructure, pAllocator);
- }
-
- void vkGetAccelerationStructureMemoryRequirementsNV(VkDevice device,
- const VkAccelerationStructureMemoryRequirementsInfoNV *pInfo,
- VkMemoryRequirements2KHR *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetAccelerationStructureMemoryRequirementsNV(device, pInfo, pMemoryRequirements);
- }
-
- VkResult vkBindAccelerationStructureMemoryNV(VkDevice device,
- uint32_t bindInfoCount,
- const VkBindAccelerationStructureMemoryInfoNV *pBindInfos) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkBindAccelerationStructureMemoryNV(device, bindInfoCount, pBindInfos);
- }
-
- void vkCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer,
- const VkAccelerationStructureInfoNV *pInfo,
- VkBuffer instanceData,
- VkDeviceSize instanceOffset,
- VkBool32 update,
- VkAccelerationStructureNV dst,
- VkAccelerationStructureNV src,
- VkBuffer scratch,
- VkDeviceSize scratchOffset) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdBuildAccelerationStructureNV(commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset);
- }
-
- void vkCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer,
- VkAccelerationStructureNV dst,
- VkAccelerationStructureNV src,
- VkCopyAccelerationStructureModeKHR mode) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdCopyAccelerationStructureNV(commandBuffer, dst, src, mode);
- }
-
- void vkCmdTraceRaysNV(VkCommandBuffer commandBuffer,
- VkBuffer raygenShaderBindingTableBuffer,
- VkDeviceSize raygenShaderBindingOffset,
- VkBuffer missShaderBindingTableBuffer,
- VkDeviceSize missShaderBindingOffset,
- VkDeviceSize missShaderBindingStride,
- VkBuffer hitShaderBindingTableBuffer,
- VkDeviceSize hitShaderBindingOffset,
- VkDeviceSize hitShaderBindingStride,
- VkBuffer callableShaderBindingTableBuffer,
- VkDeviceSize callableShaderBindingOffset,
- VkDeviceSize callableShaderBindingStride,
- uint32_t width,
- uint32_t height,
- uint32_t depth) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdTraceRaysNV(commandBuffer,
- raygenShaderBindingTableBuffer,
- raygenShaderBindingOffset,
- missShaderBindingTableBuffer,
- missShaderBindingOffset,
- missShaderBindingStride,
- hitShaderBindingTableBuffer,
- hitShaderBindingOffset,
- hitShaderBindingStride,
- callableShaderBindingTableBuffer,
- callableShaderBindingOffset,
- callableShaderBindingStride,
- width,
- height,
- depth);
- }
-
- VkResult vkCreateRayTracingPipelinesNV(VkDevice device,
- VkPipelineCache pipelineCache,
- uint32_t createInfoCount,
- const VkRayTracingPipelineCreateInfoNV *pCreateInfos,
- const VkAllocationCallbacks *pAllocator,
- VkPipeline *pPipelines) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
- }
-
- VkResult vkGetRayTracingShaderGroupHandlesNV(
- VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetRayTracingShaderGroupHandlesNV(device, pipeline, firstGroup, groupCount, dataSize, pData);
- }
-
- VkResult vkGetAccelerationStructureHandleNV(VkDevice device,
- VkAccelerationStructureNV accelerationStructure,
- size_t dataSize,
- void *pData) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetAccelerationStructureHandleNV(device, accelerationStructure, dataSize, pData);
- }
-
- void vkCmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer commandBuffer,
- uint32_t accelerationStructureCount,
- const VkAccelerationStructureNV *pAccelerationStructures,
- VkQueryType queryType,
- VkQueryPool queryPool,
- uint32_t firstQuery) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdWriteAccelerationStructuresPropertiesNV(
- commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery);
- }
-
- VkResult vkCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCompileDeferredNV(device, pipeline, shader);
- }
-
- //=== VK_KHR_maintenance3 ===
-
- void vkGetDescriptorSetLayoutSupportKHR(VkDevice device,
- const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
- VkDescriptorSetLayoutSupport *pSupport) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetDescriptorSetLayoutSupportKHR(device, pCreateInfo, pSupport);
- }
-
- //=== VK_KHR_draw_indirect_count ===
-
- void vkCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- VkBuffer countBuffer,
- VkDeviceSize countBufferOffset,
- uint32_t maxDrawCount,
- uint32_t stride) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdDrawIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
- }
-
- void vkCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- VkBuffer countBuffer,
- VkDeviceSize countBufferOffset,
- uint32_t maxDrawCount,
- uint32_t stride) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdDrawIndexedIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
- }
-
- //=== VK_EXT_external_memory_host ===
-
- VkResult vkGetMemoryHostPointerPropertiesEXT(VkDevice device,
- VkExternalMemoryHandleTypeFlagBits handleType,
- const void *pHostPointer,
- VkMemoryHostPointerPropertiesEXT *pMemoryHostPointerProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetMemoryHostPointerPropertiesEXT(device, handleType, pHostPointer, pMemoryHostPointerProperties);
- }
-
- //=== VK_AMD_buffer_marker ===
-
- void vkCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer,
- VkPipelineStageFlagBits pipelineStage,
- VkBuffer dstBuffer,
- VkDeviceSize dstOffset,
- uint32_t marker) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdWriteBufferMarkerAMD(commandBuffer, pipelineStage, dstBuffer, dstOffset, marker);
- }
-
- //=== VK_EXT_calibrated_timestamps ===
-
- VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice,
- uint32_t *pTimeDomainCount,
- VkTimeDomainEXT *pTimeDomains) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(physicalDevice, pTimeDomainCount, pTimeDomains);
- }
-
- VkResult vkGetCalibratedTimestampsEXT(VkDevice device,
- uint32_t timestampCount,
- const VkCalibratedTimestampInfoEXT *pTimestampInfos,
- uint64_t *pTimestamps,
- uint64_t *pMaxDeviation) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetCalibratedTimestampsEXT(device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation);
- }
-
- //=== VK_NV_mesh_shader ===
-
- void vkCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdDrawMeshTasksNV(commandBuffer, taskCount, firstTask);
- }
-
- void vkCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) const
- VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdDrawMeshTasksIndirectNV(commandBuffer, buffer, offset, drawCount, stride);
- }
-
- void vkCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- VkBuffer countBuffer,
- VkDeviceSize countBufferOffset,
- uint32_t maxDrawCount,
- uint32_t stride) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdDrawMeshTasksIndirectCountNV(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
- }
-
- //=== VK_NV_scissor_exclusive ===
-
- void vkCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer,
- uint32_t firstExclusiveScissor,
- uint32_t exclusiveScissorCount,
- const VkRect2D *pExclusiveScissors) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetExclusiveScissorNV(commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors);
- }
-
- //=== VK_NV_device_diagnostic_checkpoints ===
-
- void vkCmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void *pCheckpointMarker) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetCheckpointNV(commandBuffer, pCheckpointMarker);
- }
-
- void vkGetQueueCheckpointDataNV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointDataNV *pCheckpointData) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetQueueCheckpointDataNV(queue, pCheckpointDataCount, pCheckpointData);
- }
-
- //=== VK_KHR_timeline_semaphore ===
-
- VkResult vkGetSemaphoreCounterValueKHR(VkDevice device, VkSemaphore semaphore, uint64_t *pValue) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetSemaphoreCounterValueKHR(device, semaphore, pValue);
- }
-
- VkResult vkWaitSemaphoresKHR(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkWaitSemaphoresKHR(device, pWaitInfo, timeout);
- }
-
- VkResult vkSignalSemaphoreKHR(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkSignalSemaphoreKHR(device, pSignalInfo);
- }
-
- //=== VK_INTEL_performance_query ===
-
- VkResult vkInitializePerformanceApiINTEL(VkDevice device, const VkInitializePerformanceApiInfoINTEL *pInitializeInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkInitializePerformanceApiINTEL(device, pInitializeInfo);
- }
-
- void vkUninitializePerformanceApiINTEL(VkDevice device) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkUninitializePerformanceApiINTEL(device);
- }
-
- VkResult vkCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL *pMarkerInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetPerformanceMarkerINTEL(commandBuffer, pMarkerInfo);
- }
-
- VkResult vkCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer,
- const VkPerformanceStreamMarkerInfoINTEL *pMarkerInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetPerformanceStreamMarkerINTEL(commandBuffer, pMarkerInfo);
- }
-
- VkResult vkCmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL *pOverrideInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetPerformanceOverrideINTEL(commandBuffer, pOverrideInfo);
- }
-
- VkResult vkAcquirePerformanceConfigurationINTEL(VkDevice device,
- const VkPerformanceConfigurationAcquireInfoINTEL *pAcquireInfo,
- VkPerformanceConfigurationINTEL *pConfiguration) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkAcquirePerformanceConfigurationINTEL(device, pAcquireInfo, pConfiguration);
- }
-
- VkResult vkReleasePerformanceConfigurationINTEL(VkDevice device, VkPerformanceConfigurationINTEL configuration) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkReleasePerformanceConfigurationINTEL(device, configuration);
- }
-
- VkResult vkQueueSetPerformanceConfigurationINTEL(VkQueue queue, VkPerformanceConfigurationINTEL configuration) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkQueueSetPerformanceConfigurationINTEL(queue, configuration);
- }
-
- VkResult
- vkGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL *pValue) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPerformanceParameterINTEL(device, parameter, pValue);
- }
-
- //=== VK_AMD_display_native_hdr ===
-
- void vkSetLocalDimmingAMD(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkSetLocalDimmingAMD(device, swapChain, localDimmingEnable);
- }
-
-# if defined(VK_USE_PLATFORM_FUCHSIA)
- //=== VK_FUCHSIA_imagepipe_surface ===
-
- VkResult vkCreateImagePipeSurfaceFUCHSIA(VkInstance instance,
- const VkImagePipeSurfaceCreateInfoFUCHSIA *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateImagePipeSurfaceFUCHSIA(instance, pCreateInfo, pAllocator, pSurface);
- }
-# endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-# if defined(VK_USE_PLATFORM_METAL_EXT)
- //=== VK_EXT_metal_surface ===
-
- VkResult vkCreateMetalSurfaceEXT(VkInstance instance,
- const VkMetalSurfaceCreateInfoEXT *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateMetalSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface);
- }
-# endif /*VK_USE_PLATFORM_METAL_EXT*/
-
- //=== VK_KHR_fragment_shading_rate ===
-
- VkResult vkGetPhysicalDeviceFragmentShadingRatesKHR(VkPhysicalDevice physicalDevice,
- uint32_t *pFragmentShadingRateCount,
- VkPhysicalDeviceFragmentShadingRateKHR *pFragmentShadingRates) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceFragmentShadingRatesKHR(physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates);
- }
-
- void vkCmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer,
- const VkExtent2D *pFragmentSize,
- const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetFragmentShadingRateKHR(commandBuffer, pFragmentSize, combinerOps);
- }
-
- //=== VK_EXT_buffer_device_address ===
-
- VkDeviceAddress vkGetBufferDeviceAddressEXT(VkDevice device, const VkBufferDeviceAddressInfo *pInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetBufferDeviceAddressEXT(device, pInfo);
- }
-
- //=== VK_EXT_tooling_info ===
-
- VkResult vkGetPhysicalDeviceToolPropertiesEXT(VkPhysicalDevice physicalDevice,
- uint32_t *pToolCount,
- VkPhysicalDeviceToolProperties *pToolProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceToolPropertiesEXT(physicalDevice, pToolCount, pToolProperties);
- }
-
- //=== VK_KHR_present_wait ===
-
- VkResult vkWaitForPresentKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkWaitForPresentKHR(device, swapchain, presentId, timeout);
- }
-
- //=== VK_NV_cooperative_matrix ===
-
- VkResult vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice,
- uint32_t *pPropertyCount,
- VkCooperativeMatrixPropertiesNV *pProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(physicalDevice, pPropertyCount, pProperties);
- }
-
- //=== VK_NV_coverage_reduction_mode ===
-
- VkResult vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
- VkPhysicalDevice physicalDevice, uint32_t *pCombinationCount, VkFramebufferMixedSamplesCombinationNV *pCombinations) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(physicalDevice, pCombinationCount, pCombinations);
- }
-
-# if defined(VK_USE_PLATFORM_WIN32_KHR)
- //=== VK_EXT_full_screen_exclusive ===
-
- VkResult vkGetPhysicalDeviceSurfacePresentModes2EXT(VkPhysicalDevice physicalDevice,
- const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo,
- uint32_t *pPresentModeCount,
- VkPresentModeKHR *pPresentModes) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceSurfacePresentModes2EXT(physicalDevice, pSurfaceInfo, pPresentModeCount, pPresentModes);
- }
-
- VkResult vkAcquireFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkAcquireFullScreenExclusiveModeEXT(device, swapchain);
- }
-
- VkResult vkReleaseFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkReleaseFullScreenExclusiveModeEXT(device, swapchain);
- }
-
- VkResult vkGetDeviceGroupSurfacePresentModes2EXT(VkDevice device,
- const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo,
- VkDeviceGroupPresentModeFlagsKHR *pModes) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetDeviceGroupSurfacePresentModes2EXT(device, pSurfaceInfo, pModes);
- }
-# endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
- //=== VK_EXT_headless_surface ===
-
- VkResult vkCreateHeadlessSurfaceEXT(VkInstance instance,
- const VkHeadlessSurfaceCreateInfoEXT *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateHeadlessSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface);
- }
-
- //=== VK_KHR_buffer_device_address ===
-
- VkDeviceAddress vkGetBufferDeviceAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo *pInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetBufferDeviceAddressKHR(device, pInfo);
- }
-
- uint64_t vkGetBufferOpaqueCaptureAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo *pInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetBufferOpaqueCaptureAddressKHR(device, pInfo);
- }
-
- uint64_t vkGetDeviceMemoryOpaqueCaptureAddressKHR(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetDeviceMemoryOpaqueCaptureAddressKHR(device, pInfo);
- }
-
- //=== VK_EXT_line_rasterization ===
-
- void vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetLineStippleEXT(commandBuffer, lineStippleFactor, lineStipplePattern);
- }
-
- //=== VK_EXT_host_query_reset ===
-
- void vkResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkResetQueryPoolEXT(device, queryPool, firstQuery, queryCount);
- }
-
- //=== VK_EXT_extended_dynamic_state ===
-
- void vkCmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetCullModeEXT(commandBuffer, cullMode);
- }
-
- void vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetFrontFaceEXT(commandBuffer, frontFace);
- }
-
- void vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetPrimitiveTopologyEXT(commandBuffer, primitiveTopology);
- }
-
- void vkCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport *pViewports) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetViewportWithCountEXT(commandBuffer, viewportCount, pViewports);
- }
-
- void vkCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D *pScissors) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetScissorWithCountEXT(commandBuffer, scissorCount, pScissors);
- }
-
- void vkCmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer,
- uint32_t firstBinding,
- uint32_t bindingCount,
- const VkBuffer *pBuffers,
- const VkDeviceSize *pOffsets,
- const VkDeviceSize *pSizes,
- const VkDeviceSize *pStrides) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdBindVertexBuffers2EXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides);
- }
-
- void vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetDepthTestEnableEXT(commandBuffer, depthTestEnable);
- }
-
- void vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetDepthWriteEnableEXT(commandBuffer, depthWriteEnable);
- }
-
- void vkCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetDepthCompareOpEXT(commandBuffer, depthCompareOp);
- }
-
- void vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetDepthBoundsTestEnableEXT(commandBuffer, depthBoundsTestEnable);
- }
-
- void vkCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetStencilTestEnableEXT(commandBuffer, stencilTestEnable);
- }
-
- void vkCmdSetStencilOpEXT(VkCommandBuffer commandBuffer,
- VkStencilFaceFlags faceMask,
- VkStencilOp failOp,
- VkStencilOp passOp,
- VkStencilOp depthFailOp,
- VkCompareOp compareOp) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetStencilOpEXT(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp);
- }
-
- //=== VK_KHR_deferred_host_operations ===
-
- VkResult vkCreateDeferredOperationKHR(VkDevice device,
- const VkAllocationCallbacks *pAllocator,
- VkDeferredOperationKHR *pDeferredOperation) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateDeferredOperationKHR(device, pAllocator, pDeferredOperation);
- }
-
- void vkDestroyDeferredOperationKHR(VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDestroyDeferredOperationKHR(device, operation, pAllocator);
- }
-
- uint32_t vkGetDeferredOperationMaxConcurrencyKHR(VkDevice device, VkDeferredOperationKHR operation) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetDeferredOperationMaxConcurrencyKHR(device, operation);
- }
-
- VkResult vkGetDeferredOperationResultKHR(VkDevice device, VkDeferredOperationKHR operation) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetDeferredOperationResultKHR(device, operation);
- }
-
- VkResult vkDeferredOperationJoinKHR(VkDevice device, VkDeferredOperationKHR operation) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDeferredOperationJoinKHR(device, operation);
- }
-
- //=== VK_KHR_pipeline_executable_properties ===
-
- VkResult vkGetPipelineExecutablePropertiesKHR(VkDevice device,
- const VkPipelineInfoKHR *pPipelineInfo,
- uint32_t *pExecutableCount,
- VkPipelineExecutablePropertiesKHR *pProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPipelineExecutablePropertiesKHR(device, pPipelineInfo, pExecutableCount, pProperties);
- }
-
- VkResult vkGetPipelineExecutableStatisticsKHR(VkDevice device,
- const VkPipelineExecutableInfoKHR *pExecutableInfo,
- uint32_t *pStatisticCount,
- VkPipelineExecutableStatisticKHR *pStatistics) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPipelineExecutableStatisticsKHR(device, pExecutableInfo, pStatisticCount, pStatistics);
- }
-
- VkResult
- vkGetPipelineExecutableInternalRepresentationsKHR(VkDevice device,
- const VkPipelineExecutableInfoKHR *pExecutableInfo,
- uint32_t *pInternalRepresentationCount,
- VkPipelineExecutableInternalRepresentationKHR *pInternalRepresentations) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPipelineExecutableInternalRepresentationsKHR(device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations);
- }
-
- //=== VK_NV_device_generated_commands ===
-
- void vkGetGeneratedCommandsMemoryRequirementsNV(VkDevice device,
- const VkGeneratedCommandsMemoryRequirementsInfoNV *pInfo,
- VkMemoryRequirements2 *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetGeneratedCommandsMemoryRequirementsNV(device, pInfo, pMemoryRequirements);
- }
-
- void vkCmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdPreprocessGeneratedCommandsNV(commandBuffer, pGeneratedCommandsInfo);
- }
-
- void vkCmdExecuteGeneratedCommandsNV(VkCommandBuffer commandBuffer,
- VkBool32 isPreprocessed,
- const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdExecuteGeneratedCommandsNV(commandBuffer, isPreprocessed, pGeneratedCommandsInfo);
- }
-
- void vkCmdBindPipelineShaderGroupNV(VkCommandBuffer commandBuffer,
- VkPipelineBindPoint pipelineBindPoint,
- VkPipeline pipeline,
- uint32_t groupIndex) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdBindPipelineShaderGroupNV(commandBuffer, pipelineBindPoint, pipeline, groupIndex);
- }
-
- VkResult vkCreateIndirectCommandsLayoutNV(VkDevice device,
- const VkIndirectCommandsLayoutCreateInfoNV *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkIndirectCommandsLayoutNV *pIndirectCommandsLayout) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateIndirectCommandsLayoutNV(device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
- }
-
- void vkDestroyIndirectCommandsLayoutNV(VkDevice device,
- VkIndirectCommandsLayoutNV indirectCommandsLayout,
- const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDestroyIndirectCommandsLayoutNV(device, indirectCommandsLayout, pAllocator);
- }
-
- //=== VK_EXT_acquire_drm_display ===
-
- VkResult vkAcquireDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkAcquireDrmDisplayEXT(physicalDevice, drmFd, display);
- }
-
- VkResult vkGetDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR *display) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetDrmDisplayEXT(physicalDevice, drmFd, connectorId, display);
- }
-
- //=== VK_EXT_private_data ===
-
- VkResult vkCreatePrivateDataSlotEXT(VkDevice device,
- const VkPrivateDataSlotCreateInfo *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkPrivateDataSlot *pPrivateDataSlot) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreatePrivateDataSlotEXT(device, pCreateInfo, pAllocator, pPrivateDataSlot);
- }
-
- void vkDestroyPrivateDataSlotEXT(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDestroyPrivateDataSlotEXT(device, privateDataSlot, pAllocator);
- }
-
- VkResult vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) const
- VULKAN_HPP_NOEXCEPT
- {
- return ::vkSetPrivateDataEXT(device, objectType, objectHandle, privateDataSlot, data);
- }
-
- void vkGetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t *pData) const
- VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPrivateDataEXT(device, objectType, objectHandle, privateDataSlot, pData);
- }
-
-# if defined(VK_ENABLE_BETA_EXTENSIONS)
- //=== VK_KHR_video_encode_queue ===
-
- void vkCmdEncodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR *pEncodeInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdEncodeVideoKHR(commandBuffer, pEncodeInfo);
- }
-# endif /*VK_ENABLE_BETA_EXTENSIONS*/
-
- //=== VK_KHR_synchronization2 ===
-
- void vkCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo *pDependencyInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetEvent2KHR(commandBuffer, event, pDependencyInfo);
- }
-
- void vkCmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdResetEvent2KHR(commandBuffer, event, stageMask);
- }
-
- void vkCmdWaitEvents2KHR(VkCommandBuffer commandBuffer,
- uint32_t eventCount,
- const VkEvent *pEvents,
- const VkDependencyInfo *pDependencyInfos) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdWaitEvents2KHR(commandBuffer, eventCount, pEvents, pDependencyInfos);
- }
-
- void vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer, const VkDependencyInfo *pDependencyInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdPipelineBarrier2KHR(commandBuffer, pDependencyInfo);
- }
-
- void vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdWriteTimestamp2KHR(commandBuffer, stage, queryPool, query);
- }
-
- VkResult vkQueueSubmit2KHR(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 *pSubmits, VkFence fence) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkQueueSubmit2KHR(queue, submitCount, pSubmits, fence);
- }
-
- void vkCmdWriteBufferMarker2AMD(
- VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdWriteBufferMarker2AMD(commandBuffer, stage, dstBuffer, dstOffset, marker);
- }
-
- void vkGetQueueCheckpointData2NV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointData2NV *pCheckpointData) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetQueueCheckpointData2NV(queue, pCheckpointDataCount, pCheckpointData);
- }
-
- //=== VK_NV_fragment_shading_rate_enums ===
-
- void vkCmdSetFragmentShadingRateEnumNV(VkCommandBuffer commandBuffer,
- VkFragmentShadingRateNV shadingRate,
- const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetFragmentShadingRateEnumNV(commandBuffer, shadingRate, combinerOps);
- }
-
- //=== VK_KHR_copy_commands2 ===
-
- void vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 *pCopyBufferInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdCopyBuffer2KHR(commandBuffer, pCopyBufferInfo);
- }
-
- void vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer, const VkCopyImageInfo2 *pCopyImageInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdCopyImage2KHR(commandBuffer, pCopyImageInfo);
- }
-
- void vkCmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 *pCopyBufferToImageInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdCopyBufferToImage2KHR(commandBuffer, pCopyBufferToImageInfo);
- }
-
- void vkCmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 *pCopyImageToBufferInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdCopyImageToBuffer2KHR(commandBuffer, pCopyImageToBufferInfo);
- }
-
- void vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer, const VkBlitImageInfo2 *pBlitImageInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdBlitImage2KHR(commandBuffer, pBlitImageInfo);
- }
-
- void vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer, const VkResolveImageInfo2 *pResolveImageInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdResolveImage2KHR(commandBuffer, pResolveImageInfo);
- }
-
-# if defined(VK_USE_PLATFORM_WIN32_KHR)
- //=== VK_NV_acquire_winrt_display ===
-
- VkResult vkAcquireWinrtDisplayNV(VkPhysicalDevice physicalDevice, VkDisplayKHR display) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkAcquireWinrtDisplayNV(physicalDevice, display);
- }
-
- VkResult vkGetWinrtDisplayNV(VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR *pDisplay) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetWinrtDisplayNV(physicalDevice, deviceRelativeId, pDisplay);
- }
-# endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-# if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
- //=== VK_EXT_directfb_surface ===
-
- VkResult vkCreateDirectFBSurfaceEXT(VkInstance instance,
- const VkDirectFBSurfaceCreateInfoEXT *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateDirectFBSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface);
- }
-
- VkBool32
- vkGetPhysicalDeviceDirectFBPresentationSupportEXT(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, IDirectFB *dfb) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceDirectFBPresentationSupportEXT(physicalDevice, queueFamilyIndex, dfb);
- }
-# endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
-
- //=== VK_KHR_ray_tracing_pipeline ===
-
- void vkCmdTraceRaysKHR(VkCommandBuffer commandBuffer,
- const VkStridedDeviceAddressRegionKHR *pRaygenShaderBindingTable,
- const VkStridedDeviceAddressRegionKHR *pMissShaderBindingTable,
- const VkStridedDeviceAddressRegionKHR *pHitShaderBindingTable,
- const VkStridedDeviceAddressRegionKHR *pCallableShaderBindingTable,
- uint32_t width,
- uint32_t height,
- uint32_t depth) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdTraceRaysKHR(
- commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth);
- }
-
- VkResult vkCreateRayTracingPipelinesKHR(VkDevice device,
- VkDeferredOperationKHR deferredOperation,
- VkPipelineCache pipelineCache,
- uint32_t createInfoCount,
- const VkRayTracingPipelineCreateInfoKHR *pCreateInfos,
- const VkAllocationCallbacks *pAllocator,
- VkPipeline *pPipelines) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateRayTracingPipelinesKHR(device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
- }
-
- VkResult vkGetRayTracingShaderGroupHandlesKHR(
- VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetRayTracingShaderGroupHandlesKHR(device, pipeline, firstGroup, groupCount, dataSize, pData);
- }
-
- VkResult vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(
- VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(device, pipeline, firstGroup, groupCount, dataSize, pData);
- }
-
- void vkCmdTraceRaysIndirectKHR(VkCommandBuffer commandBuffer,
- const VkStridedDeviceAddressRegionKHR *pRaygenShaderBindingTable,
- const VkStridedDeviceAddressRegionKHR *pMissShaderBindingTable,
- const VkStridedDeviceAddressRegionKHR *pHitShaderBindingTable,
- const VkStridedDeviceAddressRegionKHR *pCallableShaderBindingTable,
- VkDeviceAddress indirectDeviceAddress) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdTraceRaysIndirectKHR(
- commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress);
- }
-
- VkDeviceSize vkGetRayTracingShaderGroupStackSizeKHR(VkDevice device,
- VkPipeline pipeline,
- uint32_t group,
- VkShaderGroupShaderKHR groupShader) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetRayTracingShaderGroupStackSizeKHR(device, pipeline, group, groupShader);
- }
-
- void vkCmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetRayTracingPipelineStackSizeKHR(commandBuffer, pipelineStackSize);
- }
-
- //=== VK_EXT_vertex_input_dynamic_state ===
-
- void vkCmdSetVertexInputEXT(VkCommandBuffer commandBuffer,
- uint32_t vertexBindingDescriptionCount,
- const VkVertexInputBindingDescription2EXT *pVertexBindingDescriptions,
- uint32_t vertexAttributeDescriptionCount,
- const VkVertexInputAttributeDescription2EXT *pVertexAttributeDescriptions) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetVertexInputEXT(
- commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions);
- }
-
-# if defined(VK_USE_PLATFORM_FUCHSIA)
- //=== VK_FUCHSIA_external_memory ===
-
- VkResult vkGetMemoryZirconHandleFUCHSIA(VkDevice device,
- const VkMemoryGetZirconHandleInfoFUCHSIA *pGetZirconHandleInfo,
- zx_handle_t *pZirconHandle) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetMemoryZirconHandleFUCHSIA(device, pGetZirconHandleInfo, pZirconHandle);
- }
-
- VkResult vkGetMemoryZirconHandlePropertiesFUCHSIA(VkDevice device,
- VkExternalMemoryHandleTypeFlagBits handleType,
- zx_handle_t zirconHandle,
- VkMemoryZirconHandlePropertiesFUCHSIA *pMemoryZirconHandleProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetMemoryZirconHandlePropertiesFUCHSIA(device, handleType, zirconHandle, pMemoryZirconHandleProperties);
- }
-# endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-# if defined(VK_USE_PLATFORM_FUCHSIA)
- //=== VK_FUCHSIA_external_semaphore ===
-
- VkResult vkImportSemaphoreZirconHandleFUCHSIA(VkDevice device,
- const VkImportSemaphoreZirconHandleInfoFUCHSIA *pImportSemaphoreZirconHandleInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkImportSemaphoreZirconHandleFUCHSIA(device, pImportSemaphoreZirconHandleInfo);
- }
-
- VkResult vkGetSemaphoreZirconHandleFUCHSIA(VkDevice device,
- const VkSemaphoreGetZirconHandleInfoFUCHSIA *pGetZirconHandleInfo,
- zx_handle_t *pZirconHandle) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetSemaphoreZirconHandleFUCHSIA(device, pGetZirconHandleInfo, pZirconHandle);
- }
-# endif /*VK_USE_PLATFORM_FUCHSIA*/
-
-# if defined(VK_USE_PLATFORM_FUCHSIA)
- //=== VK_FUCHSIA_buffer_collection ===
-
- VkResult vkCreateBufferCollectionFUCHSIA(VkDevice device,
- const VkBufferCollectionCreateInfoFUCHSIA *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkBufferCollectionFUCHSIA *pCollection) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateBufferCollectionFUCHSIA(device, pCreateInfo, pAllocator, pCollection);
- }
-
- VkResult vkSetBufferCollectionImageConstraintsFUCHSIA(VkDevice device,
- VkBufferCollectionFUCHSIA collection,
- const VkImageConstraintsInfoFUCHSIA *pImageConstraintsInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkSetBufferCollectionImageConstraintsFUCHSIA(device, collection, pImageConstraintsInfo);
- }
-
- VkResult vkSetBufferCollectionBufferConstraintsFUCHSIA(VkDevice device,
- VkBufferCollectionFUCHSIA collection,
- const VkBufferConstraintsInfoFUCHSIA *pBufferConstraintsInfo) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkSetBufferCollectionBufferConstraintsFUCHSIA(device, collection, pBufferConstraintsInfo);
- }
-
- void vkDestroyBufferCollectionFUCHSIA(VkDevice device,
- VkBufferCollectionFUCHSIA collection,
- const VkAllocationCallbacks *pAllocator) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkDestroyBufferCollectionFUCHSIA(device, collection, pAllocator);
- }
-
- VkResult vkGetBufferCollectionPropertiesFUCHSIA(VkDevice device,
- VkBufferCollectionFUCHSIA collection,
- VkBufferCollectionPropertiesFUCHSIA *pProperties) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetBufferCollectionPropertiesFUCHSIA(device, collection, pProperties);
- }
-# endif /*VK_USE_PLATFORM_FUCHSIA*/
-
- //=== VK_HUAWEI_subpass_shading ===
-
- VkResult
- vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(VkDevice device, VkRenderPass renderpass, VkExtent2D *pMaxWorkgroupSize) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(device, renderpass, pMaxWorkgroupSize);
- }
-
- void vkCmdSubpassShadingHUAWEI(VkCommandBuffer commandBuffer) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSubpassShadingHUAWEI(commandBuffer);
- }
-
- //=== VK_HUAWEI_invocation_mask ===
-
- void vkCmdBindInvocationMaskHUAWEI(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdBindInvocationMaskHUAWEI(commandBuffer, imageView, imageLayout);
- }
-
- //=== VK_NV_external_memory_rdma ===
-
- VkResult vkGetMemoryRemoteAddressNV(VkDevice device,
- const VkMemoryGetRemoteAddressInfoNV *pMemoryGetRemoteAddressInfo,
- VkRemoteAddressNV *pAddress) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetMemoryRemoteAddressNV(device, pMemoryGetRemoteAddressInfo, pAddress);
- }
-
- //=== VK_EXT_extended_dynamic_state2 ===
-
- void vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_t patchControlPoints) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetPatchControlPointsEXT(commandBuffer, patchControlPoints);
- }
-
- void vkCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetRasterizerDiscardEnableEXT(commandBuffer, rasterizerDiscardEnable);
- }
-
- void vkCmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetDepthBiasEnableEXT(commandBuffer, depthBiasEnable);
- }
-
- void vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetLogicOpEXT(commandBuffer, logicOp);
- }
-
- void vkCmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetPrimitiveRestartEnableEXT(commandBuffer, primitiveRestartEnable);
- }
-
-# if defined(VK_USE_PLATFORM_SCREEN_QNX)
- //=== VK_QNX_screen_surface ===
-
- VkResult vkCreateScreenSurfaceQNX(VkInstance instance,
- const VkScreenSurfaceCreateInfoQNX *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkSurfaceKHR *pSurface) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCreateScreenSurfaceQNX(instance, pCreateInfo, pAllocator, pSurface);
- }
-
- VkBool32 vkGetPhysicalDeviceScreenPresentationSupportQNX(VkPhysicalDevice physicalDevice,
- uint32_t queueFamilyIndex,
- struct _screen_window *window) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetPhysicalDeviceScreenPresentationSupportQNX(physicalDevice, queueFamilyIndex, window);
- }
-# endif /*VK_USE_PLATFORM_SCREEN_QNX*/
-
- //=== VK_EXT_color_write_enable ===
-
- void vkCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32 *pColorWriteEnables) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdSetColorWriteEnableEXT(commandBuffer, attachmentCount, pColorWriteEnables);
- }
-
- //=== VK_EXT_multi_draw ===
-
- void vkCmdDrawMultiEXT(VkCommandBuffer commandBuffer,
- uint32_t drawCount,
- const VkMultiDrawInfoEXT *pVertexInfo,
- uint32_t instanceCount,
- uint32_t firstInstance,
- uint32_t stride) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdDrawMultiEXT(commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride);
- }
-
- void vkCmdDrawMultiIndexedEXT(VkCommandBuffer commandBuffer,
- uint32_t drawCount,
- const VkMultiDrawIndexedInfoEXT *pIndexInfo,
- uint32_t instanceCount,
- uint32_t firstInstance,
- uint32_t stride,
- const int32_t *pVertexOffset) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkCmdDrawMultiIndexedEXT(commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset);
- }
-
- //=== VK_EXT_pageable_device_local_memory ===
-
- void vkSetDeviceMemoryPriorityEXT(VkDevice device, VkDeviceMemory memory, float priority) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkSetDeviceMemoryPriorityEXT(device, memory, priority);
- }
-
- //=== VK_KHR_maintenance4 ===
-
- void vkGetDeviceBufferMemoryRequirementsKHR(VkDevice device,
- const VkDeviceBufferMemoryRequirements *pInfo,
- VkMemoryRequirements2 *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetDeviceBufferMemoryRequirementsKHR(device, pInfo, pMemoryRequirements);
- }
-
- void vkGetDeviceImageMemoryRequirementsKHR(VkDevice device,
- const VkDeviceImageMemoryRequirements *pInfo,
- VkMemoryRequirements2 *pMemoryRequirements) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetDeviceImageMemoryRequirementsKHR(device, pInfo, pMemoryRequirements);
- }
-
- void vkGetDeviceImageSparseMemoryRequirementsKHR(VkDevice device,
- const VkDeviceImageMemoryRequirements *pInfo,
- uint32_t *pSparseMemoryRequirementCount,
- VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetDeviceImageSparseMemoryRequirementsKHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
- }
-
- //=== VK_VALVE_descriptor_set_host_mapping ===
-
- void vkGetDescriptorSetLayoutHostMappingInfoVALVE(VkDevice device,
- const VkDescriptorSetBindingReferenceVALVE *pBindingReference,
- VkDescriptorSetLayoutHostMappingInfoVALVE *pHostMapping) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetDescriptorSetLayoutHostMappingInfoVALVE(device, pBindingReference, pHostMapping);
- }
-
- void vkGetDescriptorSetHostMappingVALVE(VkDevice device, VkDescriptorSet descriptorSet, void **ppData) const VULKAN_HPP_NOEXCEPT
- {
- return ::vkGetDescriptorSetHostMappingVALVE(device, descriptorSet, ppData);
- }
-};
+ class DispatchLoaderDynamic;
+#if !defined( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC )
+# if defined( VK_NO_PROTOTYPES )
+# define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC 1
+# else
+# define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC 0
+# endif
#endif
-class DispatchLoaderDynamic;
-#if !defined(VULKAN_HPP_DISPATCH_LOADER_DYNAMIC)
-# if defined(VK_NO_PROTOTYPES)
-# define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC 1
-# else
-# define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC 0
-# endif
+#if !defined( VULKAN_HPP_STORAGE_API )
+# if defined( VULKAN_HPP_STORAGE_SHARED )
+# if defined( _MSC_VER )
+# if defined( VULKAN_HPP_STORAGE_SHARED_EXPORT )
+# define VULKAN_HPP_STORAGE_API __declspec( dllexport )
+# else
+# define VULKAN_HPP_STORAGE_API __declspec( dllimport )
+# endif
+# elif defined( __clang__ ) || defined( __GNUC__ )
+# if defined( VULKAN_HPP_STORAGE_SHARED_EXPORT )
+# define VULKAN_HPP_STORAGE_API __attribute__( ( visibility( "default" ) ) )
+# else
+# define VULKAN_HPP_STORAGE_API
+# endif
+# else
+# define VULKAN_HPP_STORAGE_API
+# pragma warning Unknown import / export semantics
+# endif
+# else
+# define VULKAN_HPP_STORAGE_API
+# endif
#endif
-#if !defined(VULKAN_HPP_STORAGE_API)
-# if defined(VULKAN_HPP_STORAGE_SHARED)
-# if defined(_MSC_VER)
-# if defined(VULKAN_HPP_STORAGE_SHARED_EXPORT)
-# define VULKAN_HPP_STORAGE_API __declspec(dllexport)
-# else
-# define VULKAN_HPP_STORAGE_API __declspec(dllimport)
-# endif
-# elif defined(__clang__) || defined(__GNUC__)
-# if defined(VULKAN_HPP_STORAGE_SHARED_EXPORT)
-# define VULKAN_HPP_STORAGE_API __attribute__((visibility("default")))
-# else
-# define VULKAN_HPP_STORAGE_API
-# endif
-# else
-# define VULKAN_HPP_STORAGE_API
-# pragma warning Unknown import / export semantics
-# endif
-# else
-# define VULKAN_HPP_STORAGE_API
-# endif
+#if !defined( VULKAN_HPP_DEFAULT_DISPATCHER )
+# if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1
+# define VULKAN_HPP_DEFAULT_DISPATCHER ::VULKAN_HPP_NAMESPACE::defaultDispatchLoaderDynamic
+# define VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE \
+ namespace VULKAN_HPP_NAMESPACE \
+ { \
+ VULKAN_HPP_STORAGE_API DispatchLoaderDynamic defaultDispatchLoaderDynamic; \
+ }
+ extern VULKAN_HPP_STORAGE_API DispatchLoaderDynamic defaultDispatchLoaderDynamic;
+# else
+ static inline ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic & getDispatchLoaderStatic()
+ {
+ static ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic dls;
+ return dls;
+ }
+# define VULKAN_HPP_DEFAULT_DISPATCHER ::VULKAN_HPP_NAMESPACE::getDispatchLoaderStatic()
+# define VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE
+# endif
#endif
-#if !defined(VULKAN_HPP_DEFAULT_DISPATCHER)
-# if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1
-# define VULKAN_HPP_DEFAULT_DISPATCHER ::VULKAN_HPP_NAMESPACE::defaultDispatchLoaderDynamic
-# define VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE \
- namespace VULKAN_HPP_NAMESPACE { \
- VULKAN_HPP_STORAGE_API DispatchLoaderDynamic defaultDispatchLoaderDynamic; \
- }
-extern VULKAN_HPP_STORAGE_API DispatchLoaderDynamic defaultDispatchLoaderDynamic;
-# else
-static inline ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic &getDispatchLoaderStatic()
-{
- static ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic dls;
- return dls;
-}
-# define VULKAN_HPP_DEFAULT_DISPATCHER ::VULKAN_HPP_NAMESPACE::getDispatchLoaderStatic()
-# define VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE
-# endif
+#if !defined( VULKAN_HPP_DEFAULT_DISPATCHER_TYPE )
+# if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1
+# define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE ::VULKAN_HPP_NAMESPACE::DispatchLoaderDynamic
+# else
+# define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic
+# endif
#endif
-#if !defined(VULKAN_HPP_DEFAULT_DISPATCHER_TYPE)
-# if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1
-# define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE ::VULKAN_HPP_NAMESPACE::DispatchLoaderDynamic
-# else
-# define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE ::VULKAN_HPP_NAMESPACE::DispatchLoaderStatic
-# endif
-#endif
-
-#if defined(VULKAN_HPP_NO_DEFAULT_DISPATCHER)
-# define VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT
-# define VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT
-# define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT
+#if defined( VULKAN_HPP_NO_DEFAULT_DISPATCHER )
+# define VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT
+# define VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT
+# define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT
#else
-# define VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT = {}
-# define VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT = nullptr
-# define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT = VULKAN_HPP_DEFAULT_DISPATCHER
+# define VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT = {}
+# define VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT = nullptr
+# define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT = VULKAN_HPP_DEFAULT_DISPATCHER
#endif
-struct AllocationCallbacks;
+#if !defined( VULKAN_HPP_NO_SMART_HANDLE )
+ struct AllocationCallbacks;
-template<typename OwnerType, typename Dispatch>
-class ObjectDestroy
-{
-public:
- ObjectDestroy() = default;
+ template <typename OwnerType, typename Dispatch>
+ class ObjectDestroy
+ {
+ public:
+ ObjectDestroy() = default;
- ObjectDestroy(OwnerType owner,
- Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
- Dispatch const &dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) VULKAN_HPP_NOEXCEPT
- : m_owner(owner),
- m_allocationCallbacks(allocationCallbacks),
- m_dispatch(&dispatch)
- {
- }
+ ObjectDestroy( OwnerType owner,
+ Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+ Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
+ : m_owner( owner )
+ , m_allocationCallbacks( allocationCallbacks )
+ , m_dispatch( &dispatch )
+ {
+ }
- OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
- {
- return m_owner;
- }
- Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT
- {
- return m_allocationCallbacks;
- }
+ OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
+ {
+ return m_owner;
+ }
+ Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT
+ {
+ return m_allocationCallbacks;
+ }
-protected:
- template<typename T>
- void destroy(T t) VULKAN_HPP_NOEXCEPT
- {
- VULKAN_HPP_ASSERT(m_owner && m_dispatch);
- m_owner.destroy(t, m_allocationCallbacks, *m_dispatch);
- }
+ protected:
+ template <typename T>
+ void destroy( T t ) VULKAN_HPP_NOEXCEPT
+ {
+ VULKAN_HPP_ASSERT( m_owner && m_dispatch );
+ m_owner.destroy( t, m_allocationCallbacks, *m_dispatch );
+ }
-private:
- OwnerType m_owner = {};
- Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
- Dispatch const *m_dispatch = nullptr;
-};
+ private:
+ OwnerType m_owner = {};
+ Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
+ Dispatch const * m_dispatch = nullptr;
+ };
-class NoParent;
+ class NoParent;
-template<typename Dispatch>
-class ObjectDestroy<NoParent, Dispatch>
-{
-public:
- ObjectDestroy() = default;
+ template <typename Dispatch>
+ class ObjectDestroy<NoParent, Dispatch>
+ {
+ public:
+ ObjectDestroy() = default;
- ObjectDestroy(Optional<const AllocationCallbacks> allocationCallbacks,
- Dispatch const &dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) VULKAN_HPP_NOEXCEPT
- : m_allocationCallbacks(allocationCallbacks),
- m_dispatch(&dispatch)
- {
- }
+ ObjectDestroy( Optional<const AllocationCallbacks> allocationCallbacks,
+ Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
+ : m_allocationCallbacks( allocationCallbacks )
+ , m_dispatch( &dispatch )
+ {
+ }
- Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT
- {
- return m_allocationCallbacks;
- }
+ Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT
+ {
+ return m_allocationCallbacks;
+ }
-protected:
- template<typename T>
- void destroy(T t) VULKAN_HPP_NOEXCEPT
- {
- VULKAN_HPP_ASSERT(m_dispatch);
- t.destroy(m_allocationCallbacks, *m_dispatch);
- }
+ protected:
+ template <typename T>
+ void destroy( T t ) VULKAN_HPP_NOEXCEPT
+ {
+ VULKAN_HPP_ASSERT( m_dispatch );
+ t.destroy( m_allocationCallbacks, *m_dispatch );
+ }
-private:
- Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
- Dispatch const *m_dispatch = nullptr;
-};
+ private:
+ Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
+ Dispatch const * m_dispatch = nullptr;
+ };
-template<typename OwnerType, typename Dispatch>
-class ObjectFree
-{
-public:
- ObjectFree() = default;
+ template <typename OwnerType, typename Dispatch>
+ class ObjectFree
+ {
+ public:
+ ObjectFree() = default;
- ObjectFree(OwnerType owner,
- Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
- Dispatch const &dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) VULKAN_HPP_NOEXCEPT
- : m_owner(owner),
- m_allocationCallbacks(allocationCallbacks),
- m_dispatch(&dispatch)
- {
- }
+ ObjectFree( OwnerType owner,
+ Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
+ Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
+ : m_owner( owner )
+ , m_allocationCallbacks( allocationCallbacks )
+ , m_dispatch( &dispatch )
+ {
+ }
- OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
- {
- return m_owner;
- }
+ OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
+ {
+ return m_owner;
+ }
- Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT
- {
- return m_allocationCallbacks;
- }
+ Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT
+ {
+ return m_allocationCallbacks;
+ }
-protected:
- template<typename T>
- void destroy(T t) VULKAN_HPP_NOEXCEPT
- {
- VULKAN_HPP_ASSERT(m_owner && m_dispatch);
- (m_owner.free)(t, m_allocationCallbacks, *m_dispatch);
- }
+ protected:
+ template <typename T>
+ void destroy( T t ) VULKAN_HPP_NOEXCEPT
+ {
+ VULKAN_HPP_ASSERT( m_owner && m_dispatch );
+ ( m_owner.free )( t, m_allocationCallbacks, *m_dispatch );
+ }
-private:
- OwnerType m_owner = {};
- Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
- Dispatch const *m_dispatch = nullptr;
-};
+ private:
+ OwnerType m_owner = {};
+ Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
+ Dispatch const * m_dispatch = nullptr;
+ };
-template<typename OwnerType, typename Dispatch>
-class ObjectRelease
-{
-public:
- ObjectRelease() = default;
+ template <typename OwnerType, typename Dispatch>
+ class ObjectRelease
+ {
+ public:
+ ObjectRelease() = default;
- ObjectRelease(OwnerType owner, Dispatch const &dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) VULKAN_HPP_NOEXCEPT
- : m_owner(owner),
- m_dispatch(&dispatch)
- {
- }
+ ObjectRelease( OwnerType owner, Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
+ : m_owner( owner )
+ , m_dispatch( &dispatch )
+ {
+ }
- OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
- {
- return m_owner;
- }
+ OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
+ {
+ return m_owner;
+ }
-protected:
- template<typename T>
- void destroy(T t) VULKAN_HPP_NOEXCEPT
- {
- VULKAN_HPP_ASSERT(m_owner && m_dispatch);
- m_owner.release(t, *m_dispatch);
- }
+ protected:
+ template <typename T>
+ void destroy( T t ) VULKAN_HPP_NOEXCEPT
+ {
+ VULKAN_HPP_ASSERT( m_owner && m_dispatch );
+ m_owner.release( t, *m_dispatch );
+ }
-private:
- OwnerType m_owner = {};
- Dispatch const *m_dispatch = nullptr;
-};
+ private:
+ OwnerType m_owner = {};
+ Dispatch const * m_dispatch = nullptr;
+ };
-template<typename OwnerType, typename PoolType, typename Dispatch>
-class PoolFree
-{
-public:
- PoolFree() = default;
+ template <typename OwnerType, typename PoolType, typename Dispatch>
+ class PoolFree
+ {
+ public:
+ PoolFree() = default;
- PoolFree(OwnerType owner, PoolType pool, Dispatch const &dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT) VULKAN_HPP_NOEXCEPT
- : m_owner(owner),
- m_pool(pool),
- m_dispatch(&dispatch)
- {
- }
+ PoolFree( OwnerType owner, PoolType pool, Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
+ : m_owner( owner )
+ , m_pool( pool )
+ , m_dispatch( &dispatch )
+ {
+ }
- OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
- {
- return m_owner;
- }
- PoolType getPool() const VULKAN_HPP_NOEXCEPT
- {
- return m_pool;
- }
+ OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
+ {
+ return m_owner;
+ }
+ PoolType getPool() const VULKAN_HPP_NOEXCEPT
+ {
+ return m_pool;
+ }
-protected:
- template<typename T>
- void destroy(T t) VULKAN_HPP_NOEXCEPT
- {
- (m_owner.free)(m_pool, t, *m_dispatch);
- }
+ protected:
+ template <typename T>
+ void destroy( T t ) VULKAN_HPP_NOEXCEPT
+ {
+ ( m_owner.free )( m_pool, t, *m_dispatch );
+ }
-private:
- OwnerType m_owner = OwnerType();
- PoolType m_pool = PoolType();
- Dispatch const *m_dispatch = nullptr;
-};
+ private:
+ OwnerType m_owner = OwnerType();
+ PoolType m_pool = PoolType();
+ Dispatch const * m_dispatch = nullptr;
+ };
-//==================
-//=== BASE TYPEs ===
-//==================
+#endif // !VULKAN_HPP_NO_SMART_HANDLE
-using Bool32 = uint32_t;
-using DeviceAddress = uint64_t;
-using DeviceSize = uint64_t;
-using RemoteAddressNV = void *;
-using SampleMask = uint32_t;
+ //==================
+ //=== BASE TYPEs ===
+ //==================
+
+ using Bool32 = uint32_t;
+ using DeviceAddress = uint64_t;
+ using DeviceSize = uint64_t;
+ using RemoteAddressNV = void *;
+ using SampleMask = uint32_t;
} // namespace VULKAN_HPP_NAMESPACE
#include <vulkan/vulkan_enums.hpp>
+#if !defined( VULKAN_HPP_NO_TO_STRING )
+# include <vulkan/vulkan_to_string.hpp>
+#endif
#ifndef VULKAN_HPP_NO_EXCEPTIONS
-namespace std {
-template<>
-struct is_error_code_enum<VULKAN_HPP_NAMESPACE::Result> : public true_type
+namespace std
{
-};
+ template <>
+ struct is_error_code_enum<VULKAN_HPP_NAMESPACE::Result> : public true_type
+ {
+ };
} // namespace std
#endif
-namespace VULKAN_HPP_NAMESPACE {
+namespace VULKAN_HPP_NAMESPACE
+{
#ifndef VULKAN_HPP_NO_EXCEPTIONS
+ class ErrorCategoryImpl : public std::error_category
+ {
+ public:
+ virtual const char * name() const VULKAN_HPP_NOEXCEPT override
+ {
+ return VULKAN_HPP_NAMESPACE_STRING "::Result";
+ }
+ virtual std::string message( int ev ) const override
+ {
+# if defined( VULKAN_HPP_NO_TO_STRING )
+ return std::to_string( ev );
+# else
+ return VULKAN_HPP_NAMESPACE::to_string( static_cast<VULKAN_HPP_NAMESPACE::Result>( ev ) );
+# endif
+ }
+ };
-class ErrorCategoryImpl : public std::error_category
-{
-public:
- virtual const char *name() const VULKAN_HPP_NOEXCEPT override
- {
- return VULKAN_HPP_NAMESPACE_STRING "::Result";
- }
- virtual std::string message(int ev) const override
- {
- return to_string(static_cast<Result>(ev));
- }
-};
+ class Error
+ {
+ public:
+ Error() VULKAN_HPP_NOEXCEPT = default;
+ Error( const Error & ) VULKAN_HPP_NOEXCEPT = default;
+ virtual ~Error() VULKAN_HPP_NOEXCEPT = default;
-class Error
-{
-public:
- Error() VULKAN_HPP_NOEXCEPT = default;
- Error(const Error &) VULKAN_HPP_NOEXCEPT = default;
- virtual ~Error() VULKAN_HPP_NOEXCEPT = default;
+ virtual const char * what() const VULKAN_HPP_NOEXCEPT = 0;
+ };
- virtual const char *what() const VULKAN_HPP_NOEXCEPT = 0;
-};
+ class LogicError
+ : public Error
+ , public std::logic_error
+ {
+ public:
+ explicit LogicError( const std::string & what ) : Error(), std::logic_error( what ) {}
+ explicit LogicError( char const * what ) : Error(), std::logic_error( what ) {}
-class LogicError
- : public Error,
- public std::logic_error
-{
-public:
- explicit LogicError(const std::string &what)
- : Error()
- , std::logic_error(what)
- {}
- explicit LogicError(char const *what)
- : Error()
- , std::logic_error(what)
- {}
+ virtual const char * what() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::logic_error::what();
+ }
+ };
- virtual const char *what() const VULKAN_HPP_NOEXCEPT
- {
- return std::logic_error::what();
- }
-};
+ class SystemError
+ : public Error
+ , public std::system_error
+ {
+ public:
+ SystemError( std::error_code ec ) : Error(), std::system_error( ec ) {}
+ SystemError( std::error_code ec, std::string const & what ) : Error(), std::system_error( ec, what ) {}
+ SystemError( std::error_code ec, char const * what ) : Error(), std::system_error( ec, what ) {}
+ SystemError( int ev, std::error_category const & ecat ) : Error(), std::system_error( ev, ecat ) {}
+ SystemError( int ev, std::error_category const & ecat, std::string const & what ) : Error(), std::system_error( ev, ecat, what ) {}
+ SystemError( int ev, std::error_category const & ecat, char const * what ) : Error(), std::system_error( ev, ecat, what ) {}
-class SystemError
- : public Error,
- public std::system_error
-{
-public:
- SystemError(std::error_code ec)
- : Error()
- , std::system_error(ec)
- {}
- SystemError(std::error_code ec, std::string const &what)
- : Error()
- , std::system_error(ec, what)
- {}
- SystemError(std::error_code ec, char const *what)
- : Error()
- , std::system_error(ec, what)
- {}
- SystemError(int ev, std::error_category const &ecat)
- : Error()
- , std::system_error(ev, ecat)
- {}
- SystemError(int ev, std::error_category const &ecat, std::string const &what)
- : Error()
- , std::system_error(ev, ecat, what)
- {}
- SystemError(int ev, std::error_category const &ecat, char const *what)
- : Error()
- , std::system_error(ev, ecat, what)
- {}
+ virtual const char * what() const VULKAN_HPP_NOEXCEPT
+ {
+ return std::system_error::what();
+ }
+ };
- virtual const char *what() const VULKAN_HPP_NOEXCEPT
- {
- return std::system_error::what();
- }
-};
+ VULKAN_HPP_INLINE const std::error_category & errorCategory() VULKAN_HPP_NOEXCEPT
+ {
+ static ErrorCategoryImpl instance;
+ return instance;
+ }
-VULKAN_HPP_INLINE const std::error_category &errorCategory() VULKAN_HPP_NOEXCEPT
-{
- static ErrorCategoryImpl instance;
- return instance;
-}
+ VULKAN_HPP_INLINE std::error_code make_error_code( Result e ) VULKAN_HPP_NOEXCEPT
+ {
+ return std::error_code( static_cast<int>( e ), errorCategory() );
+ }
-VULKAN_HPP_INLINE std::error_code make_error_code(Result e) VULKAN_HPP_NOEXCEPT
-{
- return std::error_code(static_cast<int>(e), errorCategory());
-}
+ VULKAN_HPP_INLINE std::error_condition make_error_condition( Result e ) VULKAN_HPP_NOEXCEPT
+ {
+ return std::error_condition( static_cast<int>( e ), errorCategory() );
+ }
-VULKAN_HPP_INLINE std::error_condition make_error_condition(Result e) VULKAN_HPP_NOEXCEPT
-{
- return std::error_condition(static_cast<int>(e), errorCategory());
-}
+ class OutOfHostMemoryError : public SystemError
+ {
+ public:
+ OutOfHostMemoryError( std::string const & message ) : SystemError( make_error_code( Result::eErrorOutOfHostMemory ), message ) {}
+ OutOfHostMemoryError( char const * message ) : SystemError( make_error_code( Result::eErrorOutOfHostMemory ), message ) {}
+ };
-class OutOfHostMemoryError : public SystemError
-{
-public:
- OutOfHostMemoryError(std::string const &message)
- : SystemError(make_error_code(Result::eErrorOutOfHostMemory), message)
- {}
- OutOfHostMemoryError(char const *message)
- : SystemError(make_error_code(Result::eErrorOutOfHostMemory), message)
- {}
-};
+ class OutOfDeviceMemoryError : public SystemError
+ {
+ public:
+ OutOfDeviceMemoryError( std::string const & message ) : SystemError( make_error_code( Result::eErrorOutOfDeviceMemory ), message ) {}
+ OutOfDeviceMemoryError( char const * message ) : SystemError( make_error_code( Result::eErrorOutOfDeviceMemory ), message ) {}
+ };
-class OutOfDeviceMemoryError : public SystemError
-{
-public:
- OutOfDeviceMemoryError(std::string const &message)
- : SystemError(make_error_code(Result::eErrorOutOfDeviceMemory), message)
- {}
- OutOfDeviceMemoryError(char const *message)
- : SystemError(make_error_code(Result::eErrorOutOfDeviceMemory), message)
- {}
-};
+ class InitializationFailedError : public SystemError
+ {
+ public:
+ InitializationFailedError( std::string const & message ) : SystemError( make_error_code( Result::eErrorInitializationFailed ), message ) {}
+ InitializationFailedError( char const * message ) : SystemError( make_error_code( Result::eErrorInitializationFailed ), message ) {}
+ };
-class InitializationFailedError : public SystemError
-{
-public:
- InitializationFailedError(std::string const &message)
- : SystemError(make_error_code(Result::eErrorInitializationFailed), message)
- {}
- InitializationFailedError(char const *message)
- : SystemError(make_error_code(Result::eErrorInitializationFailed), message)
- {}
-};
+ class DeviceLostError : public SystemError
+ {
+ public:
+ DeviceLostError( std::string const & message ) : SystemError( make_error_code( Result::eErrorDeviceLost ), message ) {}
+ DeviceLostError( char const * message ) : SystemError( make_error_code( Result::eErrorDeviceLost ), message ) {}
+ };
-class DeviceLostError : public SystemError
-{
-public:
- DeviceLostError(std::string const &message)
- : SystemError(make_error_code(Result::eErrorDeviceLost), message)
- {}
- DeviceLostError(char const *message)
- : SystemError(make_error_code(Result::eErrorDeviceLost), message)
- {}
-};
+ class MemoryMapFailedError : public SystemError
+ {
+ public:
+ MemoryMapFailedError( std::string const & message ) : SystemError( make_error_code( Result::eErrorMemoryMapFailed ), message ) {}
+ MemoryMapFailedError( char const * message ) : SystemError( make_error_code( Result::eErrorMemoryMapFailed ), message ) {}
+ };
-class MemoryMapFailedError : public SystemError
-{
-public:
- MemoryMapFailedError(std::string const &message)
- : SystemError(make_error_code(Result::eErrorMemoryMapFailed), message)
- {}
- MemoryMapFailedError(char const *message)
- : SystemError(make_error_code(Result::eErrorMemoryMapFailed), message)
- {}
-};
+ class LayerNotPresentError : public SystemError
+ {
+ public:
+ LayerNotPresentError( std::string const & message ) : SystemError( make_error_code( Result::eErrorLayerNotPresent ), message ) {}
+ LayerNotPresentError( char const * message ) : SystemError( make_error_code( Result::eErrorLayerNotPresent ), message ) {}
+ };
-class LayerNotPresentError : public SystemError
-{
-public:
- LayerNotPresentError(std::string const &message)
- : SystemError(make_error_code(Result::eErrorLayerNotPresent), message)
- {}
- LayerNotPresentError(char const *message)
- : SystemError(make_error_code(Result::eErrorLayerNotPresent), message)
- {}
-};
+ class ExtensionNotPresentError : public SystemError
+ {
+ public:
+ ExtensionNotPresentError( std::string const & message ) : SystemError( make_error_code( Result::eErrorExtensionNotPresent ), message ) {}
+ ExtensionNotPresentError( char const * message ) : SystemError( make_error_code( Result::eErrorExtensionNotPresent ), message ) {}
+ };
-class ExtensionNotPresentError : public SystemError
-{
-public:
- ExtensionNotPresentError(std::string const &message)
- : SystemError(make_error_code(Result::eErrorExtensionNotPresent), message)
- {}
- ExtensionNotPresentError(char const *message)
- : SystemError(make_error_code(Result::eErrorExtensionNotPresent), message)
- {}
-};
+ class FeatureNotPresentError : public SystemError
+ {
+ public:
+ FeatureNotPresentError( std::string const & message ) : SystemError( make_error_code( Result::eErrorFeatureNotPresent ), message ) {}
+ FeatureNotPresentError( char const * message ) : SystemError( make_error_code( Result::eErrorFeatureNotPresent ), message ) {}
+ };
-class FeatureNotPresentError : public SystemError
-{
-public:
- FeatureNotPresentError(std::string const &message)
- : SystemError(make_error_code(Result::eErrorFeatureNotPresent), message)
- {}
- FeatureNotPresentError(char const *message)
- : SystemError(make_error_code(Result::eErrorFeatureNotPresent), message)
- {}
-};
+ class IncompatibleDriverError : public SystemError
+ {
+ public:
+ IncompatibleDriverError( std::string const & message ) : SystemError( make_error_code( Result::eErrorIncompatibleDriver ), message ) {}
+ IncompatibleDriverError( char const * message ) : SystemError( make_error_code( Result::eErrorIncompatibleDriver ), message ) {}
+ };
-class IncompatibleDriverError : public SystemError
-{
-public:
- IncompatibleDriverError(std::string const &message)
- : SystemError(make_error_code(Result::eErrorIncompatibleDriver), message)
- {}
- IncompatibleDriverError(char const *message)
- : SystemError(make_error_code(Result::eErrorIncompatibleDriver), message)
- {}
-};
+ class TooManyObjectsError : public SystemError
+ {
+ public:
+ TooManyObjectsError( std::string const & message ) : SystemError( make_error_code( Result::eErrorTooManyObjects ), message ) {}
+ TooManyObjectsError( char const * message ) : SystemError( make_error_code( Result::eErrorTooManyObjects ), message ) {}
+ };
-class TooManyObjectsError : public SystemError
-{
-public:
- TooManyObjectsError(std::string const &message)
- : SystemError(make_error_code(Result::eErrorTooManyObjects), message)
- {}
- TooManyObjectsError(char const *message)
- : SystemError(make_error_code(Result::eErrorTooManyObjects), message)
- {}
-};
+ class FormatNotSupportedError : public SystemError
+ {
+ public:
+ FormatNotSupportedError( std::string const & message ) : SystemError( make_error_code( Result::eErrorFormatNotSupported ), message ) {}
+ FormatNotSupportedError( char const * message ) : SystemError( make_error_code( Result::eErrorFormatNotSupported ), message ) {}
+ };
-class FormatNotSupportedError : public SystemError
-{
-public:
- FormatNotSupportedError(std::string const &message)
- : SystemError(make_error_code(Result::eErrorFormatNotSupported), message)
- {}
- FormatNotSupportedError(char const *message)
- : SystemError(make_error_code(Result::eErrorFormatNotSupported), message)
- {}
-};
+ class FragmentedPoolError : public SystemError
+ {
+ public:
+ FragmentedPoolError( std::string const & message ) : SystemError( make_error_code( Result::eErrorFragmentedPool ), message ) {}
+ FragmentedPoolError( char const * message ) : SystemError( make_error_code( Result::eErrorFragmentedPool ), message ) {}
+ };
-class FragmentedPoolError : public SystemError
-{
-public:
- FragmentedPoolError(std::string const &message)
- : SystemError(make_error_code(Result::eErrorFragmentedPool), message)
- {}
- FragmentedPoolError(char const *message)
- : SystemError(make_error_code(Result::eErrorFragmentedPool), message)
- {}
-};
+ class UnknownError : public SystemError
+ {
+ public:
+ UnknownError( std::string const & message ) : SystemError( make_error_code( Result::eErrorUnknown ), message ) {}
+ UnknownError( char const * message ) : SystemError( make_error_code( Result::eErrorUnknown ), message ) {}
+ };
-class UnknownError : public SystemError
-{
-public:
- UnknownError(std::string const &message)
- : SystemError(make_error_code(Result::eErrorUnknown), message)
- {}
- UnknownError(char const *message)
- : SystemError(make_error_code(Result::eErrorUnknown), message)
- {}
-};
+ class OutOfPoolMemoryError : public SystemError
+ {
+ public:
+ OutOfPoolMemoryError( std::string const & message ) : SystemError( make_error_code( Result::eErrorOutOfPoolMemory ), message ) {}
+ OutOfPoolMemoryError( char const * message ) : SystemError( make_error_code( Result::eErrorOutOfPoolMemory ), message ) {}
+ };
-class OutOfPoolMemoryError : public SystemError
-{
-public:
- OutOfPoolMemoryError(std::string const &message)
- : SystemError(make_error_code(Result::eErrorOutOfPoolMemory), message)
- {}
- OutOfPoolMemoryError(char const *message)
- : SystemError(make_error_code(Result::eErrorOutOfPoolMemory), message)
- {}
-};
+ class InvalidExternalHandleError : public SystemError
+ {
+ public:
+ InvalidExternalHandleError( std::string const & message ) : SystemError( make_error_code( Result::eErrorInvalidExternalHandle ), message ) {}
+ InvalidExternalHandleError( char const * message ) : SystemError( make_error_code( Result::eErrorInvalidExternalHandle ), message ) {}
+ };
-class InvalidExternalHandleError : public SystemError
-{
-public:
- InvalidExternalHandleError(std::string const &message)
- : SystemError(make_error_code(Result::eErrorInvalidExternalHandle), message)
- {}
- InvalidExternalHandleError(char const *message)
- : SystemError(make_error_code(Result::eErrorInvalidExternalHandle), message)
- {}
-};
+ class FragmentationError : public SystemError
+ {
+ public:
+ FragmentationError( std::string const & message ) : SystemError( make_error_code( Result::eErrorFragmentation ), message ) {}
+ FragmentationError( char const * message ) : SystemError( make_error_code( Result::eErrorFragmentation ), message ) {}
+ };
-class FragmentationError : public SystemError
-{
-public:
- FragmentationError(std::string const &message)
- : SystemError(make_error_code(Result::eErrorFragmentation), message)
- {}
- FragmentationError(char const *message)
- : SystemError(make_error_code(Result::eErrorFragmentation), message)
- {}
-};
+ class InvalidOpaqueCaptureAddressError : public SystemError
+ {
+ public:
+ InvalidOpaqueCaptureAddressError( std::string const & message ) : SystemError( make_error_code( Result::eErrorInvalidOpaqueCaptureAddress ), message ) {}
+ InvalidOpaqueCaptureAddressError( char const * message ) : SystemError( make_error_code( Result::eErrorInvalidOpaqueCaptureAddress ), message ) {}
+ };
-class InvalidOpaqueCaptureAddressError : public SystemError
-{
-public:
- InvalidOpaqueCaptureAddressError(std::string const &message)
- : SystemError(make_error_code(Result::eErrorInvalidOpaqueCaptureAddress), message)
- {}
- InvalidOpaqueCaptureAddressError(char const *message)
- : SystemError(make_error_code(Result::eErrorInvalidOpaqueCaptureAddress), message)
- {}
-};
+ class SurfaceLostKHRError : public SystemError
+ {
+ public:
+ SurfaceLostKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorSurfaceLostKHR ), message ) {}
+ SurfaceLostKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorSurfaceLostKHR ), message ) {}
+ };
-class SurfaceLostKHRError : public SystemError
-{
-public:
- SurfaceLostKHRError(std::string const &message)
- : SystemError(make_error_code(Result::eErrorSurfaceLostKHR), message)
- {}
- SurfaceLostKHRError(char const *message)
- : SystemError(make_error_code(Result::eErrorSurfaceLostKHR), message)
- {}
-};
+ class NativeWindowInUseKHRError : public SystemError
+ {
+ public:
+ NativeWindowInUseKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorNativeWindowInUseKHR ), message ) {}
+ NativeWindowInUseKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorNativeWindowInUseKHR ), message ) {}
+ };
-class NativeWindowInUseKHRError : public SystemError
-{
-public:
- NativeWindowInUseKHRError(std::string const &message)
- : SystemError(make_error_code(Result::eErrorNativeWindowInUseKHR), message)
- {}
- NativeWindowInUseKHRError(char const *message)
- : SystemError(make_error_code(Result::eErrorNativeWindowInUseKHR), message)
- {}
-};
+ class OutOfDateKHRError : public SystemError
+ {
+ public:
+ OutOfDateKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorOutOfDateKHR ), message ) {}
+ OutOfDateKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorOutOfDateKHR ), message ) {}
+ };
-class OutOfDateKHRError : public SystemError
-{
-public:
- OutOfDateKHRError(std::string const &message)
- : SystemError(make_error_code(Result::eErrorOutOfDateKHR), message)
- {}
- OutOfDateKHRError(char const *message)
- : SystemError(make_error_code(Result::eErrorOutOfDateKHR), message)
- {}
-};
+ class IncompatibleDisplayKHRError : public SystemError
+ {
+ public:
+ IncompatibleDisplayKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorIncompatibleDisplayKHR ), message ) {}
+ IncompatibleDisplayKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorIncompatibleDisplayKHR ), message ) {}
+ };
-class IncompatibleDisplayKHRError : public SystemError
-{
-public:
- IncompatibleDisplayKHRError(std::string const &message)
- : SystemError(make_error_code(Result::eErrorIncompatibleDisplayKHR), message)
- {}
- IncompatibleDisplayKHRError(char const *message)
- : SystemError(make_error_code(Result::eErrorIncompatibleDisplayKHR), message)
- {}
-};
+ class ValidationFailedEXTError : public SystemError
+ {
+ public:
+ ValidationFailedEXTError( std::string const & message ) : SystemError( make_error_code( Result::eErrorValidationFailedEXT ), message ) {}
+ ValidationFailedEXTError( char const * message ) : SystemError( make_error_code( Result::eErrorValidationFailedEXT ), message ) {}
+ };
-class ValidationFailedEXTError : public SystemError
-{
-public:
- ValidationFailedEXTError(std::string const &message)
- : SystemError(make_error_code(Result::eErrorValidationFailedEXT), message)
- {}
- ValidationFailedEXTError(char const *message)
- : SystemError(make_error_code(Result::eErrorValidationFailedEXT), message)
- {}
-};
+ class InvalidShaderNVError : public SystemError
+ {
+ public:
+ InvalidShaderNVError( std::string const & message ) : SystemError( make_error_code( Result::eErrorInvalidShaderNV ), message ) {}
+ InvalidShaderNVError( char const * message ) : SystemError( make_error_code( Result::eErrorInvalidShaderNV ), message ) {}
+ };
-class InvalidShaderNVError : public SystemError
-{
-public:
- InvalidShaderNVError(std::string const &message)
- : SystemError(make_error_code(Result::eErrorInvalidShaderNV), message)
- {}
- InvalidShaderNVError(char const *message)
- : SystemError(make_error_code(Result::eErrorInvalidShaderNV), message)
- {}
-};
+# if defined( VK_ENABLE_BETA_EXTENSIONS )
+ class ImageUsageNotSupportedKHRError : public SystemError
+ {
+ public:
+ ImageUsageNotSupportedKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorImageUsageNotSupportedKHR ), message ) {}
+ ImageUsageNotSupportedKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorImageUsageNotSupportedKHR ), message ) {}
+ };
+# endif /*VK_ENABLE_BETA_EXTENSIONS*/
-class InvalidDrmFormatModifierPlaneLayoutEXTError : public SystemError
-{
-public:
- InvalidDrmFormatModifierPlaneLayoutEXTError(std::string const &message)
- : SystemError(make_error_code(Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT), message)
- {
- }
- InvalidDrmFormatModifierPlaneLayoutEXTError(char const *message)
- : SystemError(make_error_code(Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT), message)
- {
- }
-};
+# if defined( VK_ENABLE_BETA_EXTENSIONS )
+ class VideoPictureLayoutNotSupportedKHRError : public SystemError
+ {
+ public:
+ VideoPictureLayoutNotSupportedKHRError( std::string const & message )
+ : SystemError( make_error_code( Result::eErrorVideoPictureLayoutNotSupportedKHR ), message )
+ {
+ }
+ VideoPictureLayoutNotSupportedKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorVideoPictureLayoutNotSupportedKHR ), message )
+ {
+ }
+ };
+# endif /*VK_ENABLE_BETA_EXTENSIONS*/
-class NotPermittedKHRError : public SystemError
-{
-public:
- NotPermittedKHRError(std::string const &message)
- : SystemError(make_error_code(Result::eErrorNotPermittedKHR), message)
- {}
- NotPermittedKHRError(char const *message)
- : SystemError(make_error_code(Result::eErrorNotPermittedKHR), message)
- {}
-};
+# if defined( VK_ENABLE_BETA_EXTENSIONS )
+ class VideoProfileOperationNotSupportedKHRError : public SystemError
+ {
+ public:
+ VideoProfileOperationNotSupportedKHRError( std::string const & message )
+ : SystemError( make_error_code( Result::eErrorVideoProfileOperationNotSupportedKHR ), message )
+ {
+ }
+ VideoProfileOperationNotSupportedKHRError( char const * message )
+ : SystemError( make_error_code( Result::eErrorVideoProfileOperationNotSupportedKHR ), message )
+ {
+ }
+ };
+# endif /*VK_ENABLE_BETA_EXTENSIONS*/
-# if defined(VK_USE_PLATFORM_WIN32_KHR)
-class FullScreenExclusiveModeLostEXTError : public SystemError
-{
-public:
- FullScreenExclusiveModeLostEXTError(std::string const &message)
- : SystemError(make_error_code(Result::eErrorFullScreenExclusiveModeLostEXT), message)
- {
- }
- FullScreenExclusiveModeLostEXTError(char const *message)
- : SystemError(make_error_code(Result::eErrorFullScreenExclusiveModeLostEXT), message)
- {}
-};
-# endif /*VK_USE_PLATFORM_WIN32_KHR*/
+# if defined( VK_ENABLE_BETA_EXTENSIONS )
+ class VideoProfileFormatNotSupportedKHRError : public SystemError
+ {
+ public:
+ VideoProfileFormatNotSupportedKHRError( std::string const & message )
+ : SystemError( make_error_code( Result::eErrorVideoProfileFormatNotSupportedKHR ), message )
+ {
+ }
+ VideoProfileFormatNotSupportedKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorVideoProfileFormatNotSupportedKHR ), message )
+ {
+ }
+ };
+# endif /*VK_ENABLE_BETA_EXTENSIONS*/
-namespace {
-[[noreturn]] void throwResultException(Result result, char const *message)
-{
- switch(result)
- {
- case Result::eErrorOutOfHostMemory: throw OutOfHostMemoryError(message);
- case Result::eErrorOutOfDeviceMemory: throw OutOfDeviceMemoryError(message);
- case Result::eErrorInitializationFailed: throw InitializationFailedError(message);
- case Result::eErrorDeviceLost: throw DeviceLostError(message);
- case Result::eErrorMemoryMapFailed: throw MemoryMapFailedError(message);
- case Result::eErrorLayerNotPresent: throw LayerNotPresentError(message);
- case Result::eErrorExtensionNotPresent: throw ExtensionNotPresentError(message);
- case Result::eErrorFeatureNotPresent: throw FeatureNotPresentError(message);
- case Result::eErrorIncompatibleDriver: throw IncompatibleDriverError(message);
- case Result::eErrorTooManyObjects: throw TooManyObjectsError(message);
- case Result::eErrorFormatNotSupported: throw FormatNotSupportedError(message);
- case Result::eErrorFragmentedPool: throw FragmentedPoolError(message);
- case Result::eErrorUnknown: throw UnknownError(message);
- case Result::eErrorOutOfPoolMemory: throw OutOfPoolMemoryError(message);
- case Result::eErrorInvalidExternalHandle: throw InvalidExternalHandleError(message);
- case Result::eErrorFragmentation: throw FragmentationError(message);
- case Result::eErrorInvalidOpaqueCaptureAddress: throw InvalidOpaqueCaptureAddressError(message);
- case Result::eErrorSurfaceLostKHR: throw SurfaceLostKHRError(message);
- case Result::eErrorNativeWindowInUseKHR: throw NativeWindowInUseKHRError(message);
- case Result::eErrorOutOfDateKHR: throw OutOfDateKHRError(message);
- case Result::eErrorIncompatibleDisplayKHR: throw IncompatibleDisplayKHRError(message);
- case Result::eErrorValidationFailedEXT: throw ValidationFailedEXTError(message);
- case Result::eErrorInvalidShaderNV: throw InvalidShaderNVError(message);
- case Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT: throw InvalidDrmFormatModifierPlaneLayoutEXTError(message);
- case Result::eErrorNotPermittedKHR: throw NotPermittedKHRError(message);
-# if defined(VK_USE_PLATFORM_WIN32_KHR)
- case Result::eErrorFullScreenExclusiveModeLostEXT: throw FullScreenExclusiveModeLostEXTError(message);
-# endif /*VK_USE_PLATFORM_WIN32_KHR*/
- default: throw SystemError(make_error_code(result));
- }
-}
-} // namespace
+# if defined( VK_ENABLE_BETA_EXTENSIONS )
+ class VideoProfileCodecNotSupportedKHRError : public SystemError
+ {
+ public:
+ VideoProfileCodecNotSupportedKHRError( std::string const & message )
+ : SystemError( make_error_code( Result::eErrorVideoProfileCodecNotSupportedKHR ), message )
+ {
+ }
+ VideoProfileCodecNotSupportedKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorVideoProfileCodecNotSupportedKHR ), message ) {}
+ };
+# endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+# if defined( VK_ENABLE_BETA_EXTENSIONS )
+ class VideoStdVersionNotSupportedKHRError : public SystemError
+ {
+ public:
+ VideoStdVersionNotSupportedKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorVideoStdVersionNotSupportedKHR ), message )
+ {
+ }
+ VideoStdVersionNotSupportedKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorVideoStdVersionNotSupportedKHR ), message ) {}
+ };
+# endif /*VK_ENABLE_BETA_EXTENSIONS*/
+
+ class InvalidDrmFormatModifierPlaneLayoutEXTError : public SystemError
+ {
+ public:
+ InvalidDrmFormatModifierPlaneLayoutEXTError( std::string const & message )
+ : SystemError( make_error_code( Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT ), message )
+ {
+ }
+ InvalidDrmFormatModifierPlaneLayoutEXTError( char const * message )
+ : SystemError( make_error_code( Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT ), message )
+ {
+ }
+ };
+
+ class NotPermittedKHRError : public SystemError
+ {
+ public:
+ NotPermittedKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorNotPermittedKHR ), message ) {}
+ NotPermittedKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorNotPermittedKHR ), message ) {}
+ };
+
+# if defined( VK_USE_PLATFORM_WIN32_KHR )
+ class FullScreenExclusiveModeLostEXTError : public SystemError
+ {
+ public:
+ FullScreenExclusiveModeLostEXTError( std::string const & message ) : SystemError( make_error_code( Result::eErrorFullScreenExclusiveModeLostEXT ), message )
+ {
+ }
+ FullScreenExclusiveModeLostEXTError( char const * message ) : SystemError( make_error_code( Result::eErrorFullScreenExclusiveModeLostEXT ), message ) {}
+ };
+# endif /*VK_USE_PLATFORM_WIN32_KHR*/
+
+ class CompressionExhaustedEXTError : public SystemError
+ {
+ public:
+ CompressionExhaustedEXTError( std::string const & message ) : SystemError( make_error_code( Result::eErrorCompressionExhaustedEXT ), message ) {}
+ CompressionExhaustedEXTError( char const * message ) : SystemError( make_error_code( Result::eErrorCompressionExhaustedEXT ), message ) {}
+ };
+
+ namespace
+ {
+ [[noreturn]] void throwResultException( Result result, char const * message )
+ {
+ switch ( result )
+ {
+ case Result::eErrorOutOfHostMemory: throw OutOfHostMemoryError( message );
+ case Result::eErrorOutOfDeviceMemory: throw OutOfDeviceMemoryError( message );
+ case Result::eErrorInitializationFailed: throw InitializationFailedError( message );
+ case Result::eErrorDeviceLost: throw DeviceLostError( message );
+ case Result::eErrorMemoryMapFailed: throw MemoryMapFailedError( message );
+ case Result::eErrorLayerNotPresent: throw LayerNotPresentError( message );
+ case Result::eErrorExtensionNotPresent: throw ExtensionNotPresentError( message );
+ case Result::eErrorFeatureNotPresent: throw FeatureNotPresentError( message );
+ case Result::eErrorIncompatibleDriver: throw IncompatibleDriverError( message );
+ case Result::eErrorTooManyObjects: throw TooManyObjectsError( message );
+ case Result::eErrorFormatNotSupported: throw FormatNotSupportedError( message );
+ case Result::eErrorFragmentedPool: throw FragmentedPoolError( message );
+ case Result::eErrorUnknown: throw UnknownError( message );
+ case Result::eErrorOutOfPoolMemory: throw OutOfPoolMemoryError( message );
+ case Result::eErrorInvalidExternalHandle: throw InvalidExternalHandleError( message );
+ case Result::eErrorFragmentation: throw FragmentationError( message );
+ case Result::eErrorInvalidOpaqueCaptureAddress: throw InvalidOpaqueCaptureAddressError( message );
+ case Result::eErrorSurfaceLostKHR: throw SurfaceLostKHRError( message );
+ case Result::eErrorNativeWindowInUseKHR: throw NativeWindowInUseKHRError( message );
+ case Result::eErrorOutOfDateKHR: throw OutOfDateKHRError( message );
+ case Result::eErrorIncompatibleDisplayKHR: throw IncompatibleDisplayKHRError( message );
+ case Result::eErrorValidationFailedEXT: throw ValidationFailedEXTError( message );
+ case Result::eErrorInvalidShaderNV: throw InvalidShaderNVError( message );
+# if defined( VK_ENABLE_BETA_EXTENSIONS )
+ case Result::eErrorImageUsageNotSupportedKHR: throw ImageUsageNotSupportedKHRError( message );
+# endif /*VK_ENABLE_BETA_EXTENSIONS*/
+# if defined( VK_ENABLE_BETA_EXTENSIONS )
+ case Result::eErrorVideoPictureLayoutNotSupportedKHR: throw VideoPictureLayoutNotSupportedKHRError( message );
+# endif /*VK_ENABLE_BETA_EXTENSIONS*/
+# if defined( VK_ENABLE_BETA_EXTENSIONS )
+ case Result::eErrorVideoProfileOperationNotSupportedKHR: throw VideoProfileOperationNotSupportedKHRError( message );
+# endif /*VK_ENABLE_BETA_EXTENSIONS*/
+# if defined( VK_ENABLE_BETA_EXTENSIONS )
+ case Result::eErrorVideoProfileFormatNotSupportedKHR: throw VideoProfileFormatNotSupportedKHRError( message );
+# endif /*VK_ENABLE_BETA_EXTENSIONS*/
+# if defined( VK_ENABLE_BETA_EXTENSIONS )
+ case Result::eErrorVideoProfileCodecNotSupportedKHR: throw VideoProfileCodecNotSupportedKHRError( message );
+# endif /*VK_ENABLE_BETA_EXTENSIONS*/
+# if defined( VK_ENABLE_BETA_EXTENSIONS )
+ case Result::eErrorVideoStdVersionNotSupportedKHR: throw VideoStdVersionNotSupportedKHRError( message );
+# endif /*VK_ENABLE_BETA_EXTENSIONS*/
+ case Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT: throw InvalidDrmFormatModifierPlaneLayoutEXTError( message );
+ case Result::eErrorNotPermittedKHR: throw NotPermittedKHRError( message );
+# if defined( VK_USE_PLATFORM_WIN32_KHR )
+ case Result::eErrorFullScreenExclusiveModeLostEXT: throw FullScreenExclusiveModeLostEXTError( message );
+# endif /*VK_USE_PLATFORM_WIN32_KHR*/
+ case Result::eErrorCompressionExhaustedEXT: throw CompressionExhaustedEXTError( message );
+ default: throw SystemError( make_error_code( result ) );
+ }
+ }
+ } // namespace
#endif
-template<typename T>
-void ignore(T const &) VULKAN_HPP_NOEXCEPT
-{
-}
+ template <typename T>
+ void ignore( T const & ) VULKAN_HPP_NOEXCEPT
+ {
+ }
-template<typename T>
-struct ResultValue
-{
+ template <typename T>
+ struct ResultValue
+ {
#ifdef VULKAN_HPP_HAS_NOEXCEPT
- ResultValue(Result r, T &v) VULKAN_HPP_NOEXCEPT(VULKAN_HPP_NOEXCEPT(T(v)))
+ ResultValue( Result r, T & v ) VULKAN_HPP_NOEXCEPT( VULKAN_HPP_NOEXCEPT( T( v ) ) )
#else
- ResultValue(Result r, T &v)
+ ResultValue( Result r, T & v )
#endif
- : result(r)
- , value(v)
- {
- }
+ : result( r ), value( v )
+ {
+ }
#ifdef VULKAN_HPP_HAS_NOEXCEPT
- ResultValue(Result r, T &&v) VULKAN_HPP_NOEXCEPT(VULKAN_HPP_NOEXCEPT(T(std::move(v))))
+ ResultValue( Result r, T && v ) VULKAN_HPP_NOEXCEPT( VULKAN_HPP_NOEXCEPT( T( std::move( v ) ) ) )
#else
- ResultValue(Result r, T &&v)
+ ResultValue( Result r, T && v )
#endif
- : result(r)
- , value(std::move(v))
- {
- }
+ : result( r ), value( std::move( v ) )
+ {
+ }
- Result result;
- T value;
+ Result result;
+ T value;
- operator std::tuple<Result &, T &>() VULKAN_HPP_NOEXCEPT
- {
- return std::tuple<Result &, T &>(result, value);
- }
+ operator std::tuple<Result &, T &>() VULKAN_HPP_NOEXCEPT
+ {
+ return std::tuple<Result &, T &>( result, value );
+ }
+ };
-#if !defined(VULKAN_HPP_DISABLE_IMPLICIT_RESULT_VALUE_CAST)
- VULKAN_HPP_DEPRECATED("Implicit-cast operators on vk::ResultValue are deprecated. Explicitly access the value as member of ResultValue.")
- operator T const &() const &VULKAN_HPP_NOEXCEPT
- {
- return value;
- }
+#if !defined( VULKAN_HPP_NO_SMART_HANDLE )
+ template <typename Type, typename Dispatch>
+ struct ResultValue<UniqueHandle<Type, Dispatch>>
+ {
+# ifdef VULKAN_HPP_HAS_NOEXCEPT
+ ResultValue( Result r, UniqueHandle<Type, Dispatch> && v ) VULKAN_HPP_NOEXCEPT
+# else
+ ResultValue( Result r, UniqueHandle<Type, Dispatch> && v )
+# endif
+ : result( r )
+ , value( std::move( v ) )
+ {
+ }
- VULKAN_HPP_DEPRECATED("Implicit-cast operators on vk::ResultValue are deprecated. Explicitly access the value as member of ResultValue.")
- operator T &() & VULKAN_HPP_NOEXCEPT
- {
- return value;
- }
+ std::tuple<Result, UniqueHandle<Type, Dispatch>> asTuple()
+ {
+ return std::make_tuple( result, std::move( value ) );
+ }
- VULKAN_HPP_DEPRECATED("Implicit-cast operators on vk::ResultValue are deprecated. Explicitly access the value as member of ResultValue.")
- operator T const &&() const &&VULKAN_HPP_NOEXCEPT
- {
- return std::move(value);
- }
+ Result result;
+ UniqueHandle<Type, Dispatch> value;
+ };
- VULKAN_HPP_DEPRECATED("Implicit-cast operators on vk::ResultValue are deprecated. Explicitly access the value as member of ResultValue.")
- operator T &&() && VULKAN_HPP_NOEXCEPT
- {
- return std::move(value);
- }
-#endif
-};
+ template <typename Type, typename Dispatch>
+ struct ResultValue<std::vector<UniqueHandle<Type, Dispatch>>>
+ {
+# ifdef VULKAN_HPP_HAS_NOEXCEPT
+ ResultValue( Result r, std::vector<UniqueHandle<Type, Dispatch>> && v ) VULKAN_HPP_NOEXCEPT
+# else
+ ResultValue( Result r, std::vector<UniqueHandle<Type, Dispatch>> && v )
+# endif
+ : result( r )
+ , value( std::move( v ) )
+ {
+ }
-#if !defined(VULKAN_HPP_NO_SMART_HANDLE)
-template<typename Type, typename Dispatch>
-struct ResultValue<UniqueHandle<Type, Dispatch>>
-{
-# ifdef VULKAN_HPP_HAS_NOEXCEPT
- ResultValue(Result r, UniqueHandle<Type, Dispatch> &&v) VULKAN_HPP_NOEXCEPT
-# else
- ResultValue(Result r, UniqueHandle<Type, Dispatch> &&v)
-# endif
- : result(r),
- value(std::move(v))
- {
- }
+ std::tuple<Result, std::vector<UniqueHandle<Type, Dispatch>>> asTuple()
+ {
+ return std::make_tuple( result, std::move( value ) );
+ }
- std::tuple<Result, UniqueHandle<Type, Dispatch>> asTuple()
- {
- return std::make_tuple(result, std::move(value));
- }
-
-# if !defined(VULKAN_HPP_DISABLE_IMPLICIT_RESULT_VALUE_CAST)
- VULKAN_HPP_DEPRECATED("Implicit-cast operators on vk::ResultValue are deprecated. Explicitly access the value as member of ResultValue.")
- operator UniqueHandle<Type, Dispatch> &() & VULKAN_HPP_NOEXCEPT
- {
- return value;
- }
-
- VULKAN_HPP_DEPRECATED("Implicit-cast operators on vk::ResultValue are deprecated. Explicitly access the value as member of ResultValue.")
- operator UniqueHandle<Type, Dispatch>() VULKAN_HPP_NOEXCEPT
- {
- return std::move(value);
- }
-# endif
-
- Result result;
- UniqueHandle<Type, Dispatch> value;
-};
-
-template<typename Type, typename Dispatch>
-struct ResultValue<std::vector<UniqueHandle<Type, Dispatch>>>
-{
-# ifdef VULKAN_HPP_HAS_NOEXCEPT
- ResultValue(Result r, std::vector<UniqueHandle<Type, Dispatch>> &&v) VULKAN_HPP_NOEXCEPT
-# else
- ResultValue(Result r, std::vector<UniqueHandle<Type, Dispatch>> &&v)
-# endif
- : result(r),
- value(std::move(v))
- {
- }
-
- std::tuple<Result, std::vector<UniqueHandle<Type, Dispatch>>> asTuple()
- {
- return std::make_tuple(result, std::move(value));
- }
-
- Result result;
- std::vector<UniqueHandle<Type, Dispatch>> value;
-
-# if !defined(VULKAN_HPP_DISABLE_IMPLICIT_RESULT_VALUE_CAST)
- VULKAN_HPP_DEPRECATED("Implicit-cast operators on vk::ResultValue are deprecated. Explicitly access the value as member of ResultValue.")
- operator std::tuple<Result &, std::vector<UniqueHandle<Type, Dispatch>> &>() VULKAN_HPP_NOEXCEPT
- {
- return std::tuple<Result &, std::vector<UniqueHandle<Type, Dispatch>> &>(result, value);
- }
-# endif
-};
+ Result result;
+ std::vector<UniqueHandle<Type, Dispatch>> value;
+ };
#endif
-template<typename T>
-struct ResultValueType
-{
+ template <typename T>
+ struct ResultValueType
+ {
#ifdef VULKAN_HPP_NO_EXCEPTIONS
- typedef ResultValue<T> type;
+ typedef ResultValue<T> type;
#else
- typedef T type;
+ typedef T type;
#endif
-};
+ };
-template<>
-struct ResultValueType<void>
-{
+ template <>
+ struct ResultValueType<void>
+ {
#ifdef VULKAN_HPP_NO_EXCEPTIONS
- typedef Result type;
+ typedef Result type;
#else
- typedef void type;
+ typedef void type;
#endif
-};
+ };
-template<typename T>
-VULKAN_HPP_INLINE typename ResultValueType<T>::type createResultValue(Result result, T &data, char const *message)
-{
+ VULKAN_HPP_INLINE typename ResultValueType<void>::type createResultValueType( Result result )
+ {
#ifdef VULKAN_HPP_NO_EXCEPTIONS
- ignore(message);
- VULKAN_HPP_ASSERT_ON_RESULT(result == Result::eSuccess);
- return ResultValue<T>(result, std::move(data));
+ return result;
#else
- if(result != Result::eSuccess)
- {
- throwResultException(result, message);
- }
- return std::move(data);
+ ignore( result );
#endif
-}
+ }
-template<typename T>
-VULKAN_HPP_INLINE ResultValue<T> createResultValue(Result result, T &data, char const *message, std::initializer_list<Result> successCodes)
-{
+ template <typename T>
+ VULKAN_HPP_INLINE typename ResultValueType<T>::type createResultValueType( Result result, T & data )
+ {
#ifdef VULKAN_HPP_NO_EXCEPTIONS
- ignore(message);
- ignore(successCodes); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
- VULKAN_HPP_ASSERT_ON_RESULT(std::find(successCodes.begin(), successCodes.end(), result) != successCodes.end());
+ return ResultValue<T>( result, data );
#else
- if(std::find(successCodes.begin(), successCodes.end(), result) == successCodes.end())
- {
- throwResultException(result, message);
- }
+ ignore( result );
+ return data;
#endif
- return ResultValue<T>(result, std::move(data));
-}
+ }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-template<typename T, typename D>
-VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<T, D>>::type
-createResultValue(Result result, T &data, char const *message, typename UniqueHandleTraits<T, D>::deleter const &deleter)
-{
-# ifdef VULKAN_HPP_NO_EXCEPTIONS
- ignore(message);
- VULKAN_HPP_ASSERT_ON_RESULT(result == Result::eSuccess);
- return ResultValue<UniqueHandle<T, D>>(result, UniqueHandle<T, D>(data, deleter));
-# else
- if(result != Result::eSuccess)
- {
- throwResultException(result, message);
- }
- return UniqueHandle<T, D>(data, deleter);
-# endif
-}
-
-template<typename T, typename D>
-VULKAN_HPP_INLINE ResultValue<UniqueHandle<T, D>> createResultValue(
- Result result, T &data, char const *message, std::initializer_list<Result> successCodes, typename UniqueHandleTraits<T, D>::deleter const &deleter)
-{
-# ifdef VULKAN_HPP_NO_EXCEPTIONS
- ignore(message);
- ignore(successCodes); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
- VULKAN_HPP_ASSERT_ON_RESULT(std::find(successCodes.begin(), successCodes.end(), result) != successCodes.end());
-# else
- if(std::find(successCodes.begin(), successCodes.end(), result) == successCodes.end())
- {
- throwResultException(result, message);
- }
-# endif
- return ResultValue<UniqueHandle<T, D>>(result, UniqueHandle<T, D>(data, deleter));
-}
-
-template<typename T, typename D, typename Allocator = std::allocator<UniqueHandle<T, D>>>
-VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<T, D>, Allocator>>::type
-createResultValue(Result result, std::vector<UniqueHandle<T, D>, Allocator> &&data, char const *message)
-{
-# ifdef VULKAN_HPP_NO_EXCEPTIONS
- ignore(message);
- VULKAN_HPP_ASSERT_ON_RESULT(result == Result::eSuccess);
- return ResultValue<std::vector<UniqueHandle<T, D>, Allocator>>(result, std::move(data));
-# else
- if(result != Result::eSuccess)
- {
- throwResultException(result, message);
- }
- return std::move(data);
-# endif
-}
-
-template<typename T, typename D, typename Allocator = std::allocator<UniqueHandle<T, D>>>
-VULKAN_HPP_INLINE ResultValue<std::vector<UniqueHandle<T, D>, Allocator>>
-createResultValue(Result result, std::vector<UniqueHandle<T, D>, Allocator> &&data, char const *message, std::initializer_list<Result> successCodes)
-{
-# ifdef VULKAN_HPP_NO_EXCEPTIONS
- ignore(message);
- ignore(successCodes); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
- VULKAN_HPP_ASSERT_ON_RESULT(std::find(successCodes.begin(), successCodes.end(), result) != successCodes.end());
-# else
- if(std::find(successCodes.begin(), successCodes.end(), result) == successCodes.end())
- {
- throwResultException(result, message);
- }
-# endif
- return ResultValue<std::vector<UniqueHandle<T, D>, Allocator>>(result, std::move(data));
-}
-#endif
-
-template<typename T>
-VULKAN_HPP_INLINE typename ResultValueType<T>::type createResultValueType(Result result, T &data)
-{
+ template <typename T>
+ VULKAN_HPP_INLINE typename ResultValueType<T>::type createResultValueType( Result result, T && data )
+ {
#ifdef VULKAN_HPP_NO_EXCEPTIONS
- return ResultValue<T>(result, std::move(data));
+ return ResultValue<T>( result, std::move( data ) );
#else
- ignore(result);
- return std::move(data);
+ ignore( result );
+ return std::move( data );
#endif
-}
+ }
-VULKAN_HPP_INLINE typename ResultValueType<void>::type createResultValueType(Result result)
-{
+ VULKAN_HPP_INLINE void resultCheck( Result result, char const * message )
+ {
#ifdef VULKAN_HPP_NO_EXCEPTIONS
- return result;
+ ignore( result ); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
+ ignore( message );
+ VULKAN_HPP_ASSERT_ON_RESULT( result == Result::eSuccess );
#else
- ignore(result);
+ if ( result != Result::eSuccess )
+ {
+ throwResultException( result, message );
+ }
#endif
-}
+ }
-VULKAN_HPP_INLINE void resultCheck(Result result, char const *message)
-{
+ VULKAN_HPP_INLINE void resultCheck( Result result, char const * message, std::initializer_list<Result> successCodes )
+ {
#ifdef VULKAN_HPP_NO_EXCEPTIONS
- ignore(result); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
- ignore(message);
- VULKAN_HPP_ASSERT_ON_RESULT(result == Result::eSuccess);
+ ignore( result ); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
+ ignore( message );
+ ignore( successCodes ); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
+ VULKAN_HPP_ASSERT_ON_RESULT( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() );
#else
- if(result != Result::eSuccess)
- {
- throwResultException(result, message);
- }
+ if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() )
+ {
+ throwResultException( result, message );
+ }
#endif
-}
-
-VULKAN_HPP_INLINE void resultCheck(Result result, char const *message, std::initializer_list<Result> successCodes)
-{
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
- ignore(result); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
- ignore(message);
- ignore(successCodes); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
- VULKAN_HPP_ASSERT_ON_RESULT(std::find(successCodes.begin(), successCodes.end(), result) != successCodes.end());
-#else
- if(std::find(successCodes.begin(), successCodes.end(), result) == successCodes.end())
- {
- throwResultException(result, message);
- }
-#endif
-}
+ }
} // namespace VULKAN_HPP_NAMESPACE
// clang-format off
@@ -6248,7695 +6193,8212 @@
#include <vulkan/vulkan_funcs.hpp>
// clang-format on
-namespace VULKAN_HPP_NAMESPACE {
-//=======================
-//=== STRUCTS EXTENDS ===
-//=======================
-
-//=== VK_VERSION_1_0 ===
-template<>
-struct StructExtends<ShaderModuleCreateInfo, PipelineShaderStageCreateInfo>
+namespace VULKAN_HPP_NAMESPACE
{
- enum
- {
- value = true
- };
-};
+#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
-//=== VK_VERSION_1_1 ===
-template<>
-struct StructExtends<PhysicalDeviceSubgroupProperties, PhysicalDeviceProperties2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDevice16BitStorageFeatures, PhysicalDeviceFeatures2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDevice16BitStorageFeatures, DeviceCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<MemoryDedicatedRequirements, MemoryRequirements2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<MemoryDedicatedAllocateInfo, MemoryAllocateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<MemoryAllocateFlagsInfo, MemoryAllocateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<DeviceGroupRenderPassBeginInfo, RenderPassBeginInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<DeviceGroupRenderPassBeginInfo, RenderingInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<DeviceGroupCommandBufferBeginInfo, CommandBufferBeginInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<DeviceGroupSubmitInfo, SubmitInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<DeviceGroupBindSparseInfo, BindSparseInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<BindBufferMemoryDeviceGroupInfo, BindBufferMemoryInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<BindImageMemoryDeviceGroupInfo, BindImageMemoryInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<DeviceGroupDeviceCreateInfo, DeviceCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceFeatures2, DeviceCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDevicePointClippingProperties, PhysicalDeviceProperties2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<RenderPassInputAttachmentAspectCreateInfo, RenderPassCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<ImageViewUsageCreateInfo, ImageViewCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PipelineTessellationDomainOriginStateCreateInfo, PipelineTessellationStateCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<RenderPassMultiviewCreateInfo, RenderPassCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceMultiviewFeatures, PhysicalDeviceFeatures2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceMultiviewFeatures, DeviceCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceMultiviewProperties, PhysicalDeviceProperties2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceVariablePointersFeatures, PhysicalDeviceFeatures2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceVariablePointersFeatures, DeviceCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceProtectedMemoryFeatures, PhysicalDeviceFeatures2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceProtectedMemoryFeatures, DeviceCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceProtectedMemoryProperties, PhysicalDeviceProperties2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<ProtectedSubmitInfo, SubmitInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<SamplerYcbcrConversionInfo, SamplerCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<SamplerYcbcrConversionInfo, ImageViewCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<BindImagePlaneMemoryInfo, BindImageMemoryInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<ImagePlaneMemoryRequirementsInfo, ImageMemoryRequirementsInfo2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceSamplerYcbcrConversionFeatures, PhysicalDeviceFeatures2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceSamplerYcbcrConversionFeatures, DeviceCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<SamplerYcbcrConversionImageFormatProperties, ImageFormatProperties2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceExternalImageFormatInfo, PhysicalDeviceImageFormatInfo2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<ExternalImageFormatProperties, ImageFormatProperties2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceIDProperties, PhysicalDeviceProperties2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<ExternalMemoryImageCreateInfo, ImageCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<ExternalMemoryBufferCreateInfo, BufferCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<ExportMemoryAllocateInfo, MemoryAllocateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<ExportFenceCreateInfo, FenceCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<ExportSemaphoreCreateInfo, SemaphoreCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceMaintenance3Properties, PhysicalDeviceProperties2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceShaderDrawParametersFeatures, PhysicalDeviceFeatures2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceShaderDrawParametersFeatures, DeviceCreateInfo>
-{
- enum
- {
- value = true
- };
-};
+ //=======================
+ //=== STRUCTS EXTENDS ===
+ //=======================
-//=== VK_VERSION_1_2 ===
-template<>
-struct StructExtends<PhysicalDeviceVulkan11Features, PhysicalDeviceFeatures2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceVulkan11Features, DeviceCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceVulkan11Properties, PhysicalDeviceProperties2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceVulkan12Features, PhysicalDeviceFeatures2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceVulkan12Features, DeviceCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceVulkan12Properties, PhysicalDeviceProperties2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<ImageFormatListCreateInfo, ImageCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<ImageFormatListCreateInfo, SwapchainCreateInfoKHR>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<ImageFormatListCreateInfo, PhysicalDeviceImageFormatInfo2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDevice8BitStorageFeatures, PhysicalDeviceFeatures2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDevice8BitStorageFeatures, DeviceCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceDriverProperties, PhysicalDeviceProperties2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceShaderAtomicInt64Features, PhysicalDeviceFeatures2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceShaderAtomicInt64Features, DeviceCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceShaderFloat16Int8Features, PhysicalDeviceFeatures2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceShaderFloat16Int8Features, DeviceCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceFloatControlsProperties, PhysicalDeviceProperties2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<DescriptorSetLayoutBindingFlagsCreateInfo, DescriptorSetLayoutCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceDescriptorIndexingFeatures, PhysicalDeviceFeatures2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceDescriptorIndexingFeatures, DeviceCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceDescriptorIndexingProperties, PhysicalDeviceProperties2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<DescriptorSetVariableDescriptorCountAllocateInfo, DescriptorSetAllocateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<DescriptorSetVariableDescriptorCountLayoutSupport, DescriptorSetLayoutSupport>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<SubpassDescriptionDepthStencilResolve, SubpassDescription2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceDepthStencilResolveProperties, PhysicalDeviceProperties2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceScalarBlockLayoutFeatures, PhysicalDeviceFeatures2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceScalarBlockLayoutFeatures, DeviceCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<ImageStencilUsageCreateInfo, ImageCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<ImageStencilUsageCreateInfo, PhysicalDeviceImageFormatInfo2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<SamplerReductionModeCreateInfo, SamplerCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceSamplerFilterMinmaxProperties, PhysicalDeviceProperties2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceVulkanMemoryModelFeatures, PhysicalDeviceFeatures2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceVulkanMemoryModelFeatures, DeviceCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceImagelessFramebufferFeatures, PhysicalDeviceFeatures2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceImagelessFramebufferFeatures, DeviceCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<FramebufferAttachmentsCreateInfo, FramebufferCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<RenderPassAttachmentBeginInfo, RenderPassBeginInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceUniformBufferStandardLayoutFeatures, PhysicalDeviceFeatures2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceUniformBufferStandardLayoutFeatures, DeviceCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceShaderSubgroupExtendedTypesFeatures, PhysicalDeviceFeatures2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceShaderSubgroupExtendedTypesFeatures, DeviceCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceSeparateDepthStencilLayoutsFeatures, PhysicalDeviceFeatures2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceSeparateDepthStencilLayoutsFeatures, DeviceCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<AttachmentReferenceStencilLayout, AttachmentReference2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<AttachmentDescriptionStencilLayout, AttachmentDescription2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceHostQueryResetFeatures, PhysicalDeviceFeatures2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceHostQueryResetFeatures, DeviceCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceTimelineSemaphoreFeatures, PhysicalDeviceFeatures2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceTimelineSemaphoreFeatures, DeviceCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceTimelineSemaphoreProperties, PhysicalDeviceProperties2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<SemaphoreTypeCreateInfo, SemaphoreCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<SemaphoreTypeCreateInfo, PhysicalDeviceExternalSemaphoreInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<TimelineSemaphoreSubmitInfo, SubmitInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<TimelineSemaphoreSubmitInfo, BindSparseInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceBufferDeviceAddressFeatures, PhysicalDeviceFeatures2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceBufferDeviceAddressFeatures, DeviceCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<BufferOpaqueCaptureAddressCreateInfo, BufferCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<MemoryOpaqueCaptureAddressAllocateInfo, MemoryAllocateInfo>
-{
- enum
- {
- value = true
- };
-};
+ //=== VK_VERSION_1_0 ===
+ template <>
+ struct StructExtends<ShaderModuleCreateInfo, PipelineShaderStageCreateInfo>
+ {
+ enum
+ {
+ value = true
+ };
+ };
-//=== VK_VERSION_1_3 ===
-template<>
-struct StructExtends<PhysicalDeviceVulkan13Features, PhysicalDeviceFeatures2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceVulkan13Features, DeviceCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceVulkan13Properties, PhysicalDeviceProperties2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PipelineCreationFeedbackCreateInfo, GraphicsPipelineCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PipelineCreationFeedbackCreateInfo, ComputePipelineCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PipelineCreationFeedbackCreateInfo, RayTracingPipelineCreateInfoNV>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PipelineCreationFeedbackCreateInfo, RayTracingPipelineCreateInfoKHR>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceShaderTerminateInvocationFeatures, PhysicalDeviceFeatures2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceShaderTerminateInvocationFeatures, DeviceCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceShaderDemoteToHelperInvocationFeatures, PhysicalDeviceFeatures2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceShaderDemoteToHelperInvocationFeatures, DeviceCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDevicePrivateDataFeatures, PhysicalDeviceFeatures2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDevicePrivateDataFeatures, DeviceCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<DevicePrivateDataCreateInfo, DeviceCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDevicePipelineCreationCacheControlFeatures, PhysicalDeviceFeatures2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDevicePipelineCreationCacheControlFeatures, DeviceCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<MemoryBarrier2, SubpassDependency2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceSynchronization2Features, PhysicalDeviceFeatures2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceSynchronization2Features, DeviceCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures, PhysicalDeviceFeatures2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures, DeviceCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceImageRobustnessFeatures, PhysicalDeviceFeatures2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceImageRobustnessFeatures, DeviceCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceSubgroupSizeControlFeatures, PhysicalDeviceFeatures2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceSubgroupSizeControlFeatures, DeviceCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceSubgroupSizeControlProperties, PhysicalDeviceProperties2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PipelineShaderStageRequiredSubgroupSizeCreateInfo, PipelineShaderStageCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceInlineUniformBlockFeatures, PhysicalDeviceFeatures2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceInlineUniformBlockFeatures, DeviceCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceInlineUniformBlockProperties, PhysicalDeviceProperties2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<WriteDescriptorSetInlineUniformBlock, WriteDescriptorSet>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<DescriptorPoolInlineUniformBlockCreateInfo, DescriptorPoolCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceTextureCompressionASTCHDRFeatures, PhysicalDeviceFeatures2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceTextureCompressionASTCHDRFeatures, DeviceCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PipelineRenderingCreateInfo, GraphicsPipelineCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceDynamicRenderingFeatures, PhysicalDeviceFeatures2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceDynamicRenderingFeatures, DeviceCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<CommandBufferInheritanceRenderingInfo, CommandBufferInheritanceInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceShaderIntegerDotProductFeatures, PhysicalDeviceFeatures2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceShaderIntegerDotProductFeatures, DeviceCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceShaderIntegerDotProductProperties, PhysicalDeviceProperties2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceTexelBufferAlignmentProperties, PhysicalDeviceProperties2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<FormatProperties3, FormatProperties2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceMaintenance4Features, PhysicalDeviceFeatures2>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceMaintenance4Features, DeviceCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<PhysicalDeviceMaintenance4Properties, PhysicalDeviceProperties2>
-{
- enum
- {
- value = true
- };
-};
+ //=== VK_VERSION_1_1 ===
+ template <>
+ struct StructExtends<PhysicalDeviceSubgroupProperties, PhysicalDeviceProperties2>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<PhysicalDevice16BitStorageFeatures, PhysicalDeviceFeatures2>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<PhysicalDevice16BitStorageFeatures, DeviceCreateInfo>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<MemoryDedicatedRequirements, MemoryRequirements2>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<MemoryDedicatedAllocateInfo, MemoryAllocateInfo>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<MemoryAllocateFlagsInfo, MemoryAllocateInfo>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<DeviceGroupRenderPassBeginInfo, RenderPassBeginInfo>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<DeviceGroupRenderPassBeginInfo, RenderingInfo>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<DeviceGroupCommandBufferBeginInfo, CommandBufferBeginInfo>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<DeviceGroupSubmitInfo, SubmitInfo>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<DeviceGroupBindSparseInfo, BindSparseInfo>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<BindBufferMemoryDeviceGroupInfo, BindBufferMemoryInfo>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<BindImageMemoryDeviceGroupInfo, BindImageMemoryInfo>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<DeviceGroupDeviceCreateInfo, DeviceCreateInfo>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<PhysicalDeviceFeatures2, DeviceCreateInfo>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<PhysicalDevicePointClippingProperties, PhysicalDeviceProperties2>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<RenderPassInputAttachmentAspectCreateInfo, RenderPassCreateInfo>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<ImageViewUsageCreateInfo, ImageViewCreateInfo>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<PipelineTessellationDomainOriginStateCreateInfo, PipelineTessellationStateCreateInfo>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<RenderPassMultiviewCreateInfo, RenderPassCreateInfo>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<PhysicalDeviceMultiviewFeatures, PhysicalDeviceFeatures2>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<PhysicalDeviceMultiviewFeatures, DeviceCreateInfo>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<PhysicalDeviceMultiviewProperties, PhysicalDeviceProperties2>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<PhysicalDeviceVariablePointersFeatures, PhysicalDeviceFeatures2>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<PhysicalDeviceVariablePointersFeatures, DeviceCreateInfo>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<PhysicalDeviceProtectedMemoryFeatures, PhysicalDeviceFeatures2>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<PhysicalDeviceProtectedMemoryFeatures, DeviceCreateInfo>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<PhysicalDeviceProtectedMemoryProperties, PhysicalDeviceProperties2>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<ProtectedSubmitInfo, SubmitInfo>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<SamplerYcbcrConversionInfo, SamplerCreateInfo>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<SamplerYcbcrConversionInfo, ImageViewCreateInfo>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<BindImagePlaneMemoryInfo, BindImageMemoryInfo>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<ImagePlaneMemoryRequirementsInfo, ImageMemoryRequirementsInfo2>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<PhysicalDeviceSamplerYcbcrConversionFeatures, PhysicalDeviceFeatures2>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<PhysicalDeviceSamplerYcbcrConversionFeatures, DeviceCreateInfo>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<SamplerYcbcrConversionImageFormatProperties, ImageFormatProperties2>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<PhysicalDeviceExternalImageFormatInfo, PhysicalDeviceImageFormatInfo2>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<ExternalImageFormatProperties, ImageFormatProperties2>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<PhysicalDeviceIDProperties, PhysicalDeviceProperties2>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<ExternalMemoryImageCreateInfo, ImageCreateInfo>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<ExternalMemoryBufferCreateInfo, BufferCreateInfo>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<ExportMemoryAllocateInfo, MemoryAllocateInfo>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<ExportFenceCreateInfo, FenceCreateInfo>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<ExportSemaphoreCreateInfo, SemaphoreCreateInfo>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<PhysicalDeviceMaintenance3Properties, PhysicalDeviceProperties2>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<PhysicalDeviceShaderDrawParametersFeatures, PhysicalDeviceFeatures2>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<PhysicalDeviceShaderDrawParametersFeatures, DeviceCreateInfo>
+ {
+ enum
+ {
+ value = true
+ };
+ };
-//=== VK_KHR_swapchain ===
-template<>
-struct StructExtends<ImageSwapchainCreateInfoKHR, ImageCreateInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<BindImageMemorySwapchainInfoKHR, BindImageMemoryInfo>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<DeviceGroupPresentInfoKHR, PresentInfoKHR>
-{
- enum
- {
- value = true
- };
-};
-template<>
-struct StructExtends<DeviceGroupSwapchainCreateInfoKHR, SwapchainCreateInfoKHR>
-{
- enum
- {
- value = true
- };
-};
+ //=== VK_VERSION_1_2 ===
+ template <>
+ struct StructExtends<PhysicalDeviceVulkan11Features, PhysicalDeviceFeatures2>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<PhysicalDeviceVulkan11Features, DeviceCreateInfo>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<PhysicalDeviceVulkan11Properties, PhysicalDeviceProperties2>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<PhysicalDeviceVulkan12Features, PhysicalDeviceFeatures2>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<PhysicalDeviceVulkan12Features, DeviceCreateInfo>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<PhysicalDeviceVulkan12Properties, PhysicalDeviceProperties2>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<ImageFormatListCreateInfo, ImageCreateInfo>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ struct StructExtends<ImageFormatListCreateInfo, SwapchainCreateInfoKHR>
+ {
+ enum
+ {
+ value = true
+ };
+ };
+ template <>
+ 