Google Git
Sign in
swiftshader / SwiftShader / 4011ab35f3d875173cc842ea098a3ba2118b6d3a / . / include / vulkan / vulkan.hpp
blob: c20a0af6d2c4820230b05dfd0fce9eba08f391e6 [file] [log] [blame]
// 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