mirror of
https://github.com/ZDoom/zdoom-macos-deps.git
synced 2024-11-22 12:01:27 +00:00
13980 lines
596 KiB
C++
13980 lines
596 KiB
C++
// 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 <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>
|
|
#include <utility>
|
|
#include <vulkan/vulkan.h>
|
|
#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 == 216, "Wrong VK_HEADER_VERSION!" );
|
|
|
|
// 32-bit vulkan is not typesafe for non-dispatchable handles, so don't allow copy constructors on this platform by default.
|
|
// To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION
|
|
#if ( VK_USE_64_BIT_PTR_DEFINES == 1 )
|
|
# if !defined( VULKAN_HPP_TYPESAFE_CONVERSION )
|
|
# define VULKAN_HPP_TYPESAFE_CONVERSION
|
|
# endif
|
|
#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 )
|
|
{
|
|
}
|
|
|
|
template <std::size_t C>
|
|
ArrayProxy( T ( &ptr )[C] ) VULKAN_HPP_NOEXCEPT
|
|
: m_count( C )
|
|
, m_ptr( ptr )
|
|
{
|
|
}
|
|
|
|
template <std::size_t C, typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
|
|
ArrayProxy( typename std::remove_const<T>::type ( &ptr )[C] ) VULKAN_HPP_NOEXCEPT
|
|
: m_count( C )
|
|
, m_ptr( ptr )
|
|
{
|
|
}
|
|
|
|
# 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 )
|
|
{
|
|
}
|
|
|
|
template <std::size_t C>
|
|
ArrayProxyNoTemporaries( T ( &ptr )[C] ) VULKAN_HPP_NOEXCEPT
|
|
: m_count( C )
|
|
, m_ptr( ptr )
|
|
{
|
|
}
|
|
|
|
template <std::size_t C>
|
|
ArrayProxyNoTemporaries( T( &&ptr )[C] ) = delete;
|
|
|
|
template <std::size_t C, typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
|
|
ArrayProxyNoTemporaries( typename std::remove_const<T>::type ( &ptr )[C] ) VULKAN_HPP_NOEXCEPT
|
|
: m_count( C )
|
|
, m_ptr( ptr )
|
|
{
|
|
}
|
|
|
|
template <std::size_t C, typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
|
|
ArrayProxyNoTemporaries( typename std::remove_const<T>::type( &&ptr )[C] ) = delete;
|
|
|
|
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 );
|
|
}
|
|
|
|
//=== VK_EXT_image_compression_control ===
|
|
|
|
void vkGetImageSubresourceLayout2EXT( VkDevice device,
|
|
VkImage image,
|
|
const VkImageSubresource2EXT * pSubresource,
|
|
VkSubresourceLayout2EXT * pLayout ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ::vkGetImageSubresourceLayout2EXT( device, image, pSubresource, pLayout );
|
|
}
|
|
|
|
# if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
//=== VK_NV_acquire_winrt_display ===
|
|
|
|
VkResult vkAcquireWinrtDisplayNV( VkPhysicalDevice physicalDevice, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ::vkAcquireWinrtDisplayNV( physicalDevice, display );
|
|
}
|
|
|
|
VkResult vkGetWinrtDisplayNV( VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR * pDisplay ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ::vkGetWinrtDisplayNV( physicalDevice, deviceRelativeId, pDisplay );
|
|
}
|
|
# endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
|
# if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
|
|
//=== VK_EXT_directfb_surface ===
|
|
|
|
VkResult vkCreateDirectFBSurfaceEXT( VkInstance instance,
|
|
const VkDirectFBSurfaceCreateInfoEXT * pCreateInfo,
|
|
const VkAllocationCallbacks * pAllocator,
|
|
VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ::vkCreateDirectFBSurfaceEXT( instance, pCreateInfo, pAllocator, pSurface );
|
|
}
|
|
|
|
VkBool32
|
|
vkGetPhysicalDeviceDirectFBPresentationSupportEXT( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, IDirectFB * dfb ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ::vkGetPhysicalDeviceDirectFBPresentationSupportEXT( physicalDevice, queueFamilyIndex, dfb );
|
|
}
|
|
# endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
|
|
|
|
//=== VK_KHR_ray_tracing_pipeline ===
|
|
|
|
void vkCmdTraceRaysKHR( VkCommandBuffer commandBuffer,
|
|
const VkStridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
|
|
const VkStridedDeviceAddressRegionKHR * pMissShaderBindingTable,
|
|
const VkStridedDeviceAddressRegionKHR * pHitShaderBindingTable,
|
|
const VkStridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
|
|
uint32_t width,
|
|
uint32_t height,
|
|
uint32_t depth ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ::vkCmdTraceRaysKHR(
|
|
commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth );
|
|
}
|
|
|
|
VkResult vkCreateRayTracingPipelinesKHR( VkDevice device,
|
|
VkDeferredOperationKHR deferredOperation,
|
|
VkPipelineCache pipelineCache,
|
|
uint32_t createInfoCount,
|
|
const VkRayTracingPipelineCreateInfoKHR * pCreateInfos,
|
|
const VkAllocationCallbacks * pAllocator,
|
|
VkPipeline * pPipelines ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ::vkCreateRayTracingPipelinesKHR( device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
|
|
}
|
|
|
|
VkResult vkGetRayTracingShaderGroupHandlesKHR(
|
|
VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ::vkGetRayTracingShaderGroupHandlesKHR( device, pipeline, firstGroup, groupCount, dataSize, pData );
|
|
}
|
|
|
|
VkResult vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(
|
|
VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ::vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( device, pipeline, firstGroup, groupCount, dataSize, pData );
|
|
}
|
|
|
|
void vkCmdTraceRaysIndirectKHR( VkCommandBuffer commandBuffer,
|
|
const VkStridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
|
|
const VkStridedDeviceAddressRegionKHR * pMissShaderBindingTable,
|
|
const VkStridedDeviceAddressRegionKHR * pHitShaderBindingTable,
|
|
const VkStridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
|
|
VkDeviceAddress indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ::vkCmdTraceRaysIndirectKHR(
|
|
commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress );
|
|
}
|
|
|
|
VkDeviceSize vkGetRayTracingShaderGroupStackSizeKHR( VkDevice device,
|
|
VkPipeline pipeline,
|
|
uint32_t group,
|
|
VkShaderGroupShaderKHR groupShader ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ::vkGetRayTracingShaderGroupStackSizeKHR( device, pipeline, group, groupShader );
|
|
}
|
|
|
|
void vkCmdSetRayTracingPipelineStackSizeKHR( VkCommandBuffer commandBuffer, uint32_t pipelineStackSize ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ::vkCmdSetRayTracingPipelineStackSizeKHR( commandBuffer, pipelineStackSize );
|
|
}
|
|
|
|
//=== VK_EXT_vertex_input_dynamic_state ===
|
|
|
|
void vkCmdSetVertexInputEXT( VkCommandBuffer commandBuffer,
|
|
uint32_t vertexBindingDescriptionCount,
|
|
const VkVertexInputBindingDescription2EXT * pVertexBindingDescriptions,
|
|
uint32_t vertexAttributeDescriptionCount,
|
|
const VkVertexInputAttributeDescription2EXT * pVertexAttributeDescriptions ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ::vkCmdSetVertexInputEXT(
|
|
commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions );
|
|
}
|
|
|
|
# if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
//=== VK_FUCHSIA_external_memory ===
|
|
|
|
VkResult vkGetMemoryZirconHandleFUCHSIA( VkDevice device,
|
|
const VkMemoryGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
|
|
zx_handle_t * pZirconHandle ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ::vkGetMemoryZirconHandleFUCHSIA( device, pGetZirconHandleInfo, pZirconHandle );
|
|
}
|
|
|
|
VkResult vkGetMemoryZirconHandlePropertiesFUCHSIA( VkDevice device,
|
|
VkExternalMemoryHandleTypeFlagBits handleType,
|
|
zx_handle_t zirconHandle,
|
|
VkMemoryZirconHandlePropertiesFUCHSIA * pMemoryZirconHandleProperties ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ::vkGetMemoryZirconHandlePropertiesFUCHSIA( device, handleType, zirconHandle, pMemoryZirconHandleProperties );
|
|
}
|
|
# endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
|
# if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
//=== VK_FUCHSIA_external_semaphore ===
|
|
|
|
VkResult vkImportSemaphoreZirconHandleFUCHSIA( VkDevice device,
|
|
const VkImportSemaphoreZirconHandleInfoFUCHSIA * pImportSemaphoreZirconHandleInfo ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ::vkImportSemaphoreZirconHandleFUCHSIA( device, pImportSemaphoreZirconHandleInfo );
|
|
}
|
|
|
|
VkResult vkGetSemaphoreZirconHandleFUCHSIA( VkDevice device,
|
|
const VkSemaphoreGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
|
|
zx_handle_t * pZirconHandle ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ::vkGetSemaphoreZirconHandleFUCHSIA( device, pGetZirconHandleInfo, pZirconHandle );
|
|
}
|
|
# endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
|
# if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
//=== VK_FUCHSIA_buffer_collection ===
|
|
|
|
VkResult vkCreateBufferCollectionFUCHSIA( VkDevice device,
|
|
const VkBufferCollectionCreateInfoFUCHSIA * pCreateInfo,
|
|
const VkAllocationCallbacks * pAllocator,
|
|
VkBufferCollectionFUCHSIA * pCollection ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ::vkCreateBufferCollectionFUCHSIA( device, pCreateInfo, pAllocator, pCollection );
|
|
}
|
|
|
|
VkResult vkSetBufferCollectionImageConstraintsFUCHSIA( VkDevice device,
|
|
VkBufferCollectionFUCHSIA collection,
|
|
const VkImageConstraintsInfoFUCHSIA * pImageConstraintsInfo ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ::vkSetBufferCollectionImageConstraintsFUCHSIA( device, collection, pImageConstraintsInfo );
|
|
}
|
|
|
|
VkResult vkSetBufferCollectionBufferConstraintsFUCHSIA( VkDevice device,
|
|
VkBufferCollectionFUCHSIA collection,
|
|
const VkBufferConstraintsInfoFUCHSIA * pBufferConstraintsInfo ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ::vkSetBufferCollectionBufferConstraintsFUCHSIA( device, collection, pBufferConstraintsInfo );
|
|
}
|
|
|
|
void vkDestroyBufferCollectionFUCHSIA( VkDevice device,
|
|
VkBufferCollectionFUCHSIA collection,
|
|
const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ::vkDestroyBufferCollectionFUCHSIA( device, collection, pAllocator );
|
|
}
|
|
|
|
VkResult vkGetBufferCollectionPropertiesFUCHSIA( VkDevice device,
|
|
VkBufferCollectionFUCHSIA collection,
|
|
VkBufferCollectionPropertiesFUCHSIA * pProperties ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ::vkGetBufferCollectionPropertiesFUCHSIA( device, collection, pProperties );
|
|
}
|
|
# endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
|
//=== VK_HUAWEI_subpass_shading ===
|
|
|
|
VkResult
|
|
vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( VkDevice device, VkRenderPass renderpass, VkExtent2D * pMaxWorkgroupSize ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ::vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( device, renderpass, pMaxWorkgroupSize );
|
|
}
|
|
|
|
void vkCmdSubpassShadingHUAWEI( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ::vkCmdSubpassShadingHUAWEI( commandBuffer );
|
|
}
|
|
|
|
//=== VK_HUAWEI_invocation_mask ===
|
|
|
|
void vkCmdBindInvocationMaskHUAWEI( VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ::vkCmdBindInvocationMaskHUAWEI( commandBuffer, imageView, imageLayout );
|
|
}
|
|
|
|
//=== VK_NV_external_memory_rdma ===
|
|
|
|
VkResult vkGetMemoryRemoteAddressNV( VkDevice device,
|
|
const VkMemoryGetRemoteAddressInfoNV * pMemoryGetRemoteAddressInfo,
|
|
VkRemoteAddressNV * pAddress ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ::vkGetMemoryRemoteAddressNV( device, pMemoryGetRemoteAddressInfo, pAddress );
|
|
}
|
|
|
|
//=== VK_EXT_pipeline_properties ===
|
|
|
|
VkResult
|
|
vkGetPipelinePropertiesEXT( VkDevice device, const VkPipelineInfoEXT * pPipelineInfo, VkBaseOutStructure * pPipelineProperties ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ::vkGetPipelinePropertiesEXT( device, pPipelineInfo, pPipelineProperties );
|
|
}
|
|
|
|
//=== VK_EXT_extended_dynamic_state2 ===
|
|
|
|
void vkCmdSetPatchControlPointsEXT( VkCommandBuffer commandBuffer, uint32_t patchControlPoints ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ::vkCmdSetPatchControlPointsEXT( commandBuffer, patchControlPoints );
|
|
}
|
|
|
|
void vkCmdSetRasterizerDiscardEnableEXT( VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ::vkCmdSetRasterizerDiscardEnableEXT( commandBuffer, rasterizerDiscardEnable );
|
|
}
|
|
|
|
void vkCmdSetDepthBiasEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ::vkCmdSetDepthBiasEnableEXT( commandBuffer, depthBiasEnable );
|
|
}
|
|
|
|
void vkCmdSetLogicOpEXT( VkCommandBuffer commandBuffer, VkLogicOp logicOp ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ::vkCmdSetLogicOpEXT( commandBuffer, logicOp );
|
|
}
|
|
|
|
void vkCmdSetPrimitiveRestartEnableEXT( VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ::vkCmdSetPrimitiveRestartEnableEXT( commandBuffer, primitiveRestartEnable );
|
|
}
|
|
|
|
# if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
|
//=== VK_QNX_screen_surface ===
|
|
|
|
VkResult vkCreateScreenSurfaceQNX( VkInstance instance,
|
|
const VkScreenSurfaceCreateInfoQNX * pCreateInfo,
|
|
const VkAllocationCallbacks * pAllocator,
|
|
VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ::vkCreateScreenSurfaceQNX( instance, pCreateInfo, pAllocator, pSurface );
|
|
}
|
|
|
|
VkBool32 vkGetPhysicalDeviceScreenPresentationSupportQNX( VkPhysicalDevice physicalDevice,
|
|
uint32_t queueFamilyIndex,
|
|
struct _screen_window * window ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ::vkGetPhysicalDeviceScreenPresentationSupportQNX( physicalDevice, queueFamilyIndex, window );
|
|
}
|
|
# endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
|
|
|
//=== VK_EXT_color_write_enable ===
|
|
|
|
void vkCmdSetColorWriteEnableEXT( VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32 * pColorWriteEnables ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ::vkCmdSetColorWriteEnableEXT( commandBuffer, attachmentCount, pColorWriteEnables );
|
|
}
|
|
|
|
//=== VK_KHR_ray_tracing_maintenance1 ===
|
|
|
|
void vkCmdTraceRaysIndirect2KHR( VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ::vkCmdTraceRaysIndirect2KHR( commandBuffer, indirectDeviceAddress );
|
|
}
|
|
|
|
//=== VK_EXT_multi_draw ===
|
|
|
|
void vkCmdDrawMultiEXT( VkCommandBuffer commandBuffer,
|
|
uint32_t drawCount,
|
|
const VkMultiDrawInfoEXT * pVertexInfo,
|
|
uint32_t instanceCount,
|
|
uint32_t firstInstance,
|
|
uint32_t stride ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ::vkCmdDrawMultiEXT( commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride );
|
|
}
|
|
|
|
void vkCmdDrawMultiIndexedEXT( VkCommandBuffer commandBuffer,
|
|
uint32_t drawCount,
|
|
const VkMultiDrawIndexedInfoEXT * pIndexInfo,
|
|
uint32_t instanceCount,
|
|
uint32_t firstInstance,
|
|
uint32_t stride,
|
|
const int32_t * pVertexOffset ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ::vkCmdDrawMultiIndexedEXT( commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset );
|
|
}
|
|
|
|
//=== VK_EXT_pageable_device_local_memory ===
|
|
|
|
void vkSetDeviceMemoryPriorityEXT( VkDevice device, VkDeviceMemory memory, float priority ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ::vkSetDeviceMemoryPriorityEXT( device, memory, priority );
|
|
}
|
|
|
|
//=== VK_KHR_maintenance4 ===
|
|
|
|
void vkGetDeviceBufferMemoryRequirementsKHR( VkDevice device,
|
|
const VkDeviceBufferMemoryRequirements * pInfo,
|
|
VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ::vkGetDeviceBufferMemoryRequirementsKHR( device, pInfo, pMemoryRequirements );
|
|
}
|
|
|
|
void vkGetDeviceImageMemoryRequirementsKHR( VkDevice device,
|
|
const VkDeviceImageMemoryRequirements * pInfo,
|
|
VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ::vkGetDeviceImageMemoryRequirementsKHR( device, pInfo, pMemoryRequirements );
|
|
}
|
|
|
|
void vkGetDeviceImageSparseMemoryRequirementsKHR( VkDevice device,
|
|
const VkDeviceImageMemoryRequirements * pInfo,
|
|
uint32_t * pSparseMemoryRequirementCount,
|
|
VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ::vkGetDeviceImageSparseMemoryRequirementsKHR( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
|
|
}
|
|
|
|
//=== VK_VALVE_descriptor_set_host_mapping ===
|
|
|
|
void vkGetDescriptorSetLayoutHostMappingInfoVALVE( VkDevice device,
|
|
const VkDescriptorSetBindingReferenceVALVE * pBindingReference,
|
|
VkDescriptorSetLayoutHostMappingInfoVALVE * pHostMapping ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ::vkGetDescriptorSetLayoutHostMappingInfoVALVE( device, pBindingReference, pHostMapping );
|
|
}
|
|
|
|
void vkGetDescriptorSetHostMappingVALVE( VkDevice device, VkDescriptorSet descriptorSet, void ** ppData ) const VULKAN_HPP_NOEXCEPT
|
|
{
|
|
return ::vkGetDescriptorSetHostMappingVALVE( device, descriptorSet, ppData );
|
|
}
|
|
};
|
|
#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*/
|
|
|
|
class CompressionExhaustedEXTError : public SystemError
|
|
{
|
|
public:
|
|
CompressionExhaustedEXTError( std::string const & message ) : SystemError( make_error_code( Result::eErrorCompressionExhaustedEXT ), message ) {}
|
|
CompressionExhaustedEXTError( char const * message ) : SystemError( make_error_code( Result::eErrorCompressionExhaustedEXT ), message ) {}
|
|
};
|
|
|
|
namespace
|
|
{
|
|
[[noreturn]] void throwResultException( Result result, char const * message )
|
|
{
|
|
switch ( result )
|
|
{
|
|
case Result::eErrorOutOfHostMemory: throw OutOfHostMemoryError( message );
|
|
case Result::eErrorOutOfDeviceMemory: throw OutOfDeviceMemoryError( message );
|
|
case Result::eErrorInitializationFailed: throw InitializationFailedError( message );
|
|
case Result::eErrorDeviceLost: throw DeviceLostError( message );
|
|
case Result::eErrorMemoryMapFailed: throw MemoryMapFailedError( message );
|
|
case Result::eErrorLayerNotPresent: throw LayerNotPresentError( message );
|
|
case Result::eErrorExtensionNotPresent: throw ExtensionNotPresentError( message );
|
|
case Result::eErrorFeatureNotPresent: throw FeatureNotPresentError( message );
|
|
case Result::eErrorIncompatibleDriver: throw IncompatibleDriverError( message );
|
|
case Result::eErrorTooManyObjects: throw TooManyObjectsError( message );
|
|
case Result::eErrorFormatNotSupported: throw FormatNotSupportedError( message );
|
|
case Result::eErrorFragmentedPool: throw FragmentedPoolError( message );
|
|
case Result::eErrorUnknown: throw UnknownError( message );
|
|
case Result::eErrorOutOfPoolMemory: throw OutOfPoolMemoryError( message );
|
|
case Result::eErrorInvalidExternalHandle: throw InvalidExternalHandleError( message );
|
|
case Result::eErrorFragmentation: throw FragmentationError( message );
|
|
case Result::eErrorInvalidOpaqueCaptureAddress: throw InvalidOpaqueCaptureAddressError( message );
|
|
case Result::eErrorSurfaceLostKHR: throw SurfaceLostKHRError( message );
|
|
case Result::eErrorNativeWindowInUseKHR: throw NativeWindowInUseKHRError( message );
|
|
case Result::eErrorOutOfDateKHR: throw OutOfDateKHRError( message );
|
|
case Result::eErrorIncompatibleDisplayKHR: throw IncompatibleDisplayKHRError( message );
|
|
case Result::eErrorValidationFailedEXT: throw ValidationFailedEXTError( message );
|
|
case Result::eErrorInvalidShaderNV: throw InvalidShaderNVError( message );
|
|
case Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT: throw InvalidDrmFormatModifierPlaneLayoutEXTError( message );
|
|
case Result::eErrorNotPermittedKHR: throw NotPermittedKHRError( message );
|
|
# if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
case Result::eErrorFullScreenExclusiveModeLostEXT: throw FullScreenExclusiveModeLostEXTError( message );
|
|
# endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
case Result::eErrorCompressionExhaustedEXT: throw CompressionExhaustedEXTError( message );
|
|
default: throw SystemError( make_error_code( result ) );
|
|
}
|
|
}
|
|
} // namespace
|
|
#endif
|
|
|
|
template <typename T>
|
|
void ignore( T const & ) VULKAN_HPP_NOEXCEPT
|
|
{
|
|
}
|
|
|
|
template <typename T>
|
|
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_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 ) );
|
|
}
|
|
|
|
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;
|
|
};
|
|
#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
|
|
};
|
|
|
|
VULKAN_HPP_INLINE typename ResultValueType<void>::type createResultValueType( Result result )
|
|
{
|
|
#ifdef VULKAN_HPP_NO_EXCEPTIONS
|
|
return result;
|
|
#else
|
|
ignore( result );
|
|
#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, data );
|
|
#else
|
|
ignore( result );
|
|
return 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 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_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_AMD_shader_early_and_late_fragment_tests ===
|
|
template <>
|
|
struct StructExtends<PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD, PhysicalDeviceFeatures2>
|
|
{
|
|
enum
|
|
{
|
|
value = true
|
|
};
|
|
};
|
|
template <>
|
|
struct StructExtends<PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD, DeviceCreateInfo>
|
|
{
|
|
enum
|
|
{
|
|
value = true
|
|
};
|
|
};
|
|
|
|
//=== VK_KHR_fragment_shader_barycentric ===
|
|
template <>
|
|
struct StructExtends<PhysicalDeviceFragmentShaderBarycentricFeaturesKHR, PhysicalDeviceFeatures2>
|
|
{
|
|
enum
|
|
{
|
|
value = true
|
|
};
|
|
};
|
|
template <>
|
|
struct StructExtends<PhysicalDeviceFragmentShaderBarycentricFeaturesKHR, DeviceCreateInfo>
|
|
{
|
|
enum
|
|
{
|
|
value = true
|
|
};
|
|
};
|
|
template <>
|
|
struct StructExtends<PhysicalDeviceFragmentShaderBarycentricPropertiesKHR, PhysicalDeviceProperties2>
|
|
{
|
|
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_image_compression_control ===
|
|
template <>
|
|
struct StructExtends<PhysicalDeviceImageCompressionControlFeaturesEXT, PhysicalDeviceFeatures2>
|
|
{
|
|
enum
|
|
{
|
|
value = true
|
|
};
|
|
};
|
|
template <>
|
|
struct StructExtends<PhysicalDeviceImageCompressionControlFeaturesEXT, DeviceCreateInfo>
|
|
{
|
|
enum
|
|
{
|
|
value = true
|
|
};
|
|
};
|
|
template <>
|
|
struct StructExtends<ImageCompressionControlEXT, ImageCreateInfo>
|
|
{
|
|
enum
|
|
{
|
|
value = true
|
|
};
|
|
};
|
|
template <>
|
|
struct StructExtends<ImageCompressionControlEXT, SwapchainCreateInfoKHR>
|
|
{
|
|
enum
|
|
{
|
|
value = true
|
|
};
|
|
};
|
|
template <>
|
|
struct StructExtends<ImageCompressionControlEXT, PhysicalDeviceImageFormatInfo2>
|
|
{
|
|
enum
|
|
{
|
|
value = true
|
|
};
|
|
};
|
|
template <>
|
|
struct StructExtends<ImageCompressionPropertiesEXT, ImageFormatProperties2>
|
|
{
|
|
enum
|
|
{
|
|
value = true
|
|
};
|
|
};
|
|
template <>
|
|
struct StructExtends<ImageCompressionPropertiesEXT, SurfaceFormat2KHR>
|
|
{
|
|
enum
|
|
{
|
|
value = true
|
|
};
|
|
};
|
|
template <>
|
|
struct StructExtends<ImageCompressionPropertiesEXT, SubresourceLayout2EXT>
|
|
{
|
|
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_pipeline_properties ===
|
|
template <>
|
|
struct StructExtends<PipelinePropertiesIdentifierEXT, BaseOutStructure>
|
|
{
|
|
enum
|
|
{
|
|
value = true
|
|
};
|
|
};
|
|
template <>
|
|
struct StructExtends<PhysicalDevicePipelinePropertiesFeaturesEXT, PhysicalDeviceFeatures2>
|
|
{
|
|
enum
|
|
{
|
|
value = true
|
|
};
|
|
};
|
|
template <>
|
|
struct StructExtends<PhysicalDevicePipelinePropertiesFeaturesEXT, 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_KHR_ray_tracing_maintenance1 ===
|
|
template <>
|
|
struct StructExtends<PhysicalDeviceRayTracingMaintenance1FeaturesKHR, PhysicalDeviceFeatures2>
|
|
{
|
|
enum
|
|
{
|
|
value = true
|
|
};
|
|
};
|
|
template <>
|
|
struct StructExtends<PhysicalDeviceRayTracingMaintenance1FeaturesKHR, 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
|
|
};
|
|
};
|
|
|
|
//=== VK_EXT_image_compression_control_swapchain ===
|
|
template <>
|
|
struct StructExtends<PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT, PhysicalDeviceFeatures2>
|
|
{
|
|
enum
|
|
{
|
|
value = true
|
|
};
|
|
};
|
|
template <>
|
|
struct StructExtends<PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT, DeviceCreateInfo>
|
|
{
|
|
enum
|
|
{
|
|
value = true
|
|
};
|
|
};
|
|
|
|
//=== VK_EXT_subpass_merge_feedback ===
|
|
template <>
|
|
struct StructExtends<PhysicalDeviceSubpassMergeFeedbackFeaturesEXT, PhysicalDeviceFeatures2>
|
|
{
|
|
enum
|
|
{
|
|
value = true
|
|
};
|
|
};
|
|
template <>
|
|
struct StructExtends<PhysicalDeviceSubpassMergeFeedbackFeaturesEXT, DeviceCreateInfo>
|
|
{
|
|
enum
|
|
{
|
|
value = true
|
|
};
|
|
};
|
|
template <>
|
|
struct StructExtends<RenderPassCreationControlEXT, RenderPassCreateInfo2>
|
|
{
|
|
enum
|
|
{
|
|
value = true
|
|
};
|
|
};
|
|
template <>
|
|
struct StructExtends<RenderPassCreationControlEXT, SubpassDescription2>
|
|
{
|
|
enum
|
|
{
|
|
value = true
|
|
};
|
|
};
|
|
template <>
|
|
struct StructExtends<RenderPassCreationFeedbackCreateInfoEXT, RenderPassCreateInfo2>
|
|
{
|
|
enum
|
|
{
|
|
value = true
|
|
};
|
|
};
|
|
template <>
|
|
struct StructExtends<RenderPassSubpassFeedbackCreateInfoEXT, SubpassDescription2>
|
|
{
|
|
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;
|
|
|
|
//=== VK_EXT_image_compression_control ===
|
|
PFN_vkGetImageSubresourceLayout2EXT vkGetImageSubresourceLayout2EXT = 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_pipeline_properties ===
|
|
PFN_vkGetPipelinePropertiesEXT vkGetPipelinePropertiesEXT = 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_KHR_ray_tracing_maintenance1 ===
|
|
PFN_vkCmdTraceRaysIndirect2KHR vkCmdTraceRaysIndirect2KHR = 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;
|
|
|
|
//=== VK_EXT_image_compression_control ===
|
|
vkGetImageSubresourceLayout2EXT = PFN_vkGetImageSubresourceLayout2EXT( vkGetInstanceProcAddr( instance, "vkGetImageSubresourceLayout2EXT" ) );
|
|
|
|
#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_pipeline_properties ===
|
|
vkGetPipelinePropertiesEXT = PFN_vkGetPipelinePropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetPipelinePropertiesEXT" ) );
|
|
|
|
//=== 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_KHR_ray_tracing_maintenance1 ===
|
|
vkCmdTraceRaysIndirect2KHR = PFN_vkCmdTraceRaysIndirect2KHR( vkGetInstanceProcAddr( instance, "vkCmdTraceRaysIndirect2KHR" ) );
|
|
|
|
//=== 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_EXT_image_compression_control ===
|
|
vkGetImageSubresourceLayout2EXT = PFN_vkGetImageSubresourceLayout2EXT( vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout2EXT" ) );
|
|
|
|
//=== 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_pipeline_properties ===
|
|
vkGetPipelinePropertiesEXT = PFN_vkGetPipelinePropertiesEXT( vkGetDeviceProcAddr( device, "vkGetPipelinePropertiesEXT" ) );
|
|
|
|
//=== 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_KHR_ray_tracing_maintenance1 ===
|
|
vkCmdTraceRaysIndirect2KHR = PFN_vkCmdTraceRaysIndirect2KHR( vkGetDeviceProcAddr( device, "vkCmdTraceRaysIndirect2KHR" ) );
|
|
|
|
//=== 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
|