| // Copyright 2015-2022 The Khronos Group Inc. |
| // |
| // SPDX-License-Identifier: Apache-2.0 OR MIT |
| // |
| |
| // This header is generated from the Khronos Vulkan XML API Registry. |
| |
| #ifndef VULKAN_HPP |
| #define VULKAN_HPP |
| |
| #if defined(_MSVC_LANG) |
| # define VULKAN_HPP_CPLUSPLUS _MSVC_LANG |
| #else |
| # define VULKAN_HPP_CPLUSPLUS __cplusplus |
| #endif |
| |
| #if 201703L < VULKAN_HPP_CPLUSPLUS |
| # define VULKAN_HPP_CPP_VERSION 20 |
| #elif 201402L < VULKAN_HPP_CPLUSPLUS |
| # define VULKAN_HPP_CPP_VERSION 17 |
| #elif 201103L < VULKAN_HPP_CPLUSPLUS |
| # define VULKAN_HPP_CPP_VERSION 14 |
| #elif 199711L < VULKAN_HPP_CPLUSPLUS |
| # define VULKAN_HPP_CPP_VERSION 11 |
| #else |
| # error "vulkan.hpp needs at least c++ standard version 11" |
| #endif |
| |
| #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> |
| #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> |
| #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 |
| #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 |
| #endif |
| |
| #if !defined(VULKAN_HPP_ASSERT) |
| # include <cassert> |
| # define VULKAN_HPP_ASSERT assert |
| #endif |
| |
| #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 |
| #endif |
| |
| #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 |
| #endif |
| #if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) |
| # include <compare> |
| #endif |
| |
| #if(201803 <= __cpp_lib_span) |
| # define VULKAN_HPP_SUPPORT_SPAN |
| # include <span> |
| #endif |
| |
| static_assert(VK_HEADER_VERSION == 211, "Wrong VK_HEADER_VERSION!"); |
| |
| // 32-bit vulkan is not typesafe for 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 |
| #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 |
| #endif |
| #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 |
| #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 |
| #endif |
| |
| #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) |
| # define VULKAN_HPP_TYPESAFE_EXPLICIT |
| #else |
| # 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 |
| #else |
| # 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 |
| #endif |
| |
| #if 14 <= VULKAN_HPP_CPP_VERSION |
| # define VULKAN_HPP_DEPRECATED(msg) [[deprecated(msg)]] |
| #else |
| # 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 |
| #else |
| # define VULKAN_HPP_NODISCARD |
| # define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS |
| #endif |
| |
| #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) |
| |
| namespace VULKAN_HPP_NAMESPACE { |
| #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) |
| { |
| } |
| |
| VULKAN_HPP_CONSTEXPR ArrayProxy(std::nullptr_t) VULKAN_HPP_NOEXCEPT |
| : m_count(0), |
| m_ptr(nullptr) |
| { |
| } |
| |
| ArrayProxy(T &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> |
| 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; |
| }; |
| #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>() {} |
| |
| VULKAN_HPP_CONSTEXPR ArrayWrapper1D(std::array<T, N> const &data) VULKAN_HPP_NOEXCEPT : std::array<T, N>(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()); |
| } |
| |
| #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()); |
| } |
| #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); |
| } |
| #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); |
| } |
| #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); |
| } |
| }; |
| |
| // 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<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)) |
| { |
| } |
| }; |
| |
| template<typename FlagBitsType> |
| struct FlagTraits |
| { |
| }; |
| |
| 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) {} |
| |
| 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 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; |
| #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; |
| } |
| #endif |
| |
| // 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); |
| } |
| |
| 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); |
| } |
| |
| // 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; |
| } |
| |
| // 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; |
| } |
| |
| #if defined(VULKAN_HPP_FLAGS_MASK_TYPE_AS_PUBLIC) |
| public: |
| #else |
| private: |
| #endif |
| 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); |
| } |
| |
| 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); |
| } |
| |
| 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; |
| } |
| |
| 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; |
| } |
| |
| 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 |
| |
| 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); |
| } |
| }; |
| #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 |
| #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_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_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 |
| #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 |
| #endif |
| |
| struct AllocationCallbacks; |
| |
| 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) |
| { |
| } |
| |
| 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); |
| } |
| |
| private: |
| OwnerType m_owner = {}; |
| Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr; |
| Dispatch const *m_dispatch = nullptr; |
| }; |
| |
| class NoParent; |
| |
| 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) |
| { |
| } |
| |
| 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); |
| } |
| |
| private: |
| Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr; |
| Dispatch const *m_dispatch = nullptr; |
| }; |
| |
| 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) |
| { |
| } |
| |
| 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.free)(t, m_allocationCallbacks, *m_dispatch); |
| } |
| |
| 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; |
| |
| 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; |
| } |
| |
| 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; |
| }; |
| |
| 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) |
| { |
| } |
| |
| 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); |
| } |
| |
| private: |
| OwnerType m_owner = OwnerType(); |
| PoolType m_pool = PoolType(); |
| Dispatch const *m_dispatch = nullptr; |
| }; |
| |
| //================== |
| //=== 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> |
| |
| #ifndef VULKAN_HPP_NO_EXCEPTIONS |
| namespace std { |
| template<> |
| struct is_error_code_enum<VULKAN_HPP_NAMESPACE::Result> : public true_type |
| { |
| }; |
| } // namespace std |
| #endif |
| |
| 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 |
| { |
| 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; |
| |
| 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) |
| {} |
| |
| 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) |
| {} |
| |
| 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 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()); |
| } |
| |
| 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 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 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 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 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 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 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 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 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 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 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 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 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*/ |
| |
| 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 |
| #endif |
| |
| template<typename T> |
| void ignore(T const &) VULKAN_HPP_NOEXCEPT |
| { |
| } |
| |
| template<typename T> |
| struct ResultValue |
| { |
| #ifdef VULKAN_HPP_HAS_NOEXCEPT |
| ResultValue(Result r, T &v) VULKAN_HPP_NOEXCEPT(VULKAN_HPP_NOEXCEPT(T(v))) |
| #else |
| ResultValue(Result r, T &v) |
| #endif |
| : result(r) |
| , value(v) |
| { |
| } |
| |
| #ifdef VULKAN_HPP_HAS_NOEXCEPT |
| ResultValue(Result r, T &&v) VULKAN_HPP_NOEXCEPT(VULKAN_HPP_NOEXCEPT(T(std::move(v)))) |
| #else |
| ResultValue(Result r, T &&v) |
| #endif |
| : result(r) |
| , value(std::move(v)) |
| { |
| } |
| |
| Result result; |
| T 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; |
| } |
| |
| 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; |
| } |
| |
| 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); |
| } |
| |
| 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 |
| }; |
| |
| #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, 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 |
| }; |
| #endif |
| |
| template<typename T> |
| struct ResultValueType |
| { |
| #ifdef VULKAN_HPP_NO_EXCEPTIONS |
| typedef ResultValue<T> type; |
| #else |
| typedef T type; |
| #endif |
| }; |
| |
| template<> |
| struct ResultValueType<void> |
| { |
| #ifdef VULKAN_HPP_NO_EXCEPTIONS |
| typedef Result type; |
| #else |
| typedef void type; |
| #endif |
| }; |
| |
| template<typename T> |
| VULKAN_HPP_INLINE typename ResultValueType<T>::type createResultValue(Result result, T &data, char const *message) |
| { |
| #ifdef VULKAN_HPP_NO_EXCEPTIONS |
| ignore(message); |
| VULKAN_HPP_ASSERT_ON_RESULT(result == Result::eSuccess); |
| return ResultValue<T>(result, std::move(data)); |
| #else |
| if(result != Result::eSuccess) |
| { |
| throwResultException(result, message); |
| } |
| return std::move(data); |
| #endif |
| } |
| |
| template<typename T> |
| VULKAN_HPP_INLINE ResultValue<T> createResultValue(Result result, T &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<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) |
| { |
| #ifdef VULKAN_HPP_NO_EXCEPTIONS |
| return ResultValue<T>(result, std::move(data)); |
| #else |
| ignore(result); |
| return std::move(data); |
| #endif |
| } |
| |
| VULKAN_HPP_INLINE typename ResultValueType<void>::type createResultValueType(Result result) |
| { |
| #ifdef VULKAN_HPP_NO_EXCEPTIONS |
| return result; |
| #else |
| ignore(result); |
| #endif |
| } |
| |
| VULKAN_HPP_INLINE void resultCheck(Result result, char const *message) |
| { |
| #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); |
| #else |
| if(result != Result::eSuccess) |
| { |
| 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 |
| #include <vulkan/vulkan_handles.hpp> |
| #include <vulkan/vulkan_structs.hpp> |
| #include <vulkan/vulkan_funcs.hpp> |
| // clang-format on |
| |
| namespace VULKAN_HPP_NAMESPACE { |
| //======================= |
| //=== STRUCTS EXTENDS === |
| //======================= |
| |
| //=== VK_VERSION_1_0 === |
| template<> |
| struct StructExtends<ShaderModuleCreateInfo, PipelineShaderStageCreateInfo> |
| { |
| 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_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_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_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_KHR_display_swapchain === |
| template<> |
| struct StructExtends<DisplayPresentInfoKHR, PresentInfoKHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_debug_report === |
| template<> |
| struct StructExtends<DebugReportCallbackCreateInfoEXT, InstanceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_AMD_rasterization_order === |
| template<> |
| struct StructExtends<PipelineRasterizationStateRasterizationOrderAMD, PipelineRasterizationStateCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| #if defined(VK_ENABLE_BETA_EXTENSIONS) |
| //=== VK_KHR_video_queue === |
| template<> |
| struct StructExtends<QueueFamilyQueryResultStatusProperties2KHR, QueueFamilyProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoQueueFamilyProperties2KHR, QueueFamilyProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoProfileKHR, QueryPoolCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoProfileKHR, FormatProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoProfileKHR, ImageCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoProfileKHR, ImageViewCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoProfileKHR, BufferCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoProfilesKHR, FormatProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoProfilesKHR, ImageCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoProfilesKHR, ImageViewCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoProfilesKHR, BufferCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| #endif /*VK_ENABLE_BETA_EXTENSIONS*/ |
| |
| #if defined(VK_ENABLE_BETA_EXTENSIONS) |
| //=== VK_KHR_video_decode_queue === |
| template<> |
| struct StructExtends<VideoDecodeCapabilitiesKHR, VideoCapabilitiesKHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| #endif /*VK_ENABLE_BETA_EXTENSIONS*/ |
| |
| //=== VK_NV_dedicated_allocation === |
| template<> |
| struct StructExtends<DedicatedAllocationImageCreateInfoNV, ImageCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<DedicatedAllocationBufferCreateInfoNV, BufferCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<DedicatedAllocationMemoryAllocateInfoNV, MemoryAllocateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_transform_feedback === |
| template<> |
| struct StructExtends<PhysicalDeviceTransformFeedbackFeaturesEXT, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceTransformFeedbackFeaturesEXT, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceTransformFeedbackPropertiesEXT, PhysicalDeviceProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PipelineRasterizationStateStreamCreateInfoEXT, PipelineRasterizationStateCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| #if defined(VK_ENABLE_BETA_EXTENSIONS) |
| //=== VK_EXT_video_encode_h264 === |
| template<> |
| struct StructExtends<VideoEncodeH264CapabilitiesEXT, VideoEncodeCapabilitiesKHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoEncodeH264SessionParametersCreateInfoEXT, VideoSessionParametersCreateInfoKHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoEncodeH264SessionParametersAddInfoEXT, VideoSessionParametersUpdateInfoKHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoEncodeH264VclFrameInfoEXT, VideoEncodeInfoKHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoEncodeH264EmitPictureParametersEXT, VideoEncodeInfoKHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoEncodeH264ProfileEXT, VideoProfileKHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoEncodeH264ProfileEXT, QueryPoolCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoEncodeH264ProfileEXT, FormatProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoEncodeH264ProfileEXT, ImageCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoEncodeH264ProfileEXT, ImageViewCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoEncodeH264ProfileEXT, BufferCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoEncodeH264RateControlInfoEXT, VideoEncodeRateControlInfoKHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoEncodeH264RateControlLayerInfoEXT, VideoEncodeRateControlLayerInfoKHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| #endif /*VK_ENABLE_BETA_EXTENSIONS*/ |
| |
| #if defined(VK_ENABLE_BETA_EXTENSIONS) |
| //=== VK_EXT_video_encode_h265 === |
| template<> |
| struct StructExtends<VideoEncodeH265CapabilitiesEXT, VideoEncodeCapabilitiesKHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoEncodeH265SessionParametersCreateInfoEXT, VideoSessionParametersCreateInfoKHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoEncodeH265SessionParametersAddInfoEXT, VideoSessionParametersUpdateInfoKHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoEncodeH265VclFrameInfoEXT, VideoEncodeInfoKHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoEncodeH265EmitPictureParametersEXT, VideoEncodeInfoKHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoEncodeH265ProfileEXT, VideoProfileKHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoEncodeH265ProfileEXT, QueryPoolCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoEncodeH265ProfileEXT, FormatProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoEncodeH265ProfileEXT, ImageCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoEncodeH265ProfileEXT, ImageViewCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoEncodeH265ProfileEXT, BufferCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoEncodeH265RateControlInfoEXT, VideoEncodeRateControlInfoKHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoEncodeH265RateControlLayerInfoEXT, VideoEncodeRateControlLayerInfoKHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| #endif /*VK_ENABLE_BETA_EXTENSIONS*/ |
| |
| #if defined(VK_ENABLE_BETA_EXTENSIONS) |
| //=== VK_EXT_video_decode_h264 === |
| template<> |
| struct StructExtends<VideoDecodeH264ProfileEXT, VideoProfileKHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoDecodeH264ProfileEXT, QueryPoolCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoDecodeH264ProfileEXT, FormatProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoDecodeH264ProfileEXT, ImageCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoDecodeH264ProfileEXT, ImageViewCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoDecodeH264ProfileEXT, BufferCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoDecodeH264CapabilitiesEXT, VideoDecodeCapabilitiesKHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoDecodeH264SessionParametersCreateInfoEXT, VideoSessionParametersCreateInfoKHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoDecodeH264SessionParametersAddInfoEXT, VideoSessionParametersUpdateInfoKHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoDecodeH264PictureInfoEXT, VideoDecodeInfoKHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoDecodeH264MvcEXT, VideoDecodeH264PictureInfoEXT> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoDecodeH264DpbSlotInfoEXT, VideoReferenceSlotKHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| #endif /*VK_ENABLE_BETA_EXTENSIONS*/ |
| |
| //=== VK_AMD_texture_gather_bias_lod === |
| template<> |
| struct StructExtends<TextureLODGatherFormatPropertiesAMD, ImageFormatProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_KHR_dynamic_rendering === |
| template<> |
| struct StructExtends<RenderingFragmentShadingRateAttachmentInfoKHR, RenderingInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<RenderingFragmentDensityMapAttachmentInfoEXT, RenderingInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<AttachmentSampleCountInfoAMD, CommandBufferInheritanceInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<AttachmentSampleCountInfoAMD, GraphicsPipelineCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<MultiviewPerViewAttributesInfoNVX, CommandBufferInheritanceInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<MultiviewPerViewAttributesInfoNVX, GraphicsPipelineCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<MultiviewPerViewAttributesInfoNVX, RenderingInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_NV_corner_sampled_image === |
| template<> |
| struct StructExtends<PhysicalDeviceCornerSampledImageFeaturesNV, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceCornerSampledImageFeaturesNV, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_NV_external_memory === |
| template<> |
| struct StructExtends<ExternalMemoryImageCreateInfoNV, ImageCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<ExportMemoryAllocateInfoNV, MemoryAllocateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| #if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_NV_external_memory_win32 === |
| template<> |
| struct StructExtends<ImportMemoryWin32HandleInfoNV, MemoryAllocateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<ExportMemoryWin32HandleInfoNV, MemoryAllocateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| #if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_NV_win32_keyed_mutex === |
| template<> |
| struct StructExtends<Win32KeyedMutexAcquireReleaseInfoNV, SubmitInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<Win32KeyedMutexAcquireReleaseInfoNV, SubmitInfo2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_EXT_validation_flags === |
| template<> |
| struct StructExtends<ValidationFlagsEXT, InstanceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_astc_decode_mode === |
| template<> |
| struct StructExtends<ImageViewASTCDecodeModeEXT, ImageViewCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceASTCDecodeFeaturesEXT, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceASTCDecodeFeaturesEXT, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| #if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_KHR_external_memory_win32 === |
| template<> |
| struct StructExtends<ImportMemoryWin32HandleInfoKHR, MemoryAllocateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<ExportMemoryWin32HandleInfoKHR, MemoryAllocateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_KHR_external_memory_fd === |
| template<> |
| struct StructExtends<ImportMemoryFdInfoKHR, MemoryAllocateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| #if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_KHR_win32_keyed_mutex === |
| template<> |
| struct StructExtends<Win32KeyedMutexAcquireReleaseInfoKHR, SubmitInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<Win32KeyedMutexAcquireReleaseInfoKHR, SubmitInfo2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| #if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_KHR_external_semaphore_win32 === |
| template<> |
| struct StructExtends<ExportSemaphoreWin32HandleInfoKHR, SemaphoreCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<D3D12FenceSubmitInfoKHR, SubmitInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_KHR_push_descriptor === |
| template<> |
| struct StructExtends<PhysicalDevicePushDescriptorPropertiesKHR, PhysicalDeviceProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_conditional_rendering === |
| template<> |
| struct StructExtends<PhysicalDeviceConditionalRenderingFeaturesEXT, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceConditionalRenderingFeaturesEXT, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<CommandBufferInheritanceConditionalRenderingInfoEXT, CommandBufferInheritanceInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_KHR_incremental_present === |
| template<> |
| struct StructExtends<PresentRegionsKHR, PresentInfoKHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_NV_clip_space_w_scaling === |
| template<> |
| struct StructExtends<PipelineViewportWScalingStateCreateInfoNV, PipelineViewportStateCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_display_control === |
| template<> |
| struct StructExtends<SwapchainCounterCreateInfoEXT, SwapchainCreateInfoKHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_GOOGLE_display_timing === |
| template<> |
| struct StructExtends<PresentTimesInfoGOOGLE, PresentInfoKHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_NVX_multiview_per_view_attributes === |
| template<> |
| struct StructExtends<PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, PhysicalDeviceProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_NV_viewport_swizzle === |
| template<> |
| struct StructExtends<PipelineViewportSwizzleStateCreateInfoNV, PipelineViewportStateCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_discard_rectangles === |
| template<> |
| struct StructExtends<PhysicalDeviceDiscardRectanglePropertiesEXT, PhysicalDeviceProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PipelineDiscardRectangleStateCreateInfoEXT, GraphicsPipelineCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_conservative_rasterization === |
| template<> |
| struct StructExtends<PhysicalDeviceConservativeRasterizationPropertiesEXT, PhysicalDeviceProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PipelineRasterizationConservativeStateCreateInfoEXT, PipelineRasterizationStateCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_depth_clip_enable === |
| template<> |
| struct StructExtends<PhysicalDeviceDepthClipEnableFeaturesEXT, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceDepthClipEnableFeaturesEXT, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PipelineRasterizationDepthClipStateCreateInfoEXT, PipelineRasterizationStateCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_KHR_shared_presentable_image === |
| template<> |
| struct StructExtends<SharedPresentSurfaceCapabilitiesKHR, SurfaceCapabilities2KHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| #if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_KHR_external_fence_win32 === |
| template<> |
| struct StructExtends<ExportFenceWin32HandleInfoKHR, FenceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_KHR_performance_query === |
| template<> |
| struct StructExtends<PhysicalDevicePerformanceQueryFeaturesKHR, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDevicePerformanceQueryFeaturesKHR, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDevicePerformanceQueryPropertiesKHR, PhysicalDeviceProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<QueryPoolPerformanceCreateInfoKHR, QueryPoolCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PerformanceQuerySubmitInfoKHR, SubmitInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PerformanceQuerySubmitInfoKHR, SubmitInfo2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_debug_utils === |
| template<> |
| struct StructExtends<DebugUtilsMessengerCreateInfoEXT, InstanceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<DebugUtilsObjectNameInfoEXT, PipelineShaderStageCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| #if defined(VK_USE_PLATFORM_ANDROID_KHR) |
| //=== VK_ANDROID_external_memory_android_hardware_buffer === |
| template<> |
| struct StructExtends<AndroidHardwareBufferUsageANDROID, ImageFormatProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<AndroidHardwareBufferFormatPropertiesANDROID, AndroidHardwareBufferPropertiesANDROID> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<ImportAndroidHardwareBufferInfoANDROID, MemoryAllocateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<ExternalFormatANDROID, ImageCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<ExternalFormatANDROID, SamplerYcbcrConversionCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<AndroidHardwareBufferFormatProperties2ANDROID, AndroidHardwareBufferPropertiesANDROID> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ |
| |
| //=== VK_EXT_sample_locations === |
| template<> |
| struct StructExtends<SampleLocationsInfoEXT, ImageMemoryBarrier> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<SampleLocationsInfoEXT, ImageMemoryBarrier2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<RenderPassSampleLocationsBeginInfoEXT, RenderPassBeginInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PipelineSampleLocationsStateCreateInfoEXT, PipelineMultisampleStateCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceSampleLocationsPropertiesEXT, PhysicalDeviceProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_blend_operation_advanced === |
| template<> |
| struct StructExtends<PhysicalDeviceBlendOperationAdvancedFeaturesEXT, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceBlendOperationAdvancedFeaturesEXT, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceBlendOperationAdvancedPropertiesEXT, PhysicalDeviceProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PipelineColorBlendAdvancedStateCreateInfoEXT, PipelineColorBlendStateCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_NV_fragment_coverage_to_color === |
| template<> |
| struct StructExtends<PipelineCoverageToColorStateCreateInfoNV, PipelineMultisampleStateCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_KHR_acceleration_structure === |
| template<> |
| struct StructExtends<WriteDescriptorSetAccelerationStructureKHR, WriteDescriptorSet> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceAccelerationStructureFeaturesKHR, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceAccelerationStructureFeaturesKHR, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceAccelerationStructurePropertiesKHR, PhysicalDeviceProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_NV_framebuffer_mixed_samples === |
| template<> |
| struct StructExtends<PipelineCoverageModulationStateCreateInfoNV, PipelineMultisampleStateCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_NV_shader_sm_builtins === |
| template<> |
| struct StructExtends<PhysicalDeviceShaderSMBuiltinsPropertiesNV, PhysicalDeviceProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceShaderSMBuiltinsFeaturesNV, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceShaderSMBuiltinsFeaturesNV, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_image_drm_format_modifier === |
| template<> |
| struct StructExtends<DrmFormatModifierPropertiesListEXT, FormatProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceImageDrmFormatModifierInfoEXT, PhysicalDeviceImageFormatInfo2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<ImageDrmFormatModifierListCreateInfoEXT, ImageCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<ImageDrmFormatModifierExplicitCreateInfoEXT, ImageCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<DrmFormatModifierPropertiesList2EXT, FormatProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_validation_cache === |
| template<> |
| struct StructExtends<ShaderModuleValidationCacheCreateInfoEXT, ShaderModuleCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| #if defined(VK_ENABLE_BETA_EXTENSIONS) |
| //=== VK_KHR_portability_subset === |
| template<> |
| struct StructExtends<PhysicalDevicePortabilitySubsetFeaturesKHR, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDevicePortabilitySubsetFeaturesKHR, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDevicePortabilitySubsetPropertiesKHR, PhysicalDeviceProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| #endif /*VK_ENABLE_BETA_EXTENSIONS*/ |
| |
| //=== VK_NV_shading_rate_image === |
| template<> |
| struct StructExtends<PipelineViewportShadingRateImageStateCreateInfoNV, PipelineViewportStateCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceShadingRateImageFeaturesNV, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceShadingRateImageFeaturesNV, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceShadingRateImagePropertiesNV, PhysicalDeviceProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PipelineViewportCoarseSampleOrderStateCreateInfoNV, PipelineViewportStateCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_NV_ray_tracing === |
| template<> |
| struct StructExtends<WriteDescriptorSetAccelerationStructureNV, WriteDescriptorSet> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceRayTracingPropertiesNV, PhysicalDeviceProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_NV_representative_fragment_test === |
| template<> |
| struct StructExtends<PhysicalDeviceRepresentativeFragmentTestFeaturesNV, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceRepresentativeFragmentTestFeaturesNV, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PipelineRepresentativeFragmentTestStateCreateInfoNV, GraphicsPipelineCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_filter_cubic === |
| template<> |
| struct StructExtends<PhysicalDeviceImageViewImageFormatInfoEXT, PhysicalDeviceImageFormatInfo2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<FilterCubicImageViewImageFormatPropertiesEXT, ImageFormatProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_external_memory_host === |
| template<> |
| struct StructExtends<ImportMemoryHostPointerInfoEXT, MemoryAllocateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceExternalMemoryHostPropertiesEXT, PhysicalDeviceProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_KHR_shader_clock === |
| template<> |
| struct StructExtends<PhysicalDeviceShaderClockFeaturesKHR, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceShaderClockFeaturesKHR, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_AMD_pipeline_compiler_control === |
| template<> |
| struct StructExtends<PipelineCompilerControlCreateInfoAMD, GraphicsPipelineCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PipelineCompilerControlCreateInfoAMD, ComputePipelineCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_AMD_shader_core_properties === |
| template<> |
| struct StructExtends<PhysicalDeviceShaderCorePropertiesAMD, PhysicalDeviceProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| #if defined(VK_ENABLE_BETA_EXTENSIONS) |
| //=== VK_EXT_video_decode_h265 === |
| template<> |
| struct StructExtends<VideoDecodeH265ProfileEXT, VideoProfileKHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoDecodeH265ProfileEXT, QueryPoolCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoDecodeH265ProfileEXT, FormatProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoDecodeH265ProfileEXT, ImageCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoDecodeH265ProfileEXT, ImageViewCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoDecodeH265ProfileEXT, BufferCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoDecodeH265CapabilitiesEXT, VideoDecodeCapabilitiesKHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoDecodeH265SessionParametersCreateInfoEXT, VideoSessionParametersCreateInfoKHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoDecodeH265SessionParametersAddInfoEXT, VideoSessionParametersUpdateInfoKHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoDecodeH265PictureInfoEXT, VideoDecodeInfoKHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoDecodeH265DpbSlotInfoEXT, VideoReferenceSlotKHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| #endif /*VK_ENABLE_BETA_EXTENSIONS*/ |
| |
| //=== VK_KHR_global_priority === |
| template<> |
| struct StructExtends<DeviceQueueGlobalPriorityCreateInfoKHR, DeviceQueueCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceGlobalPriorityQueryFeaturesKHR, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceGlobalPriorityQueryFeaturesKHR, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<QueueFamilyGlobalPriorityPropertiesKHR, QueueFamilyProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_AMD_memory_overallocation_behavior === |
| template<> |
| struct StructExtends<DeviceMemoryOverallocationCreateInfoAMD, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_vertex_attribute_divisor === |
| template<> |
| struct StructExtends<PhysicalDeviceVertexAttributeDivisorPropertiesEXT, PhysicalDeviceProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PipelineVertexInputDivisorStateCreateInfoEXT, PipelineVertexInputStateCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceVertexAttributeDivisorFeaturesEXT, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceVertexAttributeDivisorFeaturesEXT, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| #if defined(VK_USE_PLATFORM_GGP) |
| //=== VK_GGP_frame_token === |
| template<> |
| struct StructExtends<PresentFrameTokenGGP, PresentInfoKHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| #endif /*VK_USE_PLATFORM_GGP*/ |
| |
| //=== VK_NV_compute_shader_derivatives === |
| template<> |
| struct StructExtends<PhysicalDeviceComputeShaderDerivativesFeaturesNV, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceComputeShaderDerivativesFeaturesNV, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_NV_mesh_shader === |
| template<> |
| struct StructExtends<PhysicalDeviceMeshShaderFeaturesNV, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceMeshShaderFeaturesNV, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceMeshShaderPropertiesNV, PhysicalDeviceProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_NV_fragment_shader_barycentric === |
| template<> |
| struct StructExtends<PhysicalDeviceFragmentShaderBarycentricFeaturesNV, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceFragmentShaderBarycentricFeaturesNV, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_NV_shader_image_footprint === |
| template<> |
| struct StructExtends<PhysicalDeviceShaderImageFootprintFeaturesNV, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceShaderImageFootprintFeaturesNV, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_NV_scissor_exclusive === |
| template<> |
| struct StructExtends<PipelineViewportExclusiveScissorStateCreateInfoNV, PipelineViewportStateCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceExclusiveScissorFeaturesNV, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceExclusiveScissorFeaturesNV, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_NV_device_diagnostic_checkpoints === |
| template<> |
| struct StructExtends<QueueFamilyCheckpointPropertiesNV, QueueFamilyProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_INTEL_shader_integer_functions2 === |
| template<> |
| struct StructExtends<PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_INTEL_performance_query === |
| template<> |
| struct StructExtends<QueryPoolPerformanceQueryCreateInfoINTEL, QueryPoolCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_pci_bus_info === |
| template<> |
| struct StructExtends<PhysicalDevicePCIBusInfoPropertiesEXT, PhysicalDeviceProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_AMD_display_native_hdr === |
| template<> |
| struct StructExtends<DisplayNativeHdrSurfaceCapabilitiesAMD, SurfaceCapabilities2KHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<SwapchainDisplayNativeHdrCreateInfoAMD, SwapchainCreateInfoKHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_fragment_density_map === |
| template<> |
| struct StructExtends<PhysicalDeviceFragmentDensityMapFeaturesEXT, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceFragmentDensityMapFeaturesEXT, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceFragmentDensityMapPropertiesEXT, PhysicalDeviceProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<RenderPassFragmentDensityMapCreateInfoEXT, RenderPassCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<RenderPassFragmentDensityMapCreateInfoEXT, RenderPassCreateInfo2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_KHR_fragment_shading_rate === |
| template<> |
| struct StructExtends<FragmentShadingRateAttachmentInfoKHR, SubpassDescription2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PipelineFragmentShadingRateStateCreateInfoKHR, GraphicsPipelineCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceFragmentShadingRateFeaturesKHR, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceFragmentShadingRateFeaturesKHR, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceFragmentShadingRatePropertiesKHR, PhysicalDeviceProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_AMD_shader_core_properties2 === |
| template<> |
| struct StructExtends<PhysicalDeviceShaderCoreProperties2AMD, PhysicalDeviceProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_AMD_device_coherent_memory === |
| template<> |
| struct StructExtends<PhysicalDeviceCoherentMemoryFeaturesAMD, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceCoherentMemoryFeaturesAMD, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_shader_image_atomic_int64 === |
| template<> |
| struct StructExtends<PhysicalDeviceShaderImageAtomicInt64FeaturesEXT, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceShaderImageAtomicInt64FeaturesEXT, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_memory_budget === |
| template<> |
| struct StructExtends<PhysicalDeviceMemoryBudgetPropertiesEXT, PhysicalDeviceMemoryProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_memory_priority === |
| template<> |
| struct StructExtends<PhysicalDeviceMemoryPriorityFeaturesEXT, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceMemoryPriorityFeaturesEXT, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<MemoryPriorityAllocateInfoEXT, MemoryAllocateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_KHR_surface_protected_capabilities === |
| template<> |
| struct StructExtends<SurfaceProtectedCapabilitiesKHR, SurfaceCapabilities2KHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_NV_dedicated_allocation_image_aliasing === |
| template<> |
| struct StructExtends<PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_buffer_device_address === |
| template<> |
| struct StructExtends<PhysicalDeviceBufferDeviceAddressFeaturesEXT, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceBufferDeviceAddressFeaturesEXT, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<BufferDeviceAddressCreateInfoEXT, BufferCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_validation_features === |
| template<> |
| struct StructExtends<ValidationFeaturesEXT, InstanceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_KHR_present_wait === |
| template<> |
| struct StructExtends<PhysicalDevicePresentWaitFeaturesKHR, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDevicePresentWaitFeaturesKHR, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_NV_cooperative_matrix === |
| template<> |
| struct StructExtends<PhysicalDeviceCooperativeMatrixFeaturesNV, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceCooperativeMatrixFeaturesNV, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceCooperativeMatrixPropertiesNV, PhysicalDeviceProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_NV_coverage_reduction_mode === |
| template<> |
| struct StructExtends<PhysicalDeviceCoverageReductionModeFeaturesNV, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceCoverageReductionModeFeaturesNV, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PipelineCoverageReductionStateCreateInfoNV, PipelineMultisampleStateCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_fragment_shader_interlock === |
| template<> |
| struct StructExtends<PhysicalDeviceFragmentShaderInterlockFeaturesEXT, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceFragmentShaderInterlockFeaturesEXT, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_ycbcr_image_arrays === |
| template<> |
| struct StructExtends<PhysicalDeviceYcbcrImageArraysFeaturesEXT, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceYcbcrImageArraysFeaturesEXT, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_provoking_vertex === |
| template<> |
| struct StructExtends<PhysicalDeviceProvokingVertexFeaturesEXT, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceProvokingVertexFeaturesEXT, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceProvokingVertexPropertiesEXT, PhysicalDeviceProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PipelineRasterizationProvokingVertexStateCreateInfoEXT, PipelineRasterizationStateCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| #if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_EXT_full_screen_exclusive === |
| template<> |
| struct StructExtends<SurfaceFullScreenExclusiveInfoEXT, PhysicalDeviceSurfaceInfo2KHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<SurfaceFullScreenExclusiveInfoEXT, SwapchainCreateInfoKHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<SurfaceCapabilitiesFullScreenExclusiveEXT, SurfaceCapabilities2KHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<SurfaceFullScreenExclusiveWin32InfoEXT, PhysicalDeviceSurfaceInfo2KHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<SurfaceFullScreenExclusiveWin32InfoEXT, SwapchainCreateInfoKHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_EXT_line_rasterization === |
| template<> |
| struct StructExtends<PhysicalDeviceLineRasterizationFeaturesEXT, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceLineRasterizationFeaturesEXT, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceLineRasterizationPropertiesEXT, PhysicalDeviceProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PipelineRasterizationLineStateCreateInfoEXT, PipelineRasterizationStateCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_shader_atomic_float === |
| template<> |
| struct StructExtends<PhysicalDeviceShaderAtomicFloatFeaturesEXT, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceShaderAtomicFloatFeaturesEXT, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_index_type_uint8 === |
| template<> |
| struct StructExtends<PhysicalDeviceIndexTypeUint8FeaturesEXT, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceIndexTypeUint8FeaturesEXT, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_extended_dynamic_state === |
| template<> |
| struct StructExtends<PhysicalDeviceExtendedDynamicStateFeaturesEXT, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceExtendedDynamicStateFeaturesEXT, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_KHR_pipeline_executable_properties === |
| template<> |
| struct StructExtends<PhysicalDevicePipelineExecutablePropertiesFeaturesKHR, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDevicePipelineExecutablePropertiesFeaturesKHR, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_shader_atomic_float2 === |
| template<> |
| struct StructExtends<PhysicalDeviceShaderAtomicFloat2FeaturesEXT, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceShaderAtomicFloat2FeaturesEXT, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_NV_device_generated_commands === |
| template<> |
| struct StructExtends<PhysicalDeviceDeviceGeneratedCommandsPropertiesNV, PhysicalDeviceProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceDeviceGeneratedCommandsFeaturesNV, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceDeviceGeneratedCommandsFeaturesNV, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<GraphicsPipelineShaderGroupsCreateInfoNV, GraphicsPipelineCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_NV_inherited_viewport_scissor === |
| template<> |
| struct StructExtends<PhysicalDeviceInheritedViewportScissorFeaturesNV, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceInheritedViewportScissorFeaturesNV, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<CommandBufferInheritanceViewportScissorInfoNV, CommandBufferInheritanceInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_texel_buffer_alignment === |
| template<> |
| struct StructExtends<PhysicalDeviceTexelBufferAlignmentFeaturesEXT, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceTexelBufferAlignmentFeaturesEXT, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_QCOM_render_pass_transform === |
| template<> |
| struct StructExtends<RenderPassTransformBeginInfoQCOM, RenderPassBeginInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<CommandBufferInheritanceRenderPassTransformInfoQCOM, CommandBufferInheritanceInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_device_memory_report === |
| template<> |
| struct StructExtends<PhysicalDeviceDeviceMemoryReportFeaturesEXT, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceDeviceMemoryReportFeaturesEXT, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<DeviceDeviceMemoryReportCreateInfoEXT, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_robustness2 === |
| template<> |
| struct StructExtends<PhysicalDeviceRobustness2FeaturesEXT, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceRobustness2FeaturesEXT, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceRobustness2PropertiesEXT, PhysicalDeviceProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_custom_border_color === |
| template<> |
| struct StructExtends<SamplerCustomBorderColorCreateInfoEXT, SamplerCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceCustomBorderColorPropertiesEXT, PhysicalDeviceProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceCustomBorderColorFeaturesEXT, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceCustomBorderColorFeaturesEXT, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_KHR_pipeline_library === |
| template<> |
| struct StructExtends<PipelineLibraryCreateInfoKHR, GraphicsPipelineCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_KHR_present_id === |
| template<> |
| struct StructExtends<PresentIdKHR, PresentInfoKHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDevicePresentIdFeaturesKHR, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDevicePresentIdFeaturesKHR, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| #if defined(VK_ENABLE_BETA_EXTENSIONS) |
| //=== VK_KHR_video_encode_queue === |
| template<> |
| struct StructExtends<VideoEncodeCapabilitiesKHR, VideoCapabilitiesKHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoEncodeRateControlInfoKHR, VideoCodingControlInfoKHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<VideoEncodeRateControlLayerInfoKHR, VideoCodingControlInfoKHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| #endif /*VK_ENABLE_BETA_EXTENSIONS*/ |
| |
| //=== VK_NV_device_diagnostics_config === |
| template<> |
| struct StructExtends<PhysicalDeviceDiagnosticsConfigFeaturesNV, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceDiagnosticsConfigFeaturesNV, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<DeviceDiagnosticsConfigCreateInfoNV, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_KHR_synchronization2 === |
| template<> |
| struct StructExtends<QueueFamilyCheckpointProperties2NV, QueueFamilyProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_graphics_pipeline_library === |
| template<> |
| struct StructExtends<PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT, PhysicalDeviceProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<GraphicsPipelineLibraryCreateInfoEXT, GraphicsPipelineCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_KHR_shader_subgroup_uniform_control_flow === |
| template<> |
| struct StructExtends<PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_NV_fragment_shading_rate_enums === |
| template<> |
| struct StructExtends<PhysicalDeviceFragmentShadingRateEnumsFeaturesNV, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceFragmentShadingRateEnumsFeaturesNV, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceFragmentShadingRateEnumsPropertiesNV, PhysicalDeviceProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PipelineFragmentShadingRateEnumStateCreateInfoNV, GraphicsPipelineCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_NV_ray_tracing_motion_blur === |
| template<> |
| struct StructExtends<AccelerationStructureGeometryMotionTrianglesDataNV, AccelerationStructureGeometryTrianglesDataKHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<AccelerationStructureMotionInfoNV, AccelerationStructureCreateInfoKHR> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceRayTracingMotionBlurFeaturesNV, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceRayTracingMotionBlurFeaturesNV, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_ycbcr_2plane_444_formats === |
| template<> |
| struct StructExtends<PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_fragment_density_map2 === |
| template<> |
| struct StructExtends<PhysicalDeviceFragmentDensityMap2FeaturesEXT, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceFragmentDensityMap2FeaturesEXT, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceFragmentDensityMap2PropertiesEXT, PhysicalDeviceProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_QCOM_rotated_copy_commands === |
| template<> |
| struct StructExtends<CopyCommandTransformInfoQCOM, BufferImageCopy2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<CopyCommandTransformInfoQCOM, ImageBlit2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_KHR_workgroup_memory_explicit_layout === |
| template<> |
| struct StructExtends<PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_4444_formats === |
| template<> |
| struct StructExtends<PhysicalDevice4444FormatsFeaturesEXT, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDevice4444FormatsFeaturesEXT, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_ARM_rasterization_order_attachment_access === |
| template<> |
| struct StructExtends<PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_rgba10x6_formats === |
| template<> |
| struct StructExtends<PhysicalDeviceRGBA10X6FormatsFeaturesEXT, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceRGBA10X6FormatsFeaturesEXT, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_KHR_ray_tracing_pipeline === |
| template<> |
| struct StructExtends<PhysicalDeviceRayTracingPipelineFeaturesKHR, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceRayTracingPipelineFeaturesKHR, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceRayTracingPipelinePropertiesKHR, PhysicalDeviceProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_KHR_ray_query === |
| template<> |
| struct StructExtends<PhysicalDeviceRayQueryFeaturesKHR, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceRayQueryFeaturesKHR, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_VALVE_mutable_descriptor_type === |
| template<> |
| struct StructExtends<PhysicalDeviceMutableDescriptorTypeFeaturesVALVE, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceMutableDescriptorTypeFeaturesVALVE, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<MutableDescriptorTypeCreateInfoVALVE, DescriptorSetLayoutCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<MutableDescriptorTypeCreateInfoVALVE, DescriptorPoolCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_vertex_input_dynamic_state === |
| template<> |
| struct StructExtends<PhysicalDeviceVertexInputDynamicStateFeaturesEXT, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceVertexInputDynamicStateFeaturesEXT, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_physical_device_drm === |
| template<> |
| struct StructExtends<PhysicalDeviceDrmPropertiesEXT, PhysicalDeviceProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_depth_clip_control === |
| template<> |
| struct StructExtends<PhysicalDeviceDepthClipControlFeaturesEXT, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceDepthClipControlFeaturesEXT, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PipelineViewportDepthClipControlCreateInfoEXT, PipelineViewportStateCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_primitive_topology_list_restart === |
| template<> |
| struct StructExtends<PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| #if defined(VK_USE_PLATFORM_FUCHSIA) |
| //=== VK_FUCHSIA_external_memory === |
| template<> |
| struct StructExtends<ImportMemoryZirconHandleInfoFUCHSIA, MemoryAllocateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| #endif /*VK_USE_PLATFORM_FUCHSIA*/ |
| |
| #if defined(VK_USE_PLATFORM_FUCHSIA) |
| //=== VK_FUCHSIA_buffer_collection === |
| template<> |
| struct StructExtends<ImportMemoryBufferCollectionFUCHSIA, MemoryAllocateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<BufferCollectionImageCreateInfoFUCHSIA, ImageCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<BufferCollectionBufferCreateInfoFUCHSIA, BufferCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| #endif /*VK_USE_PLATFORM_FUCHSIA*/ |
| |
| //=== VK_HUAWEI_subpass_shading === |
| template<> |
| struct StructExtends<SubpassShadingPipelineCreateInfoHUAWEI, ComputePipelineCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceSubpassShadingFeaturesHUAWEI, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceSubpassShadingFeaturesHUAWEI, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceSubpassShadingPropertiesHUAWEI, PhysicalDeviceProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_HUAWEI_invocation_mask === |
| template<> |
| struct StructExtends<PhysicalDeviceInvocationMaskFeaturesHUAWEI, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceInvocationMaskFeaturesHUAWEI, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_NV_external_memory_rdma === |
| template<> |
| struct StructExtends<PhysicalDeviceExternalMemoryRDMAFeaturesNV, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceExternalMemoryRDMAFeaturesNV, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_extended_dynamic_state2 === |
| template<> |
| struct StructExtends<PhysicalDeviceExtendedDynamicState2FeaturesEXT, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceExtendedDynamicState2FeaturesEXT, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_color_write_enable === |
| template<> |
| struct StructExtends<PhysicalDeviceColorWriteEnableFeaturesEXT, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceColorWriteEnableFeaturesEXT, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PipelineColorWriteCreateInfoEXT, PipelineColorBlendStateCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_primitives_generated_query === |
| template<> |
| struct StructExtends<PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_image_view_min_lod === |
| template<> |
| struct StructExtends<PhysicalDeviceImageViewMinLodFeaturesEXT, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceImageViewMinLodFeaturesEXT, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<ImageViewMinLodCreateInfoEXT, ImageViewCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_multi_draw === |
| template<> |
| struct StructExtends<PhysicalDeviceMultiDrawFeaturesEXT, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceMultiDrawFeaturesEXT, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceMultiDrawPropertiesEXT, PhysicalDeviceProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_image_2d_view_of_3d === |
| template<> |
| struct StructExtends<PhysicalDeviceImage2DViewOf3DFeaturesEXT, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceImage2DViewOf3DFeaturesEXT, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_border_color_swizzle === |
| template<> |
| struct StructExtends<PhysicalDeviceBorderColorSwizzleFeaturesEXT, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceBorderColorSwizzleFeaturesEXT, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<SamplerBorderColorComponentMappingCreateInfoEXT, SamplerCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_EXT_pageable_device_local_memory === |
| template<> |
| struct StructExtends<PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_VALVE_descriptor_set_host_mapping === |
| template<> |
| struct StructExtends<PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_QCOM_fragment_density_map_offset === |
| template<> |
| struct StructExtends<PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM, PhysicalDeviceProperties2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<SubpassFragmentDensityMapOffsetEndInfoQCOM, SubpassEndInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| //=== VK_NV_linear_color_attachment === |
| template<> |
| struct StructExtends<PhysicalDeviceLinearColorAttachmentFeaturesNV, PhysicalDeviceFeatures2> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| template<> |
| struct StructExtends<PhysicalDeviceLinearColorAttachmentFeaturesNV, DeviceCreateInfo> |
| { |
| enum |
| { |
| value = true |
| }; |
| }; |
| |
| #if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL |
| class DynamicLoader |
| { |
| public: |
| # ifdef VULKAN_HPP_NO_EXCEPTIONS |
| DynamicLoader(std::string const &vulkanLibraryName = {}) VULKAN_HPP_NOEXCEPT |
| # else |
| DynamicLoader(std::string const &vulkanLibraryName = {}) |
| # endif |
| { |
| if(!vulkanLibraryName.empty()) |
| { |
| # if defined(__unix__) || defined(__APPLE__) || defined(__QNXNTO__) || defined(__Fuchsia__) |
| m_library = dlopen(vulkanLibraryName.c_str(), RTLD_NOW | RTLD_LOCAL); |
| # elif defined(_WIN32) |
| m_library = ::LoadLibraryA(vulkanLibraryName.c_str()); |
| # else |
| # error unsupported platform |
| # endif |
| } |
| else |
| { |
| # if defined(__unix__) || defined(__QNXNTO__) || defined(__Fuchsia__) |
| m_library = dlopen("libvulkan.so", RTLD_NOW | RTLD_LOCAL); |
| if(m_library == nullptr) |
| { |
| m_library = dlopen("libvulkan.so.1", RTLD_NOW | RTLD_LOCAL); |
| } |
| # elif defined(__APPLE__) |
| m_library = dlopen("libvulkan.dylib", RTLD_NOW | RTLD_LOCAL); |
| # elif defined(_WIN32) |
| m_library = ::LoadLibraryA("vulkan-1.dll"); |
| # else |
| # error unsupported platform |
| # endif |
| } |
| |
| # ifndef VULKAN_HPP_NO_EXCEPTIONS |
| if(m_library == nullptr) |
| { |
| // NOTE there should be an InitializationFailedError, but msvc insists on the symbol does not exist within the scope of this function. |
| throw std::runtime_error("Failed to load vulkan library!"); |
| } |
| # endif |
| } |
| |
| DynamicLoader(DynamicLoader const &) = delete; |
| |
| DynamicLoader(DynamicLoader &&other) VULKAN_HPP_NOEXCEPT : m_library(other.m_library) |
| { |
| other.m_library = nullptr; |
| } |
| |
| DynamicLoader &operator=(DynamicLoader const &) = delete; |
| |
| DynamicLoader &operator=(DynamicLoader &&other) VULKAN_HPP_NOEXCEPT |
| { |
| std::swap(m_library, other.m_library); |
| return *this; |
| } |
| |
| ~DynamicLoader() VULKAN_HPP_NOEXCEPT |
| { |
| if(m_library) |
| { |
| # if defined(__unix__) || defined(__APPLE__) || defined(__QNXNTO__) || defined(__Fuchsia__) |
| dlclose(m_library); |
| # elif defined(_WIN32) |
| ::FreeLibrary(m_library); |
| # else |
| # error unsupported platform |
| # endif |
| } |
| } |
| |
| template<typename T> |
| T getProcAddress(const char *function) const VULKAN_HPP_NOEXCEPT |
| { |
| # if defined(__unix__) || defined(__APPLE__) || defined(__QNXNTO__) || defined(__Fuchsia__) |
| return (T)dlsym(m_library, function); |
| # elif defined(_WIN32) |
| return (T)::GetProcAddress(m_library, function); |
| # else |
| # error unsupported platform |
| # endif |
| } |
| |
| bool success() const VULKAN_HPP_NOEXCEPT |
| { |
| return m_library != nullptr; |
| } |
| |
| private: |
| # if defined(__unix__) || defined(__APPLE__) || defined(__QNXNTO__) || defined(__Fuchsia__) |
| void *m_library; |
| # elif defined(_WIN32) |
| ::HINSTANCE m_library; |
| # else |
| # error unsupported platform |
| # endif |
| }; |
| #endif |
| |
| using PFN_dummy = void (*)(); |
| |
| class DispatchLoaderDynamic : public DispatchLoaderBase |
| { |
| public: |
| //=== VK_VERSION_1_0 === |
| PFN_vkCreateInstance vkCreateInstance = 0; |
| PFN_vkDestroyInstance vkDestroyInstance = 0; |
| PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices = 0; |
| PFN_vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures = 0; |
| PFN_vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties = 0; |
| PFN_vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceImageFormatProperties = 0; |
| PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties = 0; |
| PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties = 0; |
| PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties = 0; |
| PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = 0; |
| PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr = 0; |
| PFN_vkCreateDevice vkCreateDevice = 0; |
| PFN_vkDestroyDevice vkDestroyDevice = 0; |
| PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties = 0; |
| PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties = 0; |
| PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties = 0; |
| PFN_vkEnumerateDeviceLayerProperties vkEnumerateDeviceLayerProperties = 0; |
| PFN_vkGetDeviceQueue vkGetDeviceQueue = 0; |
| PFN_vkQueueSubmit vkQueueSubmit = 0; |
| PFN_vkQueueWaitIdle vkQueueWaitIdle = 0; |
| PFN_vkDeviceWaitIdle vkDeviceWaitIdle = 0; |
| PFN_vkAllocateMemory vkAllocateMemory = 0; |
| PFN_vkFreeMemory vkFreeMemory = 0; |
| PFN_vkMapMemory vkMapMemory = 0; |
| PFN_vkUnmapMemory vkUnmapMemory = 0; |
| PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges = 0; |
| PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges = 0; |
| PFN_vkGetDeviceMemoryCommitment vkGetDeviceMemoryCommitment = 0; |
| PFN_vkBindBufferMemory vkBindBufferMemory = 0; |
| PFN_vkBindImageMemory vkBindImageMemory = 0; |
| PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements = 0; |
| PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements = 0; |
| PFN_vkGetImageSparseMemoryRequirements vkGetImageSparseMemoryRequirements = 0; |
| PFN_vkGetPhysicalDeviceSparseImageFormatProperties vkGetPhysicalDeviceSparseImageFormatProperties = 0; |
| PFN_vkQueueBindSparse vkQueueBindSparse = 0; |
| PFN_vkCreateFence vkCreateFence = 0; |
| PFN_vkDestroyFence vkDestroyFence = 0; |
| PFN_vkResetFences vkResetFences = 0; |
| PFN_vkGetFenceStatus vkGetFenceStatus = 0; |
| PFN_vkWaitForFences vkWaitForFences = 0; |
| PFN_vkCreateSemaphore vkCreateSemaphore = 0; |
| PFN_vkDestroySemaphore vkDestroySemaphore = 0; |
| PFN_vkCreateEvent vkCreateEvent = 0; |
| PFN_vkDestroyEvent vkDestroyEvent = 0; |
| PFN_vkGetEventStatus vkGetEventStatus = 0; |
| PFN_vkSetEvent vkSetEvent = 0; |
| PFN_vkResetEvent vkResetEvent = 0; |
| PFN_vkCreateQueryPool vkCreateQueryPool = 0; |
| PFN_vkDestroyQueryPool vkDestroyQueryPool = 0; |
| PFN_vkGetQueryPoolResults vkGetQueryPoolResults = 0; |
| PFN_vkCreateBuffer vkCreateBuffer = 0; |
| PFN_vkDestroyBuffer vkDestroyBuffer = 0; |
| PFN_vkCreateBufferView vkCreateBufferView = 0; |
| PFN_vkDestroyBufferView vkDestroyBufferView = 0; |
| PFN_vkCreateImage vkCreateImage = 0; |
| PFN_vkDestroyImage vkDestroyImage = 0; |
| PFN_vkGetImageSubresourceLayout vkGetImageSubresourceLayout = 0; |
| PFN_vkCreateImageView vkCreateImageView = 0; |
| PFN_vkDestroyImageView vkDestroyImageView = 0; |
| PFN_vkCreateShaderModule vkCreateShaderModule = 0; |
| PFN_vkDestroyShaderModule vkDestroyShaderModule = 0; |
| PFN_vkCreatePipelineCache vkCreatePipelineCache = 0; |
| PFN_vkDestroyPipelineCache vkDestroyPipelineCache = 0; |
| PFN_vkGetPipelineCacheData vkGetPipelineCacheData = 0; |
| PFN_vkMergePipelineCaches vkMergePipelineCaches = 0; |
| PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines = 0; |
| PFN_vkCreateComputePipelines vkCreateComputePipelines = 0; |
| PFN_vkDestroyPipeline vkDestroyPipeline = 0; |
| PFN_vkCreatePipelineLayout vkCreatePipelineLayout = 0; |
| PFN_vkDestroyPipelineLayout vkDestroyPipelineLayout = 0; |
| PFN_vkCreateSampler vkCreateSampler = 0; |
| PFN_vkDestroySampler vkDestroySampler = 0; |
| PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout = 0; |
| PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout = 0; |
| PFN_vkCreateDescriptorPool vkCreateDescriptorPool = 0; |
| PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool = 0; |
| PFN_vkResetDescriptorPool vkResetDescriptorPool = 0; |
| PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets = 0; |
| PFN_vkFreeDescriptorSets vkFreeDescriptorSets = 0; |
| PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets = 0; |
| PFN_vkCreateFramebuffer vkCreateFramebuffer = 0; |
| PFN_vkDestroyFramebuffer vkDestroyFramebuffer = 0; |
| PFN_vkCreateRenderPass vkCreateRenderPass = 0; |
| PFN_vkDestroyRenderPass vkDestroyRenderPass = 0; |
| PFN_vkGetRenderAreaGranularity vkGetRenderAreaGranularity = 0; |
| PFN_vkCreateCommandPool vkCreateCommandPool = 0; |
| PFN_vkDestroyCommandPool vkDestroyCommandPool = 0; |
| PFN_vkResetCommandPool vkResetCommandPool = 0; |
| PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers = 0; |
| PFN_vkFreeCommandBuffers vkFreeCommandBuffers = 0; |
| PFN_vkBeginCommandBuffer vkBeginCommandBuffer = 0; |
| PFN_vkEndCommandBuffer vkEndCommandBuffer = 0; |
| PFN_vkResetCommandBuffer vkResetCommandBuffer = 0; |
| PFN_vkCmdBindPipeline vkCmdBindPipeline = 0; |
| PFN_vkCmdSetViewport vkCmdSetViewport = 0; |
| PFN_vkCmdSetScissor vkCmdSetScissor = 0; |
| PFN_vkCmdSetLineWidth vkCmdSetLineWidth = 0; |
| PFN_vkCmdSetDepthBias vkCmdSetDepthBias = 0; |
| PFN_vkCmdSetBlendConstants vkCmdSetBlendConstants = 0; |
| PFN_vkCmdSetDepthBounds vkCmdSetDepthBounds = 0; |
| PFN_vkCmdSetStencilCompareMask vkCmdSetStencilCompareMask = 0; |
| PFN_vkCmdSetStencilWriteMask vkCmdSetStencilWriteMask = 0; |
| PFN_vkCmdSetStencilReference vkCmdSetStencilReference = 0; |
| PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets = 0; |
| PFN_vkCmdBindIndexBuffer vkCmdBindIndexBuffer = 0; |
| PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers = 0; |
| PFN_vkCmdDraw vkCmdDraw = 0; |
| PFN_vkCmdDrawIndexed vkCmdDrawIndexed = 0; |
| PFN_vkCmdDrawIndirect vkCmdDrawIndirect = 0; |
| PFN_vkCmdDrawIndexedIndirect vkCmdDrawIndexedIndirect = 0; |
| PFN_vkCmdDispatch vkCmdDispatch = 0; |
| PFN_vkCmdDispatchIndirect vkCmdDispatchIndirect = 0; |
| PFN_vkCmdCopyBuffer vkCmdCopyBuffer = 0; |
| PFN_vkCmdCopyImage vkCmdCopyImage = 0; |
| PFN_vkCmdBlitImage vkCmdBlitImage = 0; |
| PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage = 0; |
| PFN_vkCmdCopyImageToBuffer vkCmdCopyImageToBuffer = 0; |
| PFN_vkCmdUpdateBuffer vkCmdUpdateBuffer = 0; |
| PFN_vkCmdFillBuffer vkCmdFillBuffer = 0; |
| PFN_vkCmdClearColorImage vkCmdClearColorImage = 0; |
| PFN_vkCmdClearDepthStencilImage vkCmdClearDepthStencilImage = 0; |
| PFN_vkCmdClearAttachments vkCmdClearAttachments = 0; |
| PFN_vkCmdResolveImage vkCmdResolveImage = 0; |
| PFN_vkCmdSetEvent vkCmdSetEvent = 0; |
| PFN_vkCmdResetEvent vkCmdResetEvent = 0; |
| PFN_vkCmdWaitEvents vkCmdWaitEvents = 0; |
| PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier = 0; |
| PFN_vkCmdBeginQuery vkCmdBeginQuery = 0; |
| PFN_vkCmdEndQuery vkCmdEndQuery = 0; |
| PFN_vkCmdResetQueryPool vkCmdResetQueryPool = 0; |
| PFN_vkCmdWriteTimestamp vkCmdWriteTimestamp = 0; |
| PFN_vkCmdCopyQueryPoolResults vkCmdCopyQueryPoolResults = 0; |
| PFN_vkCmdPushConstants vkCmdPushConstants = 0; |
| PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass = 0; |
| PFN_vkCmdNextSubpass vkCmdNextSubpass = 0; |
| PFN_vkCmdEndRenderPass vkCmdEndRenderPass = 0; |
| PFN_vkCmdExecuteCommands vkCmdExecuteCommands = 0; |
| |
| //=== VK_VERSION_1_1 === |
| PFN_vkEnumerateInstanceVersion vkEnumerateInstanceVersion = 0; |
| PFN_vkBindBufferMemory2 vkBindBufferMemory2 = 0; |
| PFN_vkBindImageMemory2 vkBindImageMemory2 = 0; |
| PFN_vkGetDeviceGroupPeerMemoryFeatures vkGetDeviceGroupPeerMemoryFeatures = 0; |
| PFN_vkCmdSetDeviceMask vkCmdSetDeviceMask = 0; |
| PFN_vkCmdDispatchBase vkCmdDispatchBase = 0; |
| PFN_vkEnumeratePhysicalDeviceGroups vkEnumeratePhysicalDeviceGroups = 0; |
| PFN_vkGetImageMemoryRequirements2 vkGetImageMemoryRequirements2 = 0; |
| PFN_vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2 = 0; |
| PFN_vkGetImageSparseMemoryRequirements2 vkGetImageSparseMemoryRequirements2 = 0; |
| PFN_vkGetPhysicalDeviceFeatures2 vkGetPhysicalDeviceFeatures2 = 0; |
| PFN_vkGetPhysicalDeviceProperties2 vkGetPhysicalDeviceProperties2 = 0; |
| PFN_vkGetPhysicalDeviceFormatProperties2 vkGetPhysicalDeviceFormatProperties2 = 0; |
| PFN_vkGetPhysicalDeviceImageFormatProperties2 vkGetPhysicalDeviceImageFormatProperties2 = 0; |
| PFN_vkGetPhysicalDeviceQueueFamilyProperties2 vkGetPhysicalDeviceQueueFamilyProperties2 = 0; |
| PFN_vkGetPhysicalDeviceMemoryProperties2 vkGetPhysicalDeviceMemoryProperties2 = 0; |
| PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 vkGetPhysicalDeviceSparseImageFormatProperties2 = 0; |
| PFN_vkTrimCommandPool vkTrimCommandPool = 0; |
| PFN_vkGetDeviceQueue2 vkGetDeviceQueue2 = 0; |
| PFN_vkCreateSamplerYcbcrConversion vkCreateSamplerYcbcrConversion = 0; |
| PFN_vkDestroySamplerYcbcrConversion vkDestroySamplerYcbcrConversion = 0; |
| PFN_vkCreateDescriptorUpdateTemplate vkCreateDescriptorUpdateTemplate = 0; |
| PFN_vkDestroyDescriptorUpdateTemplate vkDestroyDescriptorUpdateTemplate = 0; |
| PFN_vkUpdateDescriptorSetWithTemplate vkUpdateDescriptorSetWithTemplate = 0; |
| PFN_vkGetPhysicalDeviceExternalBufferProperties vkGetPhysicalDeviceExternalBufferProperties = 0; |
| PFN_vkGetPhysicalDeviceExternalFenceProperties vkGetPhysicalDeviceExternalFenceProperties = 0; |
| PFN_vkGetPhysicalDeviceExternalSemaphoreProperties vkGetPhysicalDeviceExternalSemaphoreProperties = 0; |
| PFN_vkGetDescriptorSetLayoutSupport vkGetDescriptorSetLayoutSupport = 0; |
| |
| //=== VK_VERSION_1_2 === |
| PFN_vkCmdDrawIndirectCount vkCmdDrawIndirectCount = 0; |
| PFN_vkCmdDrawIndexedIndirectCount vkCmdDrawIndexedIndirectCount = 0; |
| PFN_vkCreateRenderPass2 vkCreateRenderPass2 = 0; |
| PFN_vkCmdBeginRenderPass2 vkCmdBeginRenderPass2 = 0; |
| PFN_vkCmdNextSubpass2 vkCmdNextSubpass2 = 0; |
| PFN_vkCmdEndRenderPass2 vkCmdEndRenderPass2 = 0; |
| PFN_vkResetQueryPool vkResetQueryPool = 0; |
| PFN_vkGetSemaphoreCounterValue vkGetSemaphoreCounterValue = 0; |
| PFN_vkWaitSemaphores vkWaitSemaphores = 0; |
| PFN_vkSignalSemaphore vkSignalSemaphore = 0; |
| PFN_vkGetBufferDeviceAddress vkGetBufferDeviceAddress = 0; |
| PFN_vkGetBufferOpaqueCaptureAddress vkGetBufferOpaqueCaptureAddress = 0; |
| PFN_vkGetDeviceMemoryOpaqueCaptureAddress vkGetDeviceMemoryOpaqueCaptureAddress = 0; |
| |
| //=== VK_VERSION_1_3 === |
| PFN_vkGetPhysicalDeviceToolProperties vkGetPhysicalDeviceToolProperties = 0; |
| PFN_vkCreatePrivateDataSlot vkCreatePrivateDataSlot = 0; |
| PFN_vkDestroyPrivateDataSlot vkDestroyPrivateDataSlot = 0; |
| PFN_vkSetPrivateData vkSetPrivateData = 0; |
| PFN_vkGetPrivateData vkGetPrivateData = 0; |
| PFN_vkCmdSetEvent2 vkCmdSetEvent2 = 0; |
| PFN_vkCmdResetEvent2 vkCmdResetEvent2 = 0; |
| PFN_vkCmdWaitEvents2 vkCmdWaitEvents2 = 0; |
| PFN_vkCmdPipelineBarrier2 vkCmdPipelineBarrier2 = 0; |
| PFN_vkCmdWriteTimestamp2 vkCmdWriteTimestamp2 = 0; |
| PFN_vkQueueSubmit2 vkQueueSubmit2 = 0; |
| PFN_vkCmdCopyBuffer2 vkCmdCopyBuffer2 = 0; |
| PFN_vkCmdCopyImage2 vkCmdCopyImage2 = 0; |
| PFN_vkCmdCopyBufferToImage2 vkCmdCopyBufferToImage2 = 0; |
| PFN_vkCmdCopyImageToBuffer2 vkCmdCopyImageToBuffer2 = 0; |
| PFN_vkCmdBlitImage2 vkCmdBlitImage2 = 0; |
| PFN_vkCmdResolveImage2 vkCmdResolveImage2 = 0; |
| PFN_vkCmdBeginRendering vkCmdBeginRendering = 0; |
| PFN_vkCmdEndRendering vkCmdEndRendering = 0; |
| PFN_vkCmdSetCullMode vkCmdSetCullMode = 0; |
| PFN_vkCmdSetFrontFace vkCmdSetFrontFace = 0; |
| PFN_vkCmdSetPrimitiveTopology vkCmdSetPrimitiveTopology = 0; |
| PFN_vkCmdSetViewportWithCount vkCmdSetViewportWithCount = 0; |
| PFN_vkCmdSetScissorWithCount vkCmdSetScissorWithCount = 0; |
| PFN_vkCmdBindVertexBuffers2 vkCmdBindVertexBuffers2 = 0; |
| PFN_vkCmdSetDepthTestEnable vkCmdSetDepthTestEnable = 0; |
| PFN_vkCmdSetDepthWriteEnable vkCmdSetDepthWriteEnable = 0; |
| PFN_vkCmdSetDepthCompareOp vkCmdSetDepthCompareOp = 0; |
| PFN_vkCmdSetDepthBoundsTestEnable vkCmdSetDepthBoundsTestEnable = 0; |
| PFN_vkCmdSetStencilTestEnable vkCmdSetStencilTestEnable = 0; |
| PFN_vkCmdSetStencilOp vkCmdSetStencilOp = 0; |
| PFN_vkCmdSetRasterizerDiscardEnable vkCmdSetRasterizerDiscardEnable = 0; |
| PFN_vkCmdSetDepthBiasEnable vkCmdSetDepthBiasEnable = 0; |
| PFN_vkCmdSetPrimitiveRestartEnable vkCmdSetPrimitiveRestartEnable = 0; |
| PFN_vkGetDeviceBufferMemoryRequirements vkGetDeviceBufferMemoryRequirements = 0; |
| PFN_vkGetDeviceImageMemoryRequirements vkGetDeviceImageMemoryRequirements = 0; |
| PFN_vkGetDeviceImageSparseMemoryRequirements vkGetDeviceImageSparseMemoryRequirements = 0; |
| |
| //=== VK_KHR_surface === |
| PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR = 0; |
| PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR = 0; |
| PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceCapabilitiesKHR = 0; |
| PFN_vkGetPhysicalDeviceSurfaceFormatsKHR vkGetPhysicalDeviceSurfaceFormatsKHR = 0; |
| PFN_vkGetPhysicalDeviceSurfacePresentModesKHR vkGetPhysicalDeviceSurfacePresentModesKHR = 0; |
| |
| //=== VK_KHR_swapchain === |
| PFN_vkCreateSwapchainKHR vkCreateSwapchainKHR = 0; |
| PFN_vkDestroySwapchainKHR vkDestroySwapchainKHR = 0; |
| PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR = 0; |
| PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR = 0; |
| PFN_vkQueuePresentKHR vkQueuePresentKHR = 0; |
| PFN_vkGetDeviceGroupPresentCapabilitiesKHR vkGetDeviceGroupPresentCapabilitiesKHR = 0; |
| PFN_vkGetDeviceGroupSurfacePresentModesKHR vkGetDeviceGroupSurfacePresentModesKHR = 0; |
| PFN_vkGetPhysicalDevicePresentRectanglesKHR vkGetPhysicalDevicePresentRectanglesKHR = 0; |
| PFN_vkAcquireNextImage2KHR vkAcquireNextImage2KHR = 0; |
| |
| //=== VK_KHR_display === |
| PFN_vkGetPhysicalDeviceDisplayPropertiesKHR vkGetPhysicalDeviceDisplayPropertiesKHR = 0; |
| PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR vkGetPhysicalDeviceDisplayPlanePropertiesKHR = 0; |
| PFN_vkGetDisplayPlaneSupportedDisplaysKHR vkGetDisplayPlaneSupportedDisplaysKHR = 0; |
| PFN_vkGetDisplayModePropertiesKHR vkGetDisplayModePropertiesKHR = 0; |
| PFN_vkCreateDisplayModeKHR vkCreateDisplayModeKHR = 0; |
| PFN_vkGetDisplayPlaneCapabilitiesKHR vkGetDisplayPlaneCapabilitiesKHR = 0; |
| PFN_vkCreateDisplayPlaneSurfaceKHR vkCreateDisplayPlaneSurfaceKHR = 0; |
| |
| //=== VK_KHR_display_swapchain === |
| PFN_vkCreateSharedSwapchainsKHR vkCreateSharedSwapchainsKHR = 0; |
| |
| #if defined(VK_USE_PLATFORM_XLIB_KHR) |
| //=== VK_KHR_xlib_surface === |
| PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHR = 0; |
| PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR vkGetPhysicalDeviceXlibPresentationSupportKHR = 0; |
| #else |
| PFN_dummy vkCreateXlibSurfaceKHR_placeholder = 0; |
| PFN_dummy vkGetPhysicalDeviceXlibPresentationSupportKHR_placeholder = 0; |
| #endif /*VK_USE_PLATFORM_XLIB_KHR*/ |
| |
| #if defined(VK_USE_PLATFORM_XCB_KHR) |
| //=== VK_KHR_xcb_surface === |
| PFN_vkCreateXcbSurfaceKHR vkCreateXcbSurfaceKHR = 0; |
| PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR vkGetPhysicalDeviceXcbPresentationSupportKHR = 0; |
| #else |
| PFN_dummy vkCreateXcbSurfaceKHR_placeholder = 0; |
| PFN_dummy vkGetPhysicalDeviceXcbPresentationSupportKHR_placeholder = 0; |
| #endif /*VK_USE_PLATFORM_XCB_KHR*/ |
| |
| #if defined(VK_USE_PLATFORM_WAYLAND_KHR) |
| //=== VK_KHR_wayland_surface === |
| PFN_vkCreateWaylandSurfaceKHR vkCreateWaylandSurfaceKHR = 0; |
| PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR vkGetPhysicalDeviceWaylandPresentationSupportKHR = 0; |
| #else |
| PFN_dummy vkCreateWaylandSurfaceKHR_placeholder = 0; |
| PFN_dummy vkGetPhysicalDeviceWaylandPresentationSupportKHR_placeholder = 0; |
| #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ |
| |
| #if defined(VK_USE_PLATFORM_ANDROID_KHR) |
| //=== VK_KHR_android_surface === |
| PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR = 0; |
| #else |
| PFN_dummy vkCreateAndroidSurfaceKHR_placeholder = 0; |
| #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ |
| |
| #if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_KHR_win32_surface === |
| PFN_vkCreateWin32SurfaceKHR vkCreateWin32SurfaceKHR = 0; |
| PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR vkGetPhysicalDeviceWin32PresentationSupportKHR = 0; |
| #else |
| PFN_dummy vkCreateWin32SurfaceKHR_placeholder = 0; |
| PFN_dummy vkGetPhysicalDeviceWin32PresentationSupportKHR_placeholder = 0; |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_EXT_debug_report === |
| PFN_vkCreateDebugReportCallbackEXT vkCreateDebugReportCallbackEXT = 0; |
| PFN_vkDestroyDebugReportCallbackEXT vkDestroyDebugReportCallbackEXT = 0; |
| PFN_vkDebugReportMessageEXT vkDebugReportMessageEXT = 0; |
| |
| //=== VK_EXT_debug_marker === |
| PFN_vkDebugMarkerSetObjectTagEXT vkDebugMarkerSetObjectTagEXT = 0; |
| PFN_vkDebugMarkerSetObjectNameEXT vkDebugMarkerSetObjectNameEXT = 0; |
| PFN_vkCmdDebugMarkerBeginEXT vkCmdDebugMarkerBeginEXT = 0; |
| PFN_vkCmdDebugMarkerEndEXT vkCmdDebugMarkerEndEXT = 0; |
| PFN_vkCmdDebugMarkerInsertEXT vkCmdDebugMarkerInsertEXT = 0; |
| |
| #if defined(VK_ENABLE_BETA_EXTENSIONS) |
| //=== VK_KHR_video_queue === |
| PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR vkGetPhysicalDeviceVideoCapabilitiesKHR = 0; |
| PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR vkGetPhysicalDeviceVideoFormatPropertiesKHR = 0; |
| PFN_vkCreateVideoSessionKHR vkCreateVideoSessionKHR = 0; |
| PFN_vkDestroyVideoSessionKHR vkDestroyVideoSessionKHR = 0; |
| PFN_vkGetVideoSessionMemoryRequirementsKHR vkGetVideoSessionMemoryRequirementsKHR = 0; |
| PFN_vkBindVideoSessionMemoryKHR vkBindVideoSessionMemoryKHR = 0; |
| PFN_vkCreateVideoSessionParametersKHR vkCreateVideoSessionParametersKHR = 0; |
| PFN_vkUpdateVideoSessionParametersKHR vkUpdateVideoSessionParametersKHR = 0; |
| PFN_vkDestroyVideoSessionParametersKHR vkDestroyVideoSessionParametersKHR = 0; |
| PFN_vkCmdBeginVideoCodingKHR vkCmdBeginVideoCodingKHR = 0; |
| PFN_vkCmdEndVideoCodingKHR vkCmdEndVideoCodingKHR = 0; |
| PFN_vkCmdControlVideoCodingKHR vkCmdControlVideoCodingKHR = 0; |
| #else |
| PFN_dummy vkGetPhysicalDeviceVideoCapabilitiesKHR_placeholder = 0; |
| PFN_dummy vkGetPhysicalDeviceVideoFormatPropertiesKHR_placeholder = 0; |
| PFN_dummy vkCreateVideoSessionKHR_placeholder = 0; |
| PFN_dummy vkDestroyVideoSessionKHR_placeholder = 0; |
| PFN_dummy vkGetVideoSessionMemoryRequirementsKHR_placeholder = 0; |
| PFN_dummy vkBindVideoSessionMemoryKHR_placeholder = 0; |
| PFN_dummy vkCreateVideoSessionParametersKHR_placeholder = 0; |
| PFN_dummy vkUpdateVideoSessionParametersKHR_placeholder = 0; |
| PFN_dummy vkDestroyVideoSessionParametersKHR_placeholder = 0; |
| PFN_dummy vkCmdBeginVideoCodingKHR_placeholder = 0; |
| PFN_dummy vkCmdEndVideoCodingKHR_placeholder = 0; |
| PFN_dummy vkCmdControlVideoCodingKHR_placeholder = 0; |
| #endif /*VK_ENABLE_BETA_EXTENSIONS*/ |
| |
| #if defined(VK_ENABLE_BETA_EXTENSIONS) |
| //=== VK_KHR_video_decode_queue === |
| PFN_vkCmdDecodeVideoKHR vkCmdDecodeVideoKHR = 0; |
| #else |
| PFN_dummy vkCmdDecodeVideoKHR_placeholder = 0; |
| #endif /*VK_ENABLE_BETA_EXTENSIONS*/ |
| |
| //=== VK_EXT_transform_feedback === |
| PFN_vkCmdBindTransformFeedbackBuffersEXT vkCmdBindTransformFeedbackBuffersEXT = 0; |
| PFN_vkCmdBeginTransformFeedbackEXT vkCmdBeginTransformFeedbackEXT = 0; |
| PFN_vkCmdEndTransformFeedbackEXT vkCmdEndTransformFeedbackEXT = 0; |
| PFN_vkCmdBeginQueryIndexedEXT vkCmdBeginQueryIndexedEXT = 0; |
| PFN_vkCmdEndQueryIndexedEXT vkCmdEndQueryIndexedEXT = 0; |
| PFN_vkCmdDrawIndirectByteCountEXT vkCmdDrawIndirectByteCountEXT = 0; |
| |
| //=== VK_NVX_binary_import === |
| PFN_vkCreateCuModuleNVX vkCreateCuModuleNVX = 0; |
| PFN_vkCreateCuFunctionNVX vkCreateCuFunctionNVX = 0; |
| PFN_vkDestroyCuModuleNVX vkDestroyCuModuleNVX = 0; |
| PFN_vkDestroyCuFunctionNVX vkDestroyCuFunctionNVX = 0; |
| PFN_vkCmdCuLaunchKernelNVX vkCmdCuLaunchKernelNVX = 0; |
| |
| //=== VK_NVX_image_view_handle === |
| PFN_vkGetImageViewHandleNVX vkGetImageViewHandleNVX = 0; |
| PFN_vkGetImageViewAddressNVX vkGetImageViewAddressNVX = 0; |
| |
| //=== VK_AMD_draw_indirect_count === |
| PFN_vkCmdDrawIndirectCountAMD vkCmdDrawIndirectCountAMD = 0; |
| PFN_vkCmdDrawIndexedIndirectCountAMD vkCmdDrawIndexedIndirectCountAMD = 0; |
| |
| //=== VK_AMD_shader_info === |
| PFN_vkGetShaderInfoAMD vkGetShaderInfoAMD = 0; |
| |
| //=== VK_KHR_dynamic_rendering === |
| PFN_vkCmdBeginRenderingKHR vkCmdBeginRenderingKHR = 0; |
| PFN_vkCmdEndRenderingKHR vkCmdEndRenderingKHR = 0; |
| |
| #if defined(VK_USE_PLATFORM_GGP) |
| //=== VK_GGP_stream_descriptor_surface === |
| PFN_vkCreateStreamDescriptorSurfaceGGP vkCreateStreamDescriptorSurfaceGGP = 0; |
| #else |
| PFN_dummy vkCreateStreamDescriptorSurfaceGGP_placeholder = 0; |
| #endif /*VK_USE_PLATFORM_GGP*/ |
| |
| //=== VK_NV_external_memory_capabilities === |
| PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV vkGetPhysicalDeviceExternalImageFormatPropertiesNV = 0; |
| |
| #if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_NV_external_memory_win32 === |
| PFN_vkGetMemoryWin32HandleNV vkGetMemoryWin32HandleNV = 0; |
| #else |
| PFN_dummy vkGetMemoryWin32HandleNV_placeholder = 0; |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_KHR_get_physical_device_properties2 === |
| PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR = 0; |
| PFN_vkGetPhysicalDeviceProperties2KHR vkGetPhysicalDeviceProperties2KHR = 0; |
| PFN_vkGetPhysicalDeviceFormatProperties2KHR vkGetPhysicalDeviceFormatProperties2KHR = 0; |
| PFN_vkGetPhysicalDeviceImageFormatProperties2KHR vkGetPhysicalDeviceImageFormatProperties2KHR = 0; |
| PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR vkGetPhysicalDeviceQueueFamilyProperties2KHR = 0; |
| PFN_vkGetPhysicalDeviceMemoryProperties2KHR vkGetPhysicalDeviceMemoryProperties2KHR = 0; |
| PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR vkGetPhysicalDeviceSparseImageFormatProperties2KHR = 0; |
| |
| //=== VK_KHR_device_group === |
| PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR vkGetDeviceGroupPeerMemoryFeaturesKHR = 0; |
| PFN_vkCmdSetDeviceMaskKHR vkCmdSetDeviceMaskKHR = 0; |
| PFN_vkCmdDispatchBaseKHR vkCmdDispatchBaseKHR = 0; |
| |
| #if defined(VK_USE_PLATFORM_VI_NN) |
| //=== VK_NN_vi_surface === |
| PFN_vkCreateViSurfaceNN vkCreateViSurfaceNN = 0; |
| #else |
| PFN_dummy vkCreateViSurfaceNN_placeholder = 0; |
| #endif /*VK_USE_PLATFORM_VI_NN*/ |
| |
| //=== VK_KHR_maintenance1 === |
| PFN_vkTrimCommandPoolKHR vkTrimCommandPoolKHR = 0; |
| |
| //=== VK_KHR_device_group_creation === |
| PFN_vkEnumeratePhysicalDeviceGroupsKHR vkEnumeratePhysicalDeviceGroupsKHR = 0; |
| |
| //=== VK_KHR_external_memory_capabilities === |
| PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR vkGetPhysicalDeviceExternalBufferPropertiesKHR = 0; |
| |
| #if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_KHR_external_memory_win32 === |
| PFN_vkGetMemoryWin32HandleKHR vkGetMemoryWin32HandleKHR = 0; |
| PFN_vkGetMemoryWin32HandlePropertiesKHR vkGetMemoryWin32HandlePropertiesKHR = 0; |
| #else |
| PFN_dummy vkGetMemoryWin32HandleKHR_placeholder = 0; |
| PFN_dummy vkGetMemoryWin32HandlePropertiesKHR_placeholder = 0; |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_KHR_external_memory_fd === |
| PFN_vkGetMemoryFdKHR vkGetMemoryFdKHR = 0; |
| PFN_vkGetMemoryFdPropertiesKHR vkGetMemoryFdPropertiesKHR = 0; |
| |
| //=== VK_KHR_external_semaphore_capabilities === |
| PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = 0; |
| |
| #if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_KHR_external_semaphore_win32 === |
| PFN_vkImportSemaphoreWin32HandleKHR vkImportSemaphoreWin32HandleKHR = 0; |
| PFN_vkGetSemaphoreWin32HandleKHR vkGetSemaphoreWin32HandleKHR = 0; |
| #else |
| PFN_dummy vkImportSemaphoreWin32HandleKHR_placeholder = 0; |
| PFN_dummy vkGetSemaphoreWin32HandleKHR_placeholder = 0; |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_KHR_external_semaphore_fd === |
| PFN_vkImportSemaphoreFdKHR vkImportSemaphoreFdKHR = 0; |
| PFN_vkGetSemaphoreFdKHR vkGetSemaphoreFdKHR = 0; |
| |
| //=== VK_KHR_push_descriptor === |
| PFN_vkCmdPushDescriptorSetKHR vkCmdPushDescriptorSetKHR = 0; |
| PFN_vkCmdPushDescriptorSetWithTemplateKHR vkCmdPushDescriptorSetWithTemplateKHR = 0; |
| |
| //=== VK_EXT_conditional_rendering === |
| PFN_vkCmdBeginConditionalRenderingEXT vkCmdBeginConditionalRenderingEXT = 0; |
| PFN_vkCmdEndConditionalRenderingEXT vkCmdEndConditionalRenderingEXT = 0; |
| |
| //=== VK_KHR_descriptor_update_template === |
| PFN_vkCreateDescriptorUpdateTemplateKHR vkCreateDescriptorUpdateTemplateKHR = 0; |
| PFN_vkDestroyDescriptorUpdateTemplateKHR vkDestroyDescriptorUpdateTemplateKHR = 0; |
| PFN_vkUpdateDescriptorSetWithTemplateKHR vkUpdateDescriptorSetWithTemplateKHR = 0; |
| |
| //=== VK_NV_clip_space_w_scaling === |
| PFN_vkCmdSetViewportWScalingNV vkCmdSetViewportWScalingNV = 0; |
| |
| //=== VK_EXT_direct_mode_display === |
| PFN_vkReleaseDisplayEXT vkReleaseDisplayEXT = 0; |
| |
| #if defined(VK_USE_PLATFORM_XLIB_XRANDR_EXT) |
| //=== VK_EXT_acquire_xlib_display === |
| PFN_vkAcquireXlibDisplayEXT vkAcquireXlibDisplayEXT = 0; |
| PFN_vkGetRandROutputDisplayEXT vkGetRandROutputDisplayEXT = 0; |
| #else |
| PFN_dummy vkAcquireXlibDisplayEXT_placeholder = 0; |
| PFN_dummy vkGetRandROutputDisplayEXT_placeholder = 0; |
| #endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ |
| |
| //=== VK_EXT_display_surface_counter === |
| PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT vkGetPhysicalDeviceSurfaceCapabilities2EXT = 0; |
| |
| //=== VK_EXT_display_control === |
| PFN_vkDisplayPowerControlEXT vkDisplayPowerControlEXT = 0; |
| PFN_vkRegisterDeviceEventEXT vkRegisterDeviceEventEXT = 0; |
| PFN_vkRegisterDisplayEventEXT vkRegisterDisplayEventEXT = 0; |
| PFN_vkGetSwapchainCounterEXT vkGetSwapchainCounterEXT = 0; |
| |
| //=== VK_GOOGLE_display_timing === |
| PFN_vkGetRefreshCycleDurationGOOGLE vkGetRefreshCycleDurationGOOGLE = 0; |
| PFN_vkGetPastPresentationTimingGOOGLE vkGetPastPresentationTimingGOOGLE = 0; |
| |
| //=== VK_EXT_discard_rectangles === |
| PFN_vkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXT = 0; |
| |
| //=== VK_EXT_hdr_metadata === |
| PFN_vkSetHdrMetadataEXT vkSetHdrMetadataEXT = 0; |
| |
| //=== VK_KHR_create_renderpass2 === |
| PFN_vkCreateRenderPass2KHR vkCreateRenderPass2KHR = 0; |
| PFN_vkCmdBeginRenderPass2KHR vkCmdBeginRenderPass2KHR = 0; |
| PFN_vkCmdNextSubpass2KHR vkCmdNextSubpass2KHR = 0; |
| PFN_vkCmdEndRenderPass2KHR vkCmdEndRenderPass2KHR = 0; |
| |
| //=== VK_KHR_shared_presentable_image === |
| PFN_vkGetSwapchainStatusKHR vkGetSwapchainStatusKHR = 0; |
| |
| //=== VK_KHR_external_fence_capabilities === |
| PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR vkGetPhysicalDeviceExternalFencePropertiesKHR = 0; |
| |
| #if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_KHR_external_fence_win32 === |
| PFN_vkImportFenceWin32HandleKHR vkImportFenceWin32HandleKHR = 0; |
| PFN_vkGetFenceWin32HandleKHR vkGetFenceWin32HandleKHR = 0; |
| #else |
| PFN_dummy vkImportFenceWin32HandleKHR_placeholder = 0; |
| PFN_dummy vkGetFenceWin32HandleKHR_placeholder = 0; |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_KHR_external_fence_fd === |
| PFN_vkImportFenceFdKHR vkImportFenceFdKHR = 0; |
| PFN_vkGetFenceFdKHR vkGetFenceFdKHR = 0; |
| |
| //=== VK_KHR_performance_query === |
| PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = 0; |
| PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = 0; |
| PFN_vkAcquireProfilingLockKHR vkAcquireProfilingLockKHR = 0; |
| PFN_vkReleaseProfilingLockKHR vkReleaseProfilingLockKHR = 0; |
| |
| //=== VK_KHR_get_surface_capabilities2 === |
| PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR vkGetPhysicalDeviceSurfaceCapabilities2KHR = 0; |
| PFN_vkGetPhysicalDeviceSurfaceFormats2KHR vkGetPhysicalDeviceSurfaceFormats2KHR = 0; |
| |
| //=== VK_KHR_get_display_properties2 === |
| PFN_vkGetPhysicalDeviceDisplayProperties2KHR vkGetPhysicalDeviceDisplayProperties2KHR = 0; |
| PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR vkGetPhysicalDeviceDisplayPlaneProperties2KHR = 0; |
| PFN_vkGetDisplayModeProperties2KHR vkGetDisplayModeProperties2KHR = 0; |
| PFN_vkGetDisplayPlaneCapabilities2KHR vkGetDisplayPlaneCapabilities2KHR = 0; |
| |
| #if defined(VK_USE_PLATFORM_IOS_MVK) |
| //=== VK_MVK_ios_surface === |
| PFN_vkCreateIOSSurfaceMVK vkCreateIOSSurfaceMVK = 0; |
| #else |
| PFN_dummy vkCreateIOSSurfaceMVK_placeholder = 0; |
| #endif /*VK_USE_PLATFORM_IOS_MVK*/ |
| |
| #if defined(VK_USE_PLATFORM_MACOS_MVK) |
| //=== VK_MVK_macos_surface === |
| PFN_vkCreateMacOSSurfaceMVK vkCreateMacOSSurfaceMVK = 0; |
| #else |
| PFN_dummy vkCreateMacOSSurfaceMVK_placeholder = 0; |
| #endif /*VK_USE_PLATFORM_MACOS_MVK*/ |
| |
| //=== VK_EXT_debug_utils === |
| PFN_vkSetDebugUtilsObjectNameEXT vkSetDebugUtilsObjectNameEXT = 0; |
| PFN_vkSetDebugUtilsObjectTagEXT vkSetDebugUtilsObjectTagEXT = 0; |
| PFN_vkQueueBeginDebugUtilsLabelEXT vkQueueBeginDebugUtilsLabelEXT = 0; |
| PFN_vkQueueEndDebugUtilsLabelEXT vkQueueEndDebugUtilsLabelEXT = 0; |
| PFN_vkQueueInsertDebugUtilsLabelEXT vkQueueInsertDebugUtilsLabelEXT = 0; |
| PFN_vkCmdBeginDebugUtilsLabelEXT vkCmdBeginDebugUtilsLabelEXT = 0; |
| PFN_vkCmdEndDebugUtilsLabelEXT vkCmdEndDebugUtilsLabelEXT = 0; |
| PFN_vkCmdInsertDebugUtilsLabelEXT vkCmdInsertDebugUtilsLabelEXT = 0; |
| PFN_vkCreateDebugUtilsMessengerEXT vkCreateDebugUtilsMessengerEXT = 0; |
| PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT = 0; |
| PFN_vkSubmitDebugUtilsMessageEXT vkSubmitDebugUtilsMessageEXT = 0; |
| |
| #if defined(VK_USE_PLATFORM_ANDROID_KHR) |
| //=== VK_ANDROID_external_memory_android_hardware_buffer === |
| PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID = 0; |
| PFN_vkGetMemoryAndroidHardwareBufferANDROID vkGetMemoryAndroidHardwareBufferANDROID = 0; |
| #else |
| PFN_dummy vkGetAndroidHardwareBufferPropertiesANDROID_placeholder = 0; |
| PFN_dummy vkGetMemoryAndroidHardwareBufferANDROID_placeholder = 0; |
| #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ |
| |
| //=== VK_EXT_sample_locations === |
| PFN_vkCmdSetSampleLocationsEXT vkCmdSetSampleLocationsEXT = 0; |
| PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT vkGetPhysicalDeviceMultisamplePropertiesEXT = 0; |
| |
| //=== VK_KHR_get_memory_requirements2 === |
| PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR = 0; |
| PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR = 0; |
| PFN_vkGetImageSparseMemoryRequirements2KHR vkGetImageSparseMemoryRequirements2KHR = 0; |
| |
| //=== VK_KHR_acceleration_structure === |
| PFN_vkCreateAccelerationStructureKHR vkCreateAccelerationStructureKHR = 0; |
| PFN_vkDestroyAccelerationStructureKHR vkDestroyAccelerationStructureKHR = 0; |
| PFN_vkCmdBuildAccelerationStructuresKHR vkCmdBuildAccelerationStructuresKHR = 0; |
| PFN_vkCmdBuildAccelerationStructuresIndirectKHR vkCmdBuildAccelerationStructuresIndirectKHR = 0; |
| PFN_vkBuildAccelerationStructuresKHR vkBuildAccelerationStructuresKHR = 0; |
| PFN_vkCopyAccelerationStructureKHR vkCopyAccelerationStructureKHR = 0; |
| PFN_vkCopyAccelerationStructureToMemoryKHR vkCopyAccelerationStructureToMemoryKHR = 0; |
| PFN_vkCopyMemoryToAccelerationStructureKHR vkCopyMemoryToAccelerationStructureKHR = 0; |
| PFN_vkWriteAccelerationStructuresPropertiesKHR vkWriteAccelerationStructuresPropertiesKHR = 0; |
| PFN_vkCmdCopyAccelerationStructureKHR vkCmdCopyAccelerationStructureKHR = 0; |
| PFN_vkCmdCopyAccelerationStructureToMemoryKHR vkCmdCopyAccelerationStructureToMemoryKHR = 0; |
| PFN_vkCmdCopyMemoryToAccelerationStructureKHR vkCmdCopyMemoryToAccelerationStructureKHR = 0; |
| PFN_vkGetAccelerationStructureDeviceAddressKHR vkGetAccelerationStructureDeviceAddressKHR = 0; |
| PFN_vkCmdWriteAccelerationStructuresPropertiesKHR vkCmdWriteAccelerationStructuresPropertiesKHR = 0; |
| PFN_vkGetDeviceAccelerationStructureCompatibilityKHR vkGetDeviceAccelerationStructureCompatibilityKHR = 0; |
| PFN_vkGetAccelerationStructureBuildSizesKHR vkGetAccelerationStructureBuildSizesKHR = 0; |
| |
| //=== VK_KHR_sampler_ycbcr_conversion === |
| PFN_vkCreateSamplerYcbcrConversionKHR vkCreateSamplerYcbcrConversionKHR = 0; |
| PFN_vkDestroySamplerYcbcrConversionKHR vkDestroySamplerYcbcrConversionKHR = 0; |
| |
| //=== VK_KHR_bind_memory2 === |
| PFN_vkBindBufferMemory2KHR vkBindBufferMemory2KHR = 0; |
| PFN_vkBindImageMemory2KHR vkBindImageMemory2KHR = 0; |
| |
| //=== VK_EXT_image_drm_format_modifier === |
| PFN_vkGetImageDrmFormatModifierPropertiesEXT vkGetImageDrmFormatModifierPropertiesEXT = 0; |
| |
| //=== VK_EXT_validation_cache === |
| PFN_vkCreateValidationCacheEXT vkCreateValidationCacheEXT = 0; |
| PFN_vkDestroyValidationCacheEXT vkDestroyValidationCacheEXT = 0; |
| PFN_vkMergeValidationCachesEXT vkMergeValidationCachesEXT = 0; |
| PFN_vkGetValidationCacheDataEXT vkGetValidationCacheDataEXT = 0; |
| |
| //=== VK_NV_shading_rate_image === |
| PFN_vkCmdBindShadingRateImageNV vkCmdBindShadingRateImageNV = 0; |
| PFN_vkCmdSetViewportShadingRatePaletteNV vkCmdSetViewportShadingRatePaletteNV = 0; |
| PFN_vkCmdSetCoarseSampleOrderNV vkCmdSetCoarseSampleOrderNV = 0; |
| |
| //=== VK_NV_ray_tracing === |
| PFN_vkCreateAccelerationStructureNV vkCreateAccelerationStructureNV = 0; |
| PFN_vkDestroyAccelerationStructureNV vkDestroyAccelerationStructureNV = 0; |
| PFN_vkGetAccelerationStructureMemoryRequirementsNV vkGetAccelerationStructureMemoryRequirementsNV = 0; |
| PFN_vkBindAccelerationStructureMemoryNV vkBindAccelerationStructureMemoryNV = 0; |
| PFN_vkCmdBuildAccelerationStructureNV vkCmdBuildAccelerationStructureNV = 0; |
| PFN_vkCmdCopyAccelerationStructureNV vkCmdCopyAccelerationStructureNV = 0; |
| PFN_vkCmdTraceRaysNV vkCmdTraceRaysNV = 0; |
| PFN_vkCreateRayTracingPipelinesNV vkCreateRayTracingPipelinesNV = 0; |
| PFN_vkGetRayTracingShaderGroupHandlesNV vkGetRayTracingShaderGroupHandlesNV = 0; |
| PFN_vkGetAccelerationStructureHandleNV vkGetAccelerationStructureHandleNV = 0; |
| PFN_vkCmdWriteAccelerationStructuresPropertiesNV vkCmdWriteAccelerationStructuresPropertiesNV = 0; |
| PFN_vkCompileDeferredNV vkCompileDeferredNV = 0; |
| |
| //=== VK_KHR_maintenance3 === |
| PFN_vkGetDescriptorSetLayoutSupportKHR vkGetDescriptorSetLayoutSupportKHR = 0; |
| |
| //=== VK_KHR_draw_indirect_count === |
| PFN_vkCmdDrawIndirectCountKHR vkCmdDrawIndirectCountKHR = 0; |
| PFN_vkCmdDrawIndexedIndirectCountKHR vkCmdDrawIndexedIndirectCountKHR = 0; |
| |
| //=== VK_EXT_external_memory_host === |
| PFN_vkGetMemoryHostPointerPropertiesEXT vkGetMemoryHostPointerPropertiesEXT = 0; |
| |
| //=== VK_AMD_buffer_marker === |
| PFN_vkCmdWriteBufferMarkerAMD vkCmdWriteBufferMarkerAMD = 0; |
| |
| //=== VK_EXT_calibrated_timestamps === |
| PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = 0; |
| PFN_vkGetCalibratedTimestampsEXT vkGetCalibratedTimestampsEXT = 0; |
| |
| //=== VK_NV_mesh_shader === |
| PFN_vkCmdDrawMeshTasksNV vkCmdDrawMeshTasksNV = 0; |
| PFN_vkCmdDrawMeshTasksIndirectNV vkCmdDrawMeshTasksIndirectNV = 0; |
| PFN_vkCmdDrawMeshTasksIndirectCountNV vkCmdDrawMeshTasksIndirectCountNV = 0; |
| |
| //=== VK_NV_scissor_exclusive === |
| PFN_vkCmdSetExclusiveScissorNV vkCmdSetExclusiveScissorNV = 0; |
| |
| //=== VK_NV_device_diagnostic_checkpoints === |
| PFN_vkCmdSetCheckpointNV vkCmdSetCheckpointNV = 0; |
| PFN_vkGetQueueCheckpointDataNV vkGetQueueCheckpointDataNV = 0; |
| |
| //=== VK_KHR_timeline_semaphore === |
| PFN_vkGetSemaphoreCounterValueKHR vkGetSemaphoreCounterValueKHR = 0; |
| PFN_vkWaitSemaphoresKHR vkWaitSemaphoresKHR = 0; |
| PFN_vkSignalSemaphoreKHR vkSignalSemaphoreKHR = 0; |
| |
| //=== VK_INTEL_performance_query === |
| PFN_vkInitializePerformanceApiINTEL vkInitializePerformanceApiINTEL = 0; |
| PFN_vkUninitializePerformanceApiINTEL vkUninitializePerformanceApiINTEL = 0; |
| PFN_vkCmdSetPerformanceMarkerINTEL vkCmdSetPerformanceMarkerINTEL = 0; |
| PFN_vkCmdSetPerformanceStreamMarkerINTEL vkCmdSetPerformanceStreamMarkerINTEL = 0; |
| PFN_vkCmdSetPerformanceOverrideINTEL vkCmdSetPerformanceOverrideINTEL = 0; |
| PFN_vkAcquirePerformanceConfigurationINTEL vkAcquirePerformanceConfigurationINTEL = 0; |
| PFN_vkReleasePerformanceConfigurationINTEL vkReleasePerformanceConfigurationINTEL = 0; |
| PFN_vkQueueSetPerformanceConfigurationINTEL vkQueueSetPerformanceConfigurationINTEL = 0; |
| PFN_vkGetPerformanceParameterINTEL vkGetPerformanceParameterINTEL = 0; |
| |
| //=== VK_AMD_display_native_hdr === |
| PFN_vkSetLocalDimmingAMD vkSetLocalDimmingAMD = 0; |
| |
| #if defined(VK_USE_PLATFORM_FUCHSIA) |
| //=== VK_FUCHSIA_imagepipe_surface === |
| PFN_vkCreateImagePipeSurfaceFUCHSIA vkCreateImagePipeSurfaceFUCHSIA = 0; |
| #else |
| PFN_dummy vkCreateImagePipeSurfaceFUCHSIA_placeholder = 0; |
| #endif /*VK_USE_PLATFORM_FUCHSIA*/ |
| |
| #if defined(VK_USE_PLATFORM_METAL_EXT) |
| //=== VK_EXT_metal_surface === |
| PFN_vkCreateMetalSurfaceEXT vkCreateMetalSurfaceEXT = 0; |
| #else |
| PFN_dummy vkCreateMetalSurfaceEXT_placeholder = 0; |
| #endif /*VK_USE_PLATFORM_METAL_EXT*/ |
| |
| //=== VK_KHR_fragment_shading_rate === |
| PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR vkGetPhysicalDeviceFragmentShadingRatesKHR = 0; |
| PFN_vkCmdSetFragmentShadingRateKHR vkCmdSetFragmentShadingRateKHR = 0; |
| |
| //=== VK_EXT_buffer_device_address === |
| PFN_vkGetBufferDeviceAddressEXT vkGetBufferDeviceAddressEXT = 0; |
| |
| //=== VK_EXT_tooling_info === |
| PFN_vkGetPhysicalDeviceToolPropertiesEXT vkGetPhysicalDeviceToolPropertiesEXT = 0; |
| |
| //=== VK_KHR_present_wait === |
| PFN_vkWaitForPresentKHR vkWaitForPresentKHR = 0; |
| |
| //=== VK_NV_cooperative_matrix === |
| PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = 0; |
| |
| //=== VK_NV_coverage_reduction_mode === |
| PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = 0; |
| |
| #if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_EXT_full_screen_exclusive === |
| PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT vkGetPhysicalDeviceSurfacePresentModes2EXT = 0; |
| PFN_vkAcquireFullScreenExclusiveModeEXT vkAcquireFullScreenExclusiveModeEXT = 0; |
| PFN_vkReleaseFullScreenExclusiveModeEXT vkReleaseFullScreenExclusiveModeEXT = 0; |
| PFN_vkGetDeviceGroupSurfacePresentModes2EXT vkGetDeviceGroupSurfacePresentModes2EXT = 0; |
| #else |
| PFN_dummy vkGetPhysicalDeviceSurfacePresentModes2EXT_placeholder = 0; |
| PFN_dummy vkAcquireFullScreenExclusiveModeEXT_placeholder = 0; |
| PFN_dummy vkReleaseFullScreenExclusiveModeEXT_placeholder = 0; |
| PFN_dummy vkGetDeviceGroupSurfacePresentModes2EXT_placeholder = 0; |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_EXT_headless_surface === |
| PFN_vkCreateHeadlessSurfaceEXT vkCreateHeadlessSurfaceEXT = 0; |
| |
| //=== VK_KHR_buffer_device_address === |
| PFN_vkGetBufferDeviceAddressKHR vkGetBufferDeviceAddressKHR = 0; |
| PFN_vkGetBufferOpaqueCaptureAddressKHR vkGetBufferOpaqueCaptureAddressKHR = 0; |
| PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR vkGetDeviceMemoryOpaqueCaptureAddressKHR = 0; |
| |
| //=== VK_EXT_line_rasterization === |
| PFN_vkCmdSetLineStippleEXT vkCmdSetLineStippleEXT = 0; |
| |
| //=== VK_EXT_host_query_reset === |
| PFN_vkResetQueryPoolEXT vkResetQueryPoolEXT = 0; |
| |
| //=== VK_EXT_extended_dynamic_state === |
| PFN_vkCmdSetCullModeEXT vkCmdSetCullModeEXT = 0; |
| PFN_vkCmdSetFrontFaceEXT vkCmdSetFrontFaceEXT = 0; |
| PFN_vkCmdSetPrimitiveTopologyEXT vkCmdSetPrimitiveTopologyEXT = 0; |
| PFN_vkCmdSetViewportWithCountEXT vkCmdSetViewportWithCountEXT = 0; |
| PFN_vkCmdSetScissorWithCountEXT vkCmdSetScissorWithCountEXT = 0; |
| PFN_vkCmdBindVertexBuffers2EXT vkCmdBindVertexBuffers2EXT = 0; |
| PFN_vkCmdSetDepthTestEnableEXT vkCmdSetDepthTestEnableEXT = 0; |
| PFN_vkCmdSetDepthWriteEnableEXT vkCmdSetDepthWriteEnableEXT = 0; |
| PFN_vkCmdSetDepthCompareOpEXT vkCmdSetDepthCompareOpEXT = 0; |
| PFN_vkCmdSetDepthBoundsTestEnableEXT vkCmdSetDepthBoundsTestEnableEXT = 0; |
| PFN_vkCmdSetStencilTestEnableEXT vkCmdSetStencilTestEnableEXT = 0; |
| PFN_vkCmdSetStencilOpEXT vkCmdSetStencilOpEXT = 0; |
| |
| //=== VK_KHR_deferred_host_operations === |
| PFN_vkCreateDeferredOperationKHR vkCreateDeferredOperationKHR = 0; |
| PFN_vkDestroyDeferredOperationKHR vkDestroyDeferredOperationKHR = 0; |
| PFN_vkGetDeferredOperationMaxConcurrencyKHR vkGetDeferredOperationMaxConcurrencyKHR = 0; |
| PFN_vkGetDeferredOperationResultKHR vkGetDeferredOperationResultKHR = 0; |
| PFN_vkDeferredOperationJoinKHR vkDeferredOperationJoinKHR = 0; |
| |
| //=== VK_KHR_pipeline_executable_properties === |
| PFN_vkGetPipelineExecutablePropertiesKHR vkGetPipelineExecutablePropertiesKHR = 0; |
| PFN_vkGetPipelineExecutableStatisticsKHR vkGetPipelineExecutableStatisticsKHR = 0; |
| PFN_vkGetPipelineExecutableInternalRepresentationsKHR vkGetPipelineExecutableInternalRepresentationsKHR = 0; |
| |
| //=== VK_NV_device_generated_commands === |
| PFN_vkGetGeneratedCommandsMemoryRequirementsNV vkGetGeneratedCommandsMemoryRequirementsNV = 0; |
| PFN_vkCmdPreprocessGeneratedCommandsNV vkCmdPreprocessGeneratedCommandsNV = 0; |
| PFN_vkCmdExecuteGeneratedCommandsNV vkCmdExecuteGeneratedCommandsNV = 0; |
| PFN_vkCmdBindPipelineShaderGroupNV vkCmdBindPipelineShaderGroupNV = 0; |
| PFN_vkCreateIndirectCommandsLayoutNV vkCreateIndirectCommandsLayoutNV = 0; |
| PFN_vkDestroyIndirectCommandsLayoutNV vkDestroyIndirectCommandsLayoutNV = 0; |
| |
| //=== VK_EXT_acquire_drm_display === |
| PFN_vkAcquireDrmDisplayEXT vkAcquireDrmDisplayEXT = 0; |
| PFN_vkGetDrmDisplayEXT vkGetDrmDisplayEXT = 0; |
| |
| //=== VK_EXT_private_data === |
| PFN_vkCreatePrivateDataSlotEXT vkCreatePrivateDataSlotEXT = 0; |
| PFN_vkDestroyPrivateDataSlotEXT vkDestroyPrivateDataSlotEXT = 0; |
| PFN_vkSetPrivateDataEXT vkSetPrivateDataEXT = 0; |
| PFN_vkGetPrivateDataEXT vkGetPrivateDataEXT = 0; |
| |
| #if defined(VK_ENABLE_BETA_EXTENSIONS) |
| //=== VK_KHR_video_encode_queue === |
| PFN_vkCmdEncodeVideoKHR vkCmdEncodeVideoKHR = 0; |
| #else |
| PFN_dummy vkCmdEncodeVideoKHR_placeholder = 0; |
| #endif /*VK_ENABLE_BETA_EXTENSIONS*/ |
| |
| //=== VK_KHR_synchronization2 === |
| PFN_vkCmdSetEvent2KHR vkCmdSetEvent2KHR = 0; |
| PFN_vkCmdResetEvent2KHR vkCmdResetEvent2KHR = 0; |
| PFN_vkCmdWaitEvents2KHR vkCmdWaitEvents2KHR = 0; |
| PFN_vkCmdPipelineBarrier2KHR vkCmdPipelineBarrier2KHR = 0; |
| PFN_vkCmdWriteTimestamp2KHR vkCmdWriteTimestamp2KHR = 0; |
| PFN_vkQueueSubmit2KHR vkQueueSubmit2KHR = 0; |
| PFN_vkCmdWriteBufferMarker2AMD vkCmdWriteBufferMarker2AMD = 0; |
| PFN_vkGetQueueCheckpointData2NV vkGetQueueCheckpointData2NV = 0; |
| |
| //=== VK_NV_fragment_shading_rate_enums === |
| PFN_vkCmdSetFragmentShadingRateEnumNV vkCmdSetFragmentShadingRateEnumNV = 0; |
| |
| //=== VK_KHR_copy_commands2 === |
| PFN_vkCmdCopyBuffer2KHR vkCmdCopyBuffer2KHR = 0; |
| PFN_vkCmdCopyImage2KHR vkCmdCopyImage2KHR = 0; |
| PFN_vkCmdCopyBufferToImage2KHR vkCmdCopyBufferToImage2KHR = 0; |
| PFN_vkCmdCopyImageToBuffer2KHR vkCmdCopyImageToBuffer2KHR = 0; |
| PFN_vkCmdBlitImage2KHR vkCmdBlitImage2KHR = 0; |
| PFN_vkCmdResolveImage2KHR vkCmdResolveImage2KHR = 0; |
| |
| #if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_NV_acquire_winrt_display === |
| PFN_vkAcquireWinrtDisplayNV vkAcquireWinrtDisplayNV = 0; |
| PFN_vkGetWinrtDisplayNV vkGetWinrtDisplayNV = 0; |
| #else |
| PFN_dummy vkAcquireWinrtDisplayNV_placeholder = 0; |
| PFN_dummy vkGetWinrtDisplayNV_placeholder = 0; |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| #if defined(VK_USE_PLATFORM_DIRECTFB_EXT) |
| //=== VK_EXT_directfb_surface === |
| PFN_vkCreateDirectFBSurfaceEXT vkCreateDirectFBSurfaceEXT = 0; |
| PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT vkGetPhysicalDeviceDirectFBPresentationSupportEXT = 0; |
| #else |
| PFN_dummy vkCreateDirectFBSurfaceEXT_placeholder = 0; |
| PFN_dummy vkGetPhysicalDeviceDirectFBPresentationSupportEXT_placeholder = 0; |
| #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ |
| |
| //=== VK_KHR_ray_tracing_pipeline === |
| PFN_vkCmdTraceRaysKHR vkCmdTraceRaysKHR = 0; |
| PFN_vkCreateRayTracingPipelinesKHR vkCreateRayTracingPipelinesKHR = 0; |
| PFN_vkGetRayTracingShaderGroupHandlesKHR vkGetRayTracingShaderGroupHandlesKHR = 0; |
| PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = 0; |
| PFN_vkCmdTraceRaysIndirectKHR vkCmdTraceRaysIndirectKHR = 0; |
| PFN_vkGetRayTracingShaderGroupStackSizeKHR vkGetRayTracingShaderGroupStackSizeKHR = 0; |
| PFN_vkCmdSetRayTracingPipelineStackSizeKHR vkCmdSetRayTracingPipelineStackSizeKHR = 0; |
| |
| //=== VK_EXT_vertex_input_dynamic_state === |
| PFN_vkCmdSetVertexInputEXT vkCmdSetVertexInputEXT = 0; |
| |
| #if defined(VK_USE_PLATFORM_FUCHSIA) |
| //=== VK_FUCHSIA_external_memory === |
| PFN_vkGetMemoryZirconHandleFUCHSIA vkGetMemoryZirconHandleFUCHSIA = 0; |
| PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA vkGetMemoryZirconHandlePropertiesFUCHSIA = 0; |
| #else |
| PFN_dummy vkGetMemoryZirconHandleFUCHSIA_placeholder = 0; |
| PFN_dummy vkGetMemoryZirconHandlePropertiesFUCHSIA_placeholder = 0; |
| #endif /*VK_USE_PLATFORM_FUCHSIA*/ |
| |
| #if defined(VK_USE_PLATFORM_FUCHSIA) |
| //=== VK_FUCHSIA_external_semaphore === |
| PFN_vkImportSemaphoreZirconHandleFUCHSIA vkImportSemaphoreZirconHandleFUCHSIA = 0; |
| PFN_vkGetSemaphoreZirconHandleFUCHSIA vkGetSemaphoreZirconHandleFUCHSIA = 0; |
| #else |
| PFN_dummy vkImportSemaphoreZirconHandleFUCHSIA_placeholder = 0; |
| PFN_dummy vkGetSemaphoreZirconHandleFUCHSIA_placeholder = 0; |
| #endif /*VK_USE_PLATFORM_FUCHSIA*/ |
| |
| #if defined(VK_USE_PLATFORM_FUCHSIA) |
| //=== VK_FUCHSIA_buffer_collection === |
| PFN_vkCreateBufferCollectionFUCHSIA vkCreateBufferCollectionFUCHSIA = 0; |
| PFN_vkSetBufferCollectionImageConstraintsFUCHSIA vkSetBufferCollectionImageConstraintsFUCHSIA = 0; |
| PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA vkSetBufferCollectionBufferConstraintsFUCHSIA = 0; |
| PFN_vkDestroyBufferCollectionFUCHSIA vkDestroyBufferCollectionFUCHSIA = 0; |
| PFN_vkGetBufferCollectionPropertiesFUCHSIA vkGetBufferCollectionPropertiesFUCHSIA = 0; |
| #else |
| PFN_dummy vkCreateBufferCollectionFUCHSIA_placeholder = 0; |
| PFN_dummy vkSetBufferCollectionImageConstraintsFUCHSIA_placeholder = 0; |
| PFN_dummy vkSetBufferCollectionBufferConstraintsFUCHSIA_placeholder = 0; |
| PFN_dummy vkDestroyBufferCollectionFUCHSIA_placeholder = 0; |
| PFN_dummy vkGetBufferCollectionPropertiesFUCHSIA_placeholder = 0; |
| #endif /*VK_USE_PLATFORM_FUCHSIA*/ |
| |
| //=== VK_HUAWEI_subpass_shading === |
| PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = 0; |
| PFN_vkCmdSubpassShadingHUAWEI vkCmdSubpassShadingHUAWEI = 0; |
| |
| //=== VK_HUAWEI_invocation_mask === |
| PFN_vkCmdBindInvocationMaskHUAWEI vkCmdBindInvocationMaskHUAWEI = 0; |
| |
| //=== VK_NV_external_memory_rdma === |
| PFN_vkGetMemoryRemoteAddressNV vkGetMemoryRemoteAddressNV = 0; |
| |
| //=== VK_EXT_extended_dynamic_state2 === |
| PFN_vkCmdSetPatchControlPointsEXT vkCmdSetPatchControlPointsEXT = 0; |
| PFN_vkCmdSetRasterizerDiscardEnableEXT vkCmdSetRasterizerDiscardEnableEXT = 0; |
| PFN_vkCmdSetDepthBiasEnableEXT vkCmdSetDepthBiasEnableEXT = 0; |
| PFN_vkCmdSetLogicOpEXT vkCmdSetLogicOpEXT = 0; |
| PFN_vkCmdSetPrimitiveRestartEnableEXT vkCmdSetPrimitiveRestartEnableEXT = 0; |
| |
| #if defined(VK_USE_PLATFORM_SCREEN_QNX) |
| //=== VK_QNX_screen_surface === |
| PFN_vkCreateScreenSurfaceQNX vkCreateScreenSurfaceQNX = 0; |
| PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX vkGetPhysicalDeviceScreenPresentationSupportQNX = 0; |
| #else |
| PFN_dummy vkCreateScreenSurfaceQNX_placeholder = 0; |
| PFN_dummy vkGetPhysicalDeviceScreenPresentationSupportQNX_placeholder = 0; |
| #endif /*VK_USE_PLATFORM_SCREEN_QNX*/ |
| |
| //=== VK_EXT_color_write_enable === |
| PFN_vkCmdSetColorWriteEnableEXT vkCmdSetColorWriteEnableEXT = 0; |
| |
| //=== VK_EXT_multi_draw === |
| PFN_vkCmdDrawMultiEXT vkCmdDrawMultiEXT = 0; |
| PFN_vkCmdDrawMultiIndexedEXT vkCmdDrawMultiIndexedEXT = 0; |
| |
| //=== VK_EXT_pageable_device_local_memory === |
| PFN_vkSetDeviceMemoryPriorityEXT vkSetDeviceMemoryPriorityEXT = 0; |
| |
| //=== VK_KHR_maintenance4 === |
| PFN_vkGetDeviceBufferMemoryRequirementsKHR vkGetDeviceBufferMemoryRequirementsKHR = 0; |
| PFN_vkGetDeviceImageMemoryRequirementsKHR vkGetDeviceImageMemoryRequirementsKHR = 0; |
| PFN_vkGetDeviceImageSparseMemoryRequirementsKHR vkGetDeviceImageSparseMemoryRequirementsKHR = 0; |
| |
| //=== VK_VALVE_descriptor_set_host_mapping === |
| PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE vkGetDescriptorSetLayoutHostMappingInfoVALVE = 0; |
| PFN_vkGetDescriptorSetHostMappingVALVE vkGetDescriptorSetHostMappingVALVE = 0; |
| |
| public: |
| DispatchLoaderDynamic() VULKAN_HPP_NOEXCEPT = default; |
| DispatchLoaderDynamic(DispatchLoaderDynamic const &rhs) VULKAN_HPP_NOEXCEPT = default; |
| |
| #if !defined(VK_NO_PROTOTYPES) |
| // This interface is designed to be used for per-device function pointers in combination with a linked vulkan library. |
| template<typename DynamicLoader> |
| void init(VULKAN_HPP_NAMESPACE::Instance const &instance, VULKAN_HPP_NAMESPACE::Device const &device, DynamicLoader const &dl) VULKAN_HPP_NOEXCEPT |
| { |
| PFN_vkGetInstanceProcAddr getInstanceProcAddr = dl.template getProcAddress<PFN_vkGetInstanceProcAddr>("vkGetInstanceProcAddr"); |
| PFN_vkGetDeviceProcAddr getDeviceProcAddr = dl.template getProcAddress<PFN_vkGetDeviceProcAddr>("vkGetDeviceProcAddr"); |
| init(static_cast<VkInstance>(instance), getInstanceProcAddr, static_cast<VkDevice>(device), device ? getDeviceProcAddr : nullptr); |
| } |
| |
| // This interface is designed to be used for per-device function pointers in combination with a linked vulkan library. |
| template<typename DynamicLoader |
| # if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL |
| = VULKAN_HPP_NAMESPACE::DynamicLoader |
| # endif |
| > |
| void init(VULKAN_HPP_NAMESPACE::Instance const &instance, VULKAN_HPP_NAMESPACE::Device const &device) VULKAN_HPP_NOEXCEPT |
| { |
| static DynamicLoader dl; |
| init(instance, device, dl); |
| } |
| #endif // !defined( VK_NO_PROTOTYPES ) |
| |
| DispatchLoaderDynamic(PFN_vkGetInstanceProcAddr getInstanceProcAddr) VULKAN_HPP_NOEXCEPT |
| { |
| init(getInstanceProcAddr); |
| } |
| |
| void init(PFN_vkGetInstanceProcAddr getInstanceProcAddr) VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(getInstanceProcAddr); |
| |
| vkGetInstanceProcAddr = getInstanceProcAddr; |
| |
| //=== VK_VERSION_1_0 === |
| vkCreateInstance = PFN_vkCreateInstance(vkGetInstanceProcAddr(NULL, "vkCreateInstance")); |
| vkEnumerateInstanceExtensionProperties = |
| PFN_vkEnumerateInstanceExtensionProperties(vkGetInstanceProcAddr(NULL, "vkEnumerateInstanceExtensionProperties")); |
| vkEnumerateInstanceLayerProperties = PFN_vkEnumerateInstanceLayerProperties(vkGetInstanceProcAddr(NULL, "vkEnumerateInstanceLayerProperties")); |
| |
| //=== VK_VERSION_1_1 === |
| vkEnumerateInstanceVersion = PFN_vkEnumerateInstanceVersion(vkGetInstanceProcAddr(NULL, "vkEnumerateInstanceVersion")); |
| } |
| |
| // This interface does not require a linked vulkan library. |
| DispatchLoaderDynamic(VkInstance instance, |
| PFN_vkGetInstanceProcAddr getInstanceProcAddr, |
| VkDevice device = {}, |
| PFN_vkGetDeviceProcAddr getDeviceProcAddr = nullptr) VULKAN_HPP_NOEXCEPT |
| { |
| init(instance, getInstanceProcAddr, device, getDeviceProcAddr); |
| } |
| |
| // This interface does not require a linked vulkan library. |
| void init(VkInstance instance, |
| PFN_vkGetInstanceProcAddr getInstanceProcAddr, |
| VkDevice device = {}, |
| PFN_vkGetDeviceProcAddr /*getDeviceProcAddr*/ = nullptr) VULKAN_HPP_NOEXCEPT |
| { |
| VULKAN_HPP_ASSERT(instance && getInstanceProcAddr); |
| vkGetInstanceProcAddr = getInstanceProcAddr; |
| init(VULKAN_HPP_NAMESPACE::Instance(instance)); |
| if(device) |
| { |
| init(VULKAN_HPP_NAMESPACE::Device(device)); |
| } |
| } |
| |
| void init(VULKAN_HPP_NAMESPACE::Instance instanceCpp) VULKAN_HPP_NOEXCEPT |
| { |
| VkInstance instance = static_cast<VkInstance>(instanceCpp); |
| |
| //=== VK_VERSION_1_0 === |
| vkDestroyInstance = PFN_vkDestroyInstance(vkGetInstanceProcAddr(instance, "vkDestroyInstance")); |
| vkEnumeratePhysicalDevices = PFN_vkEnumeratePhysicalDevices(vkGetInstanceProcAddr(instance, "vkEnumeratePhysicalDevices")); |
| vkGetPhysicalDeviceFeatures = PFN_vkGetPhysicalDeviceFeatures(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFeatures")); |
| vkGetPhysicalDeviceFormatProperties = PFN_vkGetPhysicalDeviceFormatProperties(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFormatProperties")); |
| vkGetPhysicalDeviceImageFormatProperties = |
| PFN_vkGetPhysicalDeviceImageFormatProperties(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceImageFormatProperties")); |
| vkGetPhysicalDeviceProperties = PFN_vkGetPhysicalDeviceProperties(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceProperties")); |
| vkGetPhysicalDeviceQueueFamilyProperties = |
| PFN_vkGetPhysicalDeviceQueueFamilyProperties(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceQueueFamilyProperties")); |
| vkGetPhysicalDeviceMemoryProperties = PFN_vkGetPhysicalDeviceMemoryProperties(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceMemoryProperties")); |
| vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr(vkGetInstanceProcAddr(instance, "vkGetDeviceProcAddr")); |
| vkCreateDevice = PFN_vkCreateDevice(vkGetInstanceProcAddr(instance, "vkCreateDevice")); |
| vkDestroyDevice = PFN_vkDestroyDevice(vkGetInstanceProcAddr(instance, "vkDestroyDevice")); |
| vkEnumerateDeviceExtensionProperties = |
| PFN_vkEnumerateDeviceExtensionProperties(vkGetInstanceProcAddr(instance, "vkEnumerateDeviceExtensionProperties")); |
| vkEnumerateDeviceLayerProperties = PFN_vkEnumerateDeviceLayerProperties(vkGetInstanceProcAddr(instance, "vkEnumerateDeviceLayerProperties")); |
| vkGetDeviceQueue = PFN_vkGetDeviceQueue(vkGetInstanceProcAddr(instance, "vkGetDeviceQueue")); |
| vkQueueSubmit = PFN_vkQueueSubmit(vkGetInstanceProcAddr(instance, "vkQueueSubmit")); |
| vkQueueWaitIdle = PFN_vkQueueWaitIdle(vkGetInstanceProcAddr(instance, "vkQueueWaitIdle")); |
| vkDeviceWaitIdle = PFN_vkDeviceWaitIdle(vkGetInstanceProcAddr(instance, "vkDeviceWaitIdle")); |
| vkAllocateMemory = PFN_vkAllocateMemory(vkGetInstanceProcAddr(instance, "vkAllocateMemory")); |
| vkFreeMemory = PFN_vkFreeMemory(vkGetInstanceProcAddr(instance, "vkFreeMemory")); |
| vkMapMemory = PFN_vkMapMemory(vkGetInstanceProcAddr(instance, "vkMapMemory")); |
| vkUnmapMemory = PFN_vkUnmapMemory(vkGetInstanceProcAddr(instance, "vkUnmapMemory")); |
| vkFlushMappedMemoryRanges = PFN_vkFlushMappedMemoryRanges(vkGetInstanceProcAddr(instance, "vkFlushMappedMemoryRanges")); |
| vkInvalidateMappedMemoryRanges = PFN_vkInvalidateMappedMemoryRanges(vkGetInstanceProcAddr(instance, "vkInvalidateMappedMemoryRanges")); |
| vkGetDeviceMemoryCommitment = PFN_vkGetDeviceMemoryCommitment(vkGetInstanceProcAddr(instance, "vkGetDeviceMemoryCommitment")); |
| vkBindBufferMemory = PFN_vkBindBufferMemory(vkGetInstanceProcAddr(instance, "vkBindBufferMemory")); |
| vkBindImageMemory = PFN_vkBindImageMemory(vkGetInstanceProcAddr(instance, "vkBindImageMemory")); |
| vkGetBufferMemoryRequirements = PFN_vkGetBufferMemoryRequirements(vkGetInstanceProcAddr(instance, "vkGetBufferMemoryRequirements")); |
| vkGetImageMemoryRequirements = PFN_vkGetImageMemoryRequirements(vkGetInstanceProcAddr(instance, "vkGetImageMemoryRequirements")); |
| vkGetImageSparseMemoryRequirements = PFN_vkGetImageSparseMemoryRequirements(vkGetInstanceProcAddr(instance, "vkGetImageSparseMemoryRequirements")); |
| vkGetPhysicalDeviceSparseImageFormatProperties = |
| PFN_vkGetPhysicalDeviceSparseImageFormatProperties(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSparseImageFormatProperties")); |
| vkQueueBindSparse = PFN_vkQueueBindSparse(vkGetInstanceProcAddr(instance, "vkQueueBindSparse")); |
| vkCreateFence = PFN_vkCreateFence(vkGetInstanceProcAddr(instance, "vkCreateFence")); |
| vkDestroyFence = PFN_vkDestroyFence(vkGetInstanceProcAddr(instance, "vkDestroyFence")); |
| vkResetFences = PFN_vkResetFences(vkGetInstanceProcAddr(instance, "vkResetFences")); |
| vkGetFenceStatus = PFN_vkGetFenceStatus(vkGetInstanceProcAddr(instance, "vkGetFenceStatus")); |
| vkWaitForFences = PFN_vkWaitForFences(vkGetInstanceProcAddr(instance, "vkWaitForFences")); |
| vkCreateSemaphore = PFN_vkCreateSemaphore(vkGetInstanceProcAddr(instance, "vkCreateSemaphore")); |
| vkDestroySemaphore = PFN_vkDestroySemaphore(vkGetInstanceProcAddr(instance, "vkDestroySemaphore")); |
| vkCreateEvent = PFN_vkCreateEvent(vkGetInstanceProcAddr(instance, "vkCreateEvent")); |
| vkDestroyEvent = PFN_vkDestroyEvent(vkGetInstanceProcAddr(instance, "vkDestroyEvent")); |
| vkGetEventStatus = PFN_vkGetEventStatus(vkGetInstanceProcAddr(instance, "vkGetEventStatus")); |
| vkSetEvent = PFN_vkSetEvent(vkGetInstanceProcAddr(instance, "vkSetEvent")); |
| vkResetEvent = PFN_vkResetEvent(vkGetInstanceProcAddr(instance, "vkResetEvent")); |
| vkCreateQueryPool = PFN_vkCreateQueryPool(vkGetInstanceProcAddr(instance, "vkCreateQueryPool")); |
| vkDestroyQueryPool = PFN_vkDestroyQueryPool(vkGetInstanceProcAddr(instance, "vkDestroyQueryPool")); |
| vkGetQueryPoolResults = PFN_vkGetQueryPoolResults(vkGetInstanceProcAddr(instance, "vkGetQueryPoolResults")); |
| vkCreateBuffer = PFN_vkCreateBuffer(vkGetInstanceProcAddr(instance, "vkCreateBuffer")); |
| vkDestroyBuffer = PFN_vkDestroyBuffer(vkGetInstanceProcAddr(instance, "vkDestroyBuffer")); |
| vkCreateBufferView = PFN_vkCreateBufferView(vkGetInstanceProcAddr(instance, "vkCreateBufferView")); |
| vkDestroyBufferView = PFN_vkDestroyBufferView(vkGetInstanceProcAddr(instance, "vkDestroyBufferView")); |
| vkCreateImage = PFN_vkCreateImage(vkGetInstanceProcAddr(instance, "vkCreateImage")); |
| vkDestroyImage = PFN_vkDestroyImage(vkGetInstanceProcAddr(instance, "vkDestroyImage")); |
| vkGetImageSubresourceLayout = PFN_vkGetImageSubresourceLayout(vkGetInstanceProcAddr(instance, "vkGetImageSubresourceLayout")); |
| vkCreateImageView = PFN_vkCreateImageView(vkGetInstanceProcAddr(instance, "vkCreateImageView")); |
| vkDestroyImageView = PFN_vkDestroyImageView(vkGetInstanceProcAddr(instance, "vkDestroyImageView")); |
| vkCreateShaderModule = PFN_vkCreateShaderModule(vkGetInstanceProcAddr(instance, "vkCreateShaderModule")); |
| vkDestroyShaderModule = PFN_vkDestroyShaderModule(vkGetInstanceProcAddr(instance, "vkDestroyShaderModule")); |
| vkCreatePipelineCache = PFN_vkCreatePipelineCache(vkGetInstanceProcAddr(instance, "vkCreatePipelineCache")); |
| vkDestroyPipelineCache = PFN_vkDestroyPipelineCache(vkGetInstanceProcAddr(instance, "vkDestroyPipelineCache")); |
| vkGetPipelineCacheData = PFN_vkGetPipelineCacheData(vkGetInstanceProcAddr(instance, "vkGetPipelineCacheData")); |
| vkMergePipelineCaches = PFN_vkMergePipelineCaches(vkGetInstanceProcAddr(instance, "vkMergePipelineCaches")); |
| vkCreateGraphicsPipelines = PFN_vkCreateGraphicsPipelines(vkGetInstanceProcAddr(instance, "vkCreateGraphicsPipelines")); |
| vkCreateComputePipelines = PFN_vkCreateComputePipelines(vkGetInstanceProcAddr(instance, "vkCreateComputePipelines")); |
| vkDestroyPipeline = PFN_vkDestroyPipeline(vkGetInstanceProcAddr(instance, "vkDestroyPipeline")); |
| vkCreatePipelineLayout = PFN_vkCreatePipelineLayout(vkGetInstanceProcAddr(instance, "vkCreatePipelineLayout")); |
| vkDestroyPipelineLayout = PFN_vkDestroyPipelineLayout(vkGetInstanceProcAddr(instance, "vkDestroyPipelineLayout")); |
| vkCreateSampler = PFN_vkCreateSampler(vkGetInstanceProcAddr(instance, "vkCreateSampler")); |
| vkDestroySampler = PFN_vkDestroySampler(vkGetInstanceProcAddr(instance, "vkDestroySampler")); |
| vkCreateDescriptorSetLayout = PFN_vkCreateDescriptorSetLayout(vkGetInstanceProcAddr(instance, "vkCreateDescriptorSetLayout")); |
| vkDestroyDescriptorSetLayout = PFN_vkDestroyDescriptorSetLayout(vkGetInstanceProcAddr(instance, "vkDestroyDescriptorSetLayout")); |
| vkCreateDescriptorPool = PFN_vkCreateDescriptorPool(vkGetInstanceProcAddr(instance, "vkCreateDescriptorPool")); |
| vkDestroyDescriptorPool = PFN_vkDestroyDescriptorPool(vkGetInstanceProcAddr(instance, "vkDestroyDescriptorPool")); |
| vkResetDescriptorPool = PFN_vkResetDescriptorPool(vkGetInstanceProcAddr(instance, "vkResetDescriptorPool")); |
| vkAllocateDescriptorSets = PFN_vkAllocateDescriptorSets(vkGetInstanceProcAddr(instance, "vkAllocateDescriptorSets")); |
| vkFreeDescriptorSets = PFN_vkFreeDescriptorSets(vkGetInstanceProcAddr(instance, "vkFreeDescriptorSets")); |
| vkUpdateDescriptorSets = PFN_vkUpdateDescriptorSets(vkGetInstanceProcAddr(instance, "vkUpdateDescriptorSets")); |
| vkCreateFramebuffer = PFN_vkCreateFramebuffer(vkGetInstanceProcAddr(instance, "vkCreateFramebuffer")); |
| vkDestroyFramebuffer = PFN_vkDestroyFramebuffer(vkGetInstanceProcAddr(instance, "vkDestroyFramebuffer")); |
| vkCreateRenderPass = PFN_vkCreateRenderPass(vkGetInstanceProcAddr(instance, "vkCreateRenderPass")); |
| vkDestroyRenderPass = PFN_vkDestroyRenderPass(vkGetInstanceProcAddr(instance, "vkDestroyRenderPass")); |
| vkGetRenderAreaGranularity = PFN_vkGetRenderAreaGranularity(vkGetInstanceProcAddr(instance, "vkGetRenderAreaGranularity")); |
| vkCreateCommandPool = PFN_vkCreateCommandPool(vkGetInstanceProcAddr(instance, "vkCreateCommandPool")); |
| vkDestroyCommandPool = PFN_vkDestroyCommandPool(vkGetInstanceProcAddr(instance, "vkDestroyCommandPool")); |
| vkResetCommandPool = PFN_vkResetCommandPool(vkGetInstanceProcAddr(instance, "vkResetCommandPool")); |
| vkAllocateCommandBuffers = PFN_vkAllocateCommandBuffers(vkGetInstanceProcAddr(instance, "vkAllocateCommandBuffers")); |
| vkFreeCommandBuffers = PFN_vkFreeCommandBuffers(vkGetInstanceProcAddr(instance, "vkFreeCommandBuffers")); |
| vkBeginCommandBuffer = PFN_vkBeginCommandBuffer(vkGetInstanceProcAddr(instance, "vkBeginCommandBuffer")); |
| vkEndCommandBuffer = PFN_vkEndCommandBuffer(vkGetInstanceProcAddr(instance, "vkEndCommandBuffer")); |
| vkResetCommandBuffer = PFN_vkResetCommandBuffer(vkGetInstanceProcAddr(instance, "vkResetCommandBuffer")); |
| vkCmdBindPipeline = PFN_vkCmdBindPipeline(vkGetInstanceProcAddr(instance, "vkCmdBindPipeline")); |
| vkCmdSetViewport = PFN_vkCmdSetViewport(vkGetInstanceProcAddr(instance, "vkCmdSetViewport")); |
| vkCmdSetScissor = PFN_vkCmdSetScissor(vkGetInstanceProcAddr(instance, "vkCmdSetScissor")); |
| vkCmdSetLineWidth = PFN_vkCmdSetLineWidth(vkGetInstanceProcAddr(instance, "vkCmdSetLineWidth")); |
| vkCmdSetDepthBias = PFN_vkCmdSetDepthBias(vkGetInstanceProcAddr(instance, "vkCmdSetDepthBias")); |
| vkCmdSetBlendConstants = PFN_vkCmdSetBlendConstants(vkGetInstanceProcAddr(instance, "vkCmdSetBlendConstants")); |
| vkCmdSetDepthBounds = PFN_vkCmdSetDepthBounds(vkGetInstanceProcAddr(instance, "vkCmdSetDepthBounds")); |
| vkCmdSetStencilCompareMask = PFN_vkCmdSetStencilCompareMask(vkGetInstanceProcAddr(instance, "vkCmdSetStencilCompareMask")); |
| vkCmdSetStencilWriteMask = PFN_vkCmdSetStencilWriteMask(vkGetInstanceProcAddr(instance, "vkCmdSetStencilWriteMask")); |
| vkCmdSetStencilReference = PFN_vkCmdSetStencilReference(vkGetInstanceProcAddr(instance, "vkCmdSetStencilReference")); |
| vkCmdBindDescriptorSets = PFN_vkCmdBindDescriptorSets(vkGetInstanceProcAddr(instance, "vkCmdBindDescriptorSets")); |
| vkCmdBindIndexBuffer = PFN_vkCmdBindIndexBuffer(vkGetInstanceProcAddr(instance, "vkCmdBindIndexBuffer")); |
| vkCmdBindVertexBuffers = PFN_vkCmdBindVertexBuffers(vkGetInstanceProcAddr(instance, "vkCmdBindVertexBuffers")); |
| vkCmdDraw = PFN_vkCmdDraw(vkGetInstanceProcAddr(instance, "vkCmdDraw")); |
| vkCmdDrawIndexed = PFN_vkCmdDrawIndexed(vkGetInstanceProcAddr(instance, "vkCmdDrawIndexed")); |
| vkCmdDrawIndirect = PFN_vkCmdDrawIndirect(vkGetInstanceProcAddr(instance, "vkCmdDrawIndirect")); |
| vkCmdDrawIndexedIndirect = PFN_vkCmdDrawIndexedIndirect(vkGetInstanceProcAddr(instance, "vkCmdDrawIndexedIndirect")); |
| vkCmdDispatch = PFN_vkCmdDispatch(vkGetInstanceProcAddr(instance, "vkCmdDispatch")); |
| vkCmdDispatchIndirect = PFN_vkCmdDispatchIndirect(vkGetInstanceProcAddr(instance, "vkCmdDispatchIndirect")); |
| vkCmdCopyBuffer = PFN_vkCmdCopyBuffer(vkGetInstanceProcAddr(instance, "vkCmdCopyBuffer")); |
| vkCmdCopyImage = PFN_vkCmdCopyImage(vkGetInstanceProcAddr(instance, "vkCmdCopyImage")); |
| vkCmdBlitImage = PFN_vkCmdBlitImage(vkGetInstanceProcAddr(instance, "vkCmdBlitImage")); |
| vkCmdCopyBufferToImage = PFN_vkCmdCopyBufferToImage(vkGetInstanceProcAddr(instance, "vkCmdCopyBufferToImage")); |
| vkCmdCopyImageToBuffer = PFN_vkCmdCopyImageToBuffer(vkGetInstanceProcAddr(instance, "vkCmdCopyImageToBuffer")); |
| vkCmdUpdateBuffer = PFN_vkCmdUpdateBuffer(vkGetInstanceProcAddr(instance, "vkCmdUpdateBuffer")); |
| vkCmdFillBuffer = PFN_vkCmdFillBuffer(vkGetInstanceProcAddr(instance, "vkCmdFillBuffer")); |
| vkCmdClearColorImage = PFN_vkCmdClearColorImage(vkGetInstanceProcAddr(instance, "vkCmdClearColorImage")); |
| vkCmdClearDepthStencilImage = PFN_vkCmdClearDepthStencilImage(vkGetInstanceProcAddr(instance, "vkCmdClearDepthStencilImage")); |
| vkCmdClearAttachments = PFN_vkCmdClearAttachments(vkGetInstanceProcAddr(instance, "vkCmdClearAttachments")); |
| vkCmdResolveImage = PFN_vkCmdResolveImage(vkGetInstanceProcAddr(instance, "vkCmdResolveImage")); |
| vkCmdSetEvent = PFN_vkCmdSetEvent(vkGetInstanceProcAddr(instance, "vkCmdSetEvent")); |
| vkCmdResetEvent = PFN_vkCmdResetEvent(vkGetInstanceProcAddr(instance, "vkCmdResetEvent")); |
| vkCmdWaitEvents = PFN_vkCmdWaitEvents(vkGetInstanceProcAddr(instance, "vkCmdWaitEvents")); |
| vkCmdPipelineBarrier = PFN_vkCmdPipelineBarrier(vkGetInstanceProcAddr(instance, "vkCmdPipelineBarrier")); |
| vkCmdBeginQuery = PFN_vkCmdBeginQuery(vkGetInstanceProcAddr(instance, "vkCmdBeginQuery")); |
| vkCmdEndQuery = PFN_vkCmdEndQuery(vkGetInstanceProcAddr(instance, "vkCmdEndQuery")); |
| vkCmdResetQueryPool = PFN_vkCmdResetQueryPool(vkGetInstanceProcAddr(instance, "vkCmdResetQueryPool")); |
| vkCmdWriteTimestamp = PFN_vkCmdWriteTimestamp(vkGetInstanceProcAddr(instance, "vkCmdWriteTimestamp")); |
| vkCmdCopyQueryPoolResults = PFN_vkCmdCopyQueryPoolResults(vkGetInstanceProcAddr(instance, "vkCmdCopyQueryPoolResults")); |
| vkCmdPushConstants = PFN_vkCmdPushConstants(vkGetInstanceProcAddr(instance, "vkCmdPushConstants")); |
| vkCmdBeginRenderPass = PFN_vkCmdBeginRenderPass(vkGetInstanceProcAddr(instance, "vkCmdBeginRenderPass")); |
| vkCmdNextSubpass = PFN_vkCmdNextSubpass(vkGetInstanceProcAddr(instance, "vkCmdNextSubpass")); |
| vkCmdEndRenderPass = PFN_vkCmdEndRenderPass(vkGetInstanceProcAddr(instance, "vkCmdEndRenderPass")); |
| vkCmdExecuteCommands = PFN_vkCmdExecuteCommands(vkGetInstanceProcAddr(instance, "vkCmdExecuteCommands")); |
| |
| //=== VK_VERSION_1_1 === |
| vkBindBufferMemory2 = PFN_vkBindBufferMemory2(vkGetInstanceProcAddr(instance, "vkBindBufferMemory2")); |
| vkBindImageMemory2 = PFN_vkBindImageMemory2(vkGetInstanceProcAddr(instance, "vkBindImageMemory2")); |
| vkGetDeviceGroupPeerMemoryFeatures = PFN_vkGetDeviceGroupPeerMemoryFeatures(vkGetInstanceProcAddr(instance, "vkGetDeviceGroupPeerMemoryFeatures")); |
| vkCmdSetDeviceMask = PFN_vkCmdSetDeviceMask(vkGetInstanceProcAddr(instance, "vkCmdSetDeviceMask")); |
| vkCmdDispatchBase = PFN_vkCmdDispatchBase(vkGetInstanceProcAddr(instance, "vkCmdDispatchBase")); |
| vkEnumeratePhysicalDeviceGroups = PFN_vkEnumeratePhysicalDeviceGroups(vkGetInstanceProcAddr(instance, "vkEnumeratePhysicalDeviceGroups")); |
| vkGetImageMemoryRequirements2 = PFN_vkGetImageMemoryRequirements2(vkGetInstanceProcAddr(instance, "vkGetImageMemoryRequirements2")); |
| vkGetBufferMemoryRequirements2 = PFN_vkGetBufferMemoryRequirements2(vkGetInstanceProcAddr(instance, "vkGetBufferMemoryRequirements2")); |
| vkGetImageSparseMemoryRequirements2 = PFN_vkGetImageSparseMemoryRequirements2(vkGetInstanceProcAddr(instance, "vkGetImageSparseMemoryRequirements2")); |
| vkGetPhysicalDeviceFeatures2 = PFN_vkGetPhysicalDeviceFeatures2(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFeatures2")); |
| vkGetPhysicalDeviceProperties2 = PFN_vkGetPhysicalDeviceProperties2(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceProperties2")); |
| vkGetPhysicalDeviceFormatProperties2 = |
| PFN_vkGetPhysicalDeviceFormatProperties2(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFormatProperties2")); |
| vkGetPhysicalDeviceImageFormatProperties2 = |
| PFN_vkGetPhysicalDeviceImageFormatProperties2(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceImageFormatProperties2")); |
| vkGetPhysicalDeviceQueueFamilyProperties2 = |
| PFN_vkGetPhysicalDeviceQueueFamilyProperties2(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceQueueFamilyProperties2")); |
| vkGetPhysicalDeviceMemoryProperties2 = |
| PFN_vkGetPhysicalDeviceMemoryProperties2(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceMemoryProperties2")); |
| vkGetPhysicalDeviceSparseImageFormatProperties2 = |
| PFN_vkGetPhysicalDeviceSparseImageFormatProperties2(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSparseImageFormatProperties2")); |
| vkTrimCommandPool = PFN_vkTrimCommandPool(vkGetInstanceProcAddr(instance, "vkTrimCommandPool")); |
| vkGetDeviceQueue2 = PFN_vkGetDeviceQueue2(vkGetInstanceProcAddr(instance, "vkGetDeviceQueue2")); |
| vkCreateSamplerYcbcrConversion = PFN_vkCreateSamplerYcbcrConversion(vkGetInstanceProcAddr(instance, "vkCreateSamplerYcbcrConversion")); |
| vkDestroySamplerYcbcrConversion = PFN_vkDestroySamplerYcbcrConversion(vkGetInstanceProcAddr(instance, "vkDestroySamplerYcbcrConversion")); |
| vkCreateDescriptorUpdateTemplate = PFN_vkCreateDescriptorUpdateTemplate(vkGetInstanceProcAddr(instance, "vkCreateDescriptorUpdateTemplate")); |
| vkDestroyDescriptorUpdateTemplate = PFN_vkDestroyDescriptorUpdateTemplate(vkGetInstanceProcAddr(instance, "vkDestroyDescriptorUpdateTemplate")); |
| vkUpdateDescriptorSetWithTemplate = PFN_vkUpdateDescriptorSetWithTemplate(vkGetInstanceProcAddr(instance, "vkUpdateDescriptorSetWithTemplate")); |
| vkGetPhysicalDeviceExternalBufferProperties = |
| PFN_vkGetPhysicalDeviceExternalBufferProperties(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceExternalBufferProperties")); |
| vkGetPhysicalDeviceExternalFenceProperties = |
| PFN_vkGetPhysicalDeviceExternalFenceProperties(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceExternalFenceProperties")); |
| vkGetPhysicalDeviceExternalSemaphoreProperties = |
| PFN_vkGetPhysicalDeviceExternalSemaphoreProperties(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceExternalSemaphoreProperties")); |
| vkGetDescriptorSetLayoutSupport = PFN_vkGetDescriptorSetLayoutSupport(vkGetInstanceProcAddr(instance, "vkGetDescriptorSetLayoutSupport")); |
| |
| //=== VK_VERSION_1_2 === |
| vkCmdDrawIndirectCount = PFN_vkCmdDrawIndirectCount(vkGetInstanceProcAddr(instance, "vkCmdDrawIndirectCount")); |
| vkCmdDrawIndexedIndirectCount = PFN_vkCmdDrawIndexedIndirectCount(vkGetInstanceProcAddr(instance, "vkCmdDrawIndexedIndirectCount")); |
| vkCreateRenderPass2 = PFN_vkCreateRenderPass2(vkGetInstanceProcAddr(instance, "vkCreateRenderPass2")); |
| vkCmdBeginRenderPass2 = PFN_vkCmdBeginRenderPass2(vkGetInstanceProcAddr(instance, "vkCmdBeginRenderPass2")); |
| vkCmdNextSubpass2 = PFN_vkCmdNextSubpass2(vkGetInstanceProcAddr(instance, "vkCmdNextSubpass2")); |
| vkCmdEndRenderPass2 = PFN_vkCmdEndRenderPass2(vkGetInstanceProcAddr(instance, "vkCmdEndRenderPass2")); |
| vkResetQueryPool = PFN_vkResetQueryPool(vkGetInstanceProcAddr(instance, "vkResetQueryPool")); |
| vkGetSemaphoreCounterValue = PFN_vkGetSemaphoreCounterValue(vkGetInstanceProcAddr(instance, "vkGetSemaphoreCounterValue")); |
| vkWaitSemaphores = PFN_vkWaitSemaphores(vkGetInstanceProcAddr(instance, "vkWaitSemaphores")); |
| vkSignalSemaphore = PFN_vkSignalSemaphore(vkGetInstanceProcAddr(instance, "vkSignalSemaphore")); |
| vkGetBufferDeviceAddress = PFN_vkGetBufferDeviceAddress(vkGetInstanceProcAddr(instance, "vkGetBufferDeviceAddress")); |
| vkGetBufferOpaqueCaptureAddress = PFN_vkGetBufferOpaqueCaptureAddress(vkGetInstanceProcAddr(instance, "vkGetBufferOpaqueCaptureAddress")); |
| vkGetDeviceMemoryOpaqueCaptureAddress = |
| PFN_vkGetDeviceMemoryOpaqueCaptureAddress(vkGetInstanceProcAddr(instance, "vkGetDeviceMemoryOpaqueCaptureAddress")); |
| |
| //=== VK_VERSION_1_3 === |
| vkGetPhysicalDeviceToolProperties = PFN_vkGetPhysicalDeviceToolProperties(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceToolProperties")); |
| vkCreatePrivateDataSlot = PFN_vkCreatePrivateDataSlot(vkGetInstanceProcAddr(instance, "vkCreatePrivateDataSlot")); |
| vkDestroyPrivateDataSlot = PFN_vkDestroyPrivateDataSlot(vkGetInstanceProcAddr(instance, "vkDestroyPrivateDataSlot")); |
| vkSetPrivateData = PFN_vkSetPrivateData(vkGetInstanceProcAddr(instance, "vkSetPrivateData")); |
| vkGetPrivateData = PFN_vkGetPrivateData(vkGetInstanceProcAddr(instance, "vkGetPrivateData")); |
| vkCmdSetEvent2 = PFN_vkCmdSetEvent2(vkGetInstanceProcAddr(instance, "vkCmdSetEvent2")); |
| vkCmdResetEvent2 = PFN_vkCmdResetEvent2(vkGetInstanceProcAddr(instance, "vkCmdResetEvent2")); |
| vkCmdWaitEvents2 = PFN_vkCmdWaitEvents2(vkGetInstanceProcAddr(instance, "vkCmdWaitEvents2")); |
| vkCmdPipelineBarrier2 = PFN_vkCmdPipelineBarrier2(vkGetInstanceProcAddr(instance, "vkCmdPipelineBarrier2")); |
| vkCmdWriteTimestamp2 = PFN_vkCmdWriteTimestamp2(vkGetInstanceProcAddr(instance, "vkCmdWriteTimestamp2")); |
| vkQueueSubmit2 = PFN_vkQueueSubmit2(vkGetInstanceProcAddr(instance, "vkQueueSubmit2")); |
| vkCmdCopyBuffer2 = PFN_vkCmdCopyBuffer2(vkGetInstanceProcAddr(instance, "vkCmdCopyBuffer2")); |
| vkCmdCopyImage2 = PFN_vkCmdCopyImage2(vkGetInstanceProcAddr(instance, "vkCmdCopyImage2")); |
| vkCmdCopyBufferToImage2 = PFN_vkCmdCopyBufferToImage2(vkGetInstanceProcAddr(instance, "vkCmdCopyBufferToImage2")); |
| vkCmdCopyImageToBuffer2 = PFN_vkCmdCopyImageToBuffer2(vkGetInstanceProcAddr(instance, "vkCmdCopyImageToBuffer2")); |
| vkCmdBlitImage2 = PFN_vkCmdBlitImage2(vkGetInstanceProcAddr(instance, "vkCmdBlitImage2")); |
| vkCmdResolveImage2 = PFN_vkCmdResolveImage2(vkGetInstanceProcAddr(instance, "vkCmdResolveImage2")); |
| vkCmdBeginRendering = PFN_vkCmdBeginRendering(vkGetInstanceProcAddr(instance, "vkCmdBeginRendering")); |
| vkCmdEndRendering = PFN_vkCmdEndRendering(vkGetInstanceProcAddr(instance, "vkCmdEndRendering")); |
| vkCmdSetCullMode = PFN_vkCmdSetCullMode(vkGetInstanceProcAddr(instance, "vkCmdSetCullMode")); |
| vkCmdSetFrontFace = PFN_vkCmdSetFrontFace(vkGetInstanceProcAddr(instance, "vkCmdSetFrontFace")); |
| vkCmdSetPrimitiveTopology = PFN_vkCmdSetPrimitiveTopology(vkGetInstanceProcAddr(instance, "vkCmdSetPrimitiveTopology")); |
| vkCmdSetViewportWithCount = PFN_vkCmdSetViewportWithCount(vkGetInstanceProcAddr(instance, "vkCmdSetViewportWithCount")); |
| vkCmdSetScissorWithCount = PFN_vkCmdSetScissorWithCount(vkGetInstanceProcAddr(instance, "vkCmdSetScissorWithCount")); |
| vkCmdBindVertexBuffers2 = PFN_vkCmdBindVertexBuffers2(vkGetInstanceProcAddr(instance, "vkCmdBindVertexBuffers2")); |
| vkCmdSetDepthTestEnable = PFN_vkCmdSetDepthTestEnable(vkGetInstanceProcAddr(instance, "vkCmdSetDepthTestEnable")); |
| vkCmdSetDepthWriteEnable = PFN_vkCmdSetDepthWriteEnable(vkGetInstanceProcAddr(instance, "vkCmdSetDepthWriteEnable")); |
| vkCmdSetDepthCompareOp = PFN_vkCmdSetDepthCompareOp(vkGetInstanceProcAddr(instance, "vkCmdSetDepthCompareOp")); |
| vkCmdSetDepthBoundsTestEnable = PFN_vkCmdSetDepthBoundsTestEnable(vkGetInstanceProcAddr(instance, "vkCmdSetDepthBoundsTestEnable")); |
| vkCmdSetStencilTestEnable = PFN_vkCmdSetStencilTestEnable(vkGetInstanceProcAddr(instance, "vkCmdSetStencilTestEnable")); |
| vkCmdSetStencilOp = PFN_vkCmdSetStencilOp(vkGetInstanceProcAddr(instance, "vkCmdSetStencilOp")); |
| vkCmdSetRasterizerDiscardEnable = PFN_vkCmdSetRasterizerDiscardEnable(vkGetInstanceProcAddr(instance, "vkCmdSetRasterizerDiscardEnable")); |
| vkCmdSetDepthBiasEnable = PFN_vkCmdSetDepthBiasEnable(vkGetInstanceProcAddr(instance, "vkCmdSetDepthBiasEnable")); |
| vkCmdSetPrimitiveRestartEnable = PFN_vkCmdSetPrimitiveRestartEnable(vkGetInstanceProcAddr(instance, "vkCmdSetPrimitiveRestartEnable")); |
| vkGetDeviceBufferMemoryRequirements = PFN_vkGetDeviceBufferMemoryRequirements(vkGetInstanceProcAddr(instance, "vkGetDeviceBufferMemoryRequirements")); |
| vkGetDeviceImageMemoryRequirements = PFN_vkGetDeviceImageMemoryRequirements(vkGetInstanceProcAddr(instance, "vkGetDeviceImageMemoryRequirements")); |
| vkGetDeviceImageSparseMemoryRequirements = |
| PFN_vkGetDeviceImageSparseMemoryRequirements(vkGetInstanceProcAddr(instance, "vkGetDeviceImageSparseMemoryRequirements")); |
| |
| //=== VK_KHR_surface === |
| vkDestroySurfaceKHR = PFN_vkDestroySurfaceKHR(vkGetInstanceProcAddr(instance, "vkDestroySurfaceKHR")); |
| vkGetPhysicalDeviceSurfaceSupportKHR = |
| PFN_vkGetPhysicalDeviceSurfaceSupportKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfaceSupportKHR")); |
| vkGetPhysicalDeviceSurfaceCapabilitiesKHR = |
| PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR")); |
| vkGetPhysicalDeviceSurfaceFormatsKHR = |
| PFN_vkGetPhysicalDeviceSurfaceFormatsKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfaceFormatsKHR")); |
| vkGetPhysicalDeviceSurfacePresentModesKHR = |
| PFN_vkGetPhysicalDeviceSurfacePresentModesKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfacePresentModesKHR")); |
| |
| //=== VK_KHR_swapchain === |
| vkCreateSwapchainKHR = PFN_vkCreateSwapchainKHR(vkGetInstanceProcAddr(instance, "vkCreateSwapchainKHR")); |
| vkDestroySwapchainKHR = PFN_vkDestroySwapchainKHR(vkGetInstanceProcAddr(instance, "vkDestroySwapchainKHR")); |
| vkGetSwapchainImagesKHR = PFN_vkGetSwapchainImagesKHR(vkGetInstanceProcAddr(instance, "vkGetSwapchainImagesKHR")); |
| vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR(vkGetInstanceProcAddr(instance, "vkAcquireNextImageKHR")); |
| vkQueuePresentKHR = PFN_vkQueuePresentKHR(vkGetInstanceProcAddr(instance, "vkQueuePresentKHR")); |
| vkGetDeviceGroupPresentCapabilitiesKHR = |
| PFN_vkGetDeviceGroupPresentCapabilitiesKHR(vkGetInstanceProcAddr(instance, "vkGetDeviceGroupPresentCapabilitiesKHR")); |
| vkGetDeviceGroupSurfacePresentModesKHR = |
| PFN_vkGetDeviceGroupSurfacePresentModesKHR(vkGetInstanceProcAddr(instance, "vkGetDeviceGroupSurfacePresentModesKHR")); |
| vkGetPhysicalDevicePresentRectanglesKHR = |
| PFN_vkGetPhysicalDevicePresentRectanglesKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDevicePresentRectanglesKHR")); |
| vkAcquireNextImage2KHR = PFN_vkAcquireNextImage2KHR(vkGetInstanceProcAddr(instance, "vkAcquireNextImage2KHR")); |
| |
| //=== VK_KHR_display === |
| vkGetPhysicalDeviceDisplayPropertiesKHR = |
| PFN_vkGetPhysicalDeviceDisplayPropertiesKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceDisplayPropertiesKHR")); |
| vkGetPhysicalDeviceDisplayPlanePropertiesKHR = |
| PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR")); |
| vkGetDisplayPlaneSupportedDisplaysKHR = |
| PFN_vkGetDisplayPlaneSupportedDisplaysKHR(vkGetInstanceProcAddr(instance, "vkGetDisplayPlaneSupportedDisplaysKHR")); |
| vkGetDisplayModePropertiesKHR = PFN_vkGetDisplayModePropertiesKHR(vkGetInstanceProcAddr(instance, "vkGetDisplayModePropertiesKHR")); |
| vkCreateDisplayModeKHR = PFN_vkCreateDisplayModeKHR(vkGetInstanceProcAddr(instance, "vkCreateDisplayModeKHR")); |
| vkGetDisplayPlaneCapabilitiesKHR = PFN_vkGetDisplayPlaneCapabilitiesKHR(vkGetInstanceProcAddr(instance, "vkGetDisplayPlaneCapabilitiesKHR")); |
| vkCreateDisplayPlaneSurfaceKHR = PFN_vkCreateDisplayPlaneSurfaceKHR(vkGetInstanceProcAddr(instance, "vkCreateDisplayPlaneSurfaceKHR")); |
| |
| //=== VK_KHR_display_swapchain === |
| vkCreateSharedSwapchainsKHR = PFN_vkCreateSharedSwapchainsKHR(vkGetInstanceProcAddr(instance, "vkCreateSharedSwapchainsKHR")); |
| |
| #if defined(VK_USE_PLATFORM_XLIB_KHR) |
| //=== VK_KHR_xlib_surface === |
| vkCreateXlibSurfaceKHR = PFN_vkCreateXlibSurfaceKHR(vkGetInstanceProcAddr(instance, "vkCreateXlibSurfaceKHR")); |
| vkGetPhysicalDeviceXlibPresentationSupportKHR = |
| PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceXlibPresentationSupportKHR")); |
| #endif /*VK_USE_PLATFORM_XLIB_KHR*/ |
| |
| #if defined(VK_USE_PLATFORM_XCB_KHR) |
| //=== VK_KHR_xcb_surface === |
| vkCreateXcbSurfaceKHR = PFN_vkCreateXcbSurfaceKHR(vkGetInstanceProcAddr(instance, "vkCreateXcbSurfaceKHR")); |
| vkGetPhysicalDeviceXcbPresentationSupportKHR = |
| PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceXcbPresentationSupportKHR")); |
| #endif /*VK_USE_PLATFORM_XCB_KHR*/ |
| |
| #if defined(VK_USE_PLATFORM_WAYLAND_KHR) |
| //=== VK_KHR_wayland_surface === |
| vkCreateWaylandSurfaceKHR = PFN_vkCreateWaylandSurfaceKHR(vkGetInstanceProcAddr(instance, "vkCreateWaylandSurfaceKHR")); |
| vkGetPhysicalDeviceWaylandPresentationSupportKHR = |
| PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceWaylandPresentationSupportKHR")); |
| #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ |
| |
| #if defined(VK_USE_PLATFORM_ANDROID_KHR) |
| //=== VK_KHR_android_surface === |
| vkCreateAndroidSurfaceKHR = PFN_vkCreateAndroidSurfaceKHR(vkGetInstanceProcAddr(instance, "vkCreateAndroidSurfaceKHR")); |
| #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ |
| |
| #if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_KHR_win32_surface === |
| vkCreateWin32SurfaceKHR = PFN_vkCreateWin32SurfaceKHR(vkGetInstanceProcAddr(instance, "vkCreateWin32SurfaceKHR")); |
| vkGetPhysicalDeviceWin32PresentationSupportKHR = |
| PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceWin32PresentationSupportKHR")); |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_EXT_debug_report === |
| vkCreateDebugReportCallbackEXT = PFN_vkCreateDebugReportCallbackEXT(vkGetInstanceProcAddr(instance, "vkCreateDebugReportCallbackEXT")); |
| vkDestroyDebugReportCallbackEXT = PFN_vkDestroyDebugReportCallbackEXT(vkGetInstanceProcAddr(instance, "vkDestroyDebugReportCallbackEXT")); |
| vkDebugReportMessageEXT = PFN_vkDebugReportMessageEXT(vkGetInstanceProcAddr(instance, "vkDebugReportMessageEXT")); |
| |
| //=== VK_EXT_debug_marker === |
| vkDebugMarkerSetObjectTagEXT = PFN_vkDebugMarkerSetObjectTagEXT(vkGetInstanceProcAddr(instance, "vkDebugMarkerSetObjectTagEXT")); |
| vkDebugMarkerSetObjectNameEXT = PFN_vkDebugMarkerSetObjectNameEXT(vkGetInstanceProcAddr(instance, "vkDebugMarkerSetObjectNameEXT")); |
| vkCmdDebugMarkerBeginEXT = PFN_vkCmdDebugMarkerBeginEXT(vkGetInstanceProcAddr(instance, "vkCmdDebugMarkerBeginEXT")); |
| vkCmdDebugMarkerEndEXT = PFN_vkCmdDebugMarkerEndEXT(vkGetInstanceProcAddr(instance, "vkCmdDebugMarkerEndEXT")); |
| vkCmdDebugMarkerInsertEXT = PFN_vkCmdDebugMarkerInsertEXT(vkGetInstanceProcAddr(instance, "vkCmdDebugMarkerInsertEXT")); |
| |
| #if defined(VK_ENABLE_BETA_EXTENSIONS) |
| //=== VK_KHR_video_queue === |
| vkGetPhysicalDeviceVideoCapabilitiesKHR = |
| PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceVideoCapabilitiesKHR")); |
| vkGetPhysicalDeviceVideoFormatPropertiesKHR = |
| PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceVideoFormatPropertiesKHR")); |
| vkCreateVideoSessionKHR = PFN_vkCreateVideoSessionKHR(vkGetInstanceProcAddr(instance, "vkCreateVideoSessionKHR")); |
| vkDestroyVideoSessionKHR = PFN_vkDestroyVideoSessionKHR(vkGetInstanceProcAddr(instance, "vkDestroyVideoSessionKHR")); |
| vkGetVideoSessionMemoryRequirementsKHR = |
| PFN_vkGetVideoSessionMemoryRequirementsKHR(vkGetInstanceProcAddr(instance, "vkGetVideoSessionMemoryRequirementsKHR")); |
| vkBindVideoSessionMemoryKHR = PFN_vkBindVideoSessionMemoryKHR(vkGetInstanceProcAddr(instance, "vkBindVideoSessionMemoryKHR")); |
| vkCreateVideoSessionParametersKHR = PFN_vkCreateVideoSessionParametersKHR(vkGetInstanceProcAddr(instance, "vkCreateVideoSessionParametersKHR")); |
| vkUpdateVideoSessionParametersKHR = PFN_vkUpdateVideoSessionParametersKHR(vkGetInstanceProcAddr(instance, "vkUpdateVideoSessionParametersKHR")); |
| vkDestroyVideoSessionParametersKHR = PFN_vkDestroyVideoSessionParametersKHR(vkGetInstanceProcAddr(instance, "vkDestroyVideoSessionParametersKHR")); |
| vkCmdBeginVideoCodingKHR = PFN_vkCmdBeginVideoCodingKHR(vkGetInstanceProcAddr(instance, "vkCmdBeginVideoCodingKHR")); |
| vkCmdEndVideoCodingKHR = PFN_vkCmdEndVideoCodingKHR(vkGetInstanceProcAddr(instance, "vkCmdEndVideoCodingKHR")); |
| vkCmdControlVideoCodingKHR = PFN_vkCmdControlVideoCodingKHR(vkGetInstanceProcAddr(instance, "vkCmdControlVideoCodingKHR")); |
| #endif /*VK_ENABLE_BETA_EXTENSIONS*/ |
| |
| #if defined(VK_ENABLE_BETA_EXTENSIONS) |
| //=== VK_KHR_video_decode_queue === |
| vkCmdDecodeVideoKHR = PFN_vkCmdDecodeVideoKHR(vkGetInstanceProcAddr(instance, "vkCmdDecodeVideoKHR")); |
| #endif /*VK_ENABLE_BETA_EXTENSIONS*/ |
| |
| //=== VK_EXT_transform_feedback === |
| vkCmdBindTransformFeedbackBuffersEXT = |
| PFN_vkCmdBindTransformFeedbackBuffersEXT(vkGetInstanceProcAddr(instance, "vkCmdBindTransformFeedbackBuffersEXT")); |
| vkCmdBeginTransformFeedbackEXT = PFN_vkCmdBeginTransformFeedbackEXT(vkGetInstanceProcAddr(instance, "vkCmdBeginTransformFeedbackEXT")); |
| vkCmdEndTransformFeedbackEXT = PFN_vkCmdEndTransformFeedbackEXT(vkGetInstanceProcAddr(instance, "vkCmdEndTransformFeedbackEXT")); |
| vkCmdBeginQueryIndexedEXT = PFN_vkCmdBeginQueryIndexedEXT(vkGetInstanceProcAddr(instance, "vkCmdBeginQueryIndexedEXT")); |
| vkCmdEndQueryIndexedEXT = PFN_vkCmdEndQueryIndexedEXT(vkGetInstanceProcAddr(instance, "vkCmdEndQueryIndexedEXT")); |
| vkCmdDrawIndirectByteCountEXT = PFN_vkCmdDrawIndirectByteCountEXT(vkGetInstanceProcAddr(instance, "vkCmdDrawIndirectByteCountEXT")); |
| |
| //=== VK_NVX_binary_import === |
| vkCreateCuModuleNVX = PFN_vkCreateCuModuleNVX(vkGetInstanceProcAddr(instance, "vkCreateCuModuleNVX")); |
| vkCreateCuFunctionNVX = PFN_vkCreateCuFunctionNVX(vkGetInstanceProcAddr(instance, "vkCreateCuFunctionNVX")); |
| vkDestroyCuModuleNVX = PFN_vkDestroyCuModuleNVX(vkGetInstanceProcAddr(instance, "vkDestroyCuModuleNVX")); |
| vkDestroyCuFunctionNVX = PFN_vkDestroyCuFunctionNVX(vkGetInstanceProcAddr(instance, "vkDestroyCuFunctionNVX")); |
| vkCmdCuLaunchKernelNVX = PFN_vkCmdCuLaunchKernelNVX(vkGetInstanceProcAddr(instance, "vkCmdCuLaunchKernelNVX")); |
| |
| //=== VK_NVX_image_view_handle === |
| vkGetImageViewHandleNVX = PFN_vkGetImageViewHandleNVX(vkGetInstanceProcAddr(instance, "vkGetImageViewHandleNVX")); |
| vkGetImageViewAddressNVX = PFN_vkGetImageViewAddressNVX(vkGetInstanceProcAddr(instance, "vkGetImageViewAddressNVX")); |
| |
| //=== VK_AMD_draw_indirect_count === |
| vkCmdDrawIndirectCountAMD = PFN_vkCmdDrawIndirectCountAMD(vkGetInstanceProcAddr(instance, "vkCmdDrawIndirectCountAMD")); |
| if(!vkCmdDrawIndirectCount) |
| vkCmdDrawIndirectCount = vkCmdDrawIndirectCountAMD; |
| vkCmdDrawIndexedIndirectCountAMD = PFN_vkCmdDrawIndexedIndirectCountAMD(vkGetInstanceProcAddr(instance, "vkCmdDrawIndexedIndirectCountAMD")); |
| if(!vkCmdDrawIndexedIndirectCount) |
| vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountAMD; |
| |
| //=== VK_AMD_shader_info === |
| vkGetShaderInfoAMD = PFN_vkGetShaderInfoAMD(vkGetInstanceProcAddr(instance, "vkGetShaderInfoAMD")); |
| |
| //=== VK_KHR_dynamic_rendering === |
| vkCmdBeginRenderingKHR = PFN_vkCmdBeginRenderingKHR(vkGetInstanceProcAddr(instance, "vkCmdBeginRenderingKHR")); |
| if(!vkCmdBeginRendering) |
| vkCmdBeginRendering = vkCmdBeginRenderingKHR; |
| vkCmdEndRenderingKHR = PFN_vkCmdEndRenderingKHR(vkGetInstanceProcAddr(instance, "vkCmdEndRenderingKHR")); |
| if(!vkCmdEndRendering) |
| vkCmdEndRendering = vkCmdEndRenderingKHR; |
| |
| #if defined(VK_USE_PLATFORM_GGP) |
| //=== VK_GGP_stream_descriptor_surface === |
| vkCreateStreamDescriptorSurfaceGGP = PFN_vkCreateStreamDescriptorSurfaceGGP(vkGetInstanceProcAddr(instance, "vkCreateStreamDescriptorSurfaceGGP")); |
| #endif /*VK_USE_PLATFORM_GGP*/ |
| |
| //=== VK_NV_external_memory_capabilities === |
| vkGetPhysicalDeviceExternalImageFormatPropertiesNV = |
| PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV")); |
| |
| #if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_NV_external_memory_win32 === |
| vkGetMemoryWin32HandleNV = PFN_vkGetMemoryWin32HandleNV(vkGetInstanceProcAddr(instance, "vkGetMemoryWin32HandleNV")); |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_KHR_get_physical_device_properties2 === |
| vkGetPhysicalDeviceFeatures2KHR = PFN_vkGetPhysicalDeviceFeatures2KHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFeatures2KHR")); |
| if(!vkGetPhysicalDeviceFeatures2) |
| vkGetPhysicalDeviceFeatures2 = vkGetPhysicalDeviceFeatures2KHR; |
| vkGetPhysicalDeviceProperties2KHR = PFN_vkGetPhysicalDeviceProperties2KHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceProperties2KHR")); |
| if(!vkGetPhysicalDeviceProperties2) |
| vkGetPhysicalDeviceProperties2 = vkGetPhysicalDeviceProperties2KHR; |
| vkGetPhysicalDeviceFormatProperties2KHR = |
| PFN_vkGetPhysicalDeviceFormatProperties2KHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFormatProperties2KHR")); |
| if(!vkGetPhysicalDeviceFormatProperties2) |
| vkGetPhysicalDeviceFormatProperties2 = vkGetPhysicalDeviceFormatProperties2KHR; |
| vkGetPhysicalDeviceImageFormatProperties2KHR = |
| PFN_vkGetPhysicalDeviceImageFormatProperties2KHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceImageFormatProperties2KHR")); |
| if(!vkGetPhysicalDeviceImageFormatProperties2) |
| vkGetPhysicalDeviceImageFormatProperties2 = vkGetPhysicalDeviceImageFormatProperties2KHR; |
| vkGetPhysicalDeviceQueueFamilyProperties2KHR = |
| PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceQueueFamilyProperties2KHR")); |
| if(!vkGetPhysicalDeviceQueueFamilyProperties2) |
| vkGetPhysicalDeviceQueueFamilyProperties2 = vkGetPhysicalDeviceQueueFamilyProperties2KHR; |
| vkGetPhysicalDeviceMemoryProperties2KHR = |
| PFN_vkGetPhysicalDeviceMemoryProperties2KHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceMemoryProperties2KHR")); |
| if(!vkGetPhysicalDeviceMemoryProperties2) |
| vkGetPhysicalDeviceMemoryProperties2 = vkGetPhysicalDeviceMemoryProperties2KHR; |
| vkGetPhysicalDeviceSparseImageFormatProperties2KHR = |
| PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR")); |
| if(!vkGetPhysicalDeviceSparseImageFormatProperties2) |
| vkGetPhysicalDeviceSparseImageFormatProperties2 = vkGetPhysicalDeviceSparseImageFormatProperties2KHR; |
| |
| //=== VK_KHR_device_group === |
| vkGetDeviceGroupPeerMemoryFeaturesKHR = |
| PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR(vkGetInstanceProcAddr(instance, "vkGetDeviceGroupPeerMemoryFeaturesKHR")); |
| if(!vkGetDeviceGroupPeerMemoryFeatures) |
| vkGetDeviceGroupPeerMemoryFeatures = vkGetDeviceGroupPeerMemoryFeaturesKHR; |
| vkCmdSetDeviceMaskKHR = PFN_vkCmdSetDeviceMaskKHR(vkGetInstanceProcAddr(instance, "vkCmdSetDeviceMaskKHR")); |
| if(!vkCmdSetDeviceMask) |
| vkCmdSetDeviceMask = vkCmdSetDeviceMaskKHR; |
| vkCmdDispatchBaseKHR = PFN_vkCmdDispatchBaseKHR(vkGetInstanceProcAddr(instance, "vkCmdDispatchBaseKHR")); |
| if(!vkCmdDispatchBase) |
| vkCmdDispatchBase = vkCmdDispatchBaseKHR; |
| |
| #if defined(VK_USE_PLATFORM_VI_NN) |
| //=== VK_NN_vi_surface === |
| vkCreateViSurfaceNN = PFN_vkCreateViSurfaceNN(vkGetInstanceProcAddr(instance, "vkCreateViSurfaceNN")); |
| #endif /*VK_USE_PLATFORM_VI_NN*/ |
| |
| //=== VK_KHR_maintenance1 === |
| vkTrimCommandPoolKHR = PFN_vkTrimCommandPoolKHR(vkGetInstanceProcAddr(instance, "vkTrimCommandPoolKHR")); |
| if(!vkTrimCommandPool) |
| vkTrimCommandPool = vkTrimCommandPoolKHR; |
| |
| //=== VK_KHR_device_group_creation === |
| vkEnumeratePhysicalDeviceGroupsKHR = PFN_vkEnumeratePhysicalDeviceGroupsKHR(vkGetInstanceProcAddr(instance, "vkEnumeratePhysicalDeviceGroupsKHR")); |
| if(!vkEnumeratePhysicalDeviceGroups) |
| vkEnumeratePhysicalDeviceGroups = vkEnumeratePhysicalDeviceGroupsKHR; |
| |
| //=== VK_KHR_external_memory_capabilities === |
| vkGetPhysicalDeviceExternalBufferPropertiesKHR = |
| PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceExternalBufferPropertiesKHR")); |
| if(!vkGetPhysicalDeviceExternalBufferProperties) |
| vkGetPhysicalDeviceExternalBufferProperties = vkGetPhysicalDeviceExternalBufferPropertiesKHR; |
| |
| #if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_KHR_external_memory_win32 === |
| vkGetMemoryWin32HandleKHR = PFN_vkGetMemoryWin32HandleKHR(vkGetInstanceProcAddr(instance, "vkGetMemoryWin32HandleKHR")); |
| vkGetMemoryWin32HandlePropertiesKHR = PFN_vkGetMemoryWin32HandlePropertiesKHR(vkGetInstanceProcAddr(instance, "vkGetMemoryWin32HandlePropertiesKHR")); |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_KHR_external_memory_fd === |
| vkGetMemoryFdKHR = PFN_vkGetMemoryFdKHR(vkGetInstanceProcAddr(instance, "vkGetMemoryFdKHR")); |
| vkGetMemoryFdPropertiesKHR = PFN_vkGetMemoryFdPropertiesKHR(vkGetInstanceProcAddr(instance, "vkGetMemoryFdPropertiesKHR")); |
| |
| //=== VK_KHR_external_semaphore_capabilities === |
| vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = |
| PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR")); |
| if(!vkGetPhysicalDeviceExternalSemaphoreProperties) |
| vkGetPhysicalDeviceExternalSemaphoreProperties = vkGetPhysicalDeviceExternalSemaphorePropertiesKHR; |
| |
| #if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_KHR_external_semaphore_win32 === |
| vkImportSemaphoreWin32HandleKHR = PFN_vkImportSemaphoreWin32HandleKHR(vkGetInstanceProcAddr(instance, "vkImportSemaphoreWin32HandleKHR")); |
| vkGetSemaphoreWin32HandleKHR = PFN_vkGetSemaphoreWin32HandleKHR(vkGetInstanceProcAddr(instance, "vkGetSemaphoreWin32HandleKHR")); |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_KHR_external_semaphore_fd === |
| vkImportSemaphoreFdKHR = PFN_vkImportSemaphoreFdKHR(vkGetInstanceProcAddr(instance, "vkImportSemaphoreFdKHR")); |
| vkGetSemaphoreFdKHR = PFN_vkGetSemaphoreFdKHR(vkGetInstanceProcAddr(instance, "vkGetSemaphoreFdKHR")); |
| |
| //=== VK_KHR_push_descriptor === |
| vkCmdPushDescriptorSetKHR = PFN_vkCmdPushDescriptorSetKHR(vkGetInstanceProcAddr(instance, "vkCmdPushDescriptorSetKHR")); |
| vkCmdPushDescriptorSetWithTemplateKHR = |
| PFN_vkCmdPushDescriptorSetWithTemplateKHR(vkGetInstanceProcAddr(instance, "vkCmdPushDescriptorSetWithTemplateKHR")); |
| |
| //=== VK_EXT_conditional_rendering === |
| vkCmdBeginConditionalRenderingEXT = PFN_vkCmdBeginConditionalRenderingEXT(vkGetInstanceProcAddr(instance, "vkCmdBeginConditionalRenderingEXT")); |
| vkCmdEndConditionalRenderingEXT = PFN_vkCmdEndConditionalRenderingEXT(vkGetInstanceProcAddr(instance, "vkCmdEndConditionalRenderingEXT")); |
| |
| //=== VK_KHR_descriptor_update_template === |
| vkCreateDescriptorUpdateTemplateKHR = PFN_vkCreateDescriptorUpdateTemplateKHR(vkGetInstanceProcAddr(instance, "vkCreateDescriptorUpdateTemplateKHR")); |
| if(!vkCreateDescriptorUpdateTemplate) |
| vkCreateDescriptorUpdateTemplate = vkCreateDescriptorUpdateTemplateKHR; |
| vkDestroyDescriptorUpdateTemplateKHR = |
| PFN_vkDestroyDescriptorUpdateTemplateKHR(vkGetInstanceProcAddr(instance, "vkDestroyDescriptorUpdateTemplateKHR")); |
| if(!vkDestroyDescriptorUpdateTemplate) |
| vkDestroyDescriptorUpdateTemplate = vkDestroyDescriptorUpdateTemplateKHR; |
| vkUpdateDescriptorSetWithTemplateKHR = |
| PFN_vkUpdateDescriptorSetWithTemplateKHR(vkGetInstanceProcAddr(instance, "vkUpdateDescriptorSetWithTemplateKHR")); |
| if(!vkUpdateDescriptorSetWithTemplate) |
| vkUpdateDescriptorSetWithTemplate = vkUpdateDescriptorSetWithTemplateKHR; |
| |
| //=== VK_NV_clip_space_w_scaling === |
| vkCmdSetViewportWScalingNV = PFN_vkCmdSetViewportWScalingNV(vkGetInstanceProcAddr(instance, "vkCmdSetViewportWScalingNV")); |
| |
| //=== VK_EXT_direct_mode_display === |
| vkReleaseDisplayEXT = PFN_vkReleaseDisplayEXT(vkGetInstanceProcAddr(instance, "vkReleaseDisplayEXT")); |
| |
| #if defined(VK_USE_PLATFORM_XLIB_XRANDR_EXT) |
| //=== VK_EXT_acquire_xlib_display === |
| vkAcquireXlibDisplayEXT = PFN_vkAcquireXlibDisplayEXT(vkGetInstanceProcAddr(instance, "vkAcquireXlibDisplayEXT")); |
| vkGetRandROutputDisplayEXT = PFN_vkGetRandROutputDisplayEXT(vkGetInstanceProcAddr(instance, "vkGetRandROutputDisplayEXT")); |
| #endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ |
| |
| //=== VK_EXT_display_surface_counter === |
| vkGetPhysicalDeviceSurfaceCapabilities2EXT = |
| PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfaceCapabilities2EXT")); |
| |
| //=== VK_EXT_display_control === |
| vkDisplayPowerControlEXT = PFN_vkDisplayPowerControlEXT(vkGetInstanceProcAddr(instance, "vkDisplayPowerControlEXT")); |
| vkRegisterDeviceEventEXT = PFN_vkRegisterDeviceEventEXT(vkGetInstanceProcAddr(instance, "vkRegisterDeviceEventEXT")); |
| vkRegisterDisplayEventEXT = PFN_vkRegisterDisplayEventEXT(vkGetInstanceProcAddr(instance, "vkRegisterDisplayEventEXT")); |
| vkGetSwapchainCounterEXT = PFN_vkGetSwapchainCounterEXT(vkGetInstanceProcAddr(instance, "vkGetSwapchainCounterEXT")); |
| |
| //=== VK_GOOGLE_display_timing === |
| vkGetRefreshCycleDurationGOOGLE = PFN_vkGetRefreshCycleDurationGOOGLE(vkGetInstanceProcAddr(instance, "vkGetRefreshCycleDurationGOOGLE")); |
| vkGetPastPresentationTimingGOOGLE = PFN_vkGetPastPresentationTimingGOOGLE(vkGetInstanceProcAddr(instance, "vkGetPastPresentationTimingGOOGLE")); |
| |
| //=== VK_EXT_discard_rectangles === |
| vkCmdSetDiscardRectangleEXT = PFN_vkCmdSetDiscardRectangleEXT(vkGetInstanceProcAddr(instance, "vkCmdSetDiscardRectangleEXT")); |
| |
| //=== VK_EXT_hdr_metadata === |
| vkSetHdrMetadataEXT = PFN_vkSetHdrMetadataEXT(vkGetInstanceProcAddr(instance, "vkSetHdrMetadataEXT")); |
| |
| //=== VK_KHR_create_renderpass2 === |
| vkCreateRenderPass2KHR = PFN_vkCreateRenderPass2KHR(vkGetInstanceProcAddr(instance, "vkCreateRenderPass2KHR")); |
| if(!vkCreateRenderPass2) |
| vkCreateRenderPass2 = vkCreateRenderPass2KHR; |
| vkCmdBeginRenderPass2KHR = PFN_vkCmdBeginRenderPass2KHR(vkGetInstanceProcAddr(instance, "vkCmdBeginRenderPass2KHR")); |
| if(!vkCmdBeginRenderPass2) |
| vkCmdBeginRenderPass2 = vkCmdBeginRenderPass2KHR; |
| vkCmdNextSubpass2KHR = PFN_vkCmdNextSubpass2KHR(vkGetInstanceProcAddr(instance, "vkCmdNextSubpass2KHR")); |
| if(!vkCmdNextSubpass2) |
| vkCmdNextSubpass2 = vkCmdNextSubpass2KHR; |
| vkCmdEndRenderPass2KHR = PFN_vkCmdEndRenderPass2KHR(vkGetInstanceProcAddr(instance, "vkCmdEndRenderPass2KHR")); |
| if(!vkCmdEndRenderPass2) |
| vkCmdEndRenderPass2 = vkCmdEndRenderPass2KHR; |
| |
| //=== VK_KHR_shared_presentable_image === |
| vkGetSwapchainStatusKHR = PFN_vkGetSwapchainStatusKHR(vkGetInstanceProcAddr(instance, "vkGetSwapchainStatusKHR")); |
| |
| //=== VK_KHR_external_fence_capabilities === |
| vkGetPhysicalDeviceExternalFencePropertiesKHR = |
| PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceExternalFencePropertiesKHR")); |
| if(!vkGetPhysicalDeviceExternalFenceProperties) |
| vkGetPhysicalDeviceExternalFenceProperties = vkGetPhysicalDeviceExternalFencePropertiesKHR; |
| |
| #if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_KHR_external_fence_win32 === |
| vkImportFenceWin32HandleKHR = PFN_vkImportFenceWin32HandleKHR(vkGetInstanceProcAddr(instance, "vkImportFenceWin32HandleKHR")); |
| vkGetFenceWin32HandleKHR = PFN_vkGetFenceWin32HandleKHR(vkGetInstanceProcAddr(instance, "vkGetFenceWin32HandleKHR")); |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_KHR_external_fence_fd === |
| vkImportFenceFdKHR = PFN_vkImportFenceFdKHR(vkGetInstanceProcAddr(instance, "vkImportFenceFdKHR")); |
| vkGetFenceFdKHR = PFN_vkGetFenceFdKHR(vkGetInstanceProcAddr(instance, "vkGetFenceFdKHR")); |
| |
| //=== VK_KHR_performance_query === |
| vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( |
| vkGetInstanceProcAddr(instance, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR")); |
| vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( |
| vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR")); |
| vkAcquireProfilingLockKHR = PFN_vkAcquireProfilingLockKHR(vkGetInstanceProcAddr(instance, "vkAcquireProfilingLockKHR")); |
| vkReleaseProfilingLockKHR = PFN_vkReleaseProfilingLockKHR(vkGetInstanceProcAddr(instance, "vkReleaseProfilingLockKHR")); |
| |
| //=== VK_KHR_get_surface_capabilities2 === |
| vkGetPhysicalDeviceSurfaceCapabilities2KHR = |
| PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfaceCapabilities2KHR")); |
| vkGetPhysicalDeviceSurfaceFormats2KHR = |
| PFN_vkGetPhysicalDeviceSurfaceFormats2KHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfaceFormats2KHR")); |
| |
| //=== VK_KHR_get_display_properties2 === |
| vkGetPhysicalDeviceDisplayProperties2KHR = |
| PFN_vkGetPhysicalDeviceDisplayProperties2KHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceDisplayProperties2KHR")); |
| vkGetPhysicalDeviceDisplayPlaneProperties2KHR = |
| PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceDisplayPlaneProperties2KHR")); |
| vkGetDisplayModeProperties2KHR = PFN_vkGetDisplayModeProperties2KHR(vkGetInstanceProcAddr(instance, "vkGetDisplayModeProperties2KHR")); |
| vkGetDisplayPlaneCapabilities2KHR = PFN_vkGetDisplayPlaneCapabilities2KHR(vkGetInstanceProcAddr(instance, "vkGetDisplayPlaneCapabilities2KHR")); |
| |
| #if defined(VK_USE_PLATFORM_IOS_MVK) |
| //=== VK_MVK_ios_surface === |
| vkCreateIOSSurfaceMVK = PFN_vkCreateIOSSurfaceMVK(vkGetInstanceProcAddr(instance, "vkCreateIOSSurfaceMVK")); |
| #endif /*VK_USE_PLATFORM_IOS_MVK*/ |
| |
| #if defined(VK_USE_PLATFORM_MACOS_MVK) |
| //=== VK_MVK_macos_surface === |
| vkCreateMacOSSurfaceMVK = PFN_vkCreateMacOSSurfaceMVK(vkGetInstanceProcAddr(instance, "vkCreateMacOSSurfaceMVK")); |
| #endif /*VK_USE_PLATFORM_MACOS_MVK*/ |
| |
| //=== VK_EXT_debug_utils === |
| vkSetDebugUtilsObjectNameEXT = PFN_vkSetDebugUtilsObjectNameEXT(vkGetInstanceProcAddr(instance, "vkSetDebugUtilsObjectNameEXT")); |
| vkSetDebugUtilsObjectTagEXT = PFN_vkSetDebugUtilsObjectTagEXT(vkGetInstanceProcAddr(instance, "vkSetDebugUtilsObjectTagEXT")); |
| vkQueueBeginDebugUtilsLabelEXT = PFN_vkQueueBeginDebugUtilsLabelEXT(vkGetInstanceProcAddr(instance, "vkQueueBeginDebugUtilsLabelEXT")); |
| vkQueueEndDebugUtilsLabelEXT = PFN_vkQueueEndDebugUtilsLabelEXT(vkGetInstanceProcAddr(instance, "vkQueueEndDebugUtilsLabelEXT")); |
| vkQueueInsertDebugUtilsLabelEXT = PFN_vkQueueInsertDebugUtilsLabelEXT(vkGetInstanceProcAddr(instance, "vkQueueInsertDebugUtilsLabelEXT")); |
| vkCmdBeginDebugUtilsLabelEXT = PFN_vkCmdBeginDebugUtilsLabelEXT(vkGetInstanceProcAddr(instance, "vkCmdBeginDebugUtilsLabelEXT")); |
| vkCmdEndDebugUtilsLabelEXT = PFN_vkCmdEndDebugUtilsLabelEXT(vkGetInstanceProcAddr(instance, "vkCmdEndDebugUtilsLabelEXT")); |
| vkCmdInsertDebugUtilsLabelEXT = PFN_vkCmdInsertDebugUtilsLabelEXT(vkGetInstanceProcAddr(instance, "vkCmdInsertDebugUtilsLabelEXT")); |
| vkCreateDebugUtilsMessengerEXT = PFN_vkCreateDebugUtilsMessengerEXT(vkGetInstanceProcAddr(instance, "vkCreateDebugUtilsMessengerEXT")); |
| vkDestroyDebugUtilsMessengerEXT = PFN_vkDestroyDebugUtilsMessengerEXT(vkGetInstanceProcAddr(instance, "vkDestroyDebugUtilsMessengerEXT")); |
| vkSubmitDebugUtilsMessageEXT = PFN_vkSubmitDebugUtilsMessageEXT(vkGetInstanceProcAddr(instance, "vkSubmitDebugUtilsMessageEXT")); |
| |
| #if defined(VK_USE_PLATFORM_ANDROID_KHR) |
| //=== VK_ANDROID_external_memory_android_hardware_buffer === |
| vkGetAndroidHardwareBufferPropertiesANDROID = |
| PFN_vkGetAndroidHardwareBufferPropertiesANDROID(vkGetInstanceProcAddr(instance, "vkGetAndroidHardwareBufferPropertiesANDROID")); |
| vkGetMemoryAndroidHardwareBufferANDROID = |
| PFN_vkGetMemoryAndroidHardwareBufferANDROID(vkGetInstanceProcAddr(instance, "vkGetMemoryAndroidHardwareBufferANDROID")); |
| #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ |
| |
| //=== VK_EXT_sample_locations === |
| vkCmdSetSampleLocationsEXT = PFN_vkCmdSetSampleLocationsEXT(vkGetInstanceProcAddr(instance, "vkCmdSetSampleLocationsEXT")); |
| vkGetPhysicalDeviceMultisamplePropertiesEXT = |
| PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceMultisamplePropertiesEXT")); |
| |
| //=== VK_KHR_get_memory_requirements2 === |
| vkGetImageMemoryRequirements2KHR = PFN_vkGetImageMemoryRequirements2KHR(vkGetInstanceProcAddr(instance, "vkGetImageMemoryRequirements2KHR")); |
| if(!vkGetImageMemoryRequirements2) |
| vkGetImageMemoryRequirements2 = vkGetImageMemoryRequirements2KHR; |
| vkGetBufferMemoryRequirements2KHR = PFN_vkGetBufferMemoryRequirements2KHR(vkGetInstanceProcAddr(instance, "vkGetBufferMemoryRequirements2KHR")); |
| if(!vkGetBufferMemoryRequirements2) |
| vkGetBufferMemoryRequirements2 = vkGetBufferMemoryRequirements2KHR; |
| vkGetImageSparseMemoryRequirements2KHR = |
| PFN_vkGetImageSparseMemoryRequirements2KHR(vkGetInstanceProcAddr(instance, "vkGetImageSparseMemoryRequirements2KHR")); |
| if(!vkGetImageSparseMemoryRequirements2) |
| vkGetImageSparseMemoryRequirements2 = vkGetImageSparseMemoryRequirements2KHR; |
| |
| //=== VK_KHR_acceleration_structure === |
| vkCreateAccelerationStructureKHR = PFN_vkCreateAccelerationStructureKHR(vkGetInstanceProcAddr(instance, "vkCreateAccelerationStructureKHR")); |
| vkDestroyAccelerationStructureKHR = PFN_vkDestroyAccelerationStructureKHR(vkGetInstanceProcAddr(instance, "vkDestroyAccelerationStructureKHR")); |
| vkCmdBuildAccelerationStructuresKHR = PFN_vkCmdBuildAccelerationStructuresKHR(vkGetInstanceProcAddr(instance, "vkCmdBuildAccelerationStructuresKHR")); |
| vkCmdBuildAccelerationStructuresIndirectKHR = |
| PFN_vkCmdBuildAccelerationStructuresIndirectKHR(vkGetInstanceProcAddr(instance, "vkCmdBuildAccelerationStructuresIndirectKHR")); |
| vkBuildAccelerationStructuresKHR = PFN_vkBuildAccelerationStructuresKHR(vkGetInstanceProcAddr(instance, "vkBuildAccelerationStructuresKHR")); |
| vkCopyAccelerationStructureKHR = PFN_vkCopyAccelerationStructureKHR(vkGetInstanceProcAddr(instance, "vkCopyAccelerationStructureKHR")); |
| vkCopyAccelerationStructureToMemoryKHR = |
| PFN_vkCopyAccelerationStructureToMemoryKHR(vkGetInstanceProcAddr(instance, "vkCopyAccelerationStructureToMemoryKHR")); |
| vkCopyMemoryToAccelerationStructureKHR = |
| PFN_vkCopyMemoryToAccelerationStructureKHR(vkGetInstanceProcAddr(instance, "vkCopyMemoryToAccelerationStructureKHR")); |
| vkWriteAccelerationStructuresPropertiesKHR = |
| PFN_vkWriteAccelerationStructuresPropertiesKHR(vkGetInstanceProcAddr(instance, "vkWriteAccelerationStructuresPropertiesKHR")); |
| vkCmdCopyAccelerationStructureKHR = PFN_vkCmdCopyAccelerationStructureKHR(vkGetInstanceProcAddr(instance, "vkCmdCopyAccelerationStructureKHR")); |
| vkCmdCopyAccelerationStructureToMemoryKHR = |
| PFN_vkCmdCopyAccelerationStructureToMemoryKHR(vkGetInstanceProcAddr(instance, "vkCmdCopyAccelerationStructureToMemoryKHR")); |
| vkCmdCopyMemoryToAccelerationStructureKHR = |
| PFN_vkCmdCopyMemoryToAccelerationStructureKHR(vkGetInstanceProcAddr(instance, "vkCmdCopyMemoryToAccelerationStructureKHR")); |
| vkGetAccelerationStructureDeviceAddressKHR = |
| PFN_vkGetAccelerationStructureDeviceAddressKHR(vkGetInstanceProcAddr(instance, "vkGetAccelerationStructureDeviceAddressKHR")); |
| vkCmdWriteAccelerationStructuresPropertiesKHR = |
| PFN_vkCmdWriteAccelerationStructuresPropertiesKHR(vkGetInstanceProcAddr(instance, "vkCmdWriteAccelerationStructuresPropertiesKHR")); |
| vkGetDeviceAccelerationStructureCompatibilityKHR = |
| PFN_vkGetDeviceAccelerationStructureCompatibilityKHR(vkGetInstanceProcAddr(instance, "vkGetDeviceAccelerationStructureCompatibilityKHR")); |
| vkGetAccelerationStructureBuildSizesKHR = |
| PFN_vkGetAccelerationStructureBuildSizesKHR(vkGetInstanceProcAddr(instance, "vkGetAccelerationStructureBuildSizesKHR")); |
| |
| //=== VK_KHR_sampler_ycbcr_conversion === |
| vkCreateSamplerYcbcrConversionKHR = PFN_vkCreateSamplerYcbcrConversionKHR(vkGetInstanceProcAddr(instance, "vkCreateSamplerYcbcrConversionKHR")); |
| if(!vkCreateSamplerYcbcrConversion) |
| vkCreateSamplerYcbcrConversion = vkCreateSamplerYcbcrConversionKHR; |
| vkDestroySamplerYcbcrConversionKHR = PFN_vkDestroySamplerYcbcrConversionKHR(vkGetInstanceProcAddr(instance, "vkDestroySamplerYcbcrConversionKHR")); |
| if(!vkDestroySamplerYcbcrConversion) |
| vkDestroySamplerYcbcrConversion = vkDestroySamplerYcbcrConversionKHR; |
| |
| //=== VK_KHR_bind_memory2 === |
| vkBindBufferMemory2KHR = PFN_vkBindBufferMemory2KHR(vkGetInstanceProcAddr(instance, "vkBindBufferMemory2KHR")); |
| if(!vkBindBufferMemory2) |
| vkBindBufferMemory2 = vkBindBufferMemory2KHR; |
| vkBindImageMemory2KHR = PFN_vkBindImageMemory2KHR(vkGetInstanceProcAddr(instance, "vkBindImageMemory2KHR")); |
| if(!vkBindImageMemory2) |
| vkBindImageMemory2 = vkBindImageMemory2KHR; |
| |
| //=== VK_EXT_image_drm_format_modifier === |
| vkGetImageDrmFormatModifierPropertiesEXT = |
| PFN_vkGetImageDrmFormatModifierPropertiesEXT(vkGetInstanceProcAddr(instance, "vkGetImageDrmFormatModifierPropertiesEXT")); |
| |
| //=== VK_EXT_validation_cache === |
| vkCreateValidationCacheEXT = PFN_vkCreateValidationCacheEXT(vkGetInstanceProcAddr(instance, "vkCreateValidationCacheEXT")); |
| vkDestroyValidationCacheEXT = PFN_vkDestroyValidationCacheEXT(vkGetInstanceProcAddr(instance, "vkDestroyValidationCacheEXT")); |
| vkMergeValidationCachesEXT = PFN_vkMergeValidationCachesEXT(vkGetInstanceProcAddr(instance, "vkMergeValidationCachesEXT")); |
| vkGetValidationCacheDataEXT = PFN_vkGetValidationCacheDataEXT(vkGetInstanceProcAddr(instance, "vkGetValidationCacheDataEXT")); |
| |
| //=== VK_NV_shading_rate_image === |
| vkCmdBindShadingRateImageNV = PFN_vkCmdBindShadingRateImageNV(vkGetInstanceProcAddr(instance, "vkCmdBindShadingRateImageNV")); |
| vkCmdSetViewportShadingRatePaletteNV = |
| PFN_vkCmdSetViewportShadingRatePaletteNV(vkGetInstanceProcAddr(instance, "vkCmdSetViewportShadingRatePaletteNV")); |
| vkCmdSetCoarseSampleOrderNV = PFN_vkCmdSetCoarseSampleOrderNV(vkGetInstanceProcAddr(instance, "vkCmdSetCoarseSampleOrderNV")); |
| |
| //=== VK_NV_ray_tracing === |
| vkCreateAccelerationStructureNV = PFN_vkCreateAccelerationStructureNV(vkGetInstanceProcAddr(instance, "vkCreateAccelerationStructureNV")); |
| vkDestroyAccelerationStructureNV = PFN_vkDestroyAccelerationStructureNV(vkGetInstanceProcAddr(instance, "vkDestroyAccelerationStructureNV")); |
| vkGetAccelerationStructureMemoryRequirementsNV = |
| PFN_vkGetAccelerationStructureMemoryRequirementsNV(vkGetInstanceProcAddr(instance, "vkGetAccelerationStructureMemoryRequirementsNV")); |
| vkBindAccelerationStructureMemoryNV = PFN_vkBindAccelerationStructureMemoryNV(vkGetInstanceProcAddr(instance, "vkBindAccelerationStructureMemoryNV")); |
| vkCmdBuildAccelerationStructureNV = PFN_vkCmdBuildAccelerationStructureNV(vkGetInstanceProcAddr(instance, "vkCmdBuildAccelerationStructureNV")); |
| vkCmdCopyAccelerationStructureNV = PFN_vkCmdCopyAccelerationStructureNV(vkGetInstanceProcAddr(instance, "vkCmdCopyAccelerationStructureNV")); |
| vkCmdTraceRaysNV = PFN_vkCmdTraceRaysNV(vkGetInstanceProcAddr(instance, "vkCmdTraceRaysNV")); |
| vkCreateRayTracingPipelinesNV = PFN_vkCreateRayTracingPipelinesNV(vkGetInstanceProcAddr(instance, "vkCreateRayTracingPipelinesNV")); |
| vkGetRayTracingShaderGroupHandlesNV = PFN_vkGetRayTracingShaderGroupHandlesNV(vkGetInstanceProcAddr(instance, "vkGetRayTracingShaderGroupHandlesNV")); |
| if(!vkGetRayTracingShaderGroupHandlesKHR) |
| vkGetRayTracingShaderGroupHandlesKHR = vkGetRayTracingShaderGroupHandlesNV; |
| vkGetAccelerationStructureHandleNV = PFN_vkGetAccelerationStructureHandleNV(vkGetInstanceProcAddr(instance, "vkGetAccelerationStructureHandleNV")); |
| vkCmdWriteAccelerationStructuresPropertiesNV = |
| PFN_vkCmdWriteAccelerationStructuresPropertiesNV(vkGetInstanceProcAddr(instance, "vkCmdWriteAccelerationStructuresPropertiesNV")); |
| vkCompileDeferredNV = PFN_vkCompileDeferredNV(vkGetInstanceProcAddr(instance, "vkCompileDeferredNV")); |
| |
| //=== VK_KHR_maintenance3 === |
| vkGetDescriptorSetLayoutSupportKHR = PFN_vkGetDescriptorSetLayoutSupportKHR(vkGetInstanceProcAddr(instance, "vkGetDescriptorSetLayoutSupportKHR")); |
| if(!vkGetDescriptorSetLayoutSupport) |
| vkGetDescriptorSetLayoutSupport = vkGetDescriptorSetLayoutSupportKHR; |
| |
| //=== VK_KHR_draw_indirect_count === |
| vkCmdDrawIndirectCountKHR = PFN_vkCmdDrawIndirectCountKHR(vkGetInstanceProcAddr(instance, "vkCmdDrawIndirectCountKHR")); |
| if(!vkCmdDrawIndirectCount) |
| vkCmdDrawIndirectCount = vkCmdDrawIndirectCountKHR; |
| vkCmdDrawIndexedIndirectCountKHR = PFN_vkCmdDrawIndexedIndirectCountKHR(vkGetInstanceProcAddr(instance, "vkCmdDrawIndexedIndirectCountKHR")); |
| if(!vkCmdDrawIndexedIndirectCount) |
| vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountKHR; |
| |
| //=== VK_EXT_external_memory_host === |
| vkGetMemoryHostPointerPropertiesEXT = PFN_vkGetMemoryHostPointerPropertiesEXT(vkGetInstanceProcAddr(instance, "vkGetMemoryHostPointerPropertiesEXT")); |
| |
| //=== VK_AMD_buffer_marker === |
| vkCmdWriteBufferMarkerAMD = PFN_vkCmdWriteBufferMarkerAMD(vkGetInstanceProcAddr(instance, "vkCmdWriteBufferMarkerAMD")); |
| |
| //=== VK_EXT_calibrated_timestamps === |
| vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = |
| PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT")); |
| vkGetCalibratedTimestampsEXT = PFN_vkGetCalibratedTimestampsEXT(vkGetInstanceProcAddr(instance, "vkGetCalibratedTimestampsEXT")); |
| |
| //=== VK_NV_mesh_shader === |
| vkCmdDrawMeshTasksNV = PFN_vkCmdDrawMeshTasksNV(vkGetInstanceProcAddr(instance, "vkCmdDrawMeshTasksNV")); |
| vkCmdDrawMeshTasksIndirectNV = PFN_vkCmdDrawMeshTasksIndirectNV(vkGetInstanceProcAddr(instance, "vkCmdDrawMeshTasksIndirectNV")); |
| vkCmdDrawMeshTasksIndirectCountNV = PFN_vkCmdDrawMeshTasksIndirectCountNV(vkGetInstanceProcAddr(instance, "vkCmdDrawMeshTasksIndirectCountNV")); |
| |
| //=== VK_NV_scissor_exclusive === |
| vkCmdSetExclusiveScissorNV = PFN_vkCmdSetExclusiveScissorNV(vkGetInstanceProcAddr(instance, "vkCmdSetExclusiveScissorNV")); |
| |
| //=== VK_NV_device_diagnostic_checkpoints === |
| vkCmdSetCheckpointNV = PFN_vkCmdSetCheckpointNV(vkGetInstanceProcAddr(instance, "vkCmdSetCheckpointNV")); |
| vkGetQueueCheckpointDataNV = PFN_vkGetQueueCheckpointDataNV(vkGetInstanceProcAddr(instance, "vkGetQueueCheckpointDataNV")); |
| |
| //=== VK_KHR_timeline_semaphore === |
| vkGetSemaphoreCounterValueKHR = PFN_vkGetSemaphoreCounterValueKHR(vkGetInstanceProcAddr(instance, "vkGetSemaphoreCounterValueKHR")); |
| if(!vkGetSemaphoreCounterValue) |
| vkGetSemaphoreCounterValue = vkGetSemaphoreCounterValueKHR; |
| vkWaitSemaphoresKHR = PFN_vkWaitSemaphoresKHR(vkGetInstanceProcAddr(instance, "vkWaitSemaphoresKHR")); |
| if(!vkWaitSemaphores) |
| vkWaitSemaphores = vkWaitSemaphoresKHR; |
| vkSignalSemaphoreKHR = PFN_vkSignalSemaphoreKHR(vkGetInstanceProcAddr(instance, "vkSignalSemaphoreKHR")); |
| if(!vkSignalSemaphore) |
| vkSignalSemaphore = vkSignalSemaphoreKHR; |
| |
| //=== VK_INTEL_performance_query === |
| vkInitializePerformanceApiINTEL = PFN_vkInitializePerformanceApiINTEL(vkGetInstanceProcAddr(instance, "vkInitializePerformanceApiINTEL")); |
| vkUninitializePerformanceApiINTEL = PFN_vkUninitializePerformanceApiINTEL(vkGetInstanceProcAddr(instance, "vkUninitializePerformanceApiINTEL")); |
| vkCmdSetPerformanceMarkerINTEL = PFN_vkCmdSetPerformanceMarkerINTEL(vkGetInstanceProcAddr(instance, "vkCmdSetPerformanceMarkerINTEL")); |
| vkCmdSetPerformanceStreamMarkerINTEL = |
| PFN_vkCmdSetPerformanceStreamMarkerINTEL(vkGetInstanceProcAddr(instance, "vkCmdSetPerformanceStreamMarkerINTEL")); |
| vkCmdSetPerformanceOverrideINTEL = PFN_vkCmdSetPerformanceOverrideINTEL(vkGetInstanceProcAddr(instance, "vkCmdSetPerformanceOverrideINTEL")); |
| vkAcquirePerformanceConfigurationINTEL = |
| PFN_vkAcquirePerformanceConfigurationINTEL(vkGetInstanceProcAddr(instance, "vkAcquirePerformanceConfigurationINTEL")); |
| vkReleasePerformanceConfigurationINTEL = |
| PFN_vkReleasePerformanceConfigurationINTEL(vkGetInstanceProcAddr(instance, "vkReleasePerformanceConfigurationINTEL")); |
| vkQueueSetPerformanceConfigurationINTEL = |
| PFN_vkQueueSetPerformanceConfigurationINTEL(vkGetInstanceProcAddr(instance, "vkQueueSetPerformanceConfigurationINTEL")); |
| vkGetPerformanceParameterINTEL = PFN_vkGetPerformanceParameterINTEL(vkGetInstanceProcAddr(instance, "vkGetPerformanceParameterINTEL")); |
| |
| //=== VK_AMD_display_native_hdr === |
| vkSetLocalDimmingAMD = PFN_vkSetLocalDimmingAMD(vkGetInstanceProcAddr(instance, "vkSetLocalDimmingAMD")); |
| |
| #if defined(VK_USE_PLATFORM_FUCHSIA) |
| //=== VK_FUCHSIA_imagepipe_surface === |
| vkCreateImagePipeSurfaceFUCHSIA = PFN_vkCreateImagePipeSurfaceFUCHSIA(vkGetInstanceProcAddr(instance, "vkCreateImagePipeSurfaceFUCHSIA")); |
| #endif /*VK_USE_PLATFORM_FUCHSIA*/ |
| |
| #if defined(VK_USE_PLATFORM_METAL_EXT) |
| //=== VK_EXT_metal_surface === |
| vkCreateMetalSurfaceEXT = PFN_vkCreateMetalSurfaceEXT(vkGetInstanceProcAddr(instance, "vkCreateMetalSurfaceEXT")); |
| #endif /*VK_USE_PLATFORM_METAL_EXT*/ |
| |
| //=== VK_KHR_fragment_shading_rate === |
| vkGetPhysicalDeviceFragmentShadingRatesKHR = |
| PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFragmentShadingRatesKHR")); |
| vkCmdSetFragmentShadingRateKHR = PFN_vkCmdSetFragmentShadingRateKHR(vkGetInstanceProcAddr(instance, "vkCmdSetFragmentShadingRateKHR")); |
| |
| //=== VK_EXT_buffer_device_address === |
| vkGetBufferDeviceAddressEXT = PFN_vkGetBufferDeviceAddressEXT(vkGetInstanceProcAddr(instance, "vkGetBufferDeviceAddressEXT")); |
| if(!vkGetBufferDeviceAddress) |
| vkGetBufferDeviceAddress = vkGetBufferDeviceAddressEXT; |
| |
| //=== VK_EXT_tooling_info === |
| vkGetPhysicalDeviceToolPropertiesEXT = |
| PFN_vkGetPhysicalDeviceToolPropertiesEXT(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceToolPropertiesEXT")); |
| if(!vkGetPhysicalDeviceToolProperties) |
| vkGetPhysicalDeviceToolProperties = vkGetPhysicalDeviceToolPropertiesEXT; |
| |
| //=== VK_KHR_present_wait === |
| vkWaitForPresentKHR = PFN_vkWaitForPresentKHR(vkGetInstanceProcAddr(instance, "vkWaitForPresentKHR")); |
| |
| //=== VK_NV_cooperative_matrix === |
| vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = |
| PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV")); |
| |
| //=== VK_NV_coverage_reduction_mode === |
| vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( |
| vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV")); |
| |
| #if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_EXT_full_screen_exclusive === |
| vkGetPhysicalDeviceSurfacePresentModes2EXT = |
| PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceSurfacePresentModes2EXT")); |
| vkAcquireFullScreenExclusiveModeEXT = PFN_vkAcquireFullScreenExclusiveModeEXT(vkGetInstanceProcAddr(instance, "vkAcquireFullScreenExclusiveModeEXT")); |
| vkReleaseFullScreenExclusiveModeEXT = PFN_vkReleaseFullScreenExclusiveModeEXT(vkGetInstanceProcAddr(instance, "vkReleaseFullScreenExclusiveModeEXT")); |
| vkGetDeviceGroupSurfacePresentModes2EXT = |
| PFN_vkGetDeviceGroupSurfacePresentModes2EXT(vkGetInstanceProcAddr(instance, "vkGetDeviceGroupSurfacePresentModes2EXT")); |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_EXT_headless_surface === |
| vkCreateHeadlessSurfaceEXT = PFN_vkCreateHeadlessSurfaceEXT(vkGetInstanceProcAddr(instance, "vkCreateHeadlessSurfaceEXT")); |
| |
| //=== VK_KHR_buffer_device_address === |
| vkGetBufferDeviceAddressKHR = PFN_vkGetBufferDeviceAddressKHR(vkGetInstanceProcAddr(instance, "vkGetBufferDeviceAddressKHR")); |
| if(!vkGetBufferDeviceAddress) |
| vkGetBufferDeviceAddress = vkGetBufferDeviceAddressKHR; |
| vkGetBufferOpaqueCaptureAddressKHR = PFN_vkGetBufferOpaqueCaptureAddressKHR(vkGetInstanceProcAddr(instance, "vkGetBufferOpaqueCaptureAddressKHR")); |
| if(!vkGetBufferOpaqueCaptureAddress) |
| vkGetBufferOpaqueCaptureAddress = vkGetBufferOpaqueCaptureAddressKHR; |
| vkGetDeviceMemoryOpaqueCaptureAddressKHR = |
| PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR(vkGetInstanceProcAddr(instance, "vkGetDeviceMemoryOpaqueCaptureAddressKHR")); |
| if(!vkGetDeviceMemoryOpaqueCaptureAddress) |
| vkGetDeviceMemoryOpaqueCaptureAddress = vkGetDeviceMemoryOpaqueCaptureAddressKHR; |
| |
| //=== VK_EXT_line_rasterization === |
| vkCmdSetLineStippleEXT = PFN_vkCmdSetLineStippleEXT(vkGetInstanceProcAddr(instance, "vkCmdSetLineStippleEXT")); |
| |
| //=== VK_EXT_host_query_reset === |
| vkResetQueryPoolEXT = PFN_vkResetQueryPoolEXT(vkGetInstanceProcAddr(instance, "vkResetQueryPoolEXT")); |
| if(!vkResetQueryPool) |
| vkResetQueryPool = vkResetQueryPoolEXT; |
| |
| //=== VK_EXT_extended_dynamic_state === |
| vkCmdSetCullModeEXT = PFN_vkCmdSetCullModeEXT(vkGetInstanceProcAddr(instance, "vkCmdSetCullModeEXT")); |
| if(!vkCmdSetCullMode) |
| vkCmdSetCullMode = vkCmdSetCullModeEXT; |
| vkCmdSetFrontFaceEXT = PFN_vkCmdSetFrontFaceEXT(vkGetInstanceProcAddr(instance, "vkCmdSetFrontFaceEXT")); |
| if(!vkCmdSetFrontFace) |
| vkCmdSetFrontFace = vkCmdSetFrontFaceEXT; |
| vkCmdSetPrimitiveTopologyEXT = PFN_vkCmdSetPrimitiveTopologyEXT(vkGetInstanceProcAddr(instance, "vkCmdSetPrimitiveTopologyEXT")); |
| if(!vkCmdSetPrimitiveTopology) |
| vkCmdSetPrimitiveTopology = vkCmdSetPrimitiveTopologyEXT; |
| vkCmdSetViewportWithCountEXT = PFN_vkCmdSetViewportWithCountEXT(vkGetInstanceProcAddr(instance, "vkCmdSetViewportWithCountEXT")); |
| if(!vkCmdSetViewportWithCount) |
| vkCmdSetViewportWithCount = vkCmdSetViewportWithCountEXT; |
| vkCmdSetScissorWithCountEXT = PFN_vkCmdSetScissorWithCountEXT(vkGetInstanceProcAddr(instance, "vkCmdSetScissorWithCountEXT")); |
| if(!vkCmdSetScissorWithCount) |
| vkCmdSetScissorWithCount = vkCmdSetScissorWithCountEXT; |
| vkCmdBindVertexBuffers2EXT = PFN_vkCmdBindVertexBuffers2EXT(vkGetInstanceProcAddr(instance, "vkCmdBindVertexBuffers2EXT")); |
| if(!vkCmdBindVertexBuffers2) |
| vkCmdBindVertexBuffers2 = vkCmdBindVertexBuffers2EXT; |
| vkCmdSetDepthTestEnableEXT = PFN_vkCmdSetDepthTestEnableEXT(vkGetInstanceProcAddr(instance, "vkCmdSetDepthTestEnableEXT")); |
| if(!vkCmdSetDepthTestEnable) |
| vkCmdSetDepthTestEnable = vkCmdSetDepthTestEnableEXT; |
| vkCmdSetDepthWriteEnableEXT = PFN_vkCmdSetDepthWriteEnableEXT(vkGetInstanceProcAddr(instance, "vkCmdSetDepthWriteEnableEXT")); |
| if(!vkCmdSetDepthWriteEnable) |
| vkCmdSetDepthWriteEnable = vkCmdSetDepthWriteEnableEXT; |
| vkCmdSetDepthCompareOpEXT = PFN_vkCmdSetDepthCompareOpEXT(vkGetInstanceProcAddr(instance, "vkCmdSetDepthCompareOpEXT")); |
| if(!vkCmdSetDepthCompareOp) |
| vkCmdSetDepthCompareOp = vkCmdSetDepthCompareOpEXT; |
| vkCmdSetDepthBoundsTestEnableEXT = PFN_vkCmdSetDepthBoundsTestEnableEXT(vkGetInstanceProcAddr(instance, "vkCmdSetDepthBoundsTestEnableEXT")); |
| if(!vkCmdSetDepthBoundsTestEnable) |
| vkCmdSetDepthBoundsTestEnable = vkCmdSetDepthBoundsTestEnableEXT; |
| vkCmdSetStencilTestEnableEXT = PFN_vkCmdSetStencilTestEnableEXT(vkGetInstanceProcAddr(instance, "vkCmdSetStencilTestEnableEXT")); |
| if(!vkCmdSetStencilTestEnable) |
| vkCmdSetStencilTestEnable = vkCmdSetStencilTestEnableEXT; |
| vkCmdSetStencilOpEXT = PFN_vkCmdSetStencilOpEXT(vkGetInstanceProcAddr(instance, "vkCmdSetStencilOpEXT")); |
| if(!vkCmdSetStencilOp) |
| vkCmdSetStencilOp = vkCmdSetStencilOpEXT; |
| |
| //=== VK_KHR_deferred_host_operations === |
| vkCreateDeferredOperationKHR = PFN_vkCreateDeferredOperationKHR(vkGetInstanceProcAddr(instance, "vkCreateDeferredOperationKHR")); |
| vkDestroyDeferredOperationKHR = PFN_vkDestroyDeferredOperationKHR(vkGetInstanceProcAddr(instance, "vkDestroyDeferredOperationKHR")); |
| vkGetDeferredOperationMaxConcurrencyKHR = |
| PFN_vkGetDeferredOperationMaxConcurrencyKHR(vkGetInstanceProcAddr(instance, "vkGetDeferredOperationMaxConcurrencyKHR")); |
| vkGetDeferredOperationResultKHR = PFN_vkGetDeferredOperationResultKHR(vkGetInstanceProcAddr(instance, "vkGetDeferredOperationResultKHR")); |
| vkDeferredOperationJoinKHR = PFN_vkDeferredOperationJoinKHR(vkGetInstanceProcAddr(instance, "vkDeferredOperationJoinKHR")); |
| |
| //=== VK_KHR_pipeline_executable_properties === |
| vkGetPipelineExecutablePropertiesKHR = |
| PFN_vkGetPipelineExecutablePropertiesKHR(vkGetInstanceProcAddr(instance, "vkGetPipelineExecutablePropertiesKHR")); |
| vkGetPipelineExecutableStatisticsKHR = |
| PFN_vkGetPipelineExecutableStatisticsKHR(vkGetInstanceProcAddr(instance, "vkGetPipelineExecutableStatisticsKHR")); |
| vkGetPipelineExecutableInternalRepresentationsKHR = |
| PFN_vkGetPipelineExecutableInternalRepresentationsKHR(vkGetInstanceProcAddr(instance, "vkGetPipelineExecutableInternalRepresentationsKHR")); |
| |
| //=== VK_NV_device_generated_commands === |
| vkGetGeneratedCommandsMemoryRequirementsNV = |
| PFN_vkGetGeneratedCommandsMemoryRequirementsNV(vkGetInstanceProcAddr(instance, "vkGetGeneratedCommandsMemoryRequirementsNV")); |
| vkCmdPreprocessGeneratedCommandsNV = PFN_vkCmdPreprocessGeneratedCommandsNV(vkGetInstanceProcAddr(instance, "vkCmdPreprocessGeneratedCommandsNV")); |
| vkCmdExecuteGeneratedCommandsNV = PFN_vkCmdExecuteGeneratedCommandsNV(vkGetInstanceProcAddr(instance, "vkCmdExecuteGeneratedCommandsNV")); |
| vkCmdBindPipelineShaderGroupNV = PFN_vkCmdBindPipelineShaderGroupNV(vkGetInstanceProcAddr(instance, "vkCmdBindPipelineShaderGroupNV")); |
| vkCreateIndirectCommandsLayoutNV = PFN_vkCreateIndirectCommandsLayoutNV(vkGetInstanceProcAddr(instance, "vkCreateIndirectCommandsLayoutNV")); |
| vkDestroyIndirectCommandsLayoutNV = PFN_vkDestroyIndirectCommandsLayoutNV(vkGetInstanceProcAddr(instance, "vkDestroyIndirectCommandsLayoutNV")); |
| |
| //=== VK_EXT_acquire_drm_display === |
| vkAcquireDrmDisplayEXT = PFN_vkAcquireDrmDisplayEXT(vkGetInstanceProcAddr(instance, "vkAcquireDrmDisplayEXT")); |
| vkGetDrmDisplayEXT = PFN_vkGetDrmDisplayEXT(vkGetInstanceProcAddr(instance, "vkGetDrmDisplayEXT")); |
| |
| //=== VK_EXT_private_data === |
| vkCreatePrivateDataSlotEXT = PFN_vkCreatePrivateDataSlotEXT(vkGetInstanceProcAddr(instance, "vkCreatePrivateDataSlotEXT")); |
| if(!vkCreatePrivateDataSlot) |
| vkCreatePrivateDataSlot = vkCreatePrivateDataSlotEXT; |
| vkDestroyPrivateDataSlotEXT = PFN_vkDestroyPrivateDataSlotEXT(vkGetInstanceProcAddr(instance, "vkDestroyPrivateDataSlotEXT")); |
| if(!vkDestroyPrivateDataSlot) |
| vkDestroyPrivateDataSlot = vkDestroyPrivateDataSlotEXT; |
| vkSetPrivateDataEXT = PFN_vkSetPrivateDataEXT(vkGetInstanceProcAddr(instance, "vkSetPrivateDataEXT")); |
| if(!vkSetPrivateData) |
| vkSetPrivateData = vkSetPrivateDataEXT; |
| vkGetPrivateDataEXT = PFN_vkGetPrivateDataEXT(vkGetInstanceProcAddr(instance, "vkGetPrivateDataEXT")); |
| if(!vkGetPrivateData) |
| vkGetPrivateData = vkGetPrivateDataEXT; |
| |
| #if defined(VK_ENABLE_BETA_EXTENSIONS) |
| //=== VK_KHR_video_encode_queue === |
| vkCmdEncodeVideoKHR = PFN_vkCmdEncodeVideoKHR(vkGetInstanceProcAddr(instance, "vkCmdEncodeVideoKHR")); |
| #endif /*VK_ENABLE_BETA_EXTENSIONS*/ |
| |
| //=== VK_KHR_synchronization2 === |
| vkCmdSetEvent2KHR = PFN_vkCmdSetEvent2KHR(vkGetInstanceProcAddr(instance, "vkCmdSetEvent2KHR")); |
| if(!vkCmdSetEvent2) |
| vkCmdSetEvent2 = vkCmdSetEvent2KHR; |
| vkCmdResetEvent2KHR = PFN_vkCmdResetEvent2KHR(vkGetInstanceProcAddr(instance, "vkCmdResetEvent2KHR")); |
| if(!vkCmdResetEvent2) |
| vkCmdResetEvent2 = vkCmdResetEvent2KHR; |
| vkCmdWaitEvents2KHR = PFN_vkCmdWaitEvents2KHR(vkGetInstanceProcAddr(instance, "vkCmdWaitEvents2KHR")); |
| if(!vkCmdWaitEvents2) |
| vkCmdWaitEvents2 = vkCmdWaitEvents2KHR; |
| vkCmdPipelineBarrier2KHR = PFN_vkCmdPipelineBarrier2KHR(vkGetInstanceProcAddr(instance, "vkCmdPipelineBarrier2KHR")); |
| if(!vkCmdPipelineBarrier2) |
| vkCmdPipelineBarrier2 = vkCmdPipelineBarrier2KHR; |
| vkCmdWriteTimestamp2KHR = PFN_vkCmdWriteTimestamp2KHR(vkGetInstanceProcAddr(instance, "vkCmdWriteTimestamp2KHR")); |
| if(!vkCmdWriteTimestamp2) |
| vkCmdWriteTimestamp2 = vkCmdWriteTimestamp2KHR; |
| vkQueueSubmit2KHR = PFN_vkQueueSubmit2KHR(vkGetInstanceProcAddr(instance, "vkQueueSubmit2KHR")); |
| if(!vkQueueSubmit2) |
| vkQueueSubmit2 = vkQueueSubmit2KHR; |
| vkCmdWriteBufferMarker2AMD = PFN_vkCmdWriteBufferMarker2AMD(vkGetInstanceProcAddr(instance, "vkCmdWriteBufferMarker2AMD")); |
| vkGetQueueCheckpointData2NV = PFN_vkGetQueueCheckpointData2NV(vkGetInstanceProcAddr(instance, "vkGetQueueCheckpointData2NV")); |
| |
| //=== VK_NV_fragment_shading_rate_enums === |
| vkCmdSetFragmentShadingRateEnumNV = PFN_vkCmdSetFragmentShadingRateEnumNV(vkGetInstanceProcAddr(instance, "vkCmdSetFragmentShadingRateEnumNV")); |
| |
| //=== VK_KHR_copy_commands2 === |
| vkCmdCopyBuffer2KHR = PFN_vkCmdCopyBuffer2KHR(vkGetInstanceProcAddr(instance, "vkCmdCopyBuffer2KHR")); |
| if(!vkCmdCopyBuffer2) |
| vkCmdCopyBuffer2 = vkCmdCopyBuffer2KHR; |
| vkCmdCopyImage2KHR = PFN_vkCmdCopyImage2KHR(vkGetInstanceProcAddr(instance, "vkCmdCopyImage2KHR")); |
| if(!vkCmdCopyImage2) |
| vkCmdCopyImage2 = vkCmdCopyImage2KHR; |
| vkCmdCopyBufferToImage2KHR = PFN_vkCmdCopyBufferToImage2KHR(vkGetInstanceProcAddr(instance, "vkCmdCopyBufferToImage2KHR")); |
| if(!vkCmdCopyBufferToImage2) |
| vkCmdCopyBufferToImage2 = vkCmdCopyBufferToImage2KHR; |
| vkCmdCopyImageToBuffer2KHR = PFN_vkCmdCopyImageToBuffer2KHR(vkGetInstanceProcAddr(instance, "vkCmdCopyImageToBuffer2KHR")); |
| if(!vkCmdCopyImageToBuffer2) |
| vkCmdCopyImageToBuffer2 = vkCmdCopyImageToBuffer2KHR; |
| vkCmdBlitImage2KHR = PFN_vkCmdBlitImage2KHR(vkGetInstanceProcAddr(instance, "vkCmdBlitImage2KHR")); |
| if(!vkCmdBlitImage2) |
| vkCmdBlitImage2 = vkCmdBlitImage2KHR; |
| vkCmdResolveImage2KHR = PFN_vkCmdResolveImage2KHR(vkGetInstanceProcAddr(instance, "vkCmdResolveImage2KHR")); |
| if(!vkCmdResolveImage2) |
| vkCmdResolveImage2 = vkCmdResolveImage2KHR; |
| |
| #if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_NV_acquire_winrt_display === |
| vkAcquireWinrtDisplayNV = PFN_vkAcquireWinrtDisplayNV(vkGetInstanceProcAddr(instance, "vkAcquireWinrtDisplayNV")); |
| vkGetWinrtDisplayNV = PFN_vkGetWinrtDisplayNV(vkGetInstanceProcAddr(instance, "vkGetWinrtDisplayNV")); |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| #if defined(VK_USE_PLATFORM_DIRECTFB_EXT) |
| //=== VK_EXT_directfb_surface === |
| vkCreateDirectFBSurfaceEXT = PFN_vkCreateDirectFBSurfaceEXT(vkGetInstanceProcAddr(instance, "vkCreateDirectFBSurfaceEXT")); |
| vkGetPhysicalDeviceDirectFBPresentationSupportEXT = |
| PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceDirectFBPresentationSupportEXT")); |
| #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ |
| |
| //=== VK_KHR_ray_tracing_pipeline === |
| vkCmdTraceRaysKHR = PFN_vkCmdTraceRaysKHR(vkGetInstanceProcAddr(instance, "vkCmdTraceRaysKHR")); |
| vkCreateRayTracingPipelinesKHR = PFN_vkCreateRayTracingPipelinesKHR(vkGetInstanceProcAddr(instance, "vkCreateRayTracingPipelinesKHR")); |
| vkGetRayTracingShaderGroupHandlesKHR = |
| PFN_vkGetRayTracingShaderGroupHandlesKHR(vkGetInstanceProcAddr(instance, "vkGetRayTracingShaderGroupHandlesKHR")); |
| vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = |
| PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(vkGetInstanceProcAddr(instance, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR")); |
| vkCmdTraceRaysIndirectKHR = PFN_vkCmdTraceRaysIndirectKHR(vkGetInstanceProcAddr(instance, "vkCmdTraceRaysIndirectKHR")); |
| vkGetRayTracingShaderGroupStackSizeKHR = |
| PFN_vkGetRayTracingShaderGroupStackSizeKHR(vkGetInstanceProcAddr(instance, "vkGetRayTracingShaderGroupStackSizeKHR")); |
| vkCmdSetRayTracingPipelineStackSizeKHR = |
| PFN_vkCmdSetRayTracingPipelineStackSizeKHR(vkGetInstanceProcAddr(instance, "vkCmdSetRayTracingPipelineStackSizeKHR")); |
| |
| //=== VK_EXT_vertex_input_dynamic_state === |
| vkCmdSetVertexInputEXT = PFN_vkCmdSetVertexInputEXT(vkGetInstanceProcAddr(instance, "vkCmdSetVertexInputEXT")); |
| |
| #if defined(VK_USE_PLATFORM_FUCHSIA) |
| //=== VK_FUCHSIA_external_memory === |
| vkGetMemoryZirconHandleFUCHSIA = PFN_vkGetMemoryZirconHandleFUCHSIA(vkGetInstanceProcAddr(instance, "vkGetMemoryZirconHandleFUCHSIA")); |
| vkGetMemoryZirconHandlePropertiesFUCHSIA = |
| PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA(vkGetInstanceProcAddr(instance, "vkGetMemoryZirconHandlePropertiesFUCHSIA")); |
| #endif /*VK_USE_PLATFORM_FUCHSIA*/ |
| |
| #if defined(VK_USE_PLATFORM_FUCHSIA) |
| //=== VK_FUCHSIA_external_semaphore === |
| vkImportSemaphoreZirconHandleFUCHSIA = |
| PFN_vkImportSemaphoreZirconHandleFUCHSIA(vkGetInstanceProcAddr(instance, "vkImportSemaphoreZirconHandleFUCHSIA")); |
| vkGetSemaphoreZirconHandleFUCHSIA = PFN_vkGetSemaphoreZirconHandleFUCHSIA(vkGetInstanceProcAddr(instance, "vkGetSemaphoreZirconHandleFUCHSIA")); |
| #endif /*VK_USE_PLATFORM_FUCHSIA*/ |
| |
| #if defined(VK_USE_PLATFORM_FUCHSIA) |
| //=== VK_FUCHSIA_buffer_collection === |
| vkCreateBufferCollectionFUCHSIA = PFN_vkCreateBufferCollectionFUCHSIA(vkGetInstanceProcAddr(instance, "vkCreateBufferCollectionFUCHSIA")); |
| vkSetBufferCollectionImageConstraintsFUCHSIA = |
| PFN_vkSetBufferCollectionImageConstraintsFUCHSIA(vkGetInstanceProcAddr(instance, "vkSetBufferCollectionImageConstraintsFUCHSIA")); |
| vkSetBufferCollectionBufferConstraintsFUCHSIA = |
| PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA(vkGetInstanceProcAddr(instance, "vkSetBufferCollectionBufferConstraintsFUCHSIA")); |
| vkDestroyBufferCollectionFUCHSIA = PFN_vkDestroyBufferCollectionFUCHSIA(vkGetInstanceProcAddr(instance, "vkDestroyBufferCollectionFUCHSIA")); |
| vkGetBufferCollectionPropertiesFUCHSIA = |
| PFN_vkGetBufferCollectionPropertiesFUCHSIA(vkGetInstanceProcAddr(instance, "vkGetBufferCollectionPropertiesFUCHSIA")); |
| #endif /*VK_USE_PLATFORM_FUCHSIA*/ |
| |
| //=== VK_HUAWEI_subpass_shading === |
| vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = |
| PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(vkGetInstanceProcAddr(instance, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI")); |
| vkCmdSubpassShadingHUAWEI = PFN_vkCmdSubpassShadingHUAWEI(vkGetInstanceProcAddr(instance, "vkCmdSubpassShadingHUAWEI")); |
| |
| //=== VK_HUAWEI_invocation_mask === |
| vkCmdBindInvocationMaskHUAWEI = PFN_vkCmdBindInvocationMaskHUAWEI(vkGetInstanceProcAddr(instance, "vkCmdBindInvocationMaskHUAWEI")); |
| |
| //=== VK_NV_external_memory_rdma === |
| vkGetMemoryRemoteAddressNV = PFN_vkGetMemoryRemoteAddressNV(vkGetInstanceProcAddr(instance, "vkGetMemoryRemoteAddressNV")); |
| |
| //=== VK_EXT_extended_dynamic_state2 === |
| vkCmdSetPatchControlPointsEXT = PFN_vkCmdSetPatchControlPointsEXT(vkGetInstanceProcAddr(instance, "vkCmdSetPatchControlPointsEXT")); |
| vkCmdSetRasterizerDiscardEnableEXT = PFN_vkCmdSetRasterizerDiscardEnableEXT(vkGetInstanceProcAddr(instance, "vkCmdSetRasterizerDiscardEnableEXT")); |
| if(!vkCmdSetRasterizerDiscardEnable) |
| vkCmdSetRasterizerDiscardEnable = vkCmdSetRasterizerDiscardEnableEXT; |
| vkCmdSetDepthBiasEnableEXT = PFN_vkCmdSetDepthBiasEnableEXT(vkGetInstanceProcAddr(instance, "vkCmdSetDepthBiasEnableEXT")); |
| if(!vkCmdSetDepthBiasEnable) |
| vkCmdSetDepthBiasEnable = vkCmdSetDepthBiasEnableEXT; |
| vkCmdSetLogicOpEXT = PFN_vkCmdSetLogicOpEXT(vkGetInstanceProcAddr(instance, "vkCmdSetLogicOpEXT")); |
| vkCmdSetPrimitiveRestartEnableEXT = PFN_vkCmdSetPrimitiveRestartEnableEXT(vkGetInstanceProcAddr(instance, "vkCmdSetPrimitiveRestartEnableEXT")); |
| if(!vkCmdSetPrimitiveRestartEnable) |
| vkCmdSetPrimitiveRestartEnable = vkCmdSetPrimitiveRestartEnableEXT; |
| |
| #if defined(VK_USE_PLATFORM_SCREEN_QNX) |
| //=== VK_QNX_screen_surface === |
| vkCreateScreenSurfaceQNX = PFN_vkCreateScreenSurfaceQNX(vkGetInstanceProcAddr(instance, "vkCreateScreenSurfaceQNX")); |
| vkGetPhysicalDeviceScreenPresentationSupportQNX = |
| PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX(vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceScreenPresentationSupportQNX")); |
| #endif /*VK_USE_PLATFORM_SCREEN_QNX*/ |
| |
| //=== VK_EXT_color_write_enable === |
| vkCmdSetColorWriteEnableEXT = PFN_vkCmdSetColorWriteEnableEXT(vkGetInstanceProcAddr(instance, "vkCmdSetColorWriteEnableEXT")); |
| |
| //=== VK_EXT_multi_draw === |
| vkCmdDrawMultiEXT = PFN_vkCmdDrawMultiEXT(vkGetInstanceProcAddr(instance, "vkCmdDrawMultiEXT")); |
| vkCmdDrawMultiIndexedEXT = PFN_vkCmdDrawMultiIndexedEXT(vkGetInstanceProcAddr(instance, "vkCmdDrawMultiIndexedEXT")); |
| |
| //=== VK_EXT_pageable_device_local_memory === |
| vkSetDeviceMemoryPriorityEXT = PFN_vkSetDeviceMemoryPriorityEXT(vkGetInstanceProcAddr(instance, "vkSetDeviceMemoryPriorityEXT")); |
| |
| //=== VK_KHR_maintenance4 === |
| vkGetDeviceBufferMemoryRequirementsKHR = |
| PFN_vkGetDeviceBufferMemoryRequirementsKHR(vkGetInstanceProcAddr(instance, "vkGetDeviceBufferMemoryRequirementsKHR")); |
| if(!vkGetDeviceBufferMemoryRequirements) |
| vkGetDeviceBufferMemoryRequirements = vkGetDeviceBufferMemoryRequirementsKHR; |
| vkGetDeviceImageMemoryRequirementsKHR = |
| PFN_vkGetDeviceImageMemoryRequirementsKHR(vkGetInstanceProcAddr(instance, "vkGetDeviceImageMemoryRequirementsKHR")); |
| if(!vkGetDeviceImageMemoryRequirements) |
| vkGetDeviceImageMemoryRequirements = vkGetDeviceImageMemoryRequirementsKHR; |
| vkGetDeviceImageSparseMemoryRequirementsKHR = |
| PFN_vkGetDeviceImageSparseMemoryRequirementsKHR(vkGetInstanceProcAddr(instance, "vkGetDeviceImageSparseMemoryRequirementsKHR")); |
| if(!vkGetDeviceImageSparseMemoryRequirements) |
| vkGetDeviceImageSparseMemoryRequirements = vkGetDeviceImageSparseMemoryRequirementsKHR; |
| |
| //=== VK_VALVE_descriptor_set_host_mapping === |
| vkGetDescriptorSetLayoutHostMappingInfoVALVE = |
| PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE(vkGetInstanceProcAddr(instance, "vkGetDescriptorSetLayoutHostMappingInfoVALVE")); |
| vkGetDescriptorSetHostMappingVALVE = PFN_vkGetDescriptorSetHostMappingVALVE(vkGetInstanceProcAddr(instance, "vkGetDescriptorSetHostMappingVALVE")); |
| } |
| |
| void init(VULKAN_HPP_NAMESPACE::Device deviceCpp) VULKAN_HPP_NOEXCEPT |
| { |
| VkDevice device = static_cast<VkDevice>(deviceCpp); |
| |
| //=== VK_VERSION_1_0 === |
| vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr(vkGetDeviceProcAddr(device, "vkGetDeviceProcAddr")); |
| vkDestroyDevice = PFN_vkDestroyDevice(vkGetDeviceProcAddr(device, "vkDestroyDevice")); |
| vkGetDeviceQueue = PFN_vkGetDeviceQueue(vkGetDeviceProcAddr(device, "vkGetDeviceQueue")); |
| vkQueueSubmit = PFN_vkQueueSubmit(vkGetDeviceProcAddr(device, "vkQueueSubmit")); |
| vkQueueWaitIdle = PFN_vkQueueWaitIdle(vkGetDeviceProcAddr(device, "vkQueueWaitIdle")); |
| vkDeviceWaitIdle = PFN_vkDeviceWaitIdle(vkGetDeviceProcAddr(device, "vkDeviceWaitIdle")); |
| vkAllocateMemory = PFN_vkAllocateMemory(vkGetDeviceProcAddr(device, "vkAllocateMemory")); |
| vkFreeMemory = PFN_vkFreeMemory(vkGetDeviceProcAddr(device, "vkFreeMemory")); |
| vkMapMemory = PFN_vkMapMemory(vkGetDeviceProcAddr(device, "vkMapMemory")); |
| vkUnmapMemory = PFN_vkUnmapMemory(vkGetDeviceProcAddr(device, "vkUnmapMemory")); |
| vkFlushMappedMemoryRanges = PFN_vkFlushMappedMemoryRanges(vkGetDeviceProcAddr(device, "vkFlushMappedMemoryRanges")); |
| vkInvalidateMappedMemoryRanges = PFN_vkInvalidateMappedMemoryRanges(vkGetDeviceProcAddr(device, "vkInvalidateMappedMemoryRanges")); |
| vkGetDeviceMemoryCommitment = PFN_vkGetDeviceMemoryCommitment(vkGetDeviceProcAddr(device, "vkGetDeviceMemoryCommitment")); |
| vkBindBufferMemory = PFN_vkBindBufferMemory(vkGetDeviceProcAddr(device, "vkBindBufferMemory")); |
| vkBindImageMemory = PFN_vkBindImageMemory(vkGetDeviceProcAddr(device, "vkBindImageMemory")); |
| vkGetBufferMemoryRequirements = PFN_vkGetBufferMemoryRequirements(vkGetDeviceProcAddr(device, "vkGetBufferMemoryRequirements")); |
| vkGetImageMemoryRequirements = PFN_vkGetImageMemoryRequirements(vkGetDeviceProcAddr(device, "vkGetImageMemoryRequirements")); |
| vkGetImageSparseMemoryRequirements = PFN_vkGetImageSparseMemoryRequirements(vkGetDeviceProcAddr(device, "vkGetImageSparseMemoryRequirements")); |
| vkQueueBindSparse = PFN_vkQueueBindSparse(vkGetDeviceProcAddr(device, "vkQueueBindSparse")); |
| vkCreateFence = PFN_vkCreateFence(vkGetDeviceProcAddr(device, "vkCreateFence")); |
| vkDestroyFence = PFN_vkDestroyFence(vkGetDeviceProcAddr(device, "vkDestroyFence")); |
| vkResetFences = PFN_vkResetFences(vkGetDeviceProcAddr(device, "vkResetFences")); |
| vkGetFenceStatus = PFN_vkGetFenceStatus(vkGetDeviceProcAddr(device, "vkGetFenceStatus")); |
| vkWaitForFences = PFN_vkWaitForFences(vkGetDeviceProcAddr(device, "vkWaitForFences")); |
| vkCreateSemaphore = PFN_vkCreateSemaphore(vkGetDeviceProcAddr(device, "vkCreateSemaphore")); |
| vkDestroySemaphore = PFN_vkDestroySemaphore(vkGetDeviceProcAddr(device, "vkDestroySemaphore")); |
| vkCreateEvent = PFN_vkCreateEvent(vkGetDeviceProcAddr(device, "vkCreateEvent")); |
| vkDestroyEvent = PFN_vkDestroyEvent(vkGetDeviceProcAddr(device, "vkDestroyEvent")); |
| vkGetEventStatus = PFN_vkGetEventStatus(vkGetDeviceProcAddr(device, "vkGetEventStatus")); |
| vkSetEvent = PFN_vkSetEvent(vkGetDeviceProcAddr(device, "vkSetEvent")); |
| vkResetEvent = PFN_vkResetEvent(vkGetDeviceProcAddr(device, "vkResetEvent")); |
| vkCreateQueryPool = PFN_vkCreateQueryPool(vkGetDeviceProcAddr(device, "vkCreateQueryPool")); |
| vkDestroyQueryPool = PFN_vkDestroyQueryPool(vkGetDeviceProcAddr(device, "vkDestroyQueryPool")); |
| vkGetQueryPoolResults = PFN_vkGetQueryPoolResults(vkGetDeviceProcAddr(device, "vkGetQueryPoolResults")); |
| vkCreateBuffer = PFN_vkCreateBuffer(vkGetDeviceProcAddr(device, "vkCreateBuffer")); |
| vkDestroyBuffer = PFN_vkDestroyBuffer(vkGetDeviceProcAddr(device, "vkDestroyBuffer")); |
| vkCreateBufferView = PFN_vkCreateBufferView(vkGetDeviceProcAddr(device, "vkCreateBufferView")); |
| vkDestroyBufferView = PFN_vkDestroyBufferView(vkGetDeviceProcAddr(device, "vkDestroyBufferView")); |
| vkCreateImage = PFN_vkCreateImage(vkGetDeviceProcAddr(device, "vkCreateImage")); |
| vkDestroyImage = PFN_vkDestroyImage(vkGetDeviceProcAddr(device, "vkDestroyImage")); |
| vkGetImageSubresourceLayout = PFN_vkGetImageSubresourceLayout(vkGetDeviceProcAddr(device, "vkGetImageSubresourceLayout")); |
| vkCreateImageView = PFN_vkCreateImageView(vkGetDeviceProcAddr(device, "vkCreateImageView")); |
| vkDestroyImageView = PFN_vkDestroyImageView(vkGetDeviceProcAddr(device, "vkDestroyImageView")); |
| vkCreateShaderModule = PFN_vkCreateShaderModule(vkGetDeviceProcAddr(device, "vkCreateShaderModule")); |
| vkDestroyShaderModule = PFN_vkDestroyShaderModule(vkGetDeviceProcAddr(device, "vkDestroyShaderModule")); |
| vkCreatePipelineCache = PFN_vkCreatePipelineCache(vkGetDeviceProcAddr(device, "vkCreatePipelineCache")); |
| vkDestroyPipelineCache = PFN_vkDestroyPipelineCache(vkGetDeviceProcAddr(device, "vkDestroyPipelineCache")); |
| vkGetPipelineCacheData = PFN_vkGetPipelineCacheData(vkGetDeviceProcAddr(device, "vkGetPipelineCacheData")); |
| vkMergePipelineCaches = PFN_vkMergePipelineCaches(vkGetDeviceProcAddr(device, "vkMergePipelineCaches")); |
| vkCreateGraphicsPipelines = PFN_vkCreateGraphicsPipelines(vkGetDeviceProcAddr(device, "vkCreateGraphicsPipelines")); |
| vkCreateComputePipelines = PFN_vkCreateComputePipelines(vkGetDeviceProcAddr(device, "vkCreateComputePipelines")); |
| vkDestroyPipeline = PFN_vkDestroyPipeline(vkGetDeviceProcAddr(device, "vkDestroyPipeline")); |
| vkCreatePipelineLayout = PFN_vkCreatePipelineLayout(vkGetDeviceProcAddr(device, "vkCreatePipelineLayout")); |
| vkDestroyPipelineLayout = PFN_vkDestroyPipelineLayout(vkGetDeviceProcAddr(device, "vkDestroyPipelineLayout")); |
| vkCreateSampler = PFN_vkCreateSampler(vkGetDeviceProcAddr(device, "vkCreateSampler")); |
| vkDestroySampler = PFN_vkDestroySampler(vkGetDeviceProcAddr(device, "vkDestroySampler")); |
| vkCreateDescriptorSetLayout = PFN_vkCreateDescriptorSetLayout(vkGetDeviceProcAddr(device, "vkCreateDescriptorSetLayout")); |
| vkDestroyDescriptorSetLayout = PFN_vkDestroyDescriptorSetLayout(vkGetDeviceProcAddr(device, "vkDestroyDescriptorSetLayout")); |
| vkCreateDescriptorPool = PFN_vkCreateDescriptorPool(vkGetDeviceProcAddr(device, "vkCreateDescriptorPool")); |
| vkDestroyDescriptorPool = PFN_vkDestroyDescriptorPool(vkGetDeviceProcAddr(device, "vkDestroyDescriptorPool")); |
| vkResetDescriptorPool = PFN_vkResetDescriptorPool(vkGetDeviceProcAddr(device, "vkResetDescriptorPool")); |
| vkAllocateDescriptorSets = PFN_vkAllocateDescriptorSets(vkGetDeviceProcAddr(device, "vkAllocateDescriptorSets")); |
| vkFreeDescriptorSets = PFN_vkFreeDescriptorSets(vkGetDeviceProcAddr(device, "vkFreeDescriptorSets")); |
| vkUpdateDescriptorSets = PFN_vkUpdateDescriptorSets(vkGetDeviceProcAddr(device, "vkUpdateDescriptorSets")); |
| vkCreateFramebuffer = PFN_vkCreateFramebuffer(vkGetDeviceProcAddr(device, "vkCreateFramebuffer")); |
| vkDestroyFramebuffer = PFN_vkDestroyFramebuffer(vkGetDeviceProcAddr(device, "vkDestroyFramebuffer")); |
| vkCreateRenderPass = PFN_vkCreateRenderPass(vkGetDeviceProcAddr(device, "vkCreateRenderPass")); |
| vkDestroyRenderPass = PFN_vkDestroyRenderPass(vkGetDeviceProcAddr(device, "vkDestroyRenderPass")); |
| vkGetRenderAreaGranularity = PFN_vkGetRenderAreaGranularity(vkGetDeviceProcAddr(device, "vkGetRenderAreaGranularity")); |
| vkCreateCommandPool = PFN_vkCreateCommandPool(vkGetDeviceProcAddr(device, "vkCreateCommandPool")); |
| vkDestroyCommandPool = PFN_vkDestroyCommandPool(vkGetDeviceProcAddr(device, "vkDestroyCommandPool")); |
| vkResetCommandPool = PFN_vkResetCommandPool(vkGetDeviceProcAddr(device, "vkResetCommandPool")); |
| vkAllocateCommandBuffers = PFN_vkAllocateCommandBuffers(vkGetDeviceProcAddr(device, "vkAllocateCommandBuffers")); |
| vkFreeCommandBuffers = PFN_vkFreeCommandBuffers(vkGetDeviceProcAddr(device, "vkFreeCommandBuffers")); |
| vkBeginCommandBuffer = PFN_vkBeginCommandBuffer(vkGetDeviceProcAddr(device, "vkBeginCommandBuffer")); |
| vkEndCommandBuffer = PFN_vkEndCommandBuffer(vkGetDeviceProcAddr(device, "vkEndCommandBuffer")); |
| vkResetCommandBuffer = PFN_vkResetCommandBuffer(vkGetDeviceProcAddr(device, "vkResetCommandBuffer")); |
| vkCmdBindPipeline = PFN_vkCmdBindPipeline(vkGetDeviceProcAddr(device, "vkCmdBindPipeline")); |
| vkCmdSetViewport = PFN_vkCmdSetViewport(vkGetDeviceProcAddr(device, "vkCmdSetViewport")); |
| vkCmdSetScissor = PFN_vkCmdSetScissor(vkGetDeviceProcAddr(device, "vkCmdSetScissor")); |
| vkCmdSetLineWidth = PFN_vkCmdSetLineWidth(vkGetDeviceProcAddr(device, "vkCmdSetLineWidth")); |
| vkCmdSetDepthBias = PFN_vkCmdSetDepthBias(vkGetDeviceProcAddr(device, "vkCmdSetDepthBias")); |
| vkCmdSetBlendConstants = PFN_vkCmdSetBlendConstants(vkGetDeviceProcAddr(device, "vkCmdSetBlendConstants")); |
| vkCmdSetDepthBounds = PFN_vkCmdSetDepthBounds(vkGetDeviceProcAddr(device, "vkCmdSetDepthBounds")); |
| vkCmdSetStencilCompareMask = PFN_vkCmdSetStencilCompareMask(vkGetDeviceProcAddr(device, "vkCmdSetStencilCompareMask")); |
| vkCmdSetStencilWriteMask = PFN_vkCmdSetStencilWriteMask(vkGetDeviceProcAddr(device, "vkCmdSetStencilWriteMask")); |
| vkCmdSetStencilReference = PFN_vkCmdSetStencilReference(vkGetDeviceProcAddr(device, "vkCmdSetStencilReference")); |
| vkCmdBindDescriptorSets = PFN_vkCmdBindDescriptorSets(vkGetDeviceProcAddr(device, "vkCmdBindDescriptorSets")); |
| vkCmdBindIndexBuffer = PFN_vkCmdBindIndexBuffer(vkGetDeviceProcAddr(device, "vkCmdBindIndexBuffer")); |
| vkCmdBindVertexBuffers = PFN_vkCmdBindVertexBuffers(vkGetDeviceProcAddr(device, "vkCmdBindVertexBuffers")); |
| vkCmdDraw = PFN_vkCmdDraw(vkGetDeviceProcAddr(device, "vkCmdDraw")); |
| vkCmdDrawIndexed = PFN_vkCmdDrawIndexed(vkGetDeviceProcAddr(device, "vkCmdDrawIndexed")); |
| vkCmdDrawIndirect = PFN_vkCmdDrawIndirect(vkGetDeviceProcAddr(device, "vkCmdDrawIndirect")); |
| vkCmdDrawIndexedIndirect = PFN_vkCmdDrawIndexedIndirect(vkGetDeviceProcAddr(device, "vkCmdDrawIndexedIndirect")); |
| vkCmdDispatch = PFN_vkCmdDispatch(vkGetDeviceProcAddr(device, "vkCmdDispatch")); |
| vkCmdDispatchIndirect = PFN_vkCmdDispatchIndirect(vkGetDeviceProcAddr(device, "vkCmdDispatchIndirect")); |
| vkCmdCopyBuffer = PFN_vkCmdCopyBuffer(vkGetDeviceProcAddr(device, "vkCmdCopyBuffer")); |
| vkCmdCopyImage = PFN_vkCmdCopyImage(vkGetDeviceProcAddr(device, "vkCmdCopyImage")); |
| vkCmdBlitImage = PFN_vkCmdBlitImage(vkGetDeviceProcAddr(device, "vkCmdBlitImage")); |
| vkCmdCopyBufferToImage = PFN_vkCmdCopyBufferToImage(vkGetDeviceProcAddr(device, "vkCmdCopyBufferToImage")); |
| vkCmdCopyImageToBuffer = PFN_vkCmdCopyImageToBuffer(vkGetDeviceProcAddr(device, "vkCmdCopyImageToBuffer")); |
| vkCmdUpdateBuffer = PFN_vkCmdUpdateBuffer(vkGetDeviceProcAddr(device, "vkCmdUpdateBuffer")); |
| vkCmdFillBuffer = PFN_vkCmdFillBuffer(vkGetDeviceProcAddr(device, "vkCmdFillBuffer")); |
| vkCmdClearColorImage = PFN_vkCmdClearColorImage(vkGetDeviceProcAddr(device, "vkCmdClearColorImage")); |
| vkCmdClearDepthStencilImage = PFN_vkCmdClearDepthStencilImage(vkGetDeviceProcAddr(device, "vkCmdClearDepthStencilImage")); |
| vkCmdClearAttachments = PFN_vkCmdClearAttachments(vkGetDeviceProcAddr(device, "vkCmdClearAttachments")); |
| vkCmdResolveImage = PFN_vkCmdResolveImage(vkGetDeviceProcAddr(device, "vkCmdResolveImage")); |
| vkCmdSetEvent = PFN_vkCmdSetEvent(vkGetDeviceProcAddr(device, "vkCmdSetEvent")); |
| vkCmdResetEvent = PFN_vkCmdResetEvent(vkGetDeviceProcAddr(device, "vkCmdResetEvent")); |
| vkCmdWaitEvents = PFN_vkCmdWaitEvents(vkGetDeviceProcAddr(device, "vkCmdWaitEvents")); |
| vkCmdPipelineBarrier = PFN_vkCmdPipelineBarrier(vkGetDeviceProcAddr(device, "vkCmdPipelineBarrier")); |
| vkCmdBeginQuery = PFN_vkCmdBeginQuery(vkGetDeviceProcAddr(device, "vkCmdBeginQuery")); |
| vkCmdEndQuery = PFN_vkCmdEndQuery(vkGetDeviceProcAddr(device, "vkCmdEndQuery")); |
| vkCmdResetQueryPool = PFN_vkCmdResetQueryPool(vkGetDeviceProcAddr(device, "vkCmdResetQueryPool")); |
| vkCmdWriteTimestamp = PFN_vkCmdWriteTimestamp(vkGetDeviceProcAddr(device, "vkCmdWriteTimestamp")); |
| vkCmdCopyQueryPoolResults = PFN_vkCmdCopyQueryPoolResults(vkGetDeviceProcAddr(device, "vkCmdCopyQueryPoolResults")); |
| vkCmdPushConstants = PFN_vkCmdPushConstants(vkGetDeviceProcAddr(device, "vkCmdPushConstants")); |
| vkCmdBeginRenderPass = PFN_vkCmdBeginRenderPass(vkGetDeviceProcAddr(device, "vkCmdBeginRenderPass")); |
| vkCmdNextSubpass = PFN_vkCmdNextSubpass(vkGetDeviceProcAddr(device, "vkCmdNextSubpass")); |
| vkCmdEndRenderPass = PFN_vkCmdEndRenderPass(vkGetDeviceProcAddr(device, "vkCmdEndRenderPass")); |
| vkCmdExecuteCommands = PFN_vkCmdExecuteCommands(vkGetDeviceProcAddr(device, "vkCmdExecuteCommands")); |
| |
| //=== VK_VERSION_1_1 === |
| vkBindBufferMemory2 = PFN_vkBindBufferMemory2(vkGetDeviceProcAddr(device, "vkBindBufferMemory2")); |
| vkBindImageMemory2 = PFN_vkBindImageMemory2(vkGetDeviceProcAddr(device, "vkBindImageMemory2")); |
| vkGetDeviceGroupPeerMemoryFeatures = PFN_vkGetDeviceGroupPeerMemoryFeatures(vkGetDeviceProcAddr(device, "vkGetDeviceGroupPeerMemoryFeatures")); |
| vkCmdSetDeviceMask = PFN_vkCmdSetDeviceMask(vkGetDeviceProcAddr(device, "vkCmdSetDeviceMask")); |
| vkCmdDispatchBase = PFN_vkCmdDispatchBase(vkGetDeviceProcAddr(device, "vkCmdDispatchBase")); |
| vkGetImageMemoryRequirements2 = PFN_vkGetImageMemoryRequirements2(vkGetDeviceProcAddr(device, "vkGetImageMemoryRequirements2")); |
| vkGetBufferMemoryRequirements2 = PFN_vkGetBufferMemoryRequirements2(vkGetDeviceProcAddr(device, "vkGetBufferMemoryRequirements2")); |
| vkGetImageSparseMemoryRequirements2 = PFN_vkGetImageSparseMemoryRequirements2(vkGetDeviceProcAddr(device, "vkGetImageSparseMemoryRequirements2")); |
| vkTrimCommandPool = PFN_vkTrimCommandPool(vkGetDeviceProcAddr(device, "vkTrimCommandPool")); |
| vkGetDeviceQueue2 = PFN_vkGetDeviceQueue2(vkGetDeviceProcAddr(device, "vkGetDeviceQueue2")); |
| vkCreateSamplerYcbcrConversion = PFN_vkCreateSamplerYcbcrConversion(vkGetDeviceProcAddr(device, "vkCreateSamplerYcbcrConversion")); |
| vkDestroySamplerYcbcrConversion = PFN_vkDestroySamplerYcbcrConversion(vkGetDeviceProcAddr(device, "vkDestroySamplerYcbcrConversion")); |
| vkCreateDescriptorUpdateTemplate = PFN_vkCreateDescriptorUpdateTemplate(vkGetDeviceProcAddr(device, "vkCreateDescriptorUpdateTemplate")); |
| vkDestroyDescriptorUpdateTemplate = PFN_vkDestroyDescriptorUpdateTemplate(vkGetDeviceProcAddr(device, "vkDestroyDescriptorUpdateTemplate")); |
| vkUpdateDescriptorSetWithTemplate = PFN_vkUpdateDescriptorSetWithTemplate(vkGetDeviceProcAddr(device, "vkUpdateDescriptorSetWithTemplate")); |
| vkGetDescriptorSetLayoutSupport = PFN_vkGetDescriptorSetLayoutSupport(vkGetDeviceProcAddr(device, "vkGetDescriptorSetLayoutSupport")); |
| |
| //=== VK_VERSION_1_2 === |
| vkCmdDrawIndirectCount = PFN_vkCmdDrawIndirectCount(vkGetDeviceProcAddr(device, "vkCmdDrawIndirectCount")); |
| vkCmdDrawIndexedIndirectCount = PFN_vkCmdDrawIndexedIndirectCount(vkGetDeviceProcAddr(device, "vkCmdDrawIndexedIndirectCount")); |
| vkCreateRenderPass2 = PFN_vkCreateRenderPass2(vkGetDeviceProcAddr(device, "vkCreateRenderPass2")); |
| vkCmdBeginRenderPass2 = PFN_vkCmdBeginRenderPass2(vkGetDeviceProcAddr(device, "vkCmdBeginRenderPass2")); |
| vkCmdNextSubpass2 = PFN_vkCmdNextSubpass2(vkGetDeviceProcAddr(device, "vkCmdNextSubpass2")); |
| vkCmdEndRenderPass2 = PFN_vkCmdEndRenderPass2(vkGetDeviceProcAddr(device, "vkCmdEndRenderPass2")); |
| vkResetQueryPool = PFN_vkResetQueryPool(vkGetDeviceProcAddr(device, "vkResetQueryPool")); |
| vkGetSemaphoreCounterValue = PFN_vkGetSemaphoreCounterValue(vkGetDeviceProcAddr(device, "vkGetSemaphoreCounterValue")); |
| vkWaitSemaphores = PFN_vkWaitSemaphores(vkGetDeviceProcAddr(device, "vkWaitSemaphores")); |
| vkSignalSemaphore = PFN_vkSignalSemaphore(vkGetDeviceProcAddr(device, "vkSignalSemaphore")); |
| vkGetBufferDeviceAddress = PFN_vkGetBufferDeviceAddress(vkGetDeviceProcAddr(device, "vkGetBufferDeviceAddress")); |
| vkGetBufferOpaqueCaptureAddress = PFN_vkGetBufferOpaqueCaptureAddress(vkGetDeviceProcAddr(device, "vkGetBufferOpaqueCaptureAddress")); |
| vkGetDeviceMemoryOpaqueCaptureAddress = |
| PFN_vkGetDeviceMemoryOpaqueCaptureAddress(vkGetDeviceProcAddr(device, "vkGetDeviceMemoryOpaqueCaptureAddress")); |
| |
| //=== VK_VERSION_1_3 === |
| vkCreatePrivateDataSlot = PFN_vkCreatePrivateDataSlot(vkGetDeviceProcAddr(device, "vkCreatePrivateDataSlot")); |
| vkDestroyPrivateDataSlot = PFN_vkDestroyPrivateDataSlot(vkGetDeviceProcAddr(device, "vkDestroyPrivateDataSlot")); |
| vkSetPrivateData = PFN_vkSetPrivateData(vkGetDeviceProcAddr(device, "vkSetPrivateData")); |
| vkGetPrivateData = PFN_vkGetPrivateData(vkGetDeviceProcAddr(device, "vkGetPrivateData")); |
| vkCmdSetEvent2 = PFN_vkCmdSetEvent2(vkGetDeviceProcAddr(device, "vkCmdSetEvent2")); |
| vkCmdResetEvent2 = PFN_vkCmdResetEvent2(vkGetDeviceProcAddr(device, "vkCmdResetEvent2")); |
| vkCmdWaitEvents2 = PFN_vkCmdWaitEvents2(vkGetDeviceProcAddr(device, "vkCmdWaitEvents2")); |
| vkCmdPipelineBarrier2 = PFN_vkCmdPipelineBarrier2(vkGetDeviceProcAddr(device, "vkCmdPipelineBarrier2")); |
| vkCmdWriteTimestamp2 = PFN_vkCmdWriteTimestamp2(vkGetDeviceProcAddr(device, "vkCmdWriteTimestamp2")); |
| vkQueueSubmit2 = PFN_vkQueueSubmit2(vkGetDeviceProcAddr(device, "vkQueueSubmit2")); |
| vkCmdCopyBuffer2 = PFN_vkCmdCopyBuffer2(vkGetDeviceProcAddr(device, "vkCmdCopyBuffer2")); |
| vkCmdCopyImage2 = PFN_vkCmdCopyImage2(vkGetDeviceProcAddr(device, "vkCmdCopyImage2")); |
| vkCmdCopyBufferToImage2 = PFN_vkCmdCopyBufferToImage2(vkGetDeviceProcAddr(device, "vkCmdCopyBufferToImage2")); |
| vkCmdCopyImageToBuffer2 = PFN_vkCmdCopyImageToBuffer2(vkGetDeviceProcAddr(device, "vkCmdCopyImageToBuffer2")); |
| vkCmdBlitImage2 = PFN_vkCmdBlitImage2(vkGetDeviceProcAddr(device, "vkCmdBlitImage2")); |
| vkCmdResolveImage2 = PFN_vkCmdResolveImage2(vkGetDeviceProcAddr(device, "vkCmdResolveImage2")); |
| vkCmdBeginRendering = PFN_vkCmdBeginRendering(vkGetDeviceProcAddr(device, "vkCmdBeginRendering")); |
| vkCmdEndRendering = PFN_vkCmdEndRendering(vkGetDeviceProcAddr(device, "vkCmdEndRendering")); |
| vkCmdSetCullMode = PFN_vkCmdSetCullMode(vkGetDeviceProcAddr(device, "vkCmdSetCullMode")); |
| vkCmdSetFrontFace = PFN_vkCmdSetFrontFace(vkGetDeviceProcAddr(device, "vkCmdSetFrontFace")); |
| vkCmdSetPrimitiveTopology = PFN_vkCmdSetPrimitiveTopology(vkGetDeviceProcAddr(device, "vkCmdSetPrimitiveTopology")); |
| vkCmdSetViewportWithCount = PFN_vkCmdSetViewportWithCount(vkGetDeviceProcAddr(device, "vkCmdSetViewportWithCount")); |
| vkCmdSetScissorWithCount = PFN_vkCmdSetScissorWithCount(vkGetDeviceProcAddr(device, "vkCmdSetScissorWithCount")); |
| vkCmdBindVertexBuffers2 = PFN_vkCmdBindVertexBuffers2(vkGetDeviceProcAddr(device, "vkCmdBindVertexBuffers2")); |
| vkCmdSetDepthTestEnable = PFN_vkCmdSetDepthTestEnable(vkGetDeviceProcAddr(device, "vkCmdSetDepthTestEnable")); |
| vkCmdSetDepthWriteEnable = PFN_vkCmdSetDepthWriteEnable(vkGetDeviceProcAddr(device, "vkCmdSetDepthWriteEnable")); |
| vkCmdSetDepthCompareOp = PFN_vkCmdSetDepthCompareOp(vkGetDeviceProcAddr(device, "vkCmdSetDepthCompareOp")); |
| vkCmdSetDepthBoundsTestEnable = PFN_vkCmdSetDepthBoundsTestEnable(vkGetDeviceProcAddr(device, "vkCmdSetDepthBoundsTestEnable")); |
| vkCmdSetStencilTestEnable = PFN_vkCmdSetStencilTestEnable(vkGetDeviceProcAddr(device, "vkCmdSetStencilTestEnable")); |
| vkCmdSetStencilOp = PFN_vkCmdSetStencilOp(vkGetDeviceProcAddr(device, "vkCmdSetStencilOp")); |
| vkCmdSetRasterizerDiscardEnable = PFN_vkCmdSetRasterizerDiscardEnable(vkGetDeviceProcAddr(device, "vkCmdSetRasterizerDiscardEnable")); |
| vkCmdSetDepthBiasEnable = PFN_vkCmdSetDepthBiasEnable(vkGetDeviceProcAddr(device, "vkCmdSetDepthBiasEnable")); |
| vkCmdSetPrimitiveRestartEnable = PFN_vkCmdSetPrimitiveRestartEnable(vkGetDeviceProcAddr(device, "vkCmdSetPrimitiveRestartEnable")); |
| vkGetDeviceBufferMemoryRequirements = PFN_vkGetDeviceBufferMemoryRequirements(vkGetDeviceProcAddr(device, "vkGetDeviceBufferMemoryRequirements")); |
| vkGetDeviceImageMemoryRequirements = PFN_vkGetDeviceImageMemoryRequirements(vkGetDeviceProcAddr(device, "vkGetDeviceImageMemoryRequirements")); |
| vkGetDeviceImageSparseMemoryRequirements = |
| PFN_vkGetDeviceImageSparseMemoryRequirements(vkGetDeviceProcAddr(device, "vkGetDeviceImageSparseMemoryRequirements")); |
| |
| //=== VK_KHR_swapchain === |
| vkCreateSwapchainKHR = PFN_vkCreateSwapchainKHR(vkGetDeviceProcAddr(device, "vkCreateSwapchainKHR")); |
| vkDestroySwapchainKHR = PFN_vkDestroySwapchainKHR(vkGetDeviceProcAddr(device, "vkDestroySwapchainKHR")); |
| vkGetSwapchainImagesKHR = PFN_vkGetSwapchainImagesKHR(vkGetDeviceProcAddr(device, "vkGetSwapchainImagesKHR")); |
| vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR(vkGetDeviceProcAddr(device, "vkAcquireNextImageKHR")); |
| vkQueuePresentKHR = PFN_vkQueuePresentKHR(vkGetDeviceProcAddr(device, "vkQueuePresentKHR")); |
| vkGetDeviceGroupPresentCapabilitiesKHR = |
| PFN_vkGetDeviceGroupPresentCapabilitiesKHR(vkGetDeviceProcAddr(device, "vkGetDeviceGroupPresentCapabilitiesKHR")); |
| vkGetDeviceGroupSurfacePresentModesKHR = |
| PFN_vkGetDeviceGroupSurfacePresentModesKHR(vkGetDeviceProcAddr(device, "vkGetDeviceGroupSurfacePresentModesKHR")); |
| vkAcquireNextImage2KHR = PFN_vkAcquireNextImage2KHR(vkGetDeviceProcAddr(device, "vkAcquireNextImage2KHR")); |
| |
| //=== VK_KHR_display_swapchain === |
| vkCreateSharedSwapchainsKHR = PFN_vkCreateSharedSwapchainsKHR(vkGetDeviceProcAddr(device, "vkCreateSharedSwapchainsKHR")); |
| |
| //=== VK_EXT_debug_marker === |
| vkDebugMarkerSetObjectTagEXT = PFN_vkDebugMarkerSetObjectTagEXT(vkGetDeviceProcAddr(device, "vkDebugMarkerSetObjectTagEXT")); |
| vkDebugMarkerSetObjectNameEXT = PFN_vkDebugMarkerSetObjectNameEXT(vkGetDeviceProcAddr(device, "vkDebugMarkerSetObjectNameEXT")); |
| vkCmdDebugMarkerBeginEXT = PFN_vkCmdDebugMarkerBeginEXT(vkGetDeviceProcAddr(device, "vkCmdDebugMarkerBeginEXT")); |
| vkCmdDebugMarkerEndEXT = PFN_vkCmdDebugMarkerEndEXT(vkGetDeviceProcAddr(device, "vkCmdDebugMarkerEndEXT")); |
| vkCmdDebugMarkerInsertEXT = PFN_vkCmdDebugMarkerInsertEXT(vkGetDeviceProcAddr(device, "vkCmdDebugMarkerInsertEXT")); |
| |
| #if defined(VK_ENABLE_BETA_EXTENSIONS) |
| //=== VK_KHR_video_queue === |
| vkCreateVideoSessionKHR = PFN_vkCreateVideoSessionKHR(vkGetDeviceProcAddr(device, "vkCreateVideoSessionKHR")); |
| vkDestroyVideoSessionKHR = PFN_vkDestroyVideoSessionKHR(vkGetDeviceProcAddr(device, "vkDestroyVideoSessionKHR")); |
| vkGetVideoSessionMemoryRequirementsKHR = |
| PFN_vkGetVideoSessionMemoryRequirementsKHR(vkGetDeviceProcAddr(device, "vkGetVideoSessionMemoryRequirementsKHR")); |
| vkBindVideoSessionMemoryKHR = PFN_vkBindVideoSessionMemoryKHR(vkGetDeviceProcAddr(device, "vkBindVideoSessionMemoryKHR")); |
| vkCreateVideoSessionParametersKHR = PFN_vkCreateVideoSessionParametersKHR(vkGetDeviceProcAddr(device, "vkCreateVideoSessionParametersKHR")); |
| vkUpdateVideoSessionParametersKHR = PFN_vkUpdateVideoSessionParametersKHR(vkGetDeviceProcAddr(device, "vkUpdateVideoSessionParametersKHR")); |
| vkDestroyVideoSessionParametersKHR = PFN_vkDestroyVideoSessionParametersKHR(vkGetDeviceProcAddr(device, "vkDestroyVideoSessionParametersKHR")); |
| vkCmdBeginVideoCodingKHR = PFN_vkCmdBeginVideoCodingKHR(vkGetDeviceProcAddr(device, "vkCmdBeginVideoCodingKHR")); |
| vkCmdEndVideoCodingKHR = PFN_vkCmdEndVideoCodingKHR(vkGetDeviceProcAddr(device, "vkCmdEndVideoCodingKHR")); |
| vkCmdControlVideoCodingKHR = PFN_vkCmdControlVideoCodingKHR(vkGetDeviceProcAddr(device, "vkCmdControlVideoCodingKHR")); |
| #endif /*VK_ENABLE_BETA_EXTENSIONS*/ |
| |
| #if defined(VK_ENABLE_BETA_EXTENSIONS) |
| //=== VK_KHR_video_decode_queue === |
| vkCmdDecodeVideoKHR = PFN_vkCmdDecodeVideoKHR(vkGetDeviceProcAddr(device, "vkCmdDecodeVideoKHR")); |
| #endif /*VK_ENABLE_BETA_EXTENSIONS*/ |
| |
| //=== VK_EXT_transform_feedback === |
| vkCmdBindTransformFeedbackBuffersEXT = PFN_vkCmdBindTransformFeedbackBuffersEXT(vkGetDeviceProcAddr(device, "vkCmdBindTransformFeedbackBuffersEXT")); |
| vkCmdBeginTransformFeedbackEXT = PFN_vkCmdBeginTransformFeedbackEXT(vkGetDeviceProcAddr(device, "vkCmdBeginTransformFeedbackEXT")); |
| vkCmdEndTransformFeedbackEXT = PFN_vkCmdEndTransformFeedbackEXT(vkGetDeviceProcAddr(device, "vkCmdEndTransformFeedbackEXT")); |
| vkCmdBeginQueryIndexedEXT = PFN_vkCmdBeginQueryIndexedEXT(vkGetDeviceProcAddr(device, "vkCmdBeginQueryIndexedEXT")); |
| vkCmdEndQueryIndexedEXT = PFN_vkCmdEndQueryIndexedEXT(vkGetDeviceProcAddr(device, "vkCmdEndQueryIndexedEXT")); |
| vkCmdDrawIndirectByteCountEXT = PFN_vkCmdDrawIndirectByteCountEXT(vkGetDeviceProcAddr(device, "vkCmdDrawIndirectByteCountEXT")); |
| |
| //=== VK_NVX_binary_import === |
| vkCreateCuModuleNVX = PFN_vkCreateCuModuleNVX(vkGetDeviceProcAddr(device, "vkCreateCuModuleNVX")); |
| vkCreateCuFunctionNVX = PFN_vkCreateCuFunctionNVX(vkGetDeviceProcAddr(device, "vkCreateCuFunctionNVX")); |
| vkDestroyCuModuleNVX = PFN_vkDestroyCuModuleNVX(vkGetDeviceProcAddr(device, "vkDestroyCuModuleNVX")); |
| vkDestroyCuFunctionNVX = PFN_vkDestroyCuFunctionNVX(vkGetDeviceProcAddr(device, "vkDestroyCuFunctionNVX")); |
| vkCmdCuLaunchKernelNVX = PFN_vkCmdCuLaunchKernelNVX(vkGetDeviceProcAddr(device, "vkCmdCuLaunchKernelNVX")); |
| |
| //=== VK_NVX_image_view_handle === |
| vkGetImageViewHandleNVX = PFN_vkGetImageViewHandleNVX(vkGetDeviceProcAddr(device, "vkGetImageViewHandleNVX")); |
| vkGetImageViewAddressNVX = PFN_vkGetImageViewAddressNVX(vkGetDeviceProcAddr(device, "vkGetImageViewAddressNVX")); |
| |
| //=== VK_AMD_draw_indirect_count === |
| vkCmdDrawIndirectCountAMD = PFN_vkCmdDrawIndirectCountAMD(vkGetDeviceProcAddr(device, "vkCmdDrawIndirectCountAMD")); |
| if(!vkCmdDrawIndirectCount) |
| vkCmdDrawIndirectCount = vkCmdDrawIndirectCountAMD; |
| vkCmdDrawIndexedIndirectCountAMD = PFN_vkCmdDrawIndexedIndirectCountAMD(vkGetDeviceProcAddr(device, "vkCmdDrawIndexedIndirectCountAMD")); |
| if(!vkCmdDrawIndexedIndirectCount) |
| vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountAMD; |
| |
| //=== VK_AMD_shader_info === |
| vkGetShaderInfoAMD = PFN_vkGetShaderInfoAMD(vkGetDeviceProcAddr(device, "vkGetShaderInfoAMD")); |
| |
| //=== VK_KHR_dynamic_rendering === |
| vkCmdBeginRenderingKHR = PFN_vkCmdBeginRenderingKHR(vkGetDeviceProcAddr(device, "vkCmdBeginRenderingKHR")); |
| if(!vkCmdBeginRendering) |
| vkCmdBeginRendering = vkCmdBeginRenderingKHR; |
| vkCmdEndRenderingKHR = PFN_vkCmdEndRenderingKHR(vkGetDeviceProcAddr(device, "vkCmdEndRenderingKHR")); |
| if(!vkCmdEndRendering) |
| vkCmdEndRendering = vkCmdEndRenderingKHR; |
| |
| #if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_NV_external_memory_win32 === |
| vkGetMemoryWin32HandleNV = PFN_vkGetMemoryWin32HandleNV(vkGetDeviceProcAddr(device, "vkGetMemoryWin32HandleNV")); |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_KHR_device_group === |
| vkGetDeviceGroupPeerMemoryFeaturesKHR = |
| PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR(vkGetDeviceProcAddr(device, "vkGetDeviceGroupPeerMemoryFeaturesKHR")); |
| if(!vkGetDeviceGroupPeerMemoryFeatures) |
| vkGetDeviceGroupPeerMemoryFeatures = vkGetDeviceGroupPeerMemoryFeaturesKHR; |
| vkCmdSetDeviceMaskKHR = PFN_vkCmdSetDeviceMaskKHR(vkGetDeviceProcAddr(device, "vkCmdSetDeviceMaskKHR")); |
| if(!vkCmdSetDeviceMask) |
| vkCmdSetDeviceMask = vkCmdSetDeviceMaskKHR; |
| vkCmdDispatchBaseKHR = PFN_vkCmdDispatchBaseKHR(vkGetDeviceProcAddr(device, "vkCmdDispatchBaseKHR")); |
| if(!vkCmdDispatchBase) |
| vkCmdDispatchBase = vkCmdDispatchBaseKHR; |
| |
| //=== VK_KHR_maintenance1 === |
| vkTrimCommandPoolKHR = PFN_vkTrimCommandPoolKHR(vkGetDeviceProcAddr(device, "vkTrimCommandPoolKHR")); |
| if(!vkTrimCommandPool) |
| vkTrimCommandPool = vkTrimCommandPoolKHR; |
| |
| #if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_KHR_external_memory_win32 === |
| vkGetMemoryWin32HandleKHR = PFN_vkGetMemoryWin32HandleKHR(vkGetDeviceProcAddr(device, "vkGetMemoryWin32HandleKHR")); |
| vkGetMemoryWin32HandlePropertiesKHR = PFN_vkGetMemoryWin32HandlePropertiesKHR(vkGetDeviceProcAddr(device, "vkGetMemoryWin32HandlePropertiesKHR")); |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_KHR_external_memory_fd === |
| vkGetMemoryFdKHR = PFN_vkGetMemoryFdKHR(vkGetDeviceProcAddr(device, "vkGetMemoryFdKHR")); |
| vkGetMemoryFdPropertiesKHR = PFN_vkGetMemoryFdPropertiesKHR(vkGetDeviceProcAddr(device, "vkGetMemoryFdPropertiesKHR")); |
| |
| #if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_KHR_external_semaphore_win32 === |
| vkImportSemaphoreWin32HandleKHR = PFN_vkImportSemaphoreWin32HandleKHR(vkGetDeviceProcAddr(device, "vkImportSemaphoreWin32HandleKHR")); |
| vkGetSemaphoreWin32HandleKHR = PFN_vkGetSemaphoreWin32HandleKHR(vkGetDeviceProcAddr(device, "vkGetSemaphoreWin32HandleKHR")); |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_KHR_external_semaphore_fd === |
| vkImportSemaphoreFdKHR = PFN_vkImportSemaphoreFdKHR(vkGetDeviceProcAddr(device, "vkImportSemaphoreFdKHR")); |
| vkGetSemaphoreFdKHR = PFN_vkGetSemaphoreFdKHR(vkGetDeviceProcAddr(device, "vkGetSemaphoreFdKHR")); |
| |
| //=== VK_KHR_push_descriptor === |
| vkCmdPushDescriptorSetKHR = PFN_vkCmdPushDescriptorSetKHR(vkGetDeviceProcAddr(device, "vkCmdPushDescriptorSetKHR")); |
| vkCmdPushDescriptorSetWithTemplateKHR = |
| PFN_vkCmdPushDescriptorSetWithTemplateKHR(vkGetDeviceProcAddr(device, "vkCmdPushDescriptorSetWithTemplateKHR")); |
| |
| //=== VK_EXT_conditional_rendering === |
| vkCmdBeginConditionalRenderingEXT = PFN_vkCmdBeginConditionalRenderingEXT(vkGetDeviceProcAddr(device, "vkCmdBeginConditionalRenderingEXT")); |
| vkCmdEndConditionalRenderingEXT = PFN_vkCmdEndConditionalRenderingEXT(vkGetDeviceProcAddr(device, "vkCmdEndConditionalRenderingEXT")); |
| |
| //=== VK_KHR_descriptor_update_template === |
| vkCreateDescriptorUpdateTemplateKHR = PFN_vkCreateDescriptorUpdateTemplateKHR(vkGetDeviceProcAddr(device, "vkCreateDescriptorUpdateTemplateKHR")); |
| if(!vkCreateDescriptorUpdateTemplate) |
| vkCreateDescriptorUpdateTemplate = vkCreateDescriptorUpdateTemplateKHR; |
| vkDestroyDescriptorUpdateTemplateKHR = PFN_vkDestroyDescriptorUpdateTemplateKHR(vkGetDeviceProcAddr(device, "vkDestroyDescriptorUpdateTemplateKHR")); |
| if(!vkDestroyDescriptorUpdateTemplate) |
| vkDestroyDescriptorUpdateTemplate = vkDestroyDescriptorUpdateTemplateKHR; |
| vkUpdateDescriptorSetWithTemplateKHR = PFN_vkUpdateDescriptorSetWithTemplateKHR(vkGetDeviceProcAddr(device, "vkUpdateDescriptorSetWithTemplateKHR")); |
| if(!vkUpdateDescriptorSetWithTemplate) |
| vkUpdateDescriptorSetWithTemplate = vkUpdateDescriptorSetWithTemplateKHR; |
| |
| //=== VK_NV_clip_space_w_scaling === |
| vkCmdSetViewportWScalingNV = PFN_vkCmdSetViewportWScalingNV(vkGetDeviceProcAddr(device, "vkCmdSetViewportWScalingNV")); |
| |
| //=== VK_EXT_display_control === |
| vkDisplayPowerControlEXT = PFN_vkDisplayPowerControlEXT(vkGetDeviceProcAddr(device, "vkDisplayPowerControlEXT")); |
| vkRegisterDeviceEventEXT = PFN_vkRegisterDeviceEventEXT(vkGetDeviceProcAddr(device, "vkRegisterDeviceEventEXT")); |
| vkRegisterDisplayEventEXT = PFN_vkRegisterDisplayEventEXT(vkGetDeviceProcAddr(device, "vkRegisterDisplayEventEXT")); |
| vkGetSwapchainCounterEXT = PFN_vkGetSwapchainCounterEXT(vkGetDeviceProcAddr(device, "vkGetSwapchainCounterEXT")); |
| |
| //=== VK_GOOGLE_display_timing === |
| vkGetRefreshCycleDurationGOOGLE = PFN_vkGetRefreshCycleDurationGOOGLE(vkGetDeviceProcAddr(device, "vkGetRefreshCycleDurationGOOGLE")); |
| vkGetPastPresentationTimingGOOGLE = PFN_vkGetPastPresentationTimingGOOGLE(vkGetDeviceProcAddr(device, "vkGetPastPresentationTimingGOOGLE")); |
| |
| //=== VK_EXT_discard_rectangles === |
| vkCmdSetDiscardRectangleEXT = PFN_vkCmdSetDiscardRectangleEXT(vkGetDeviceProcAddr(device, "vkCmdSetDiscardRectangleEXT")); |
| |
| //=== VK_EXT_hdr_metadata === |
| vkSetHdrMetadataEXT = PFN_vkSetHdrMetadataEXT(vkGetDeviceProcAddr(device, "vkSetHdrMetadataEXT")); |
| |
| //=== VK_KHR_create_renderpass2 === |
| vkCreateRenderPass2KHR = PFN_vkCreateRenderPass2KHR(vkGetDeviceProcAddr(device, "vkCreateRenderPass2KHR")); |
| if(!vkCreateRenderPass2) |
| vkCreateRenderPass2 = vkCreateRenderPass2KHR; |
| vkCmdBeginRenderPass2KHR = PFN_vkCmdBeginRenderPass2KHR(vkGetDeviceProcAddr(device, "vkCmdBeginRenderPass2KHR")); |
| if(!vkCmdBeginRenderPass2) |
| vkCmdBeginRenderPass2 = vkCmdBeginRenderPass2KHR; |
| vkCmdNextSubpass2KHR = PFN_vkCmdNextSubpass2KHR(vkGetDeviceProcAddr(device, "vkCmdNextSubpass2KHR")); |
| if(!vkCmdNextSubpass2) |
| vkCmdNextSubpass2 = vkCmdNextSubpass2KHR; |
| vkCmdEndRenderPass2KHR = PFN_vkCmdEndRenderPass2KHR(vkGetDeviceProcAddr(device, "vkCmdEndRenderPass2KHR")); |
| if(!vkCmdEndRenderPass2) |
| vkCmdEndRenderPass2 = vkCmdEndRenderPass2KHR; |
| |
| //=== VK_KHR_shared_presentable_image === |
| vkGetSwapchainStatusKHR = PFN_vkGetSwapchainStatusKHR(vkGetDeviceProcAddr(device, "vkGetSwapchainStatusKHR")); |
| |
| #if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_KHR_external_fence_win32 === |
| vkImportFenceWin32HandleKHR = PFN_vkImportFenceWin32HandleKHR(vkGetDeviceProcAddr(device, "vkImportFenceWin32HandleKHR")); |
| vkGetFenceWin32HandleKHR = PFN_vkGetFenceWin32HandleKHR(vkGetDeviceProcAddr(device, "vkGetFenceWin32HandleKHR")); |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_KHR_external_fence_fd === |
| vkImportFenceFdKHR = PFN_vkImportFenceFdKHR(vkGetDeviceProcAddr(device, "vkImportFenceFdKHR")); |
| vkGetFenceFdKHR = PFN_vkGetFenceFdKHR(vkGetDeviceProcAddr(device, "vkGetFenceFdKHR")); |
| |
| //=== VK_KHR_performance_query === |
| vkAcquireProfilingLockKHR = PFN_vkAcquireProfilingLockKHR(vkGetDeviceProcAddr(device, "vkAcquireProfilingLockKHR")); |
| vkReleaseProfilingLockKHR = PFN_vkReleaseProfilingLockKHR(vkGetDeviceProcAddr(device, "vkReleaseProfilingLockKHR")); |
| |
| //=== VK_EXT_debug_utils === |
| vkSetDebugUtilsObjectNameEXT = PFN_vkSetDebugUtilsObjectNameEXT(vkGetDeviceProcAddr(device, "vkSetDebugUtilsObjectNameEXT")); |
| vkSetDebugUtilsObjectTagEXT = PFN_vkSetDebugUtilsObjectTagEXT(vkGetDeviceProcAddr(device, "vkSetDebugUtilsObjectTagEXT")); |
| vkQueueBeginDebugUtilsLabelEXT = PFN_vkQueueBeginDebugUtilsLabelEXT(vkGetDeviceProcAddr(device, "vkQueueBeginDebugUtilsLabelEXT")); |
| vkQueueEndDebugUtilsLabelEXT = PFN_vkQueueEndDebugUtilsLabelEXT(vkGetDeviceProcAddr(device, "vkQueueEndDebugUtilsLabelEXT")); |
| vkQueueInsertDebugUtilsLabelEXT = PFN_vkQueueInsertDebugUtilsLabelEXT(vkGetDeviceProcAddr(device, "vkQueueInsertDebugUtilsLabelEXT")); |
| vkCmdBeginDebugUtilsLabelEXT = PFN_vkCmdBeginDebugUtilsLabelEXT(vkGetDeviceProcAddr(device, "vkCmdBeginDebugUtilsLabelEXT")); |
| vkCmdEndDebugUtilsLabelEXT = PFN_vkCmdEndDebugUtilsLabelEXT(vkGetDeviceProcAddr(device, "vkCmdEndDebugUtilsLabelEXT")); |
| vkCmdInsertDebugUtilsLabelEXT = PFN_vkCmdInsertDebugUtilsLabelEXT(vkGetDeviceProcAddr(device, "vkCmdInsertDebugUtilsLabelEXT")); |
| |
| #if defined(VK_USE_PLATFORM_ANDROID_KHR) |
| //=== VK_ANDROID_external_memory_android_hardware_buffer === |
| vkGetAndroidHardwareBufferPropertiesANDROID = |
| PFN_vkGetAndroidHardwareBufferPropertiesANDROID(vkGetDeviceProcAddr(device, "vkGetAndroidHardwareBufferPropertiesANDROID")); |
| vkGetMemoryAndroidHardwareBufferANDROID = |
| PFN_vkGetMemoryAndroidHardwareBufferANDROID(vkGetDeviceProcAddr(device, "vkGetMemoryAndroidHardwareBufferANDROID")); |
| #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ |
| |
| //=== VK_EXT_sample_locations === |
| vkCmdSetSampleLocationsEXT = PFN_vkCmdSetSampleLocationsEXT(vkGetDeviceProcAddr(device, "vkCmdSetSampleLocationsEXT")); |
| |
| //=== VK_KHR_get_memory_requirements2 === |
| vkGetImageMemoryRequirements2KHR = PFN_vkGetImageMemoryRequirements2KHR(vkGetDeviceProcAddr(device, "vkGetImageMemoryRequirements2KHR")); |
| if(!vkGetImageMemoryRequirements2) |
| vkGetImageMemoryRequirements2 = vkGetImageMemoryRequirements2KHR; |
| vkGetBufferMemoryRequirements2KHR = PFN_vkGetBufferMemoryRequirements2KHR(vkGetDeviceProcAddr(device, "vkGetBufferMemoryRequirements2KHR")); |
| if(!vkGetBufferMemoryRequirements2) |
| vkGetBufferMemoryRequirements2 = vkGetBufferMemoryRequirements2KHR; |
| vkGetImageSparseMemoryRequirements2KHR = |
| PFN_vkGetImageSparseMemoryRequirements2KHR(vkGetDeviceProcAddr(device, "vkGetImageSparseMemoryRequirements2KHR")); |
| if(!vkGetImageSparseMemoryRequirements2) |
| vkGetImageSparseMemoryRequirements2 = vkGetImageSparseMemoryRequirements2KHR; |
| |
| //=== VK_KHR_acceleration_structure === |
| vkCreateAccelerationStructureKHR = PFN_vkCreateAccelerationStructureKHR(vkGetDeviceProcAddr(device, "vkCreateAccelerationStructureKHR")); |
| vkDestroyAccelerationStructureKHR = PFN_vkDestroyAccelerationStructureKHR(vkGetDeviceProcAddr(device, "vkDestroyAccelerationStructureKHR")); |
| vkCmdBuildAccelerationStructuresKHR = PFN_vkCmdBuildAccelerationStructuresKHR(vkGetDeviceProcAddr(device, "vkCmdBuildAccelerationStructuresKHR")); |
| vkCmdBuildAccelerationStructuresIndirectKHR = |
| PFN_vkCmdBuildAccelerationStructuresIndirectKHR(vkGetDeviceProcAddr(device, "vkCmdBuildAccelerationStructuresIndirectKHR")); |
| vkBuildAccelerationStructuresKHR = PFN_vkBuildAccelerationStructuresKHR(vkGetDeviceProcAddr(device, "vkBuildAccelerationStructuresKHR")); |
| vkCopyAccelerationStructureKHR = PFN_vkCopyAccelerationStructureKHR(vkGetDeviceProcAddr(device, "vkCopyAccelerationStructureKHR")); |
| vkCopyAccelerationStructureToMemoryKHR = |
| PFN_vkCopyAccelerationStructureToMemoryKHR(vkGetDeviceProcAddr(device, "vkCopyAccelerationStructureToMemoryKHR")); |
| vkCopyMemoryToAccelerationStructureKHR = |
| PFN_vkCopyMemoryToAccelerationStructureKHR(vkGetDeviceProcAddr(device, "vkCopyMemoryToAccelerationStructureKHR")); |
| vkWriteAccelerationStructuresPropertiesKHR = |
| PFN_vkWriteAccelerationStructuresPropertiesKHR(vkGetDeviceProcAddr(device, "vkWriteAccelerationStructuresPropertiesKHR")); |
| vkCmdCopyAccelerationStructureKHR = PFN_vkCmdCopyAccelerationStructureKHR(vkGetDeviceProcAddr(device, "vkCmdCopyAccelerationStructureKHR")); |
| vkCmdCopyAccelerationStructureToMemoryKHR = |
| PFN_vkCmdCopyAccelerationStructureToMemoryKHR(vkGetDeviceProcAddr(device, "vkCmdCopyAccelerationStructureToMemoryKHR")); |
| vkCmdCopyMemoryToAccelerationStructureKHR = |
| PFN_vkCmdCopyMemoryToAccelerationStructureKHR(vkGetDeviceProcAddr(device, "vkCmdCopyMemoryToAccelerationStructureKHR")); |
| vkGetAccelerationStructureDeviceAddressKHR = |
| PFN_vkGetAccelerationStructureDeviceAddressKHR(vkGetDeviceProcAddr(device, "vkGetAccelerationStructureDeviceAddressKHR")); |
| vkCmdWriteAccelerationStructuresPropertiesKHR = |
| PFN_vkCmdWriteAccelerationStructuresPropertiesKHR(vkGetDeviceProcAddr(device, "vkCmdWriteAccelerationStructuresPropertiesKHR")); |
| vkGetDeviceAccelerationStructureCompatibilityKHR = |
| PFN_vkGetDeviceAccelerationStructureCompatibilityKHR(vkGetDeviceProcAddr(device, "vkGetDeviceAccelerationStructureCompatibilityKHR")); |
| vkGetAccelerationStructureBuildSizesKHR = |
| PFN_vkGetAccelerationStructureBuildSizesKHR(vkGetDeviceProcAddr(device, "vkGetAccelerationStructureBuildSizesKHR")); |
| |
| //=== VK_KHR_sampler_ycbcr_conversion === |
| vkCreateSamplerYcbcrConversionKHR = PFN_vkCreateSamplerYcbcrConversionKHR(vkGetDeviceProcAddr(device, "vkCreateSamplerYcbcrConversionKHR")); |
| if(!vkCreateSamplerYcbcrConversion) |
| vkCreateSamplerYcbcrConversion = vkCreateSamplerYcbcrConversionKHR; |
| vkDestroySamplerYcbcrConversionKHR = PFN_vkDestroySamplerYcbcrConversionKHR(vkGetDeviceProcAddr(device, "vkDestroySamplerYcbcrConversionKHR")); |
| if(!vkDestroySamplerYcbcrConversion) |
| vkDestroySamplerYcbcrConversion = vkDestroySamplerYcbcrConversionKHR; |
| |
| //=== VK_KHR_bind_memory2 === |
| vkBindBufferMemory2KHR = PFN_vkBindBufferMemory2KHR(vkGetDeviceProcAddr(device, "vkBindBufferMemory2KHR")); |
| if(!vkBindBufferMemory2) |
| vkBindBufferMemory2 = vkBindBufferMemory2KHR; |
| vkBindImageMemory2KHR = PFN_vkBindImageMemory2KHR(vkGetDeviceProcAddr(device, "vkBindImageMemory2KHR")); |
| if(!vkBindImageMemory2) |
| vkBindImageMemory2 = vkBindImageMemory2KHR; |
| |
| //=== VK_EXT_image_drm_format_modifier === |
| vkGetImageDrmFormatModifierPropertiesEXT = |
| PFN_vkGetImageDrmFormatModifierPropertiesEXT(vkGetDeviceProcAddr(device, "vkGetImageDrmFormatModifierPropertiesEXT")); |
| |
| //=== VK_EXT_validation_cache === |
| vkCreateValidationCacheEXT = PFN_vkCreateValidationCacheEXT(vkGetDeviceProcAddr(device, "vkCreateValidationCacheEXT")); |
| vkDestroyValidationCacheEXT = PFN_vkDestroyValidationCacheEXT(vkGetDeviceProcAddr(device, "vkDestroyValidationCacheEXT")); |
| vkMergeValidationCachesEXT = PFN_vkMergeValidationCachesEXT(vkGetDeviceProcAddr(device, "vkMergeValidationCachesEXT")); |
| vkGetValidationCacheDataEXT = PFN_vkGetValidationCacheDataEXT(vkGetDeviceProcAddr(device, "vkGetValidationCacheDataEXT")); |
| |
| //=== VK_NV_shading_rate_image === |
| vkCmdBindShadingRateImageNV = PFN_vkCmdBindShadingRateImageNV(vkGetDeviceProcAddr(device, "vkCmdBindShadingRateImageNV")); |
| vkCmdSetViewportShadingRatePaletteNV = PFN_vkCmdSetViewportShadingRatePaletteNV(vkGetDeviceProcAddr(device, "vkCmdSetViewportShadingRatePaletteNV")); |
| vkCmdSetCoarseSampleOrderNV = PFN_vkCmdSetCoarseSampleOrderNV(vkGetDeviceProcAddr(device, "vkCmdSetCoarseSampleOrderNV")); |
| |
| //=== VK_NV_ray_tracing === |
| vkCreateAccelerationStructureNV = PFN_vkCreateAccelerationStructureNV(vkGetDeviceProcAddr(device, "vkCreateAccelerationStructureNV")); |
| vkDestroyAccelerationStructureNV = PFN_vkDestroyAccelerationStructureNV(vkGetDeviceProcAddr(device, "vkDestroyAccelerationStructureNV")); |
| vkGetAccelerationStructureMemoryRequirementsNV = |
| PFN_vkGetAccelerationStructureMemoryRequirementsNV(vkGetDeviceProcAddr(device, "vkGetAccelerationStructureMemoryRequirementsNV")); |
| vkBindAccelerationStructureMemoryNV = PFN_vkBindAccelerationStructureMemoryNV(vkGetDeviceProcAddr(device, "vkBindAccelerationStructureMemoryNV")); |
| vkCmdBuildAccelerationStructureNV = PFN_vkCmdBuildAccelerationStructureNV(vkGetDeviceProcAddr(device, "vkCmdBuildAccelerationStructureNV")); |
| vkCmdCopyAccelerationStructureNV = PFN_vkCmdCopyAccelerationStructureNV(vkGetDeviceProcAddr(device, "vkCmdCopyAccelerationStructureNV")); |
| vkCmdTraceRaysNV = PFN_vkCmdTraceRaysNV(vkGetDeviceProcAddr(device, "vkCmdTraceRaysNV")); |
| vkCreateRayTracingPipelinesNV = PFN_vkCreateRayTracingPipelinesNV(vkGetDeviceProcAddr(device, "vkCreateRayTracingPipelinesNV")); |
| vkGetRayTracingShaderGroupHandlesNV = PFN_vkGetRayTracingShaderGroupHandlesNV(vkGetDeviceProcAddr(device, "vkGetRayTracingShaderGroupHandlesNV")); |
| if(!vkGetRayTracingShaderGroupHandlesKHR) |
| vkGetRayTracingShaderGroupHandlesKHR = vkGetRayTracingShaderGroupHandlesNV; |
| vkGetAccelerationStructureHandleNV = PFN_vkGetAccelerationStructureHandleNV(vkGetDeviceProcAddr(device, "vkGetAccelerationStructureHandleNV")); |
| vkCmdWriteAccelerationStructuresPropertiesNV = |
| PFN_vkCmdWriteAccelerationStructuresPropertiesNV(vkGetDeviceProcAddr(device, "vkCmdWriteAccelerationStructuresPropertiesNV")); |
| vkCompileDeferredNV = PFN_vkCompileDeferredNV(vkGetDeviceProcAddr(device, "vkCompileDeferredNV")); |
| |
| //=== VK_KHR_maintenance3 === |
| vkGetDescriptorSetLayoutSupportKHR = PFN_vkGetDescriptorSetLayoutSupportKHR(vkGetDeviceProcAddr(device, "vkGetDescriptorSetLayoutSupportKHR")); |
| if(!vkGetDescriptorSetLayoutSupport) |
| vkGetDescriptorSetLayoutSupport = vkGetDescriptorSetLayoutSupportKHR; |
| |
| //=== VK_KHR_draw_indirect_count === |
| vkCmdDrawIndirectCountKHR = PFN_vkCmdDrawIndirectCountKHR(vkGetDeviceProcAddr(device, "vkCmdDrawIndirectCountKHR")); |
| if(!vkCmdDrawIndirectCount) |
| vkCmdDrawIndirectCount = vkCmdDrawIndirectCountKHR; |
| vkCmdDrawIndexedIndirectCountKHR = PFN_vkCmdDrawIndexedIndirectCountKHR(vkGetDeviceProcAddr(device, "vkCmdDrawIndexedIndirectCountKHR")); |
| if(!vkCmdDrawIndexedIndirectCount) |
| vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountKHR; |
| |
| //=== VK_EXT_external_memory_host === |
| vkGetMemoryHostPointerPropertiesEXT = PFN_vkGetMemoryHostPointerPropertiesEXT(vkGetDeviceProcAddr(device, "vkGetMemoryHostPointerPropertiesEXT")); |
| |
| //=== VK_AMD_buffer_marker === |
| vkCmdWriteBufferMarkerAMD = PFN_vkCmdWriteBufferMarkerAMD(vkGetDeviceProcAddr(device, "vkCmdWriteBufferMarkerAMD")); |
| |
| //=== VK_EXT_calibrated_timestamps === |
| vkGetCalibratedTimestampsEXT = PFN_vkGetCalibratedTimestampsEXT(vkGetDeviceProcAddr(device, "vkGetCalibratedTimestampsEXT")); |
| |
| //=== VK_NV_mesh_shader === |
| vkCmdDrawMeshTasksNV = PFN_vkCmdDrawMeshTasksNV(vkGetDeviceProcAddr(device, "vkCmdDrawMeshTasksNV")); |
| vkCmdDrawMeshTasksIndirectNV = PFN_vkCmdDrawMeshTasksIndirectNV(vkGetDeviceProcAddr(device, "vkCmdDrawMeshTasksIndirectNV")); |
| vkCmdDrawMeshTasksIndirectCountNV = PFN_vkCmdDrawMeshTasksIndirectCountNV(vkGetDeviceProcAddr(device, "vkCmdDrawMeshTasksIndirectCountNV")); |
| |
| //=== VK_NV_scissor_exclusive === |
| vkCmdSetExclusiveScissorNV = PFN_vkCmdSetExclusiveScissorNV(vkGetDeviceProcAddr(device, "vkCmdSetExclusiveScissorNV")); |
| |
| //=== VK_NV_device_diagnostic_checkpoints === |
| vkCmdSetCheckpointNV = PFN_vkCmdSetCheckpointNV(vkGetDeviceProcAddr(device, "vkCmdSetCheckpointNV")); |
| vkGetQueueCheckpointDataNV = PFN_vkGetQueueCheckpointDataNV(vkGetDeviceProcAddr(device, "vkGetQueueCheckpointDataNV")); |
| |
| //=== VK_KHR_timeline_semaphore === |
| vkGetSemaphoreCounterValueKHR = PFN_vkGetSemaphoreCounterValueKHR(vkGetDeviceProcAddr(device, "vkGetSemaphoreCounterValueKHR")); |
| if(!vkGetSemaphoreCounterValue) |
| vkGetSemaphoreCounterValue = vkGetSemaphoreCounterValueKHR; |
| vkWaitSemaphoresKHR = PFN_vkWaitSemaphoresKHR(vkGetDeviceProcAddr(device, "vkWaitSemaphoresKHR")); |
| if(!vkWaitSemaphores) |
| vkWaitSemaphores = vkWaitSemaphoresKHR; |
| vkSignalSemaphoreKHR = PFN_vkSignalSemaphoreKHR(vkGetDeviceProcAddr(device, "vkSignalSemaphoreKHR")); |
| if(!vkSignalSemaphore) |
| vkSignalSemaphore = vkSignalSemaphoreKHR; |
| |
| //=== VK_INTEL_performance_query === |
| vkInitializePerformanceApiINTEL = PFN_vkInitializePerformanceApiINTEL(vkGetDeviceProcAddr(device, "vkInitializePerformanceApiINTEL")); |
| vkUninitializePerformanceApiINTEL = PFN_vkUninitializePerformanceApiINTEL(vkGetDeviceProcAddr(device, "vkUninitializePerformanceApiINTEL")); |
| vkCmdSetPerformanceMarkerINTEL = PFN_vkCmdSetPerformanceMarkerINTEL(vkGetDeviceProcAddr(device, "vkCmdSetPerformanceMarkerINTEL")); |
| vkCmdSetPerformanceStreamMarkerINTEL = PFN_vkCmdSetPerformanceStreamMarkerINTEL(vkGetDeviceProcAddr(device, "vkCmdSetPerformanceStreamMarkerINTEL")); |
| vkCmdSetPerformanceOverrideINTEL = PFN_vkCmdSetPerformanceOverrideINTEL(vkGetDeviceProcAddr(device, "vkCmdSetPerformanceOverrideINTEL")); |
| vkAcquirePerformanceConfigurationINTEL = |
| PFN_vkAcquirePerformanceConfigurationINTEL(vkGetDeviceProcAddr(device, "vkAcquirePerformanceConfigurationINTEL")); |
| vkReleasePerformanceConfigurationINTEL = |
| PFN_vkReleasePerformanceConfigurationINTEL(vkGetDeviceProcAddr(device, "vkReleasePerformanceConfigurationINTEL")); |
| vkQueueSetPerformanceConfigurationINTEL = |
| PFN_vkQueueSetPerformanceConfigurationINTEL(vkGetDeviceProcAddr(device, "vkQueueSetPerformanceConfigurationINTEL")); |
| vkGetPerformanceParameterINTEL = PFN_vkGetPerformanceParameterINTEL(vkGetDeviceProcAddr(device, "vkGetPerformanceParameterINTEL")); |
| |
| //=== VK_AMD_display_native_hdr === |
| vkSetLocalDimmingAMD = PFN_vkSetLocalDimmingAMD(vkGetDeviceProcAddr(device, "vkSetLocalDimmingAMD")); |
| |
| //=== VK_KHR_fragment_shading_rate === |
| vkCmdSetFragmentShadingRateKHR = PFN_vkCmdSetFragmentShadingRateKHR(vkGetDeviceProcAddr(device, "vkCmdSetFragmentShadingRateKHR")); |
| |
| //=== VK_EXT_buffer_device_address === |
| vkGetBufferDeviceAddressEXT = PFN_vkGetBufferDeviceAddressEXT(vkGetDeviceProcAddr(device, "vkGetBufferDeviceAddressEXT")); |
| if(!vkGetBufferDeviceAddress) |
| vkGetBufferDeviceAddress = vkGetBufferDeviceAddressEXT; |
| |
| //=== VK_KHR_present_wait === |
| vkWaitForPresentKHR = PFN_vkWaitForPresentKHR(vkGetDeviceProcAddr(device, "vkWaitForPresentKHR")); |
| |
| #if defined(VK_USE_PLATFORM_WIN32_KHR) |
| //=== VK_EXT_full_screen_exclusive === |
| vkAcquireFullScreenExclusiveModeEXT = PFN_vkAcquireFullScreenExclusiveModeEXT(vkGetDeviceProcAddr(device, "vkAcquireFullScreenExclusiveModeEXT")); |
| vkReleaseFullScreenExclusiveModeEXT = PFN_vkReleaseFullScreenExclusiveModeEXT(vkGetDeviceProcAddr(device, "vkReleaseFullScreenExclusiveModeEXT")); |
| vkGetDeviceGroupSurfacePresentModes2EXT = |
| PFN_vkGetDeviceGroupSurfacePresentModes2EXT(vkGetDeviceProcAddr(device, "vkGetDeviceGroupSurfacePresentModes2EXT")); |
| #endif /*VK_USE_PLATFORM_WIN32_KHR*/ |
| |
| //=== VK_KHR_buffer_device_address === |
| vkGetBufferDeviceAddressKHR = PFN_vkGetBufferDeviceAddressKHR(vkGetDeviceProcAddr(device, "vkGetBufferDeviceAddressKHR")); |
| if(!vkGetBufferDeviceAddress) |
| vkGetBufferDeviceAddress = vkGetBufferDeviceAddressKHR; |
| vkGetBufferOpaqueCaptureAddressKHR = PFN_vkGetBufferOpaqueCaptureAddressKHR(vkGetDeviceProcAddr(device, "vkGetBufferOpaqueCaptureAddressKHR")); |
| if(!vkGetBufferOpaqueCaptureAddress) |
| vkGetBufferOpaqueCaptureAddress = vkGetBufferOpaqueCaptureAddressKHR; |
| vkGetDeviceMemoryOpaqueCaptureAddressKHR = |
| PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR(vkGetDeviceProcAddr(device, "vkGetDeviceMemoryOpaqueCaptureAddressKHR")); |
| if(!vkGetDeviceMemoryOpaqueCaptureAddress) |
| vkGetDeviceMemoryOpaqueCaptureAddress = vkGetDeviceMemoryOpaqueCaptureAddressKHR; |
| |
| //=== VK_EXT_line_rasterization === |
| vkCmdSetLineStippleEXT = PFN_vkCmdSetLineStippleEXT(vkGetDeviceProcAddr(device, "vkCmdSetLineStippleEXT")); |
| |
| //=== VK_EXT_host_query_reset === |
| vkResetQueryPoolEXT = PFN_vkResetQueryPoolEXT(vkGetDeviceProcAddr(device, "vkResetQueryPoolEXT")); |
| if(!vkResetQueryPool) |
| vkResetQueryPool = vkResetQueryPoolEXT; |
| |
| //=== VK_EXT_extended_dynamic_state === |
| vkCmdSetCullModeEXT = PFN_vkCmdSetCullModeEXT(vkGetDeviceProcAddr(device, "vkCmdSetCullModeEXT")); |
| if(!vkCmdSetCullMode) |
| vkCmdSetCullMode = vkCmdSetCullModeEXT; |
| vkCmdSetFrontFaceEXT = PFN_vkCmdSetFrontFaceEXT(vkGetDeviceProcAddr(device, "vkCmdSetFrontFaceEXT")); |
| if(!vkCmdSetFrontFace) |
| vkCmdSetFrontFace = vkCmdSetFrontFaceEXT; |
| vkCmdSetPrimitiveTopologyEXT = PFN_vkCmdSetPrimitiveTopologyEXT(vkGetDeviceProcAddr(device, "vkCmdSetPrimitiveTopologyEXT")); |
| if(!vkCmdSetPrimitiveTopology) |
| vkCmdSetPrimitiveTopology = vkCmdSetPrimitiveTopologyEXT; |
| vkCmdSetViewportWithCountEXT = PFN_vkCmdSetViewportWithCountEXT(vkGetDeviceProcAddr(device, "vkCmdSetViewportWithCountEXT")); |
| if(!vkCmdSetViewportWithCount) |
| vkCmdSetViewportWithCount = vkCmdSetViewportWithCountEXT; |
| vkCmdSetScissorWithCountEXT = PFN_vkCmdSetScissorWithCountEXT(vkGetDeviceProcAddr(device, "vkCmdSetScissorWithCountEXT")); |
| if(!vkCmdSetScissorWithCount) |
| vkCmdSetScissorWithCount = vkCmdSetScissorWithCountEXT; |
| vkCmdBindVertexBuffers2EXT = PFN_vkCmdBindVertexBuffers2EXT(vkGetDeviceProcAddr(device, "vkCmdBindVertexBuffers2EXT")); |
| if(!vkCmdBindVertexBuffers2) |
| vkCmdBindVertexBuffers2 = vkCmdBindVertexBuffers2EXT; |
| vkCmdSetDepthTestEnableEXT = PFN_vkCmdSetDepthTestEnableEXT(vkGetDeviceProcAddr(device, "vkCmdSetDepthTestEnableEXT")); |
| if(!vkCmdSetDepthTestEnable) |
| vkCmdSetDepthTestEnable = vkCmdSetDepthTestEnableEXT; |
| vkCmdSetDepthWriteEnableEXT = PFN_vkCmdSetDepthWriteEnableEXT(vkGetDeviceProcAddr(device, "vkCmdSetDepthWriteEnableEXT")); |
| if(!vkCmdSetDepthWriteEnable) |
| vkCmdSetDepthWriteEnable = vkCmdSetDepthWriteEnableEXT; |
| vkCmdSetDepthCompareOpEXT = PFN_vkCmdSetDepthCompareOpEXT(vkGetDeviceProcAddr(device, "vkCmdSetDepthCompareOpEXT")); |
| if(!vkCmdSetDepthCompareOp) |
| vkCmdSetDepthCompareOp = vkCmdSetDepthCompareOpEXT; |
| vkCmdSetDepthBoundsTestEnableEXT = PFN_vkCmdSetDepthBoundsTestEnableEXT(vkGetDeviceProcAddr(device, "vkCmdSetDepthBoundsTestEnableEXT")); |
| if(!vkCmdSetDepthBoundsTestEnable) |
| vkCmdSetDepthBoundsTestEnable = vkCmdSetDepthBoundsTestEnableEXT; |
| vkCmdSetStencilTestEnableEXT = PFN_vkCmdSetStencilTestEnableEXT(vkGetDeviceProcAddr(device, "vkCmdSetStencilTestEnableEXT")); |
| if(!vkCmdSetStencilTestEnable) |
| vkCmdSetStencilTestEnable = vkCmdSetStencilTestEnableEXT; |
| vkCmdSetStencilOpEXT = PFN_vkCmdSetStencilOpEXT(vkGetDeviceProcAddr(device, "vkCmdSetStencilOpEXT")); |
| if(!vkCmdSetStencilOp) |
| vkCmdSetStencilOp = vkCmdSetStencilOpEXT; |
| |
| //=== VK_KHR_deferred_host_operations === |
| vkCreateDeferredOperationKHR = PFN_vkCreateDeferredOperationKHR(vkGetDeviceProcAddr(device, "vkCreateDeferredOperationKHR")); |
| vkDestroyDeferredOperationKHR = PFN_vkDestroyDeferredOperationKHR(vkGetDeviceProcAddr(device, "vkDestroyDeferredOperationKHR")); |
| vkGetDeferredOperationMaxConcurrencyKHR = |
| PFN_vkGetDeferredOperationMaxConcurrencyKHR(vkGetDeviceProcAddr(device, "vkGetDeferredOperationMaxConcurrencyKHR")); |
| vkGetDeferredOperationResultKHR = PFN_vkGetDeferredOperationResultKHR(vkGetDeviceProcAddr(device, "vkGetDeferredOperationResultKHR")); |
| vkDeferredOperationJoinKHR = PFN_vkDeferredOperationJoinKHR(vkGetDeviceProcAddr(device, "vkDeferredOperationJoinKHR")); |
| |
| //=== VK_KHR_pipeline_executable_properties === |
| vkGetPipelineExecutablePropertiesKHR = PFN_vkGetPipelineExecutablePropertiesKHR(vkGetDeviceProcAddr(device, "vkGetPipelineExecutablePropertiesKHR")); |
| vkGetPipelineExecutableStatisticsKHR = PFN_vkGetPipelineExecutableStatisticsKHR(vkGetDeviceProcAddr(device, "vkGetPipelineExecutableStatisticsKHR")); |
| vkGetPipelineExecutableInternalRepresentationsKHR = |
| PFN_vkGetPipelineExecutableInternalRepresentationsKHR(vkGetDeviceProcAddr(device, "vkGetPipelineExecutableInternalRepresentationsKHR")); |
| |
| //=== VK_NV_device_generated_commands === |
| vkGetGeneratedCommandsMemoryRequirementsNV = |
| PFN_vkGetGeneratedCommandsMemoryRequirementsNV(vkGetDeviceProcAddr(device, "vkGetGeneratedCommandsMemoryRequirementsNV")); |
| vkCmdPreprocessGeneratedCommandsNV = PFN_vkCmdPreprocessGeneratedCommandsNV(vkGetDeviceProcAddr(device, "vkCmdPreprocessGeneratedCommandsNV")); |
| vkCmdExecuteGeneratedCommandsNV = PFN_vkCmdExecuteGeneratedCommandsNV(vkGetDeviceProcAddr(device, "vkCmdExecuteGeneratedCommandsNV")); |
| vkCmdBindPipelineShaderGroupNV = PFN_vkCmdBindPipelineShaderGroupNV(vkGetDeviceProcAddr(device, "vkCmdBindPipelineShaderGroupNV")); |
| vkCreateIndirectCommandsLayoutNV = PFN_vkCreateIndirectCommandsLayoutNV(vkGetDeviceProcAddr(device, "vkCreateIndirectCommandsLayoutNV")); |
| vkDestroyIndirectCommandsLayoutNV = PFN_vkDestroyIndirectCommandsLayoutNV(vkGetDeviceProcAddr(device, "vkDestroyIndirectCommandsLayoutNV")); |
| |
| //=== VK_EXT_private_data === |
| vkCreatePrivateDataSlotEXT = PFN_vkCreatePrivateDataSlotEXT(vkGetDeviceProcAddr(device, "vkCreatePrivateDataSlotEXT")); |
| if(!vkCreatePrivateDataSlot) |
| vkCreatePrivateDataSlot = vkCreatePrivateDataSlotEXT; |
| vkDestroyPrivateDataSlotEXT = PFN_vkDestroyPrivateDataSlotEXT(vkGetDeviceProcAddr(device, "vkDestroyPrivateDataSlotEXT")); |
| if(!vkDestroyPrivateDataSlot) |
| vkDestroyPrivateDataSlot = vkDestroyPrivateDataSlotEXT; |
| vkSetPrivateDataEXT = PFN_vkSetPrivateDataEXT(vkGetDeviceProcAddr(device, "vkSetPrivateDataEXT")); |
| if(!vkSetPrivateData) |
| vkSetPrivateData = vkSetPrivateDataEXT; |
| vkGetPrivateDataEXT = PFN_vkGetPrivateDataEXT(vkGetDeviceProcAddr(device, "vkGetPrivateDataEXT")); |
| if(!vkGetPrivateData) |
| vkGetPrivateData = vkGetPrivateDataEXT; |
| |
| #if defined(VK_ENABLE_BETA_EXTENSIONS) |
| //=== VK_KHR_video_encode_queue === |
| vkCmdEncodeVideoKHR = PFN_vkCmdEncodeVideoKHR(vkGetDeviceProcAddr(device, "vkCmdEncodeVideoKHR")); |
| #endif /*VK_ENABLE_BETA_EXTENSIONS*/ |
| |
| //=== VK_KHR_synchronization2 === |
| vkCmdSetEvent2KHR = PFN_vkCmdSetEvent2KHR(vkGetDeviceProcAddr(device, "vkCmdSetEvent2KHR")); |
| if(!vkCmdSetEvent2) |
| vkCmdSetEvent2 = vkCmdSetEvent2KHR; |
| vkCmdResetEvent2KHR = PFN_vkCmdResetEvent2KHR(vkGetDeviceProcAddr(device, "vkCmdResetEvent2KHR")); |
| if(!vkCmdResetEvent2) |
| vkCmdResetEvent2 = vkCmdResetEvent2KHR; |
| vkCmdWaitEvents2KHR = PFN_vkCmdWaitEvents2KHR(vkGetDeviceProcAddr(device, "vkCmdWaitEvents2KHR")); |
| if(!vkCmdWaitEvents2) |
| vkCmdWaitEvents2 = vkCmdWaitEvents2KHR; |
| vkCmdPipelineBarrier2KHR = PFN_vkCmdPipelineBarrier2KHR(vkGetDeviceProcAddr(device, "vkCmdPipelineBarrier2KHR")); |
| if(!vkCmdPipelineBarrier2) |
| vkCmdPipelineBarrier2 = vkCmdPipelineBarrier2KHR; |
| vkCmdWriteTimestamp2KHR = PFN_vkCmdWriteTimestamp2KHR(vkGetDeviceProcAddr(device, "vkCmdWriteTimestamp2KHR")); |
| if(!vkCmdWriteTimestamp2) |
| vkCmdWriteTimestamp2 = vkCmdWriteTimestamp2KHR; |
| vkQueueSubmit2KHR = PFN_vkQueueSubmit2KHR(vkGetDeviceProcAddr(device, "vkQueueSubmit2KHR")); |
| if(!vkQueueSubmit2) |
| vkQueueSubmit2 = vkQueueSubmit2KHR; |
| vkCmdWriteBufferMarker2AMD = PFN_vkCmdWriteBufferMarker2AMD(vkGetDeviceProcAddr(device, "vkCmdWriteBufferMarker2AMD")); |
| vkGetQueueCheckpointData2NV = PFN_vkGetQueueCheckpointData2NV(vkGetDeviceProcAddr(device, "vkGetQueueCheckpointData2NV")); |
| |
| //=== VK_NV_fragment_shading_rate_enums === |
| vkCmdSetFragmentShadingRateEnumNV = PFN_vkCmdSetFragmentShadingRateEnumNV(vkGetDeviceProcAddr(device, "vkCmdSetFragmentShadingRateEnumNV")); |
| |
| //=== VK_KHR_copy_commands2 === |
| vkCmdCopyBuffer2KHR = PFN_vkCmdCopyBuffer2KHR(vkGetDeviceProcAddr(device, "vkCmdCopyBuffer2KHR")); |
| if(!vkCmdCopyBuffer2) |
| vkCmdCopyBuffer2 = vkCmdCopyBuffer2KHR; |
| vkCmdCopyImage2KHR = PFN_vkCmdCopyImage2KHR(vkGetDeviceProcAddr(device, "vkCmdCopyImage2KHR")); |
| if(!vkCmdCopyImage2) |
| vkCmdCopyImage2 = vkCmdCopyImage2KHR; |
| vkCmdCopyBufferToImage2KHR = PFN_vkCmdCopyBufferToImage2KHR(vkGetDeviceProcAddr(device, "vkCmdCopyBufferToImage2KHR")); |
| if(!vkCmdCopyBufferToImage2) |
| vkCmdCopyBufferToImage2 = vkCmdCopyBufferToImage2KHR; |
| vkCmdCopyImageToBuffer2KHR = PFN_vkCmdCopyImageToBuffer2KHR(vkGetDeviceProcAddr(device, "vkCmdCopyImageToBuffer2KHR")); |
| if(!vkCmdCopyImageToBuffer2) |
| vkCmdCopyImageToBuffer2 = vkCmdCopyImageToBuffer2KHR; |
| vkCmdBlitImage2KHR = PFN_vkCmdBlitImage2KHR(vkGetDeviceProcAddr(device, "vkCmdBlitImage2KHR")); |
| if(!vkCmdBlitImage2) |
| vkCmdBlitImage2 = vkCmdBlitImage2KHR; |
| vkCmdResolveImage2KHR = PFN_vkCmdResolveImage2KHR(vkGetDeviceProcAddr(device, "vkCmdResolveImage2KHR")); |
| if(!vkCmdResolveImage2) |
| vkCmdResolveImage2 = vkCmdResolveImage2KHR; |
| |
| //=== VK_KHR_ray_tracing_pipeline === |
| vkCmdTraceRaysKHR = PFN_vkCmdTraceRaysKHR(vkGetDeviceProcAddr(device, "vkCmdTraceRaysKHR")); |
| vkCreateRayTracingPipelinesKHR = PFN_vkCreateRayTracingPipelinesKHR(vkGetDeviceProcAddr(device, "vkCreateRayTracingPipelinesKHR")); |
| vkGetRayTracingShaderGroupHandlesKHR = PFN_vkGetRayTracingShaderGroupHandlesKHR(vkGetDeviceProcAddr(device, "vkGetRayTracingShaderGroupHandlesKHR")); |
| vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = |
| PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(vkGetDeviceProcAddr(device, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR")); |
| vkCmdTraceRaysIndirectKHR = PFN_vkCmdTraceRaysIndirectKHR(vkGetDeviceProcAddr(device, "vkCmdTraceRaysIndirectKHR")); |
| vkGetRayTracingShaderGroupStackSizeKHR = |
| PFN_vkGetRayTracingShaderGroupStackSizeKHR(vkGetDeviceProcAddr(device, "vkGetRayTracingShaderGroupStackSizeKHR")); |
| vkCmdSetRayTracingPipelineStackSizeKHR = |
| PFN_vkCmdSetRayTracingPipelineStackSizeKHR(vkGetDeviceProcAddr(device, "vkCmdSetRayTracingPipelineStackSizeKHR")); |
| |
| //=== VK_EXT_vertex_input_dynamic_state === |
| vkCmdSetVertexInputEXT = PFN_vkCmdSetVertexInputEXT(vkGetDeviceProcAddr(device, "vkCmdSetVertexInputEXT")); |
| |
| #if defined(VK_USE_PLATFORM_FUCHSIA) |
| //=== VK_FUCHSIA_external_memory === |
| vkGetMemoryZirconHandleFUCHSIA = PFN_vkGetMemoryZirconHandleFUCHSIA(vkGetDeviceProcAddr(device, "vkGetMemoryZirconHandleFUCHSIA")); |
| vkGetMemoryZirconHandlePropertiesFUCHSIA = |
| PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA(vkGetDeviceProcAddr(device, "vkGetMemoryZirconHandlePropertiesFUCHSIA")); |
| #endif /*VK_USE_PLATFORM_FUCHSIA*/ |
| |
| #if defined(VK_USE_PLATFORM_FUCHSIA) |
| //=== VK_FUCHSIA_external_semaphore === |
| vkImportSemaphoreZirconHandleFUCHSIA = PFN_vkImportSemaphoreZirconHandleFUCHSIA(vkGetDeviceProcAddr(device, "vkImportSemaphoreZirconHandleFUCHSIA")); |
| vkGetSemaphoreZirconHandleFUCHSIA = PFN_vkGetSemaphoreZirconHandleFUCHSIA(vkGetDeviceProcAddr(device, "vkGetSemaphoreZirconHandleFUCHSIA")); |
| #endif /*VK_USE_PLATFORM_FUCHSIA*/ |
| |
| #if defined(VK_USE_PLATFORM_FUCHSIA) |
| //=== VK_FUCHSIA_buffer_collection === |
| vkCreateBufferCollectionFUCHSIA = PFN_vkCreateBufferCollectionFUCHSIA(vkGetDeviceProcAddr(device, "vkCreateBufferCollectionFUCHSIA")); |
| vkSetBufferCollectionImageConstraintsFUCHSIA = |
| PFN_vkSetBufferCollectionImageConstraintsFUCHSIA(vkGetDeviceProcAddr(device, "vkSetBufferCollectionImageConstraintsFUCHSIA")); |
| vkSetBufferCollectionBufferConstraintsFUCHSIA = |
| PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA(vkGetDeviceProcAddr(device, "vkSetBufferCollectionBufferConstraintsFUCHSIA")); |
| vkDestroyBufferCollectionFUCHSIA = PFN_vkDestroyBufferCollectionFUCHSIA(vkGetDeviceProcAddr(device, "vkDestroyBufferCollectionFUCHSIA")); |
| vkGetBufferCollectionPropertiesFUCHSIA = |
| PFN_vkGetBufferCollectionPropertiesFUCHSIA(vkGetDeviceProcAddr(device, "vkGetBufferCollectionPropertiesFUCHSIA")); |
| #endif /*VK_USE_PLATFORM_FUCHSIA*/ |
| |
| //=== VK_HUAWEI_subpass_shading === |
| vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = |
| PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(vkGetDeviceProcAddr(device, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI")); |
| vkCmdSubpassShadingHUAWEI = PFN_vkCmdSubpassShadingHUAWEI(vkGetDeviceProcAddr(device, "vkCmdSubpassShadingHUAWEI")); |
| |
| //=== VK_HUAWEI_invocation_mask === |
| vkCmdBindInvocationMaskHUAWEI = PFN_vkCmdBindInvocationMaskHUAWEI(vkGetDeviceProcAddr(device, "vkCmdBindInvocationMaskHUAWEI")); |
| |
| //=== VK_NV_external_memory_rdma === |
| vkGetMemoryRemoteAddressNV = PFN_vkGetMemoryRemoteAddressNV(vkGetDeviceProcAddr(device, "vkGetMemoryRemoteAddressNV")); |
| |
| //=== VK_EXT_extended_dynamic_state2 === |
| vkCmdSetPatchControlPointsEXT = PFN_vkCmdSetPatchControlPointsEXT(vkGetDeviceProcAddr(device, "vkCmdSetPatchControlPointsEXT")); |
| vkCmdSetRasterizerDiscardEnableEXT = PFN_vkCmdSetRasterizerDiscardEnableEXT(vkGetDeviceProcAddr(device, "vkCmdSetRasterizerDiscardEnableEXT")); |
| if(!vkCmdSetRasterizerDiscardEnable) |
| vkCmdSetRasterizerDiscardEnable = vkCmdSetRasterizerDiscardEnableEXT; |
| vkCmdSetDepthBiasEnableEXT = PFN_vkCmdSetDepthBiasEnableEXT(vkGetDeviceProcAddr(device, "vkCmdSetDepthBiasEnableEXT")); |
| if(!vkCmdSetDepthBiasEnable) |
| vkCmdSetDepthBiasEnable = vkCmdSetDepthBiasEnableEXT; |
| vkCmdSetLogicOpEXT = PFN_vkCmdSetLogicOpEXT(vkGetDeviceProcAddr(device, "vkCmdSetLogicOpEXT")); |
| vkCmdSetPrimitiveRestartEnableEXT = PFN_vkCmdSetPrimitiveRestartEnableEXT(vkGetDeviceProcAddr(device, "vkCmdSetPrimitiveRestartEnableEXT")); |
| if(!vkCmdSetPrimitiveRestartEnable) |
| vkCmdSetPrimitiveRestartEnable = vkCmdSetPrimitiveRestartEnableEXT; |
| |
| //=== VK_EXT_color_write_enable === |
| vkCmdSetColorWriteEnableEXT = PFN_vkCmdSetColorWriteEnableEXT(vkGetDeviceProcAddr(device, "vkCmdSetColorWriteEnableEXT")); |
| |
| //=== VK_EXT_multi_draw === |
| vkCmdDrawMultiEXT = PFN_vkCmdDrawMultiEXT(vkGetDeviceProcAddr(device, "vkCmdDrawMultiEXT")); |
| vkCmdDrawMultiIndexedEXT = PFN_vkCmdDrawMultiIndexedEXT(vkGetDeviceProcAddr(device, "vkCmdDrawMultiIndexedEXT")); |
| |
| //=== VK_EXT_pageable_device_local_memory === |
| vkSetDeviceMemoryPriorityEXT = PFN_vkSetDeviceMemoryPriorityEXT(vkGetDeviceProcAddr(device, "vkSetDeviceMemoryPriorityEXT")); |
| |
| //=== VK_KHR_maintenance4 === |
| vkGetDeviceBufferMemoryRequirementsKHR = |
| PFN_vkGetDeviceBufferMemoryRequirementsKHR(vkGetDeviceProcAddr(device, "vkGetDeviceBufferMemoryRequirementsKHR")); |
| if(!vkGetDeviceBufferMemoryRequirements) |
| vkGetDeviceBufferMemoryRequirements = vkGetDeviceBufferMemoryRequirementsKHR; |
| vkGetDeviceImageMemoryRequirementsKHR = |
| PFN_vkGetDeviceImageMemoryRequirementsKHR(vkGetDeviceProcAddr(device, "vkGetDeviceImageMemoryRequirementsKHR")); |
| if(!vkGetDeviceImageMemoryRequirements) |
| vkGetDeviceImageMemoryRequirements = vkGetDeviceImageMemoryRequirementsKHR; |
| vkGetDeviceImageSparseMemoryRequirementsKHR = |
| PFN_vkGetDeviceImageSparseMemoryRequirementsKHR(vkGetDeviceProcAddr(device, "vkGetDeviceImageSparseMemoryRequirementsKHR")); |
| if(!vkGetDeviceImageSparseMemoryRequirements) |
| vkGetDeviceImageSparseMemoryRequirements = vkGetDeviceImageSparseMemoryRequirementsKHR; |
| |
| //=== VK_VALVE_descriptor_set_host_mapping === |
| vkGetDescriptorSetLayoutHostMappingInfoVALVE = |
| PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE(vkGetDeviceProcAddr(device, "vkGetDescriptorSetLayoutHostMappingInfoVALVE")); |
| vkGetDescriptorSetHostMappingVALVE = PFN_vkGetDescriptorSetHostMappingVALVE(vkGetDeviceProcAddr(device, "vkGetDescriptorSetHostMappingVALVE")); |
| } |
| }; |
| } // namespace VULKAN_HPP_NAMESPACE |
| #endif |