|
1501
|
1 // Copyright 2015-2025 The Khronos Group Inc.
|
|
|
2 //
|
|
|
3 // SPDX-License-Identifier: Apache-2.0 OR MIT
|
|
|
4 //
|
|
|
5
|
|
|
6 // This header is generated from the Khronos Vulkan XML API Registry.
|
|
|
7
|
|
|
8 #ifndef VULKAN_HPP
|
|
|
9 #define VULKAN_HPP
|
|
|
10
|
|
|
11 #include <vulkan/vulkan.h>
|
|
|
12 #if !defined( VULKAN_HPP_CXX_MODULE )
|
|
|
13 // clang-format off
|
|
|
14 # include <vulkan/vulkan_hpp_macros.hpp>
|
|
|
15 // clang-format on
|
|
|
16 # include <algorithm>
|
|
|
17 # include <array> // ArrayWrapperND
|
|
|
18 # include <cassert>
|
|
|
19 # include <string.h> // strnlen
|
|
|
20 # include <string> // std::string
|
|
|
21 # include <utility> // std::exchange
|
|
|
22 # if 17 <= VULKAN_HPP_CPP_VERSION
|
|
|
23 # include <string_view>
|
|
|
24 # endif
|
|
|
25 # if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
|
|
|
26 # include <tuple> // std::tie
|
|
|
27 # include <vector> // std::vector
|
|
|
28 # endif
|
|
|
29 # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
|
|
|
30 # include <compare>
|
|
|
31 # endif
|
|
|
32 # if !defined( VULKAN_HPP_NO_EXCEPTIONS )
|
|
|
33 # include <system_error> // std::is_error_code_enum
|
|
|
34 # endif
|
|
|
35 # if defined( VULKAN_HPP_SUPPORT_SPAN )
|
|
|
36 # include <span>
|
|
|
37 # endif
|
|
|
38 #else
|
|
|
39 # include <cassert>
|
|
|
40 # include <cstring>
|
|
|
41 import std;
|
|
|
42 #endif
|
|
|
43
|
|
|
44 #if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL == 1
|
|
|
45 # if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNX__ ) || defined( __Fuchsia__ )
|
|
|
46 # include <dlfcn.h>
|
|
|
47 # elif defined( _WIN32 ) && !defined( VULKAN_HPP_NO_WIN32_PROTOTYPES )
|
|
|
48 using HINSTANCE = struct HINSTANCE__ *;
|
|
|
49 # if defined( _WIN64 )
|
|
|
50 using FARPROC = int64_t( __stdcall * )();
|
|
|
51 # else
|
|
|
52 using FARPROC = int( __stdcall * )();
|
|
|
53 # endif
|
|
|
54 extern "C" __declspec( dllimport ) HINSTANCE __stdcall LoadLibraryA( char const * lpLibFileName );
|
|
|
55 extern "C" __declspec( dllimport ) int __stdcall FreeLibrary( HINSTANCE hLibModule );
|
|
|
56 extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE hModule, const char * lpProcName );
|
|
|
57 # endif
|
|
|
58 #endif
|
|
|
59
|
|
|
60 VULKAN_HPP_STATIC_ASSERT( VK_HEADER_VERSION == 334, "Wrong VK_HEADER_VERSION!" );
|
|
|
61
|
|
|
62 // <tuple> includes <sys/sysmacros.h> through some other header
|
|
|
63 // this results in major(x) being resolved to gnu_dev_major(x)
|
|
|
64 // which is an expression in a constructor initializer list.
|
|
|
65 #if defined( major )
|
|
|
66 # undef major
|
|
|
67 #endif
|
|
|
68 #if defined( minor )
|
|
|
69 # undef minor
|
|
|
70 #endif
|
|
|
71
|
|
|
72 // Windows defines MemoryBarrier which is deprecated and collides
|
|
|
73 // with the VULKAN_HPP_NAMESPACE::MemoryBarrier struct.
|
|
|
74 #if defined( MemoryBarrier )
|
|
|
75 # undef MemoryBarrier
|
|
|
76 #endif
|
|
|
77
|
|
|
78 // XLib.h defines True/False, which collides with our VULKAN_HPP_NAMESPACE::True/VULKAN_HPP_NAMESPACE::False
|
|
|
79 // -> undef them and provide some namepace-secure constexpr
|
|
|
80 #if defined( True )
|
|
|
81 # undef True
|
|
|
82 constexpr int True = 1;
|
|
|
83 #endif
|
|
|
84 #if defined( False )
|
|
|
85 # undef False
|
|
|
86 constexpr int False = 0;
|
|
|
87 #endif
|
|
|
88
|
|
|
89 namespace VULKAN_HPP_NAMESPACE
|
|
|
90 {
|
|
|
91 template <typename T, size_t N>
|
|
|
92 class ArrayWrapper1D : public std::array<T, N>
|
|
|
93 {
|
|
|
94 public:
|
|
|
95 VULKAN_HPP_CONSTEXPR ArrayWrapper1D() VULKAN_HPP_NOEXCEPT : std::array<T, N>() {}
|
|
|
96
|
|
|
97 VULKAN_HPP_CONSTEXPR ArrayWrapper1D( std::array<T, N> const & data ) VULKAN_HPP_NOEXCEPT : std::array<T, N>( data ) {}
|
|
|
98
|
|
|
99 template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
|
|
|
100 VULKAN_HPP_CONSTEXPR_14 ArrayWrapper1D( std::string const & data ) VULKAN_HPP_NOEXCEPT
|
|
|
101 {
|
|
|
102 copy( data.data(), data.length() );
|
|
|
103 }
|
|
|
104
|
|
|
105 #if 17 <= VULKAN_HPP_CPP_VERSION
|
|
|
106 template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
|
|
|
107 VULKAN_HPP_CONSTEXPR_14 ArrayWrapper1D( std::string_view data ) VULKAN_HPP_NOEXCEPT
|
|
|
108 {
|
|
|
109 copy( data.data(), data.length() );
|
|
|
110 }
|
|
|
111 #endif
|
|
|
112
|
|
|
113 #if ( VK_USE_64_BIT_PTR_DEFINES == 0 )
|
|
|
114 // on 32 bit compiles, needs overloads on index type int to resolve ambiguities
|
|
|
115 VULKAN_HPP_CONSTEXPR T const & operator[]( int index ) const VULKAN_HPP_NOEXCEPT
|
|
|
116 {
|
|
|
117 return std::array<T, N>::operator[]( index );
|
|
|
118 }
|
|
|
119
|
|
|
120 T & operator[]( int index ) VULKAN_HPP_NOEXCEPT
|
|
|
121 {
|
|
|
122 return std::array<T, N>::operator[]( index );
|
|
|
123 }
|
|
|
124 #endif
|
|
|
125
|
|
|
126 operator T const *() const VULKAN_HPP_NOEXCEPT
|
|
|
127 {
|
|
|
128 return this->data();
|
|
|
129 }
|
|
|
130
|
|
|
131 operator T *() VULKAN_HPP_NOEXCEPT
|
|
|
132 {
|
|
|
133 return this->data();
|
|
|
134 }
|
|
|
135
|
|
|
136 template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
|
|
|
137 operator std::string() const
|
|
|
138 {
|
|
|
139 return std::string( this->data(), strnlen( this->data(), N ) );
|
|
|
140 }
|
|
|
141
|
|
|
142 #if 17 <= VULKAN_HPP_CPP_VERSION
|
|
|
143 template <typename B = T, typename std::enable_if<std::is_same<B, char>::value, int>::type = 0>
|
|
|
144 operator std::string_view() const
|
|
|
145 {
|
|
|
146 return std::string_view( this->data(), strnlen( this->data(), N ) );
|
|
|
147 }
|
|
|
148 #endif
|
|
|
149
|
|
|
150 private:
|
|
|
151 VULKAN_HPP_CONSTEXPR_14 void copy( char const * data, size_t len ) VULKAN_HPP_NOEXCEPT
|
|
|
152 {
|
|
|
153 size_t n = ( std::min )( N - 1, len );
|
|
|
154 for ( size_t i = 0; i < n; ++i )
|
|
|
155 {
|
|
|
156 ( *this )[i] = data[i];
|
|
|
157 }
|
|
|
158 ( *this )[n] = 0;
|
|
|
159 }
|
|
|
160 };
|
|
|
161
|
|
|
162 // relational operators between ArrayWrapper1D of chars with potentially different sizes
|
|
|
163 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
|
|
|
164 template <size_t N, size_t M>
|
|
|
165 std::strong_ordering operator<=>( ArrayWrapper1D<char, N> const & lhs, ArrayWrapper1D<char, M> const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
166 {
|
|
|
167 int result = strcmp( lhs.data(), rhs.data() );
|
|
|
168 return ( result < 0 ) ? std::strong_ordering::less : ( ( result > 0 ) ? std::strong_ordering::greater : std::strong_ordering::equal );
|
|
|
169 }
|
|
|
170 #else
|
|
|
171 template <size_t N, size_t M>
|
|
|
172 bool operator<( ArrayWrapper1D<char, N> const & lhs, ArrayWrapper1D<char, M> const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
173 {
|
|
|
174 return strcmp( lhs.data(), rhs.data() ) < 0;
|
|
|
175 }
|
|
|
176
|
|
|
177 template <size_t N, size_t M>
|
|
|
178 bool operator<=( ArrayWrapper1D<char, N> const & lhs, ArrayWrapper1D<char, M> const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
179 {
|
|
|
180 return strcmp( lhs.data(), rhs.data() ) <= 0;
|
|
|
181 }
|
|
|
182
|
|
|
183 template <size_t N, size_t M>
|
|
|
184 bool operator>( ArrayWrapper1D<char, N> const & lhs, ArrayWrapper1D<char, M> const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
185 {
|
|
|
186 return strcmp( lhs.data(), rhs.data() ) > 0;
|
|
|
187 }
|
|
|
188
|
|
|
189 template <size_t N, size_t M>
|
|
|
190 bool operator>=( ArrayWrapper1D<char, N> const & lhs, ArrayWrapper1D<char, M> const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
191 {
|
|
|
192 return strcmp( lhs.data(), rhs.data() ) >= 0;
|
|
|
193 }
|
|
|
194 #endif
|
|
|
195
|
|
|
196 template <size_t N, size_t M>
|
|
|
197 bool operator==( ArrayWrapper1D<char, N> const & lhs, ArrayWrapper1D<char, M> const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
198 {
|
|
|
199 return strcmp( lhs.data(), rhs.data() ) == 0;
|
|
|
200 }
|
|
|
201
|
|
|
202 template <size_t N, size_t M>
|
|
|
203 bool operator!=( ArrayWrapper1D<char, N> const & lhs, ArrayWrapper1D<char, M> const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
204 {
|
|
|
205 return strcmp( lhs.data(), rhs.data() ) != 0;
|
|
|
206 }
|
|
|
207
|
|
|
208 // specialization of relational operators between std::string and arrays of chars
|
|
|
209 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
|
|
|
210 template <size_t N>
|
|
|
211 std::strong_ordering operator<=>( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
212 {
|
|
|
213 return lhs <=> rhs.data();
|
|
|
214 }
|
|
|
215 #else
|
|
|
216 template <size_t N>
|
|
|
217 bool operator<( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
218 {
|
|
|
219 return lhs < rhs.data();
|
|
|
220 }
|
|
|
221
|
|
|
222 template <size_t N>
|
|
|
223 bool operator<=( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
224 {
|
|
|
225 return lhs <= rhs.data();
|
|
|
226 }
|
|
|
227
|
|
|
228 template <size_t N>
|
|
|
229 bool operator>( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
230 {
|
|
|
231 return lhs > rhs.data();
|
|
|
232 }
|
|
|
233
|
|
|
234 template <size_t N>
|
|
|
235 bool operator>=( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
236 {
|
|
|
237 return lhs >= rhs.data();
|
|
|
238 }
|
|
|
239 #endif
|
|
|
240
|
|
|
241 template <size_t N>
|
|
|
242 bool operator==( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
243 {
|
|
|
244 return lhs == rhs.data();
|
|
|
245 }
|
|
|
246
|
|
|
247 template <size_t N>
|
|
|
248 bool operator!=( std::string const & lhs, ArrayWrapper1D<char, N> const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
249 {
|
|
|
250 return lhs != rhs.data();
|
|
|
251 }
|
|
|
252
|
|
|
253 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
|
|
|
254 template <size_t N>
|
|
|
255 std::strong_ordering operator<=>( ArrayWrapper1D<char, N> const & lhs, std::string const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
256 {
|
|
|
257 return lhs.data() <=> rhs;
|
|
|
258 }
|
|
|
259 #else
|
|
|
260 template <size_t N>
|
|
|
261 bool operator<( ArrayWrapper1D<char, N> const & lhs, std::string const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
262 {
|
|
|
263 return lhs.data() < rhs;
|
|
|
264 }
|
|
|
265
|
|
|
266 template <size_t N>
|
|
|
267 bool operator<=( ArrayWrapper1D<char, N> const & lhs, std::string const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
268 {
|
|
|
269 return lhs.data() <= rhs;
|
|
|
270 }
|
|
|
271
|
|
|
272 template <size_t N>
|
|
|
273 bool operator>( ArrayWrapper1D<char, N> const & lhs, std::string const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
274 {
|
|
|
275 return lhs.data() > rhs;
|
|
|
276 }
|
|
|
277
|
|
|
278 template <size_t N>
|
|
|
279 bool operator>=( ArrayWrapper1D<char, N> const & lhs, std::string const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
280 {
|
|
|
281 return lhs.data() >= rhs;
|
|
|
282 }
|
|
|
283 #endif
|
|
|
284
|
|
|
285 template <size_t N>
|
|
|
286 bool operator==( ArrayWrapper1D<char, N> const & lhs, std::string const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
287 {
|
|
|
288 return lhs.data() == rhs;
|
|
|
289 }
|
|
|
290
|
|
|
291 template <size_t N>
|
|
|
292 bool operator!=( ArrayWrapper1D<char, N> const & lhs, std::string const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
293 {
|
|
|
294 return lhs.data() != rhs;
|
|
|
295 }
|
|
|
296
|
|
|
297 template <typename T, size_t N, size_t M>
|
|
|
298 class ArrayWrapper2D : public std::array<ArrayWrapper1D<T, M>, N>
|
|
|
299 {
|
|
|
300 public:
|
|
|
301 VULKAN_HPP_CONSTEXPR ArrayWrapper2D() VULKAN_HPP_NOEXCEPT : std::array<ArrayWrapper1D<T, M>, N>() {}
|
|
|
302
|
|
|
303 VULKAN_HPP_CONSTEXPR ArrayWrapper2D( std::array<std::array<T, M>, N> const & data ) VULKAN_HPP_NOEXCEPT
|
|
|
304 : std::array<ArrayWrapper1D<T, M>, N>( *reinterpret_cast<std::array<ArrayWrapper1D<T, M>, N> const *>( &data ) )
|
|
|
305 {
|
|
|
306 }
|
|
|
307 };
|
|
|
308
|
|
|
309 #if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
|
|
|
310 template <typename T>
|
|
|
311 class ArrayProxy
|
|
|
312 {
|
|
|
313 public:
|
|
|
314 VULKAN_HPP_CONSTEXPR ArrayProxy() VULKAN_HPP_NOEXCEPT
|
|
|
315 : m_count( 0 )
|
|
|
316 , m_ptr( nullptr )
|
|
|
317 {
|
|
|
318 }
|
|
|
319
|
|
|
320 VULKAN_HPP_CONSTEXPR ArrayProxy( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
321 : m_count( 0 )
|
|
|
322 , m_ptr( nullptr )
|
|
|
323 {
|
|
|
324 }
|
|
|
325
|
|
|
326 ArrayProxy( T const & value ) VULKAN_HPP_NOEXCEPT
|
|
|
327 : m_count( 1 )
|
|
|
328 , m_ptr( &value )
|
|
|
329 {
|
|
|
330 }
|
|
|
331
|
|
|
332 ArrayProxy( uint32_t count, T const * ptr ) VULKAN_HPP_NOEXCEPT
|
|
|
333 : m_count( count )
|
|
|
334 , m_ptr( ptr )
|
|
|
335 {
|
|
|
336 }
|
|
|
337
|
|
|
338 template <std::size_t C>
|
|
|
339 ArrayProxy( T const ( &ptr )[C] ) VULKAN_HPP_NOEXCEPT
|
|
|
340 : m_count( C )
|
|
|
341 , m_ptr( ptr )
|
|
|
342 {
|
|
|
343 }
|
|
|
344
|
|
|
345 # if __GNUC__ >= 9
|
|
|
346 # pragma GCC diagnostic push
|
|
|
347 # pragma GCC diagnostic ignored "-Winit-list-lifetime"
|
|
|
348 # endif
|
|
|
349
|
|
|
350 ArrayProxy( std::initializer_list<T> const & list ) VULKAN_HPP_NOEXCEPT
|
|
|
351 : m_count( static_cast<uint32_t>( list.size() ) )
|
|
|
352 , m_ptr( list.begin() )
|
|
|
353 {
|
|
|
354 }
|
|
|
355
|
|
|
356 template <typename B = T, typename std::enable_if<std::is_const<B>::value, int>::type = 0>
|
|
|
357 ArrayProxy( std::initializer_list<typename std::remove_const<T>::type> const & list ) VULKAN_HPP_NOEXCEPT
|
|
|
358 : m_count( static_cast<uint32_t>( list.size() ) )
|
|
|
359 , m_ptr( list.begin() )
|
|
|
360 {
|
|
|
361 }
|
|
|
362
|
|
|
363 # if __GNUC__ >= 9
|
|
|
364 # pragma GCC diagnostic pop
|
|
|
365 # endif
|
|
|
366
|
|
|
367 // Any type with a .data() return type implicitly convertible to T*, and a .size() return type implicitly
|
|
|
368 // convertible to size_t. The const version can capture temporaries, with lifetime ending at end of statement.
|
|
|
369 template <typename V,
|
|
|
370 typename std::enable_if<std::is_convertible<decltype( std::declval<V>().data() ), T *>::value &&
|
|
|
371 std::is_convertible<decltype( std::declval<V>().size() ), std::size_t>::value>::type * = nullptr>
|
|
|
372 ArrayProxy( V const & v ) VULKAN_HPP_NOEXCEPT
|
|
|
373 : m_count( static_cast<uint32_t>( v.size() ) )
|
|
|
374 , m_ptr( v.data() )
|
|
|
375 {
|
|
|
376 }
|
|
|
377
|
|
|
378 const T * begin() const VULKAN_HPP_NOEXCEPT
|
|
|
379 {
|
|
|
380 return m_ptr;
|
|
|
381 }
|
|
|
382
|
|
|
383 const T * end() const VULKAN_HPP_NOEXCEPT
|
|
|
384 {
|
|
|
385 return m_ptr + m_count;
|
|
|
386 }
|
|
|
387
|
|
|
388 const T & front() const VULKAN_HPP_NOEXCEPT
|
|
|
389 {
|
|
|
390 VULKAN_HPP_ASSERT( m_count && m_ptr );
|
|
|
391 return *m_ptr;
|
|
|
392 }
|
|
|
393
|
|
|
394 const T & back() const VULKAN_HPP_NOEXCEPT
|
|
|
395 {
|
|
|
396 VULKAN_HPP_ASSERT( m_count && m_ptr );
|
|
|
397 return *( m_ptr + m_count - 1 );
|
|
|
398 }
|
|
|
399
|
|
|
400 bool empty() const VULKAN_HPP_NOEXCEPT
|
|
|
401 {
|
|
|
402 return ( m_count == 0 );
|
|
|
403 }
|
|
|
404
|
|
|
405 uint32_t size() const VULKAN_HPP_NOEXCEPT
|
|
|
406 {
|
|
|
407 return m_count;
|
|
|
408 }
|
|
|
409
|
|
|
410 T const * data() const VULKAN_HPP_NOEXCEPT
|
|
|
411 {
|
|
|
412 return m_ptr;
|
|
|
413 }
|
|
|
414
|
|
|
415 private:
|
|
|
416 uint32_t m_count;
|
|
|
417 T const * m_ptr;
|
|
|
418 };
|
|
|
419
|
|
|
420 template <typename T>
|
|
|
421 class ArrayProxyNoTemporaries
|
|
|
422 {
|
|
|
423 public:
|
|
|
424 VULKAN_HPP_CONSTEXPR ArrayProxyNoTemporaries() VULKAN_HPP_NOEXCEPT
|
|
|
425 : m_count( 0 )
|
|
|
426 , m_ptr( nullptr )
|
|
|
427 {
|
|
|
428 }
|
|
|
429
|
|
|
430 VULKAN_HPP_CONSTEXPR ArrayProxyNoTemporaries( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
431 : m_count( 0 )
|
|
|
432 , m_ptr( nullptr )
|
|
|
433 {
|
|
|
434 }
|
|
|
435
|
|
|
436 template <typename B = T, typename std::enable_if<std::is_convertible<B, T>::value && std::is_lvalue_reference<B>::value, int>::type = 0>
|
|
|
437 ArrayProxyNoTemporaries( B && value ) VULKAN_HPP_NOEXCEPT
|
|
|
438 : m_count( 1 )
|
|
|
439 , m_ptr( &value )
|
|
|
440 {
|
|
|
441 }
|
|
|
442
|
|
|
443 ArrayProxyNoTemporaries( uint32_t count, T * ptr ) VULKAN_HPP_NOEXCEPT
|
|
|
444 : m_count( count )
|
|
|
445 , m_ptr( ptr )
|
|
|
446 {
|
|
|
447 }
|
|
|
448
|
|
|
449 template <std::size_t C>
|
|
|
450 ArrayProxyNoTemporaries( T ( &ptr )[C] ) VULKAN_HPP_NOEXCEPT
|
|
|
451 : m_count( C )
|
|
|
452 , m_ptr( ptr )
|
|
|
453 {
|
|
|
454 }
|
|
|
455
|
|
|
456 template <std::size_t C>
|
|
|
457 ArrayProxyNoTemporaries( T ( &&ptr )[C] ) = delete;
|
|
|
458
|
|
|
459 // Any l-value reference with a .data() return type implicitly convertible to T*, and a .size() return type implicitly convertible to size_t.
|
|
|
460 template <typename V,
|
|
|
461 typename std::enable_if<!std::is_convertible<decltype( std::declval<V>().begin() ), T *>::value &&
|
|
|
462 std::is_convertible<decltype( std::declval<V>().data() ), T *>::value &&
|
|
|
463 std::is_convertible<decltype( std::declval<V>().size() ), std::size_t>::value && std::is_lvalue_reference<V>::value,
|
|
|
464 int>::type = 0>
|
|
|
465 ArrayProxyNoTemporaries( V && v ) VULKAN_HPP_NOEXCEPT
|
|
|
466 : m_count( static_cast<uint32_t>( v.size() ) )
|
|
|
467 , m_ptr( v.data() )
|
|
|
468 {
|
|
|
469 }
|
|
|
470
|
|
|
471 // Any l-value reference with a .begin() return type implicitly convertible to T*, and a .size() return type implicitly convertible to size_t.
|
|
|
472 template <typename V,
|
|
|
473 typename std::enable_if<std::is_convertible<decltype( std::declval<V>().begin() ), T *>::value &&
|
|
|
474 std::is_convertible<decltype( std::declval<V>().size() ), std::size_t>::value && std::is_lvalue_reference<V>::value,
|
|
|
475 int>::type = 0>
|
|
|
476 ArrayProxyNoTemporaries( V && v ) VULKAN_HPP_NOEXCEPT
|
|
|
477 : m_count( static_cast<uint32_t>( v.size() ) )
|
|
|
478 , m_ptr( v.begin() )
|
|
|
479 {
|
|
|
480 }
|
|
|
481
|
|
|
482 const T * begin() const VULKAN_HPP_NOEXCEPT
|
|
|
483 {
|
|
|
484 return m_ptr;
|
|
|
485 }
|
|
|
486
|
|
|
487 const T * end() const VULKAN_HPP_NOEXCEPT
|
|
|
488 {
|
|
|
489 return m_ptr + m_count;
|
|
|
490 }
|
|
|
491
|
|
|
492 const T & front() const VULKAN_HPP_NOEXCEPT
|
|
|
493 {
|
|
|
494 VULKAN_HPP_ASSERT( m_count && m_ptr );
|
|
|
495 return *m_ptr;
|
|
|
496 }
|
|
|
497
|
|
|
498 const T & back() const VULKAN_HPP_NOEXCEPT
|
|
|
499 {
|
|
|
500 VULKAN_HPP_ASSERT( m_count && m_ptr );
|
|
|
501 return *( m_ptr + m_count - 1 );
|
|
|
502 }
|
|
|
503
|
|
|
504 bool empty() const VULKAN_HPP_NOEXCEPT
|
|
|
505 {
|
|
|
506 return ( m_count == 0 );
|
|
|
507 }
|
|
|
508
|
|
|
509 uint32_t size() const VULKAN_HPP_NOEXCEPT
|
|
|
510 {
|
|
|
511 return m_count;
|
|
|
512 }
|
|
|
513
|
|
|
514 T * data() const VULKAN_HPP_NOEXCEPT
|
|
|
515 {
|
|
|
516 return m_ptr;
|
|
|
517 }
|
|
|
518
|
|
|
519 private:
|
|
|
520 uint32_t m_count;
|
|
|
521 T * m_ptr;
|
|
|
522 };
|
|
|
523
|
|
|
524 template <typename T>
|
|
|
525 class StridedArrayProxy : protected ArrayProxy<T>
|
|
|
526 {
|
|
|
527 public:
|
|
|
528 using ArrayProxy<T>::ArrayProxy;
|
|
|
529
|
|
|
530 StridedArrayProxy( uint32_t count, T const * ptr, uint32_t stride ) VULKAN_HPP_NOEXCEPT
|
|
|
531 : ArrayProxy<T>( count, ptr )
|
|
|
532 , m_stride( stride )
|
|
|
533 {
|
|
|
534 VULKAN_HPP_ASSERT( sizeof( T ) <= stride );
|
|
|
535 }
|
|
|
536
|
|
|
537 using ArrayProxy<T>::begin;
|
|
|
538
|
|
|
539 const T * end() const VULKAN_HPP_NOEXCEPT
|
|
|
540 {
|
|
|
541 return reinterpret_cast<T const *>( static_cast<uint8_t const *>( begin() ) + size() * m_stride );
|
|
|
542 }
|
|
|
543
|
|
|
544 using ArrayProxy<T>::front;
|
|
|
545
|
|
|
546 const T & back() const VULKAN_HPP_NOEXCEPT
|
|
|
547 {
|
|
|
548 VULKAN_HPP_ASSERT( begin() && size() );
|
|
|
549 return *reinterpret_cast<T const *>( static_cast<uint8_t const *>( begin() ) + ( size() - 1 ) * m_stride );
|
|
|
550 }
|
|
|
551
|
|
|
552 using ArrayProxy<T>::empty;
|
|
|
553 using ArrayProxy<T>::size;
|
|
|
554 using ArrayProxy<T>::data;
|
|
|
555
|
|
|
556 uint32_t stride() const
|
|
|
557 {
|
|
|
558 return m_stride;
|
|
|
559 }
|
|
|
560
|
|
|
561 private:
|
|
|
562 uint32_t m_stride = sizeof( T );
|
|
|
563 };
|
|
|
564
|
|
|
565 template <typename RefType>
|
|
|
566 class Optional
|
|
|
567 {
|
|
|
568 public:
|
|
|
569 Optional( RefType & reference ) VULKAN_HPP_NOEXCEPT
|
|
|
570 {
|
|
|
571 m_ptr = &reference;
|
|
|
572 }
|
|
|
573
|
|
|
574 Optional( RefType * ptr ) VULKAN_HPP_NOEXCEPT
|
|
|
575 {
|
|
|
576 m_ptr = ptr;
|
|
|
577 }
|
|
|
578
|
|
|
579 Optional( std::nullptr_t ) VULKAN_HPP_NOEXCEPT
|
|
|
580 {
|
|
|
581 m_ptr = nullptr;
|
|
|
582 }
|
|
|
583
|
|
|
584 operator RefType *() const VULKAN_HPP_NOEXCEPT
|
|
|
585 {
|
|
|
586 return m_ptr;
|
|
|
587 }
|
|
|
588
|
|
|
589 RefType const * operator->() const VULKAN_HPP_NOEXCEPT
|
|
|
590 {
|
|
|
591 return m_ptr;
|
|
|
592 }
|
|
|
593
|
|
|
594 RefType const * get() const VULKAN_HPP_NOEXCEPT
|
|
|
595 {
|
|
|
596 return m_ptr;
|
|
|
597 }
|
|
|
598
|
|
|
599 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
600 {
|
|
|
601 return !!m_ptr;
|
|
|
602 }
|
|
|
603
|
|
|
604 private:
|
|
|
605 RefType * m_ptr;
|
|
|
606 };
|
|
|
607
|
|
|
608 template <typename X, typename Y>
|
|
|
609 struct StructExtends
|
|
|
610 {
|
|
|
611 enum
|
|
|
612 {
|
|
|
613 value = false
|
|
|
614 };
|
|
|
615 };
|
|
|
616
|
|
|
617 template <typename Type, class...>
|
|
|
618 struct IsPartOfStructureChain
|
|
|
619 {
|
|
|
620 static const bool valid = false;
|
|
|
621 };
|
|
|
622
|
|
|
623 template <typename Type, typename Head, typename... Tail>
|
|
|
624 struct IsPartOfStructureChain<Type, Head, Tail...>
|
|
|
625 {
|
|
|
626 static const bool valid = std::is_same<Type, Head>::value || IsPartOfStructureChain<Type, Tail...>::valid;
|
|
|
627 };
|
|
|
628
|
|
|
629 template <size_t Index, typename T, typename... ChainElements>
|
|
|
630 struct StructureChainContains
|
|
|
631 {
|
|
|
632 static const bool value = std::is_same<T, typename std::tuple_element<Index, std::tuple<ChainElements...>>::type>::value ||
|
|
|
633 StructureChainContains<Index - 1, T, ChainElements...>::value;
|
|
|
634 };
|
|
|
635
|
|
|
636 template <typename T, typename... ChainElements>
|
|
|
637 struct StructureChainContains<0, T, ChainElements...>
|
|
|
638 {
|
|
|
639 static const bool value = std::is_same<T, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value;
|
|
|
640 };
|
|
|
641
|
|
|
642 template <size_t Index, typename... ChainElements>
|
|
|
643 struct StructureChainValidation
|
|
|
644 {
|
|
|
645 using TestType = typename std::tuple_element<Index, std::tuple<ChainElements...>>::type;
|
|
|
646 static const bool valid = StructExtends<TestType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value &&
|
|
|
647 ( TestType::allowDuplicate || !StructureChainContains<Index - 1, TestType, ChainElements...>::value ) &&
|
|
|
648 StructureChainValidation<Index - 1, ChainElements...>::valid;
|
|
|
649 };
|
|
|
650
|
|
|
651 template <typename... ChainElements>
|
|
|
652 struct StructureChainValidation<0, ChainElements...>
|
|
|
653 {
|
|
|
654 static const bool valid = true;
|
|
|
655 };
|
|
|
656
|
|
|
657 template <typename... ChainElements>
|
|
|
658 class StructureChain : public std::tuple<ChainElements...>
|
|
|
659 {
|
|
|
660 // Note: StructureChain has no move constructor or move assignment operator, as it is not supposed to contain movable containers.
|
|
|
661 // In order to get a copy-operation on a move-operations, those functions are neither deleted nor defaulted.
|
|
|
662 public:
|
|
|
663 StructureChain() VULKAN_HPP_NOEXCEPT
|
|
|
664 {
|
|
|
665 VULKAN_HPP_STATIC_ASSERT( StructureChainValidation<sizeof...( ChainElements ) - 1, ChainElements...>::valid, "The structure chain is not valid!" );
|
|
|
666 link<sizeof...( ChainElements ) - 1>();
|
|
|
667 }
|
|
|
668
|
|
|
669 StructureChain( StructureChain const & rhs ) VULKAN_HPP_NOEXCEPT : std::tuple<ChainElements...>( rhs )
|
|
|
670 {
|
|
|
671 VULKAN_HPP_STATIC_ASSERT( StructureChainValidation<sizeof...( ChainElements ) - 1, ChainElements...>::valid, "The structure chain is not valid!" );
|
|
|
672 link( &std::get<0>( *this ),
|
|
|
673 &std::get<0>( rhs ),
|
|
|
674 reinterpret_cast<VkBaseOutStructure *>( &std::get<0>( *this ) ),
|
|
|
675 reinterpret_cast<VkBaseInStructure const *>( &std::get<0>( rhs ) ) );
|
|
|
676 }
|
|
|
677
|
|
|
678 StructureChain( ChainElements const &... elems ) VULKAN_HPP_NOEXCEPT : std::tuple<ChainElements...>( elems... )
|
|
|
679 {
|
|
|
680 VULKAN_HPP_STATIC_ASSERT( StructureChainValidation<sizeof...( ChainElements ) - 1, ChainElements...>::valid, "The structure chain is not valid!" );
|
|
|
681 link<sizeof...( ChainElements ) - 1>();
|
|
|
682 }
|
|
|
683
|
|
|
684 StructureChain & operator=( StructureChain const & rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
685 {
|
|
|
686 std::tuple<ChainElements...>::operator=( rhs );
|
|
|
687 link( &std::get<0>( *this ),
|
|
|
688 &std::get<0>( rhs ),
|
|
|
689 reinterpret_cast<VkBaseOutStructure *>( &std::get<0>( *this ) ),
|
|
|
690 reinterpret_cast<VkBaseInStructure const *>( &std::get<0>( rhs ) ) );
|
|
|
691 return *this;
|
|
|
692 }
|
|
|
693
|
|
|
694 template <typename T = typename std::tuple_element<0, std::tuple<ChainElements...>>::type, size_t Which = 0>
|
|
|
695 T & get() VULKAN_HPP_NOEXCEPT
|
|
|
696 {
|
|
|
697 return std::get<ChainElementIndex<0, T, Which, void, ChainElements...>::value>( static_cast<std::tuple<ChainElements...> &>( *this ) );
|
|
|
698 }
|
|
|
699
|
|
|
700 template <typename T = typename std::tuple_element<0, std::tuple<ChainElements...>>::type, size_t Which = 0>
|
|
|
701 T const & get() const VULKAN_HPP_NOEXCEPT
|
|
|
702 {
|
|
|
703 return std::get<ChainElementIndex<0, T, Which, void, ChainElements...>::value>( static_cast<std::tuple<ChainElements...> const &>( *this ) );
|
|
|
704 }
|
|
|
705
|
|
|
706 template <typename T0, typename T1, typename... Ts>
|
|
|
707 std::tuple<T0 &, T1 &, Ts &...> get() VULKAN_HPP_NOEXCEPT
|
|
|
708 {
|
|
|
709 return std::tie( get<T0>(), get<T1>(), get<Ts>()... );
|
|
|
710 }
|
|
|
711
|
|
|
712 template <typename T0, typename T1, typename... Ts>
|
|
|
713 std::tuple<T0 const &, T1 const &, Ts const &...> get() const VULKAN_HPP_NOEXCEPT
|
|
|
714 {
|
|
|
715 return std::tie( get<T0>(), get<T1>(), get<Ts>()... );
|
|
|
716 }
|
|
|
717
|
|
|
718 // assign a complete structure to the StructureChain without modifying the chaining
|
|
|
719 template <typename T = typename std::tuple_element<0, std::tuple<ChainElements...>>::type, size_t Which = 0>
|
|
|
720 StructureChain & assign( const T & rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
721 {
|
|
|
722 T & lhs = get<T, Which>();
|
|
|
723 auto pNext = lhs.pNext;
|
|
|
724 lhs = rhs;
|
|
|
725 lhs.pNext = pNext;
|
|
|
726 return *this;
|
|
|
727 }
|
|
|
728
|
|
|
729 template <typename ClassType, size_t Which = 0>
|
|
|
730 typename std::enable_if<std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value && ( Which == 0 ), bool>::type
|
|
|
731 isLinked() const VULKAN_HPP_NOEXCEPT
|
|
|
732 {
|
|
|
733 return true;
|
|
|
734 }
|
|
|
735
|
|
|
736 template <typename ClassType, size_t Which = 0>
|
|
|
737 typename std::enable_if<!std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value || ( Which != 0 ), bool>::type
|
|
|
738 isLinked() const VULKAN_HPP_NOEXCEPT
|
|
|
739 {
|
|
|
740 VULKAN_HPP_STATIC_ASSERT( IsPartOfStructureChain<ClassType, ChainElements...>::valid, "Can't unlink Structure that's not part of this StructureChain!" );
|
|
|
741 return isLinked( reinterpret_cast<VkBaseInStructure const *>( &get<ClassType, Which>() ) );
|
|
|
742 }
|
|
|
743
|
|
|
744 template <typename ClassType, size_t Which = 0>
|
|
|
745 typename std::enable_if<!std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value || ( Which != 0 ), void>::type
|
|
|
746 relink() VULKAN_HPP_NOEXCEPT
|
|
|
747 {
|
|
|
748 VULKAN_HPP_STATIC_ASSERT( IsPartOfStructureChain<ClassType, ChainElements...>::valid, "Can't relink Structure that's not part of this StructureChain!" );
|
|
|
749 auto pNext = reinterpret_cast<VkBaseInStructure *>( &get<ClassType, Which>() );
|
|
|
750 VULKAN_HPP_ASSERT( !isLinked( pNext ) );
|
|
|
751 auto & headElement = std::get<0>( static_cast<std::tuple<ChainElements...> &>( *this ) );
|
|
|
752 pNext->pNext = reinterpret_cast<VkBaseInStructure const *>( headElement.pNext );
|
|
|
753 headElement.pNext = pNext;
|
|
|
754 }
|
|
|
755
|
|
|
756 template <typename ClassType, size_t Which = 0>
|
|
|
757 typename std::enable_if<!std::is_same<ClassType, typename std::tuple_element<0, std::tuple<ChainElements...>>::type>::value || ( Which != 0 ), void>::type
|
|
|
758 unlink() VULKAN_HPP_NOEXCEPT
|
|
|
759 {
|
|
|
760 VULKAN_HPP_STATIC_ASSERT( IsPartOfStructureChain<ClassType, ChainElements...>::valid, "Can't unlink Structure that's not part of this StructureChain!" );
|
|
|
761 unlink( reinterpret_cast<VkBaseOutStructure const *>( &get<ClassType, Which>() ) );
|
|
|
762 }
|
|
|
763
|
|
|
764 private:
|
|
|
765 template <int Index, typename T, int Which, typename, class First, class... Types>
|
|
|
766 struct ChainElementIndex : ChainElementIndex<Index + 1, T, Which, void, Types...>
|
|
|
767 {
|
|
|
768 };
|
|
|
769
|
|
|
770 template <int Index, typename T, int Which, class First, class... Types>
|
|
|
771 struct ChainElementIndex<Index, T, Which, typename std::enable_if<!std::is_same<T, First>::value, void>::type, First, Types...>
|
|
|
772 : ChainElementIndex<Index + 1, T, Which, void, Types...>
|
|
|
773 {
|
|
|
774 };
|
|
|
775
|
|
|
776 template <int Index, typename T, int Which, class First, class... Types>
|
|
|
777 struct ChainElementIndex<Index, T, Which, typename std::enable_if<std::is_same<T, First>::value, void>::type, First, Types...>
|
|
|
778 : ChainElementIndex<Index + 1, T, Which - 1, void, Types...>
|
|
|
779 {
|
|
|
780 };
|
|
|
781
|
|
|
782 template <int Index, typename T, class First, class... Types>
|
|
|
783 struct ChainElementIndex<Index, T, 0, typename std::enable_if<std::is_same<T, First>::value, void>::type, First, Types...>
|
|
|
784 : std::integral_constant<int, Index>
|
|
|
785 {
|
|
|
786 };
|
|
|
787
|
|
|
788 bool isLinked( VkBaseInStructure const * pNext ) const VULKAN_HPP_NOEXCEPT
|
|
|
789 {
|
|
|
790 VkBaseInStructure const * elementPtr =
|
|
|
791 reinterpret_cast<VkBaseInStructure const *>( &std::get<0>( static_cast<std::tuple<ChainElements...> const &>( *this ) ) );
|
|
|
792 while ( elementPtr )
|
|
|
793 {
|
|
|
794 if ( elementPtr->pNext == pNext )
|
|
|
795 {
|
|
|
796 return true;
|
|
|
797 }
|
|
|
798 elementPtr = elementPtr->pNext;
|
|
|
799 }
|
|
|
800 return false;
|
|
|
801 }
|
|
|
802
|
|
|
803 template <size_t Index>
|
|
|
804 typename std::enable_if<Index != 0, void>::type link() VULKAN_HPP_NOEXCEPT
|
|
|
805 {
|
|
|
806 auto & x = std::get<Index - 1>( static_cast<std::tuple<ChainElements...> &>( *this ) );
|
|
|
807 x.pNext = &std::get<Index>( static_cast<std::tuple<ChainElements...> &>( *this ) );
|
|
|
808 link<Index - 1>();
|
|
|
809 }
|
|
|
810
|
|
|
811 template <size_t Index>
|
|
|
812 typename std::enable_if<Index == 0, void>::type link() VULKAN_HPP_NOEXCEPT
|
|
|
813 {
|
|
|
814 }
|
|
|
815
|
|
|
816 void link( void * dstBase, void const * srcBase, VkBaseOutStructure * dst, VkBaseInStructure const * src )
|
|
|
817 {
|
|
|
818 while ( src->pNext )
|
|
|
819 {
|
|
|
820 std::ptrdiff_t offset = reinterpret_cast<char const *>( src->pNext ) - reinterpret_cast<char const *>( srcBase );
|
|
|
821 dst->pNext = reinterpret_cast<VkBaseOutStructure *>( reinterpret_cast<char *>( dstBase ) + offset );
|
|
|
822 dst = dst->pNext;
|
|
|
823 src = src->pNext;
|
|
|
824 }
|
|
|
825 dst->pNext = nullptr;
|
|
|
826 }
|
|
|
827
|
|
|
828 void unlink( VkBaseOutStructure const * pNext ) VULKAN_HPP_NOEXCEPT
|
|
|
829 {
|
|
|
830 VkBaseOutStructure * elementPtr = reinterpret_cast<VkBaseOutStructure *>( &std::get<0>( static_cast<std::tuple<ChainElements...> &>( *this ) ) );
|
|
|
831 while ( elementPtr && ( elementPtr->pNext != pNext ) )
|
|
|
832 {
|
|
|
833 elementPtr = elementPtr->pNext;
|
|
|
834 }
|
|
|
835 if ( elementPtr )
|
|
|
836 {
|
|
|
837 elementPtr->pNext = pNext->pNext;
|
|
|
838 }
|
|
|
839 else
|
|
|
840 {
|
|
|
841 VULKAN_HPP_ASSERT( false ); // fires, if the ClassType member has already been unlinked !
|
|
|
842 }
|
|
|
843 }
|
|
|
844 };
|
|
|
845
|
|
|
846 // interupt the VULKAN_HPP_NAMESPACE for a moment to add specializations of std::tuple_size and std::tuple_element for the StructureChain!
|
|
|
847 }
|
|
|
848
|
|
|
849 namespace std
|
|
|
850 {
|
|
|
851 template <typename... Elements>
|
|
|
852 struct tuple_size<VULKAN_HPP_NAMESPACE::StructureChain<Elements...>>
|
|
|
853 {
|
|
|
854 static constexpr size_t value = std::tuple_size<std::tuple<Elements...>>::value;
|
|
|
855 };
|
|
|
856
|
|
|
857 template <std::size_t Index, typename... Elements>
|
|
|
858 struct tuple_element<Index, VULKAN_HPP_NAMESPACE::StructureChain<Elements...>>
|
|
|
859 {
|
|
|
860 using type = typename std::tuple_element<Index, std::tuple<Elements...>>::type;
|
|
|
861 };
|
|
|
862 } // namespace std
|
|
|
863
|
|
|
864 namespace VULKAN_HPP_NAMESPACE
|
|
|
865 {
|
|
|
866
|
|
|
867 # if !defined( VULKAN_HPP_NO_SMART_HANDLE )
|
|
|
868 template <typename Type, typename Dispatch>
|
|
|
869 class UniqueHandleTraits;
|
|
|
870
|
|
|
871 template <typename Type, typename Dispatch>
|
|
|
872 class UniqueHandle : public UniqueHandleTraits<Type, Dispatch>::deleter
|
|
|
873 {
|
|
|
874 private:
|
|
|
875 using Deleter = typename UniqueHandleTraits<Type, Dispatch>::deleter;
|
|
|
876
|
|
|
877 public:
|
|
|
878 using element_type = Type;
|
|
|
879
|
|
|
880 UniqueHandle() : Deleter(), m_value() {}
|
|
|
881
|
|
|
882 explicit UniqueHandle( Type const & value, Deleter const & deleter = Deleter() ) VULKAN_HPP_NOEXCEPT
|
|
|
883 : Deleter( deleter )
|
|
|
884 , m_value( value )
|
|
|
885 {
|
|
|
886 }
|
|
|
887
|
|
|
888 UniqueHandle( UniqueHandle const & ) = delete;
|
|
|
889
|
|
|
890 UniqueHandle( UniqueHandle && other ) VULKAN_HPP_NOEXCEPT
|
|
|
891 : Deleter( std::move( static_cast<Deleter &>( other ) ) )
|
|
|
892 , m_value( other.release() )
|
|
|
893 {
|
|
|
894 }
|
|
|
895
|
|
|
896 ~UniqueHandle() VULKAN_HPP_NOEXCEPT
|
|
|
897 {
|
|
|
898 if ( m_value )
|
|
|
899 {
|
|
|
900 this->destroy( m_value );
|
|
|
901 }
|
|
|
902 }
|
|
|
903
|
|
|
904 UniqueHandle & operator=( UniqueHandle const & ) = delete;
|
|
|
905
|
|
|
906 UniqueHandle & operator=( UniqueHandle && other ) VULKAN_HPP_NOEXCEPT
|
|
|
907 {
|
|
|
908 reset( other.release() );
|
|
|
909 *static_cast<Deleter *>( this ) = std::move( static_cast<Deleter &>( other ) );
|
|
|
910 return *this;
|
|
|
911 }
|
|
|
912
|
|
|
913 explicit operator bool() const VULKAN_HPP_NOEXCEPT
|
|
|
914 {
|
|
|
915 return m_value.operator bool();
|
|
|
916 }
|
|
|
917
|
|
|
918 # if defined( VULKAN_HPP_SMART_HANDLE_IMPLICIT_CAST )
|
|
|
919 operator Type() const VULKAN_HPP_NOEXCEPT
|
|
|
920 {
|
|
|
921 return m_value;
|
|
|
922 }
|
|
|
923 # endif
|
|
|
924
|
|
|
925 Type const * operator->() const VULKAN_HPP_NOEXCEPT
|
|
|
926 {
|
|
|
927 return &m_value;
|
|
|
928 }
|
|
|
929
|
|
|
930 Type * operator->() VULKAN_HPP_NOEXCEPT
|
|
|
931 {
|
|
|
932 return &m_value;
|
|
|
933 }
|
|
|
934
|
|
|
935 Type const & operator*() const VULKAN_HPP_NOEXCEPT
|
|
|
936 {
|
|
|
937 return m_value;
|
|
|
938 }
|
|
|
939
|
|
|
940 Type & operator*() VULKAN_HPP_NOEXCEPT
|
|
|
941 {
|
|
|
942 return m_value;
|
|
|
943 }
|
|
|
944
|
|
|
945 const Type & get() const VULKAN_HPP_NOEXCEPT
|
|
|
946 {
|
|
|
947 return m_value;
|
|
|
948 }
|
|
|
949
|
|
|
950 Type & get() VULKAN_HPP_NOEXCEPT
|
|
|
951 {
|
|
|
952 return m_value;
|
|
|
953 }
|
|
|
954
|
|
|
955 void reset( Type const & value = Type() ) VULKAN_HPP_NOEXCEPT
|
|
|
956 {
|
|
|
957 if ( m_value != value )
|
|
|
958 {
|
|
|
959 if ( m_value )
|
|
|
960 {
|
|
|
961 this->destroy( m_value );
|
|
|
962 }
|
|
|
963 m_value = value;
|
|
|
964 }
|
|
|
965 }
|
|
|
966
|
|
|
967 Type release() VULKAN_HPP_NOEXCEPT
|
|
|
968 {
|
|
|
969 Type value = m_value;
|
|
|
970 m_value = nullptr;
|
|
|
971 return value;
|
|
|
972 }
|
|
|
973
|
|
|
974 void swap( UniqueHandle<Type, Dispatch> & rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
975 {
|
|
|
976 std::swap( m_value, rhs.m_value );
|
|
|
977 std::swap( static_cast<Deleter &>( *this ), static_cast<Deleter &>( rhs ) );
|
|
|
978 }
|
|
|
979
|
|
|
980 private:
|
|
|
981 Type m_value;
|
|
|
982 };
|
|
|
983
|
|
|
984 template <typename UniqueType>
|
|
|
985 VULKAN_HPP_INLINE std::vector<typename UniqueType::element_type> uniqueToRaw( std::vector<UniqueType> const & handles )
|
|
|
986 {
|
|
|
987 std::vector<typename UniqueType::element_type> newBuffer( handles.size() );
|
|
|
988 std::transform( handles.begin(), handles.end(), newBuffer.begin(), []( UniqueType const & handle ) { return handle.get(); } );
|
|
|
989 return newBuffer;
|
|
|
990 }
|
|
|
991
|
|
|
992 template <typename Type, typename Dispatch>
|
|
|
993 VULKAN_HPP_INLINE void swap( UniqueHandle<Type, Dispatch> & lhs, UniqueHandle<Type, Dispatch> & rhs ) VULKAN_HPP_NOEXCEPT
|
|
|
994 {
|
|
|
995 lhs.swap( rhs );
|
|
|
996 }
|
|
|
997 # endif
|
|
|
998 #endif // VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
999
|
|
|
1000 namespace detail
|
|
|
1001 {
|
|
|
1002 class DispatchLoaderBase
|
|
|
1003 {
|
|
|
1004 public:
|
|
|
1005 DispatchLoaderBase() = default;
|
|
|
1006 DispatchLoaderBase( std::nullptr_t )
|
|
|
1007 #if !defined( NDEBUG )
|
|
|
1008 : m_valid( false )
|
|
|
1009 #endif
|
|
|
1010 {
|
|
|
1011 }
|
|
|
1012
|
|
|
1013 #if !defined( NDEBUG )
|
|
|
1014 size_t getVkHeaderVersion() const
|
|
|
1015 {
|
|
|
1016 VULKAN_HPP_ASSERT( m_valid );
|
|
|
1017 return vkHeaderVersion;
|
|
|
1018 }
|
|
|
1019
|
|
|
1020 private:
|
|
|
1021 size_t vkHeaderVersion = VK_HEADER_VERSION;
|
|
|
1022 bool m_valid = true;
|
|
|
1023 #endif
|
|
|
1024 };
|
|
|
1025
|
|
|
1026 template <typename Type>
|
|
|
1027 struct isDispatchLoader
|
|
|
1028 {
|
|
|
1029 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = false;
|
|
|
1030 };
|
|
|
1031
|
|
|
1032 #if !defined( VK_NO_PROTOTYPES ) || ( defined( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC ) && ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 0 ) )
|
|
|
1033 class DispatchLoaderStatic : public DispatchLoaderBase
|
|
|
1034 {
|
|
|
1035 public:
|
|
|
1036 //=== VK_VERSION_1_0 ===
|
|
|
1037
|
|
|
1038 VkResult
|
|
|
1039 vkCreateInstance( const VkInstanceCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkInstance * pInstance ) const VULKAN_HPP_NOEXCEPT
|
|
|
1040 {
|
|
|
1041 return ::vkCreateInstance( pCreateInfo, pAllocator, pInstance );
|
|
|
1042 }
|
|
|
1043
|
|
|
1044 void vkDestroyInstance( VkInstance instance, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
1045 {
|
|
|
1046 return ::vkDestroyInstance( instance, pAllocator );
|
|
|
1047 }
|
|
|
1048
|
|
|
1049 VkResult vkEnumeratePhysicalDevices( VkInstance instance, uint32_t * pPhysicalDeviceCount, VkPhysicalDevice * pPhysicalDevices ) const VULKAN_HPP_NOEXCEPT
|
|
|
1050 {
|
|
|
1051 return ::vkEnumeratePhysicalDevices( instance, pPhysicalDeviceCount, pPhysicalDevices );
|
|
|
1052 }
|
|
|
1053
|
|
|
1054 void vkGetPhysicalDeviceFeatures( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures * pFeatures ) const VULKAN_HPP_NOEXCEPT
|
|
|
1055 {
|
|
|
1056 return ::vkGetPhysicalDeviceFeatures( physicalDevice, pFeatures );
|
|
|
1057 }
|
|
|
1058
|
|
|
1059 void vkGetPhysicalDeviceFormatProperties( VkPhysicalDevice physicalDevice,
|
|
|
1060 VkFormat format,
|
|
|
1061 VkFormatProperties * pFormatProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
1062 {
|
|
|
1063 return ::vkGetPhysicalDeviceFormatProperties( physicalDevice, format, pFormatProperties );
|
|
|
1064 }
|
|
|
1065
|
|
|
1066 VkResult vkGetPhysicalDeviceImageFormatProperties( VkPhysicalDevice physicalDevice,
|
|
|
1067 VkFormat format,
|
|
|
1068 VkImageType type,
|
|
|
1069 VkImageTiling tiling,
|
|
|
1070 VkImageUsageFlags usage,
|
|
|
1071 VkImageCreateFlags flags,
|
|
|
1072 VkImageFormatProperties * pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
1073 {
|
|
|
1074 return ::vkGetPhysicalDeviceImageFormatProperties( physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties );
|
|
|
1075 }
|
|
|
1076
|
|
|
1077 void vkGetPhysicalDeviceProperties( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
1078 {
|
|
|
1079 return ::vkGetPhysicalDeviceProperties( physicalDevice, pProperties );
|
|
|
1080 }
|
|
|
1081
|
|
|
1082 void vkGetPhysicalDeviceQueueFamilyProperties( VkPhysicalDevice physicalDevice,
|
|
|
1083 uint32_t * pQueueFamilyPropertyCount,
|
|
|
1084 VkQueueFamilyProperties * pQueueFamilyProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
1085 {
|
|
|
1086 return ::vkGetPhysicalDeviceQueueFamilyProperties( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties );
|
|
|
1087 }
|
|
|
1088
|
|
|
1089 void vkGetPhysicalDeviceMemoryProperties( VkPhysicalDevice physicalDevice,
|
|
|
1090 VkPhysicalDeviceMemoryProperties * pMemoryProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
1091 {
|
|
|
1092 return ::vkGetPhysicalDeviceMemoryProperties( physicalDevice, pMemoryProperties );
|
|
|
1093 }
|
|
|
1094
|
|
|
1095 PFN_vkVoidFunction vkGetInstanceProcAddr( VkInstance instance, const char * pName ) const VULKAN_HPP_NOEXCEPT
|
|
|
1096 {
|
|
|
1097 return ::vkGetInstanceProcAddr( instance, pName );
|
|
|
1098 }
|
|
|
1099
|
|
|
1100 PFN_vkVoidFunction vkGetDeviceProcAddr( VkDevice device, const char * pName ) const VULKAN_HPP_NOEXCEPT
|
|
|
1101 {
|
|
|
1102 return ::vkGetDeviceProcAddr( device, pName );
|
|
|
1103 }
|
|
|
1104
|
|
|
1105 VkResult vkCreateDevice( VkPhysicalDevice physicalDevice,
|
|
|
1106 const VkDeviceCreateInfo * pCreateInfo,
|
|
|
1107 const VkAllocationCallbacks * pAllocator,
|
|
|
1108 VkDevice * pDevice ) const VULKAN_HPP_NOEXCEPT
|
|
|
1109 {
|
|
|
1110 return ::vkCreateDevice( physicalDevice, pCreateInfo, pAllocator, pDevice );
|
|
|
1111 }
|
|
|
1112
|
|
|
1113 void vkDestroyDevice( VkDevice device, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
1114 {
|
|
|
1115 return ::vkDestroyDevice( device, pAllocator );
|
|
|
1116 }
|
|
|
1117
|
|
|
1118 VkResult vkEnumerateInstanceExtensionProperties( const char * pLayerName,
|
|
|
1119 uint32_t * pPropertyCount,
|
|
|
1120 VkExtensionProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
1121 {
|
|
|
1122 return ::vkEnumerateInstanceExtensionProperties( pLayerName, pPropertyCount, pProperties );
|
|
|
1123 }
|
|
|
1124
|
|
|
1125 VkResult vkEnumerateDeviceExtensionProperties( VkPhysicalDevice physicalDevice,
|
|
|
1126 const char * pLayerName,
|
|
|
1127 uint32_t * pPropertyCount,
|
|
|
1128 VkExtensionProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
1129 {
|
|
|
1130 return ::vkEnumerateDeviceExtensionProperties( physicalDevice, pLayerName, pPropertyCount, pProperties );
|
|
|
1131 }
|
|
|
1132
|
|
|
1133 VkResult vkEnumerateInstanceLayerProperties( uint32_t * pPropertyCount, VkLayerProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
1134 {
|
|
|
1135 return ::vkEnumerateInstanceLayerProperties( pPropertyCount, pProperties );
|
|
|
1136 }
|
|
|
1137
|
|
|
1138 VkResult vkEnumerateDeviceLayerProperties( VkPhysicalDevice physicalDevice,
|
|
|
1139 uint32_t * pPropertyCount,
|
|
|
1140 VkLayerProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
1141 {
|
|
|
1142 return ::vkEnumerateDeviceLayerProperties( physicalDevice, pPropertyCount, pProperties );
|
|
|
1143 }
|
|
|
1144
|
|
|
1145 void vkGetDeviceQueue( VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue * pQueue ) const VULKAN_HPP_NOEXCEPT
|
|
|
1146 {
|
|
|
1147 return ::vkGetDeviceQueue( device, queueFamilyIndex, queueIndex, pQueue );
|
|
|
1148 }
|
|
|
1149
|
|
|
1150 VkResult vkQueueSubmit( VkQueue queue, uint32_t submitCount, const VkSubmitInfo * pSubmits, VkFence fence ) const VULKAN_HPP_NOEXCEPT
|
|
|
1151 {
|
|
|
1152 return ::vkQueueSubmit( queue, submitCount, pSubmits, fence );
|
|
|
1153 }
|
|
|
1154
|
|
|
1155 VkResult vkQueueWaitIdle( VkQueue queue ) const VULKAN_HPP_NOEXCEPT
|
|
|
1156 {
|
|
|
1157 return ::vkQueueWaitIdle( queue );
|
|
|
1158 }
|
|
|
1159
|
|
|
1160 VkResult vkDeviceWaitIdle( VkDevice device ) const VULKAN_HPP_NOEXCEPT
|
|
|
1161 {
|
|
|
1162 return ::vkDeviceWaitIdle( device );
|
|
|
1163 }
|
|
|
1164
|
|
|
1165 VkResult vkAllocateMemory( VkDevice device,
|
|
|
1166 const VkMemoryAllocateInfo * pAllocateInfo,
|
|
|
1167 const VkAllocationCallbacks * pAllocator,
|
|
|
1168 VkDeviceMemory * pMemory ) const VULKAN_HPP_NOEXCEPT
|
|
|
1169 {
|
|
|
1170 return ::vkAllocateMemory( device, pAllocateInfo, pAllocator, pMemory );
|
|
|
1171 }
|
|
|
1172
|
|
|
1173 void vkFreeMemory( VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
1174 {
|
|
|
1175 return ::vkFreeMemory( device, memory, pAllocator );
|
|
|
1176 }
|
|
|
1177
|
|
|
1178 VkResult vkMapMemory( VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void ** ppData ) const
|
|
|
1179 VULKAN_HPP_NOEXCEPT
|
|
|
1180 {
|
|
|
1181 return ::vkMapMemory( device, memory, offset, size, flags, ppData );
|
|
|
1182 }
|
|
|
1183
|
|
|
1184 void vkUnmapMemory( VkDevice device, VkDeviceMemory memory ) const VULKAN_HPP_NOEXCEPT
|
|
|
1185 {
|
|
|
1186 return ::vkUnmapMemory( device, memory );
|
|
|
1187 }
|
|
|
1188
|
|
|
1189 VkResult vkFlushMappedMemoryRanges( VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange * pMemoryRanges ) const VULKAN_HPP_NOEXCEPT
|
|
|
1190 {
|
|
|
1191 return ::vkFlushMappedMemoryRanges( device, memoryRangeCount, pMemoryRanges );
|
|
|
1192 }
|
|
|
1193
|
|
|
1194 VkResult vkInvalidateMappedMemoryRanges( VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange * pMemoryRanges ) const VULKAN_HPP_NOEXCEPT
|
|
|
1195 {
|
|
|
1196 return ::vkInvalidateMappedMemoryRanges( device, memoryRangeCount, pMemoryRanges );
|
|
|
1197 }
|
|
|
1198
|
|
|
1199 void vkGetDeviceMemoryCommitment( VkDevice device, VkDeviceMemory memory, VkDeviceSize * pCommittedMemoryInBytes ) const VULKAN_HPP_NOEXCEPT
|
|
|
1200 {
|
|
|
1201 return ::vkGetDeviceMemoryCommitment( device, memory, pCommittedMemoryInBytes );
|
|
|
1202 }
|
|
|
1203
|
|
|
1204 VkResult vkBindBufferMemory( VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset ) const VULKAN_HPP_NOEXCEPT
|
|
|
1205 {
|
|
|
1206 return ::vkBindBufferMemory( device, buffer, memory, memoryOffset );
|
|
|
1207 }
|
|
|
1208
|
|
|
1209 VkResult vkBindImageMemory( VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset ) const VULKAN_HPP_NOEXCEPT
|
|
|
1210 {
|
|
|
1211 return ::vkBindImageMemory( device, image, memory, memoryOffset );
|
|
|
1212 }
|
|
|
1213
|
|
|
1214 void vkGetBufferMemoryRequirements( VkDevice device, VkBuffer buffer, VkMemoryRequirements * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
|
|
|
1215 {
|
|
|
1216 return ::vkGetBufferMemoryRequirements( device, buffer, pMemoryRequirements );
|
|
|
1217 }
|
|
|
1218
|
|
|
1219 void vkGetImageMemoryRequirements( VkDevice device, VkImage image, VkMemoryRequirements * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
|
|
|
1220 {
|
|
|
1221 return ::vkGetImageMemoryRequirements( device, image, pMemoryRequirements );
|
|
|
1222 }
|
|
|
1223
|
|
|
1224 void vkGetImageSparseMemoryRequirements( VkDevice device,
|
|
|
1225 VkImage image,
|
|
|
1226 uint32_t * pSparseMemoryRequirementCount,
|
|
|
1227 VkSparseImageMemoryRequirements * pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
|
|
|
1228 {
|
|
|
1229 return ::vkGetImageSparseMemoryRequirements( device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
|
|
|
1230 }
|
|
|
1231
|
|
|
1232 void vkGetPhysicalDeviceSparseImageFormatProperties( VkPhysicalDevice physicalDevice,
|
|
|
1233 VkFormat format,
|
|
|
1234 VkImageType type,
|
|
|
1235 VkSampleCountFlagBits samples,
|
|
|
1236 VkImageUsageFlags usage,
|
|
|
1237 VkImageTiling tiling,
|
|
|
1238 uint32_t * pPropertyCount,
|
|
|
1239 VkSparseImageFormatProperties * pProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
1240 {
|
|
|
1241 return ::vkGetPhysicalDeviceSparseImageFormatProperties( physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties );
|
|
|
1242 }
|
|
|
1243
|
|
|
1244 VkResult vkQueueBindSparse( VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo * pBindInfo, VkFence fence ) const VULKAN_HPP_NOEXCEPT
|
|
|
1245 {
|
|
|
1246 return ::vkQueueBindSparse( queue, bindInfoCount, pBindInfo, fence );
|
|
|
1247 }
|
|
|
1248
|
|
|
1249 VkResult vkCreateFence( VkDevice device,
|
|
|
1250 const VkFenceCreateInfo * pCreateInfo,
|
|
|
1251 const VkAllocationCallbacks * pAllocator,
|
|
|
1252 VkFence * pFence ) const VULKAN_HPP_NOEXCEPT
|
|
|
1253 {
|
|
|
1254 return ::vkCreateFence( device, pCreateInfo, pAllocator, pFence );
|
|
|
1255 }
|
|
|
1256
|
|
|
1257 void vkDestroyFence( VkDevice device, VkFence fence, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
1258 {
|
|
|
1259 return ::vkDestroyFence( device, fence, pAllocator );
|
|
|
1260 }
|
|
|
1261
|
|
|
1262 VkResult vkResetFences( VkDevice device, uint32_t fenceCount, const VkFence * pFences ) const VULKAN_HPP_NOEXCEPT
|
|
|
1263 {
|
|
|
1264 return ::vkResetFences( device, fenceCount, pFences );
|
|
|
1265 }
|
|
|
1266
|
|
|
1267 VkResult vkGetFenceStatus( VkDevice device, VkFence fence ) const VULKAN_HPP_NOEXCEPT
|
|
|
1268 {
|
|
|
1269 return ::vkGetFenceStatus( device, fence );
|
|
|
1270 }
|
|
|
1271
|
|
|
1272 VkResult vkWaitForFences( VkDevice device, uint32_t fenceCount, const VkFence * pFences, VkBool32 waitAll, uint64_t timeout ) const VULKAN_HPP_NOEXCEPT
|
|
|
1273 {
|
|
|
1274 return ::vkWaitForFences( device, fenceCount, pFences, waitAll, timeout );
|
|
|
1275 }
|
|
|
1276
|
|
|
1277 VkResult vkCreateSemaphore( VkDevice device,
|
|
|
1278 const VkSemaphoreCreateInfo * pCreateInfo,
|
|
|
1279 const VkAllocationCallbacks * pAllocator,
|
|
|
1280 VkSemaphore * pSemaphore ) const VULKAN_HPP_NOEXCEPT
|
|
|
1281 {
|
|
|
1282 return ::vkCreateSemaphore( device, pCreateInfo, pAllocator, pSemaphore );
|
|
|
1283 }
|
|
|
1284
|
|
|
1285 void vkDestroySemaphore( VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
1286 {
|
|
|
1287 return ::vkDestroySemaphore( device, semaphore, pAllocator );
|
|
|
1288 }
|
|
|
1289
|
|
|
1290 VkResult vkCreateQueryPool( VkDevice device,
|
|
|
1291 const VkQueryPoolCreateInfo * pCreateInfo,
|
|
|
1292 const VkAllocationCallbacks * pAllocator,
|
|
|
1293 VkQueryPool * pQueryPool ) const VULKAN_HPP_NOEXCEPT
|
|
|
1294 {
|
|
|
1295 return ::vkCreateQueryPool( device, pCreateInfo, pAllocator, pQueryPool );
|
|
|
1296 }
|
|
|
1297
|
|
|
1298 void vkDestroyQueryPool( VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
1299 {
|
|
|
1300 return ::vkDestroyQueryPool( device, queryPool, pAllocator );
|
|
|
1301 }
|
|
|
1302
|
|
|
1303 VkResult vkGetQueryPoolResults( VkDevice device,
|
|
|
1304 VkQueryPool queryPool,
|
|
|
1305 uint32_t firstQuery,
|
|
|
1306 uint32_t queryCount,
|
|
|
1307 size_t dataSize,
|
|
|
1308 void * pData,
|
|
|
1309 VkDeviceSize stride,
|
|
|
1310 VkQueryResultFlags flags ) const VULKAN_HPP_NOEXCEPT
|
|
|
1311 {
|
|
|
1312 return ::vkGetQueryPoolResults( device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags );
|
|
|
1313 }
|
|
|
1314
|
|
|
1315 VkResult vkCreateBuffer( VkDevice device,
|
|
|
1316 const VkBufferCreateInfo * pCreateInfo,
|
|
|
1317 const VkAllocationCallbacks * pAllocator,
|
|
|
1318 VkBuffer * pBuffer ) const VULKAN_HPP_NOEXCEPT
|
|
|
1319 {
|
|
|
1320 return ::vkCreateBuffer( device, pCreateInfo, pAllocator, pBuffer );
|
|
|
1321 }
|
|
|
1322
|
|
|
1323 void vkDestroyBuffer( VkDevice device, VkBuffer buffer, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
1324 {
|
|
|
1325 return ::vkDestroyBuffer( device, buffer, pAllocator );
|
|
|
1326 }
|
|
|
1327
|
|
|
1328 VkResult vkCreateImage( VkDevice device,
|
|
|
1329 const VkImageCreateInfo * pCreateInfo,
|
|
|
1330 const VkAllocationCallbacks * pAllocator,
|
|
|
1331 VkImage * pImage ) const VULKAN_HPP_NOEXCEPT
|
|
|
1332 {
|
|
|
1333 return ::vkCreateImage( device, pCreateInfo, pAllocator, pImage );
|
|
|
1334 }
|
|
|
1335
|
|
|
1336 void vkDestroyImage( VkDevice device, VkImage image, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
1337 {
|
|
|
1338 return ::vkDestroyImage( device, image, pAllocator );
|
|
|
1339 }
|
|
|
1340
|
|
|
1341 void vkGetImageSubresourceLayout( VkDevice device,
|
|
|
1342 VkImage image,
|
|
|
1343 const VkImageSubresource * pSubresource,
|
|
|
1344 VkSubresourceLayout * pLayout ) const VULKAN_HPP_NOEXCEPT
|
|
|
1345 {
|
|
|
1346 return ::vkGetImageSubresourceLayout( device, image, pSubresource, pLayout );
|
|
|
1347 }
|
|
|
1348
|
|
|
1349 VkResult vkCreateImageView( VkDevice device,
|
|
|
1350 const VkImageViewCreateInfo * pCreateInfo,
|
|
|
1351 const VkAllocationCallbacks * pAllocator,
|
|
|
1352 VkImageView * pView ) const VULKAN_HPP_NOEXCEPT
|
|
|
1353 {
|
|
|
1354 return ::vkCreateImageView( device, pCreateInfo, pAllocator, pView );
|
|
|
1355 }
|
|
|
1356
|
|
|
1357 void vkDestroyImageView( VkDevice device, VkImageView imageView, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
1358 {
|
|
|
1359 return ::vkDestroyImageView( device, imageView, pAllocator );
|
|
|
1360 }
|
|
|
1361
|
|
|
1362 VkResult vkCreateCommandPool( VkDevice device,
|
|
|
1363 const VkCommandPoolCreateInfo * pCreateInfo,
|
|
|
1364 const VkAllocationCallbacks * pAllocator,
|
|
|
1365 VkCommandPool * pCommandPool ) const VULKAN_HPP_NOEXCEPT
|
|
|
1366 {
|
|
|
1367 return ::vkCreateCommandPool( device, pCreateInfo, pAllocator, pCommandPool );
|
|
|
1368 }
|
|
|
1369
|
|
|
1370 void vkDestroyCommandPool( VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
1371 {
|
|
|
1372 return ::vkDestroyCommandPool( device, commandPool, pAllocator );
|
|
|
1373 }
|
|
|
1374
|
|
|
1375 VkResult vkResetCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags ) const VULKAN_HPP_NOEXCEPT
|
|
|
1376 {
|
|
|
1377 return ::vkResetCommandPool( device, commandPool, flags );
|
|
|
1378 }
|
|
|
1379
|
|
|
1380 VkResult vkAllocateCommandBuffers( VkDevice device,
|
|
|
1381 const VkCommandBufferAllocateInfo * pAllocateInfo,
|
|
|
1382 VkCommandBuffer * pCommandBuffers ) const VULKAN_HPP_NOEXCEPT
|
|
|
1383 {
|
|
|
1384 return ::vkAllocateCommandBuffers( device, pAllocateInfo, pCommandBuffers );
|
|
|
1385 }
|
|
|
1386
|
|
|
1387 void vkFreeCommandBuffers( VkDevice device,
|
|
|
1388 VkCommandPool commandPool,
|
|
|
1389 uint32_t commandBufferCount,
|
|
|
1390 const VkCommandBuffer * pCommandBuffers ) const VULKAN_HPP_NOEXCEPT
|
|
|
1391 {
|
|
|
1392 return ::vkFreeCommandBuffers( device, commandPool, commandBufferCount, pCommandBuffers );
|
|
|
1393 }
|
|
|
1394
|
|
|
1395 VkResult vkBeginCommandBuffer( VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo * pBeginInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
1396 {
|
|
|
1397 return ::vkBeginCommandBuffer( commandBuffer, pBeginInfo );
|
|
|
1398 }
|
|
|
1399
|
|
|
1400 VkResult vkEndCommandBuffer( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
|
|
|
1401 {
|
|
|
1402 return ::vkEndCommandBuffer( commandBuffer );
|
|
|
1403 }
|
|
|
1404
|
|
|
1405 VkResult vkResetCommandBuffer( VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags ) const VULKAN_HPP_NOEXCEPT
|
|
|
1406 {
|
|
|
1407 return ::vkResetCommandBuffer( commandBuffer, flags );
|
|
|
1408 }
|
|
|
1409
|
|
|
1410 void vkCmdCopyBuffer( VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy * pRegions ) const
|
|
|
1411 VULKAN_HPP_NOEXCEPT
|
|
|
1412 {
|
|
|
1413 return ::vkCmdCopyBuffer( commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions );
|
|
|
1414 }
|
|
|
1415
|
|
|
1416 void vkCmdCopyImage( VkCommandBuffer commandBuffer,
|
|
|
1417 VkImage srcImage,
|
|
|
1418 VkImageLayout srcImageLayout,
|
|
|
1419 VkImage dstImage,
|
|
|
1420 VkImageLayout dstImageLayout,
|
|
|
1421 uint32_t regionCount,
|
|
|
1422 const VkImageCopy * pRegions ) const VULKAN_HPP_NOEXCEPT
|
|
|
1423 {
|
|
|
1424 return ::vkCmdCopyImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions );
|
|
|
1425 }
|
|
|
1426
|
|
|
1427 void vkCmdCopyBufferToImage( VkCommandBuffer commandBuffer,
|
|
|
1428 VkBuffer srcBuffer,
|
|
|
1429 VkImage dstImage,
|
|
|
1430 VkImageLayout dstImageLayout,
|
|
|
1431 uint32_t regionCount,
|
|
|
1432 const VkBufferImageCopy * pRegions ) const VULKAN_HPP_NOEXCEPT
|
|
|
1433 {
|
|
|
1434 return ::vkCmdCopyBufferToImage( commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions );
|
|
|
1435 }
|
|
|
1436
|
|
|
1437 void vkCmdCopyImageToBuffer( VkCommandBuffer commandBuffer,
|
|
|
1438 VkImage srcImage,
|
|
|
1439 VkImageLayout srcImageLayout,
|
|
|
1440 VkBuffer dstBuffer,
|
|
|
1441 uint32_t regionCount,
|
|
|
1442 const VkBufferImageCopy * pRegions ) const VULKAN_HPP_NOEXCEPT
|
|
|
1443 {
|
|
|
1444 return ::vkCmdCopyImageToBuffer( commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions );
|
|
|
1445 }
|
|
|
1446
|
|
|
1447 void vkCmdUpdateBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void * pData ) const
|
|
|
1448 VULKAN_HPP_NOEXCEPT
|
|
|
1449 {
|
|
|
1450 return ::vkCmdUpdateBuffer( commandBuffer, dstBuffer, dstOffset, dataSize, pData );
|
|
|
1451 }
|
|
|
1452
|
|
|
1453 void
|
|
|
1454 vkCmdFillBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data ) const VULKAN_HPP_NOEXCEPT
|
|
|
1455 {
|
|
|
1456 return ::vkCmdFillBuffer( commandBuffer, dstBuffer, dstOffset, size, data );
|
|
|
1457 }
|
|
|
1458
|
|
|
1459 void vkCmdPipelineBarrier( VkCommandBuffer commandBuffer,
|
|
|
1460 VkPipelineStageFlags srcStageMask,
|
|
|
1461 VkPipelineStageFlags dstStageMask,
|
|
|
1462 VkDependencyFlags dependencyFlags,
|
|
|
1463 uint32_t memoryBarrierCount,
|
|
|
1464 const VkMemoryBarrier * pMemoryBarriers,
|
|
|
1465 uint32_t bufferMemoryBarrierCount,
|
|
|
1466 const VkBufferMemoryBarrier * pBufferMemoryBarriers,
|
|
|
1467 uint32_t imageMemoryBarrierCount,
|
|
|
1468 const VkImageMemoryBarrier * pImageMemoryBarriers ) const VULKAN_HPP_NOEXCEPT
|
|
|
1469 {
|
|
|
1470 return ::vkCmdPipelineBarrier( commandBuffer,
|
|
|
1471 srcStageMask,
|
|
|
1472 dstStageMask,
|
|
|
1473 dependencyFlags,
|
|
|
1474 memoryBarrierCount,
|
|
|
1475 pMemoryBarriers,
|
|
|
1476 bufferMemoryBarrierCount,
|
|
|
1477 pBufferMemoryBarriers,
|
|
|
1478 imageMemoryBarrierCount,
|
|
|
1479 pImageMemoryBarriers );
|
|
|
1480 }
|
|
|
1481
|
|
|
1482 void vkCmdBeginQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags ) const VULKAN_HPP_NOEXCEPT
|
|
|
1483 {
|
|
|
1484 return ::vkCmdBeginQuery( commandBuffer, queryPool, query, flags );
|
|
|
1485 }
|
|
|
1486
|
|
|
1487 void vkCmdEndQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT
|
|
|
1488 {
|
|
|
1489 return ::vkCmdEndQuery( commandBuffer, queryPool, query );
|
|
|
1490 }
|
|
|
1491
|
|
|
1492 void vkCmdResetQueryPool( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT
|
|
|
1493 {
|
|
|
1494 return ::vkCmdResetQueryPool( commandBuffer, queryPool, firstQuery, queryCount );
|
|
|
1495 }
|
|
|
1496
|
|
|
1497 void vkCmdWriteTimestamp( VkCommandBuffer commandBuffer,
|
|
|
1498 VkPipelineStageFlagBits pipelineStage,
|
|
|
1499 VkQueryPool queryPool,
|
|
|
1500 uint32_t query ) const VULKAN_HPP_NOEXCEPT
|
|
|
1501 {
|
|
|
1502 return ::vkCmdWriteTimestamp( commandBuffer, pipelineStage, queryPool, query );
|
|
|
1503 }
|
|
|
1504
|
|
|
1505 void vkCmdCopyQueryPoolResults( VkCommandBuffer commandBuffer,
|
|
|
1506 VkQueryPool queryPool,
|
|
|
1507 uint32_t firstQuery,
|
|
|
1508 uint32_t queryCount,
|
|
|
1509 VkBuffer dstBuffer,
|
|
|
1510 VkDeviceSize dstOffset,
|
|
|
1511 VkDeviceSize stride,
|
|
|
1512 VkQueryResultFlags flags ) const VULKAN_HPP_NOEXCEPT
|
|
|
1513 {
|
|
|
1514 return ::vkCmdCopyQueryPoolResults( commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags );
|
|
|
1515 }
|
|
|
1516
|
|
|
1517 void vkCmdExecuteCommands( VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer * pCommandBuffers ) const VULKAN_HPP_NOEXCEPT
|
|
|
1518 {
|
|
|
1519 return ::vkCmdExecuteCommands( commandBuffer, commandBufferCount, pCommandBuffers );
|
|
|
1520 }
|
|
|
1521
|
|
|
1522 VkResult vkCreateEvent( VkDevice device,
|
|
|
1523 const VkEventCreateInfo * pCreateInfo,
|
|
|
1524 const VkAllocationCallbacks * pAllocator,
|
|
|
1525 VkEvent * pEvent ) const VULKAN_HPP_NOEXCEPT
|
|
|
1526 {
|
|
|
1527 return ::vkCreateEvent( device, pCreateInfo, pAllocator, pEvent );
|
|
|
1528 }
|
|
|
1529
|
|
|
1530 void vkDestroyEvent( VkDevice device, VkEvent event, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
1531 {
|
|
|
1532 return ::vkDestroyEvent( device, event, pAllocator );
|
|
|
1533 }
|
|
|
1534
|
|
|
1535 VkResult vkGetEventStatus( VkDevice device, VkEvent event ) const VULKAN_HPP_NOEXCEPT
|
|
|
1536 {
|
|
|
1537 return ::vkGetEventStatus( device, event );
|
|
|
1538 }
|
|
|
1539
|
|
|
1540 VkResult vkSetEvent( VkDevice device, VkEvent event ) const VULKAN_HPP_NOEXCEPT
|
|
|
1541 {
|
|
|
1542 return ::vkSetEvent( device, event );
|
|
|
1543 }
|
|
|
1544
|
|
|
1545 VkResult vkResetEvent( VkDevice device, VkEvent event ) const VULKAN_HPP_NOEXCEPT
|
|
|
1546 {
|
|
|
1547 return ::vkResetEvent( device, event );
|
|
|
1548 }
|
|
|
1549
|
|
|
1550 VkResult vkCreateBufferView( VkDevice device,
|
|
|
1551 const VkBufferViewCreateInfo * pCreateInfo,
|
|
|
1552 const VkAllocationCallbacks * pAllocator,
|
|
|
1553 VkBufferView * pView ) const VULKAN_HPP_NOEXCEPT
|
|
|
1554 {
|
|
|
1555 return ::vkCreateBufferView( device, pCreateInfo, pAllocator, pView );
|
|
|
1556 }
|
|
|
1557
|
|
|
1558 void vkDestroyBufferView( VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
1559 {
|
|
|
1560 return ::vkDestroyBufferView( device, bufferView, pAllocator );
|
|
|
1561 }
|
|
|
1562
|
|
|
1563 VkResult vkCreateShaderModule( VkDevice device,
|
|
|
1564 const VkShaderModuleCreateInfo * pCreateInfo,
|
|
|
1565 const VkAllocationCallbacks * pAllocator,
|
|
|
1566 VkShaderModule * pShaderModule ) const VULKAN_HPP_NOEXCEPT
|
|
|
1567 {
|
|
|
1568 return ::vkCreateShaderModule( device, pCreateInfo, pAllocator, pShaderModule );
|
|
|
1569 }
|
|
|
1570
|
|
|
1571 void vkDestroyShaderModule( VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
1572 {
|
|
|
1573 return ::vkDestroyShaderModule( device, shaderModule, pAllocator );
|
|
|
1574 }
|
|
|
1575
|
|
|
1576 VkResult vkCreatePipelineCache( VkDevice device,
|
|
|
1577 const VkPipelineCacheCreateInfo * pCreateInfo,
|
|
|
1578 const VkAllocationCallbacks * pAllocator,
|
|
|
1579 VkPipelineCache * pPipelineCache ) const VULKAN_HPP_NOEXCEPT
|
|
|
1580 {
|
|
|
1581 return ::vkCreatePipelineCache( device, pCreateInfo, pAllocator, pPipelineCache );
|
|
|
1582 }
|
|
|
1583
|
|
|
1584 void vkDestroyPipelineCache( VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
1585 {
|
|
|
1586 return ::vkDestroyPipelineCache( device, pipelineCache, pAllocator );
|
|
|
1587 }
|
|
|
1588
|
|
|
1589 VkResult vkGetPipelineCacheData( VkDevice device, VkPipelineCache pipelineCache, size_t * pDataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
|
|
|
1590 {
|
|
|
1591 return ::vkGetPipelineCacheData( device, pipelineCache, pDataSize, pData );
|
|
|
1592 }
|
|
|
1593
|
|
|
1594 VkResult
|
|
|
1595 vkMergePipelineCaches( VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache * pSrcCaches ) const VULKAN_HPP_NOEXCEPT
|
|
|
1596 {
|
|
|
1597 return ::vkMergePipelineCaches( device, dstCache, srcCacheCount, pSrcCaches );
|
|
|
1598 }
|
|
|
1599
|
|
|
1600 VkResult vkCreateComputePipelines( VkDevice device,
|
|
|
1601 VkPipelineCache pipelineCache,
|
|
|
1602 uint32_t createInfoCount,
|
|
|
1603 const VkComputePipelineCreateInfo * pCreateInfos,
|
|
|
1604 const VkAllocationCallbacks * pAllocator,
|
|
|
1605 VkPipeline * pPipelines ) const VULKAN_HPP_NOEXCEPT
|
|
|
1606 {
|
|
|
1607 return ::vkCreateComputePipelines( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
|
|
|
1608 }
|
|
|
1609
|
|
|
1610 void vkDestroyPipeline( VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
1611 {
|
|
|
1612 return ::vkDestroyPipeline( device, pipeline, pAllocator );
|
|
|
1613 }
|
|
|
1614
|
|
|
1615 VkResult vkCreatePipelineLayout( VkDevice device,
|
|
|
1616 const VkPipelineLayoutCreateInfo * pCreateInfo,
|
|
|
1617 const VkAllocationCallbacks * pAllocator,
|
|
|
1618 VkPipelineLayout * pPipelineLayout ) const VULKAN_HPP_NOEXCEPT
|
|
|
1619 {
|
|
|
1620 return ::vkCreatePipelineLayout( device, pCreateInfo, pAllocator, pPipelineLayout );
|
|
|
1621 }
|
|
|
1622
|
|
|
1623 void vkDestroyPipelineLayout( VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
1624 {
|
|
|
1625 return ::vkDestroyPipelineLayout( device, pipelineLayout, pAllocator );
|
|
|
1626 }
|
|
|
1627
|
|
|
1628 VkResult vkCreateSampler( VkDevice device,
|
|
|
1629 const VkSamplerCreateInfo * pCreateInfo,
|
|
|
1630 const VkAllocationCallbacks * pAllocator,
|
|
|
1631 VkSampler * pSampler ) const VULKAN_HPP_NOEXCEPT
|
|
|
1632 {
|
|
|
1633 return ::vkCreateSampler( device, pCreateInfo, pAllocator, pSampler );
|
|
|
1634 }
|
|
|
1635
|
|
|
1636 void vkDestroySampler( VkDevice device, VkSampler sampler, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
1637 {
|
|
|
1638 return ::vkDestroySampler( device, sampler, pAllocator );
|
|
|
1639 }
|
|
|
1640
|
|
|
1641 VkResult vkCreateDescriptorSetLayout( VkDevice device,
|
|
|
1642 const VkDescriptorSetLayoutCreateInfo * pCreateInfo,
|
|
|
1643 const VkAllocationCallbacks * pAllocator,
|
|
|
1644 VkDescriptorSetLayout * pSetLayout ) const VULKAN_HPP_NOEXCEPT
|
|
|
1645 {
|
|
|
1646 return ::vkCreateDescriptorSetLayout( device, pCreateInfo, pAllocator, pSetLayout );
|
|
|
1647 }
|
|
|
1648
|
|
|
1649 void vkDestroyDescriptorSetLayout( VkDevice device,
|
|
|
1650 VkDescriptorSetLayout descriptorSetLayout,
|
|
|
1651 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
1652 {
|
|
|
1653 return ::vkDestroyDescriptorSetLayout( device, descriptorSetLayout, pAllocator );
|
|
|
1654 }
|
|
|
1655
|
|
|
1656 VkResult vkCreateDescriptorPool( VkDevice device,
|
|
|
1657 const VkDescriptorPoolCreateInfo * pCreateInfo,
|
|
|
1658 const VkAllocationCallbacks * pAllocator,
|
|
|
1659 VkDescriptorPool * pDescriptorPool ) const VULKAN_HPP_NOEXCEPT
|
|
|
1660 {
|
|
|
1661 return ::vkCreateDescriptorPool( device, pCreateInfo, pAllocator, pDescriptorPool );
|
|
|
1662 }
|
|
|
1663
|
|
|
1664 void vkDestroyDescriptorPool( VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
1665 {
|
|
|
1666 return ::vkDestroyDescriptorPool( device, descriptorPool, pAllocator );
|
|
|
1667 }
|
|
|
1668
|
|
|
1669 VkResult vkResetDescriptorPool( VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags ) const VULKAN_HPP_NOEXCEPT
|
|
|
1670 {
|
|
|
1671 return ::vkResetDescriptorPool( device, descriptorPool, flags );
|
|
|
1672 }
|
|
|
1673
|
|
|
1674 VkResult vkAllocateDescriptorSets( VkDevice device,
|
|
|
1675 const VkDescriptorSetAllocateInfo * pAllocateInfo,
|
|
|
1676 VkDescriptorSet * pDescriptorSets ) const VULKAN_HPP_NOEXCEPT
|
|
|
1677 {
|
|
|
1678 return ::vkAllocateDescriptorSets( device, pAllocateInfo, pDescriptorSets );
|
|
|
1679 }
|
|
|
1680
|
|
|
1681 VkResult vkFreeDescriptorSets( VkDevice device,
|
|
|
1682 VkDescriptorPool descriptorPool,
|
|
|
1683 uint32_t descriptorSetCount,
|
|
|
1684 const VkDescriptorSet * pDescriptorSets ) const VULKAN_HPP_NOEXCEPT
|
|
|
1685 {
|
|
|
1686 return ::vkFreeDescriptorSets( device, descriptorPool, descriptorSetCount, pDescriptorSets );
|
|
|
1687 }
|
|
|
1688
|
|
|
1689 void vkUpdateDescriptorSets( VkDevice device,
|
|
|
1690 uint32_t descriptorWriteCount,
|
|
|
1691 const VkWriteDescriptorSet * pDescriptorWrites,
|
|
|
1692 uint32_t descriptorCopyCount,
|
|
|
1693 const VkCopyDescriptorSet * pDescriptorCopies ) const VULKAN_HPP_NOEXCEPT
|
|
|
1694 {
|
|
|
1695 return ::vkUpdateDescriptorSets( device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies );
|
|
|
1696 }
|
|
|
1697
|
|
|
1698 void vkCmdBindPipeline( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline ) const VULKAN_HPP_NOEXCEPT
|
|
|
1699 {
|
|
|
1700 return ::vkCmdBindPipeline( commandBuffer, pipelineBindPoint, pipeline );
|
|
|
1701 }
|
|
|
1702
|
|
|
1703 void vkCmdBindDescriptorSets( VkCommandBuffer commandBuffer,
|
|
|
1704 VkPipelineBindPoint pipelineBindPoint,
|
|
|
1705 VkPipelineLayout layout,
|
|
|
1706 uint32_t firstSet,
|
|
|
1707 uint32_t descriptorSetCount,
|
|
|
1708 const VkDescriptorSet * pDescriptorSets,
|
|
|
1709 uint32_t dynamicOffsetCount,
|
|
|
1710 const uint32_t * pDynamicOffsets ) const VULKAN_HPP_NOEXCEPT
|
|
|
1711 {
|
|
|
1712 return ::vkCmdBindDescriptorSets(
|
|
|
1713 commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets );
|
|
|
1714 }
|
|
|
1715
|
|
|
1716 void vkCmdClearColorImage( VkCommandBuffer commandBuffer,
|
|
|
1717 VkImage image,
|
|
|
1718 VkImageLayout imageLayout,
|
|
|
1719 const VkClearColorValue * pColor,
|
|
|
1720 uint32_t rangeCount,
|
|
|
1721 const VkImageSubresourceRange * pRanges ) const VULKAN_HPP_NOEXCEPT
|
|
|
1722 {
|
|
|
1723 return ::vkCmdClearColorImage( commandBuffer, image, imageLayout, pColor, rangeCount, pRanges );
|
|
|
1724 }
|
|
|
1725
|
|
|
1726 void vkCmdDispatch( VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
|
|
|
1727 {
|
|
|
1728 return ::vkCmdDispatch( commandBuffer, groupCountX, groupCountY, groupCountZ );
|
|
|
1729 }
|
|
|
1730
|
|
|
1731 void vkCmdDispatchIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset ) const VULKAN_HPP_NOEXCEPT
|
|
|
1732 {
|
|
|
1733 return ::vkCmdDispatchIndirect( commandBuffer, buffer, offset );
|
|
|
1734 }
|
|
|
1735
|
|
|
1736 void vkCmdSetEvent( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask ) const VULKAN_HPP_NOEXCEPT
|
|
|
1737 {
|
|
|
1738 return ::vkCmdSetEvent( commandBuffer, event, stageMask );
|
|
|
1739 }
|
|
|
1740
|
|
|
1741 void vkCmdResetEvent( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask ) const VULKAN_HPP_NOEXCEPT
|
|
|
1742 {
|
|
|
1743 return ::vkCmdResetEvent( commandBuffer, event, stageMask );
|
|
|
1744 }
|
|
|
1745
|
|
|
1746 void vkCmdWaitEvents( VkCommandBuffer commandBuffer,
|
|
|
1747 uint32_t eventCount,
|
|
|
1748 const VkEvent * pEvents,
|
|
|
1749 VkPipelineStageFlags srcStageMask,
|
|
|
1750 VkPipelineStageFlags dstStageMask,
|
|
|
1751 uint32_t memoryBarrierCount,
|
|
|
1752 const VkMemoryBarrier * pMemoryBarriers,
|
|
|
1753 uint32_t bufferMemoryBarrierCount,
|
|
|
1754 const VkBufferMemoryBarrier * pBufferMemoryBarriers,
|
|
|
1755 uint32_t imageMemoryBarrierCount,
|
|
|
1756 const VkImageMemoryBarrier * pImageMemoryBarriers ) const VULKAN_HPP_NOEXCEPT
|
|
|
1757 {
|
|
|
1758 return ::vkCmdWaitEvents( commandBuffer,
|
|
|
1759 eventCount,
|
|
|
1760 pEvents,
|
|
|
1761 srcStageMask,
|
|
|
1762 dstStageMask,
|
|
|
1763 memoryBarrierCount,
|
|
|
1764 pMemoryBarriers,
|
|
|
1765 bufferMemoryBarrierCount,
|
|
|
1766 pBufferMemoryBarriers,
|
|
|
1767 imageMemoryBarrierCount,
|
|
|
1768 pImageMemoryBarriers );
|
|
|
1769 }
|
|
|
1770
|
|
|
1771 void vkCmdPushConstants( VkCommandBuffer commandBuffer,
|
|
|
1772 VkPipelineLayout layout,
|
|
|
1773 VkShaderStageFlags stageFlags,
|
|
|
1774 uint32_t offset,
|
|
|
1775 uint32_t size,
|
|
|
1776 const void * pValues ) const VULKAN_HPP_NOEXCEPT
|
|
|
1777 {
|
|
|
1778 return ::vkCmdPushConstants( commandBuffer, layout, stageFlags, offset, size, pValues );
|
|
|
1779 }
|
|
|
1780
|
|
|
1781 VkResult vkCreateGraphicsPipelines( VkDevice device,
|
|
|
1782 VkPipelineCache pipelineCache,
|
|
|
1783 uint32_t createInfoCount,
|
|
|
1784 const VkGraphicsPipelineCreateInfo * pCreateInfos,
|
|
|
1785 const VkAllocationCallbacks * pAllocator,
|
|
|
1786 VkPipeline * pPipelines ) const VULKAN_HPP_NOEXCEPT
|
|
|
1787 {
|
|
|
1788 return ::vkCreateGraphicsPipelines( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
|
|
|
1789 }
|
|
|
1790
|
|
|
1791 VkResult vkCreateFramebuffer( VkDevice device,
|
|
|
1792 const VkFramebufferCreateInfo * pCreateInfo,
|
|
|
1793 const VkAllocationCallbacks * pAllocator,
|
|
|
1794 VkFramebuffer * pFramebuffer ) const VULKAN_HPP_NOEXCEPT
|
|
|
1795 {
|
|
|
1796 return ::vkCreateFramebuffer( device, pCreateInfo, pAllocator, pFramebuffer );
|
|
|
1797 }
|
|
|
1798
|
|
|
1799 void vkDestroyFramebuffer( VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
1800 {
|
|
|
1801 return ::vkDestroyFramebuffer( device, framebuffer, pAllocator );
|
|
|
1802 }
|
|
|
1803
|
|
|
1804 VkResult vkCreateRenderPass( VkDevice device,
|
|
|
1805 const VkRenderPassCreateInfo * pCreateInfo,
|
|
|
1806 const VkAllocationCallbacks * pAllocator,
|
|
|
1807 VkRenderPass * pRenderPass ) const VULKAN_HPP_NOEXCEPT
|
|
|
1808 {
|
|
|
1809 return ::vkCreateRenderPass( device, pCreateInfo, pAllocator, pRenderPass );
|
|
|
1810 }
|
|
|
1811
|
|
|
1812 void vkDestroyRenderPass( VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
1813 {
|
|
|
1814 return ::vkDestroyRenderPass( device, renderPass, pAllocator );
|
|
|
1815 }
|
|
|
1816
|
|
|
1817 void vkGetRenderAreaGranularity( VkDevice device, VkRenderPass renderPass, VkExtent2D * pGranularity ) const VULKAN_HPP_NOEXCEPT
|
|
|
1818 {
|
|
|
1819 return ::vkGetRenderAreaGranularity( device, renderPass, pGranularity );
|
|
|
1820 }
|
|
|
1821
|
|
|
1822 void vkCmdSetViewport( VkCommandBuffer commandBuffer,
|
|
|
1823 uint32_t firstViewport,
|
|
|
1824 uint32_t viewportCount,
|
|
|
1825 const VkViewport * pViewports ) const VULKAN_HPP_NOEXCEPT
|
|
|
1826 {
|
|
|
1827 return ::vkCmdSetViewport( commandBuffer, firstViewport, viewportCount, pViewports );
|
|
|
1828 }
|
|
|
1829
|
|
|
1830 void vkCmdSetScissor( VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D * pScissors ) const VULKAN_HPP_NOEXCEPT
|
|
|
1831 {
|
|
|
1832 return ::vkCmdSetScissor( commandBuffer, firstScissor, scissorCount, pScissors );
|
|
|
1833 }
|
|
|
1834
|
|
|
1835 void vkCmdSetLineWidth( VkCommandBuffer commandBuffer, float lineWidth ) const VULKAN_HPP_NOEXCEPT
|
|
|
1836 {
|
|
|
1837 return ::vkCmdSetLineWidth( commandBuffer, lineWidth );
|
|
|
1838 }
|
|
|
1839
|
|
|
1840 void vkCmdSetDepthBias( VkCommandBuffer commandBuffer,
|
|
|
1841 float depthBiasConstantFactor,
|
|
|
1842 float depthBiasClamp,
|
|
|
1843 float depthBiasSlopeFactor ) const VULKAN_HPP_NOEXCEPT
|
|
|
1844 {
|
|
|
1845 return ::vkCmdSetDepthBias( commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor );
|
|
|
1846 }
|
|
|
1847
|
|
|
1848 void vkCmdSetBlendConstants( VkCommandBuffer commandBuffer, const float blendConstants[4] ) const VULKAN_HPP_NOEXCEPT
|
|
|
1849 {
|
|
|
1850 return ::vkCmdSetBlendConstants( commandBuffer, blendConstants );
|
|
|
1851 }
|
|
|
1852
|
|
|
1853 void vkCmdSetDepthBounds( VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds ) const VULKAN_HPP_NOEXCEPT
|
|
|
1854 {
|
|
|
1855 return ::vkCmdSetDepthBounds( commandBuffer, minDepthBounds, maxDepthBounds );
|
|
|
1856 }
|
|
|
1857
|
|
|
1858 void vkCmdSetStencilCompareMask( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask ) const VULKAN_HPP_NOEXCEPT
|
|
|
1859 {
|
|
|
1860 return ::vkCmdSetStencilCompareMask( commandBuffer, faceMask, compareMask );
|
|
|
1861 }
|
|
|
1862
|
|
|
1863 void vkCmdSetStencilWriteMask( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask ) const VULKAN_HPP_NOEXCEPT
|
|
|
1864 {
|
|
|
1865 return ::vkCmdSetStencilWriteMask( commandBuffer, faceMask, writeMask );
|
|
|
1866 }
|
|
|
1867
|
|
|
1868 void vkCmdSetStencilReference( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference ) const VULKAN_HPP_NOEXCEPT
|
|
|
1869 {
|
|
|
1870 return ::vkCmdSetStencilReference( commandBuffer, faceMask, reference );
|
|
|
1871 }
|
|
|
1872
|
|
|
1873 void vkCmdBindIndexBuffer( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType ) const VULKAN_HPP_NOEXCEPT
|
|
|
1874 {
|
|
|
1875 return ::vkCmdBindIndexBuffer( commandBuffer, buffer, offset, indexType );
|
|
|
1876 }
|
|
|
1877
|
|
|
1878 void vkCmdBindVertexBuffers( VkCommandBuffer commandBuffer,
|
|
|
1879 uint32_t firstBinding,
|
|
|
1880 uint32_t bindingCount,
|
|
|
1881 const VkBuffer * pBuffers,
|
|
|
1882 const VkDeviceSize * pOffsets ) const VULKAN_HPP_NOEXCEPT
|
|
|
1883 {
|
|
|
1884 return ::vkCmdBindVertexBuffers( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets );
|
|
|
1885 }
|
|
|
1886
|
|
|
1887 void vkCmdDraw( VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance ) const
|
|
|
1888 VULKAN_HPP_NOEXCEPT
|
|
|
1889 {
|
|
|
1890 return ::vkCmdDraw( commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance );
|
|
|
1891 }
|
|
|
1892
|
|
|
1893 void vkCmdDrawIndexed( VkCommandBuffer commandBuffer,
|
|
|
1894 uint32_t indexCount,
|
|
|
1895 uint32_t instanceCount,
|
|
|
1896 uint32_t firstIndex,
|
|
|
1897 int32_t vertexOffset,
|
|
|
1898 uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT
|
|
|
1899 {
|
|
|
1900 return ::vkCmdDrawIndexed( commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance );
|
|
|
1901 }
|
|
|
1902
|
|
|
1903 void
|
|
|
1904 vkCmdDrawIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const VULKAN_HPP_NOEXCEPT
|
|
|
1905 {
|
|
|
1906 return ::vkCmdDrawIndirect( commandBuffer, buffer, offset, drawCount, stride );
|
|
|
1907 }
|
|
|
1908
|
|
|
1909 void vkCmdDrawIndexedIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const
|
|
|
1910 VULKAN_HPP_NOEXCEPT
|
|
|
1911 {
|
|
|
1912 return ::vkCmdDrawIndexedIndirect( commandBuffer, buffer, offset, drawCount, stride );
|
|
|
1913 }
|
|
|
1914
|
|
|
1915 void vkCmdBlitImage( VkCommandBuffer commandBuffer,
|
|
|
1916 VkImage srcImage,
|
|
|
1917 VkImageLayout srcImageLayout,
|
|
|
1918 VkImage dstImage,
|
|
|
1919 VkImageLayout dstImageLayout,
|
|
|
1920 uint32_t regionCount,
|
|
|
1921 const VkImageBlit * pRegions,
|
|
|
1922 VkFilter filter ) const VULKAN_HPP_NOEXCEPT
|
|
|
1923 {
|
|
|
1924 return ::vkCmdBlitImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter );
|
|
|
1925 }
|
|
|
1926
|
|
|
1927 void vkCmdClearDepthStencilImage( VkCommandBuffer commandBuffer,
|
|
|
1928 VkImage image,
|
|
|
1929 VkImageLayout imageLayout,
|
|
|
1930 const VkClearDepthStencilValue * pDepthStencil,
|
|
|
1931 uint32_t rangeCount,
|
|
|
1932 const VkImageSubresourceRange * pRanges ) const VULKAN_HPP_NOEXCEPT
|
|
|
1933 {
|
|
|
1934 return ::vkCmdClearDepthStencilImage( commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges );
|
|
|
1935 }
|
|
|
1936
|
|
|
1937 void vkCmdClearAttachments( VkCommandBuffer commandBuffer,
|
|
|
1938 uint32_t attachmentCount,
|
|
|
1939 const VkClearAttachment * pAttachments,
|
|
|
1940 uint32_t rectCount,
|
|
|
1941 const VkClearRect * pRects ) const VULKAN_HPP_NOEXCEPT
|
|
|
1942 {
|
|
|
1943 return ::vkCmdClearAttachments( commandBuffer, attachmentCount, pAttachments, rectCount, pRects );
|
|
|
1944 }
|
|
|
1945
|
|
|
1946 void vkCmdResolveImage( VkCommandBuffer commandBuffer,
|
|
|
1947 VkImage srcImage,
|
|
|
1948 VkImageLayout srcImageLayout,
|
|
|
1949 VkImage dstImage,
|
|
|
1950 VkImageLayout dstImageLayout,
|
|
|
1951 uint32_t regionCount,
|
|
|
1952 const VkImageResolve * pRegions ) const VULKAN_HPP_NOEXCEPT
|
|
|
1953 {
|
|
|
1954 return ::vkCmdResolveImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions );
|
|
|
1955 }
|
|
|
1956
|
|
|
1957 void vkCmdBeginRenderPass( VkCommandBuffer commandBuffer,
|
|
|
1958 const VkRenderPassBeginInfo * pRenderPassBegin,
|
|
|
1959 VkSubpassContents contents ) const VULKAN_HPP_NOEXCEPT
|
|
|
1960 {
|
|
|
1961 return ::vkCmdBeginRenderPass( commandBuffer, pRenderPassBegin, contents );
|
|
|
1962 }
|
|
|
1963
|
|
|
1964 void vkCmdNextSubpass( VkCommandBuffer commandBuffer, VkSubpassContents contents ) const VULKAN_HPP_NOEXCEPT
|
|
|
1965 {
|
|
|
1966 return ::vkCmdNextSubpass( commandBuffer, contents );
|
|
|
1967 }
|
|
|
1968
|
|
|
1969 void vkCmdEndRenderPass( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
|
|
|
1970 {
|
|
|
1971 return ::vkCmdEndRenderPass( commandBuffer );
|
|
|
1972 }
|
|
|
1973
|
|
|
1974 //=== VK_VERSION_1_1 ===
|
|
|
1975
|
|
|
1976 VkResult vkEnumerateInstanceVersion( uint32_t * pApiVersion ) const VULKAN_HPP_NOEXCEPT
|
|
|
1977 {
|
|
|
1978 return ::vkEnumerateInstanceVersion( pApiVersion );
|
|
|
1979 }
|
|
|
1980
|
|
|
1981 VkResult vkBindBufferMemory2( VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT
|
|
|
1982 {
|
|
|
1983 return ::vkBindBufferMemory2( device, bindInfoCount, pBindInfos );
|
|
|
1984 }
|
|
|
1985
|
|
|
1986 VkResult vkBindImageMemory2( VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT
|
|
|
1987 {
|
|
|
1988 return ::vkBindImageMemory2( device, bindInfoCount, pBindInfos );
|
|
|
1989 }
|
|
|
1990
|
|
|
1991 void vkGetDeviceGroupPeerMemoryFeatures( VkDevice device,
|
|
|
1992 uint32_t heapIndex,
|
|
|
1993 uint32_t localDeviceIndex,
|
|
|
1994 uint32_t remoteDeviceIndex,
|
|
|
1995 VkPeerMemoryFeatureFlags * pPeerMemoryFeatures ) const VULKAN_HPP_NOEXCEPT
|
|
|
1996 {
|
|
|
1997 return ::vkGetDeviceGroupPeerMemoryFeatures( device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures );
|
|
|
1998 }
|
|
|
1999
|
|
|
2000 void vkCmdSetDeviceMask( VkCommandBuffer commandBuffer, uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT
|
|
|
2001 {
|
|
|
2002 return ::vkCmdSetDeviceMask( commandBuffer, deviceMask );
|
|
|
2003 }
|
|
|
2004
|
|
|
2005 VkResult vkEnumeratePhysicalDeviceGroups( VkInstance instance,
|
|
|
2006 uint32_t * pPhysicalDeviceGroupCount,
|
|
|
2007 VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
2008 {
|
|
|
2009 return ::vkEnumeratePhysicalDeviceGroups( instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties );
|
|
|
2010 }
|
|
|
2011
|
|
|
2012 void vkGetImageMemoryRequirements2( VkDevice device,
|
|
|
2013 const VkImageMemoryRequirementsInfo2 * pInfo,
|
|
|
2014 VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
|
|
|
2015 {
|
|
|
2016 return ::vkGetImageMemoryRequirements2( device, pInfo, pMemoryRequirements );
|
|
|
2017 }
|
|
|
2018
|
|
|
2019 void vkGetBufferMemoryRequirements2( VkDevice device,
|
|
|
2020 const VkBufferMemoryRequirementsInfo2 * pInfo,
|
|
|
2021 VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
|
|
|
2022 {
|
|
|
2023 return ::vkGetBufferMemoryRequirements2( device, pInfo, pMemoryRequirements );
|
|
|
2024 }
|
|
|
2025
|
|
|
2026 void vkGetImageSparseMemoryRequirements2( VkDevice device,
|
|
|
2027 const VkImageSparseMemoryRequirementsInfo2 * pInfo,
|
|
|
2028 uint32_t * pSparseMemoryRequirementCount,
|
|
|
2029 VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
|
|
|
2030 {
|
|
|
2031 return ::vkGetImageSparseMemoryRequirements2( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
|
|
|
2032 }
|
|
|
2033
|
|
|
2034 void vkGetPhysicalDeviceFeatures2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 * pFeatures ) const VULKAN_HPP_NOEXCEPT
|
|
|
2035 {
|
|
|
2036 return ::vkGetPhysicalDeviceFeatures2( physicalDevice, pFeatures );
|
|
|
2037 }
|
|
|
2038
|
|
|
2039 void vkGetPhysicalDeviceProperties2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 * pProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
2040 {
|
|
|
2041 return ::vkGetPhysicalDeviceProperties2( physicalDevice, pProperties );
|
|
|
2042 }
|
|
|
2043
|
|
|
2044 void vkGetPhysicalDeviceFormatProperties2( VkPhysicalDevice physicalDevice,
|
|
|
2045 VkFormat format,
|
|
|
2046 VkFormatProperties2 * pFormatProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
2047 {
|
|
|
2048 return ::vkGetPhysicalDeviceFormatProperties2( physicalDevice, format, pFormatProperties );
|
|
|
2049 }
|
|
|
2050
|
|
|
2051 VkResult vkGetPhysicalDeviceImageFormatProperties2( VkPhysicalDevice physicalDevice,
|
|
|
2052 const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,
|
|
|
2053 VkImageFormatProperties2 * pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
2054 {
|
|
|
2055 return ::vkGetPhysicalDeviceImageFormatProperties2( physicalDevice, pImageFormatInfo, pImageFormatProperties );
|
|
|
2056 }
|
|
|
2057
|
|
|
2058 void vkGetPhysicalDeviceQueueFamilyProperties2( VkPhysicalDevice physicalDevice,
|
|
|
2059 uint32_t * pQueueFamilyPropertyCount,
|
|
|
2060 VkQueueFamilyProperties2 * pQueueFamilyProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
2061 {
|
|
|
2062 return ::vkGetPhysicalDeviceQueueFamilyProperties2( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties );
|
|
|
2063 }
|
|
|
2064
|
|
|
2065 void vkGetPhysicalDeviceMemoryProperties2( VkPhysicalDevice physicalDevice,
|
|
|
2066 VkPhysicalDeviceMemoryProperties2 * pMemoryProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
2067 {
|
|
|
2068 return ::vkGetPhysicalDeviceMemoryProperties2( physicalDevice, pMemoryProperties );
|
|
|
2069 }
|
|
|
2070
|
|
|
2071 void vkGetPhysicalDeviceSparseImageFormatProperties2( VkPhysicalDevice physicalDevice,
|
|
|
2072 const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
|
|
|
2073 uint32_t * pPropertyCount,
|
|
|
2074 VkSparseImageFormatProperties2 * pProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
2075 {
|
|
|
2076 return ::vkGetPhysicalDeviceSparseImageFormatProperties2( physicalDevice, pFormatInfo, pPropertyCount, pProperties );
|
|
|
2077 }
|
|
|
2078
|
|
|
2079 void vkTrimCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags ) const VULKAN_HPP_NOEXCEPT
|
|
|
2080 {
|
|
|
2081 return ::vkTrimCommandPool( device, commandPool, flags );
|
|
|
2082 }
|
|
|
2083
|
|
|
2084 void vkGetDeviceQueue2( VkDevice device, const VkDeviceQueueInfo2 * pQueueInfo, VkQueue * pQueue ) const VULKAN_HPP_NOEXCEPT
|
|
|
2085 {
|
|
|
2086 return ::vkGetDeviceQueue2( device, pQueueInfo, pQueue );
|
|
|
2087 }
|
|
|
2088
|
|
|
2089 void vkGetPhysicalDeviceExternalBufferProperties( VkPhysicalDevice physicalDevice,
|
|
|
2090 const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
|
|
|
2091 VkExternalBufferProperties * pExternalBufferProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
2092 {
|
|
|
2093 return ::vkGetPhysicalDeviceExternalBufferProperties( physicalDevice, pExternalBufferInfo, pExternalBufferProperties );
|
|
|
2094 }
|
|
|
2095
|
|
|
2096 void vkGetPhysicalDeviceExternalFenceProperties( VkPhysicalDevice physicalDevice,
|
|
|
2097 const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,
|
|
|
2098 VkExternalFenceProperties * pExternalFenceProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
2099 {
|
|
|
2100 return ::vkGetPhysicalDeviceExternalFenceProperties( physicalDevice, pExternalFenceInfo, pExternalFenceProperties );
|
|
|
2101 }
|
|
|
2102
|
|
|
2103 void vkGetPhysicalDeviceExternalSemaphoreProperties( VkPhysicalDevice physicalDevice,
|
|
|
2104 const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,
|
|
|
2105 VkExternalSemaphoreProperties * pExternalSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
2106 {
|
|
|
2107 return ::vkGetPhysicalDeviceExternalSemaphoreProperties( physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties );
|
|
|
2108 }
|
|
|
2109
|
|
|
2110 void vkCmdDispatchBase( VkCommandBuffer commandBuffer,
|
|
|
2111 uint32_t baseGroupX,
|
|
|
2112 uint32_t baseGroupY,
|
|
|
2113 uint32_t baseGroupZ,
|
|
|
2114 uint32_t groupCountX,
|
|
|
2115 uint32_t groupCountY,
|
|
|
2116 uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
|
|
|
2117 {
|
|
|
2118 return ::vkCmdDispatchBase( commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
|
|
|
2119 }
|
|
|
2120
|
|
|
2121 VkResult vkCreateDescriptorUpdateTemplate( VkDevice device,
|
|
|
2122 const VkDescriptorUpdateTemplateCreateInfo * pCreateInfo,
|
|
|
2123 const VkAllocationCallbacks * pAllocator,
|
|
|
2124 VkDescriptorUpdateTemplate * pDescriptorUpdateTemplate ) const VULKAN_HPP_NOEXCEPT
|
|
|
2125 {
|
|
|
2126 return ::vkCreateDescriptorUpdateTemplate( device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate );
|
|
|
2127 }
|
|
|
2128
|
|
|
2129 void vkDestroyDescriptorUpdateTemplate( VkDevice device,
|
|
|
2130 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
|
|
|
2131 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
2132 {
|
|
|
2133 return ::vkDestroyDescriptorUpdateTemplate( device, descriptorUpdateTemplate, pAllocator );
|
|
|
2134 }
|
|
|
2135
|
|
|
2136 void vkUpdateDescriptorSetWithTemplate( VkDevice device,
|
|
|
2137 VkDescriptorSet descriptorSet,
|
|
|
2138 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
|
|
|
2139 const void * pData ) const VULKAN_HPP_NOEXCEPT
|
|
|
2140 {
|
|
|
2141 return ::vkUpdateDescriptorSetWithTemplate( device, descriptorSet, descriptorUpdateTemplate, pData );
|
|
|
2142 }
|
|
|
2143
|
|
|
2144 void vkGetDescriptorSetLayoutSupport( VkDevice device,
|
|
|
2145 const VkDescriptorSetLayoutCreateInfo * pCreateInfo,
|
|
|
2146 VkDescriptorSetLayoutSupport * pSupport ) const VULKAN_HPP_NOEXCEPT
|
|
|
2147 {
|
|
|
2148 return ::vkGetDescriptorSetLayoutSupport( device, pCreateInfo, pSupport );
|
|
|
2149 }
|
|
|
2150
|
|
|
2151 VkResult vkCreateSamplerYcbcrConversion( VkDevice device,
|
|
|
2152 const VkSamplerYcbcrConversionCreateInfo * pCreateInfo,
|
|
|
2153 const VkAllocationCallbacks * pAllocator,
|
|
|
2154 VkSamplerYcbcrConversion * pYcbcrConversion ) const VULKAN_HPP_NOEXCEPT
|
|
|
2155 {
|
|
|
2156 return ::vkCreateSamplerYcbcrConversion( device, pCreateInfo, pAllocator, pYcbcrConversion );
|
|
|
2157 }
|
|
|
2158
|
|
|
2159 void vkDestroySamplerYcbcrConversion( VkDevice device,
|
|
|
2160 VkSamplerYcbcrConversion ycbcrConversion,
|
|
|
2161 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
2162 {
|
|
|
2163 return ::vkDestroySamplerYcbcrConversion( device, ycbcrConversion, pAllocator );
|
|
|
2164 }
|
|
|
2165
|
|
|
2166 //=== VK_VERSION_1_2 ===
|
|
|
2167
|
|
|
2168 void vkResetQueryPool( VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT
|
|
|
2169 {
|
|
|
2170 return ::vkResetQueryPool( device, queryPool, firstQuery, queryCount );
|
|
|
2171 }
|
|
|
2172
|
|
|
2173 VkResult vkGetSemaphoreCounterValue( VkDevice device, VkSemaphore semaphore, uint64_t * pValue ) const VULKAN_HPP_NOEXCEPT
|
|
|
2174 {
|
|
|
2175 return ::vkGetSemaphoreCounterValue( device, semaphore, pValue );
|
|
|
2176 }
|
|
|
2177
|
|
|
2178 VkResult vkWaitSemaphores( VkDevice device, const VkSemaphoreWaitInfo * pWaitInfo, uint64_t timeout ) const VULKAN_HPP_NOEXCEPT
|
|
|
2179 {
|
|
|
2180 return ::vkWaitSemaphores( device, pWaitInfo, timeout );
|
|
|
2181 }
|
|
|
2182
|
|
|
2183 VkResult vkSignalSemaphore( VkDevice device, const VkSemaphoreSignalInfo * pSignalInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
2184 {
|
|
|
2185 return ::vkSignalSemaphore( device, pSignalInfo );
|
|
|
2186 }
|
|
|
2187
|
|
|
2188 VkDeviceAddress vkGetBufferDeviceAddress( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
2189 {
|
|
|
2190 return ::vkGetBufferDeviceAddress( device, pInfo );
|
|
|
2191 }
|
|
|
2192
|
|
|
2193 uint64_t vkGetBufferOpaqueCaptureAddress( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
2194 {
|
|
|
2195 return ::vkGetBufferOpaqueCaptureAddress( device, pInfo );
|
|
|
2196 }
|
|
|
2197
|
|
|
2198 uint64_t vkGetDeviceMemoryOpaqueCaptureAddress( VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
2199 {
|
|
|
2200 return ::vkGetDeviceMemoryOpaqueCaptureAddress( device, pInfo );
|
|
|
2201 }
|
|
|
2202
|
|
|
2203 void vkCmdDrawIndirectCount( VkCommandBuffer commandBuffer,
|
|
|
2204 VkBuffer buffer,
|
|
|
2205 VkDeviceSize offset,
|
|
|
2206 VkBuffer countBuffer,
|
|
|
2207 VkDeviceSize countBufferOffset,
|
|
|
2208 uint32_t maxDrawCount,
|
|
|
2209 uint32_t stride ) const VULKAN_HPP_NOEXCEPT
|
|
|
2210 {
|
|
|
2211 return ::vkCmdDrawIndirectCount( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
|
|
|
2212 }
|
|
|
2213
|
|
|
2214 void vkCmdDrawIndexedIndirectCount( VkCommandBuffer commandBuffer,
|
|
|
2215 VkBuffer buffer,
|
|
|
2216 VkDeviceSize offset,
|
|
|
2217 VkBuffer countBuffer,
|
|
|
2218 VkDeviceSize countBufferOffset,
|
|
|
2219 uint32_t maxDrawCount,
|
|
|
2220 uint32_t stride ) const VULKAN_HPP_NOEXCEPT
|
|
|
2221 {
|
|
|
2222 return ::vkCmdDrawIndexedIndirectCount( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
|
|
|
2223 }
|
|
|
2224
|
|
|
2225 VkResult vkCreateRenderPass2( VkDevice device,
|
|
|
2226 const VkRenderPassCreateInfo2 * pCreateInfo,
|
|
|
2227 const VkAllocationCallbacks * pAllocator,
|
|
|
2228 VkRenderPass * pRenderPass ) const VULKAN_HPP_NOEXCEPT
|
|
|
2229 {
|
|
|
2230 return ::vkCreateRenderPass2( device, pCreateInfo, pAllocator, pRenderPass );
|
|
|
2231 }
|
|
|
2232
|
|
|
2233 void vkCmdBeginRenderPass2( VkCommandBuffer commandBuffer,
|
|
|
2234 const VkRenderPassBeginInfo * pRenderPassBegin,
|
|
|
2235 const VkSubpassBeginInfo * pSubpassBeginInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
2236 {
|
|
|
2237 return ::vkCmdBeginRenderPass2( commandBuffer, pRenderPassBegin, pSubpassBeginInfo );
|
|
|
2238 }
|
|
|
2239
|
|
|
2240 void vkCmdNextSubpass2( VkCommandBuffer commandBuffer,
|
|
|
2241 const VkSubpassBeginInfo * pSubpassBeginInfo,
|
|
|
2242 const VkSubpassEndInfo * pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
2243 {
|
|
|
2244 return ::vkCmdNextSubpass2( commandBuffer, pSubpassBeginInfo, pSubpassEndInfo );
|
|
|
2245 }
|
|
|
2246
|
|
|
2247 void vkCmdEndRenderPass2( VkCommandBuffer commandBuffer, const VkSubpassEndInfo * pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
2248 {
|
|
|
2249 return ::vkCmdEndRenderPass2( commandBuffer, pSubpassEndInfo );
|
|
|
2250 }
|
|
|
2251
|
|
|
2252 //=== VK_VERSION_1_3 ===
|
|
|
2253
|
|
|
2254 VkResult vkGetPhysicalDeviceToolProperties( VkPhysicalDevice physicalDevice,
|
|
|
2255 uint32_t * pToolCount,
|
|
|
2256 VkPhysicalDeviceToolProperties * pToolProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
2257 {
|
|
|
2258 return ::vkGetPhysicalDeviceToolProperties( physicalDevice, pToolCount, pToolProperties );
|
|
|
2259 }
|
|
|
2260
|
|
|
2261 VkResult vkCreatePrivateDataSlot( VkDevice device,
|
|
|
2262 const VkPrivateDataSlotCreateInfo * pCreateInfo,
|
|
|
2263 const VkAllocationCallbacks * pAllocator,
|
|
|
2264 VkPrivateDataSlot * pPrivateDataSlot ) const VULKAN_HPP_NOEXCEPT
|
|
|
2265 {
|
|
|
2266 return ::vkCreatePrivateDataSlot( device, pCreateInfo, pAllocator, pPrivateDataSlot );
|
|
|
2267 }
|
|
|
2268
|
|
|
2269 void vkDestroyPrivateDataSlot( VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
2270 {
|
|
|
2271 return ::vkDestroyPrivateDataSlot( device, privateDataSlot, pAllocator );
|
|
|
2272 }
|
|
|
2273
|
|
|
2274 VkResult vkSetPrivateData( VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data ) const
|
|
|
2275 VULKAN_HPP_NOEXCEPT
|
|
|
2276 {
|
|
|
2277 return ::vkSetPrivateData( device, objectType, objectHandle, privateDataSlot, data );
|
|
|
2278 }
|
|
|
2279
|
|
|
2280 void vkGetPrivateData( VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t * pData ) const
|
|
|
2281 VULKAN_HPP_NOEXCEPT
|
|
|
2282 {
|
|
|
2283 return ::vkGetPrivateData( device, objectType, objectHandle, privateDataSlot, pData );
|
|
|
2284 }
|
|
|
2285
|
|
|
2286 void vkCmdPipelineBarrier2( VkCommandBuffer commandBuffer, const VkDependencyInfo * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
2287 {
|
|
|
2288 return ::vkCmdPipelineBarrier2( commandBuffer, pDependencyInfo );
|
|
|
2289 }
|
|
|
2290
|
|
|
2291 void vkCmdWriteTimestamp2( VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT
|
|
|
2292 {
|
|
|
2293 return ::vkCmdWriteTimestamp2( commandBuffer, stage, queryPool, query );
|
|
|
2294 }
|
|
|
2295
|
|
|
2296 VkResult vkQueueSubmit2( VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 * pSubmits, VkFence fence ) const VULKAN_HPP_NOEXCEPT
|
|
|
2297 {
|
|
|
2298 return ::vkQueueSubmit2( queue, submitCount, pSubmits, fence );
|
|
|
2299 }
|
|
|
2300
|
|
|
2301 void vkCmdCopyBuffer2( VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 * pCopyBufferInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
2302 {
|
|
|
2303 return ::vkCmdCopyBuffer2( commandBuffer, pCopyBufferInfo );
|
|
|
2304 }
|
|
|
2305
|
|
|
2306 void vkCmdCopyImage2( VkCommandBuffer commandBuffer, const VkCopyImageInfo2 * pCopyImageInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
2307 {
|
|
|
2308 return ::vkCmdCopyImage2( commandBuffer, pCopyImageInfo );
|
|
|
2309 }
|
|
|
2310
|
|
|
2311 void vkCmdCopyBufferToImage2( VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 * pCopyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
2312 {
|
|
|
2313 return ::vkCmdCopyBufferToImage2( commandBuffer, pCopyBufferToImageInfo );
|
|
|
2314 }
|
|
|
2315
|
|
|
2316 void vkCmdCopyImageToBuffer2( VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 * pCopyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
2317 {
|
|
|
2318 return ::vkCmdCopyImageToBuffer2( commandBuffer, pCopyImageToBufferInfo );
|
|
|
2319 }
|
|
|
2320
|
|
|
2321 void vkGetDeviceBufferMemoryRequirements( VkDevice device,
|
|
|
2322 const VkDeviceBufferMemoryRequirements * pInfo,
|
|
|
2323 VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
|
|
|
2324 {
|
|
|
2325 return ::vkGetDeviceBufferMemoryRequirements( device, pInfo, pMemoryRequirements );
|
|
|
2326 }
|
|
|
2327
|
|
|
2328 void vkGetDeviceImageMemoryRequirements( VkDevice device,
|
|
|
2329 const VkDeviceImageMemoryRequirements * pInfo,
|
|
|
2330 VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
|
|
|
2331 {
|
|
|
2332 return ::vkGetDeviceImageMemoryRequirements( device, pInfo, pMemoryRequirements );
|
|
|
2333 }
|
|
|
2334
|
|
|
2335 void vkGetDeviceImageSparseMemoryRequirements( VkDevice device,
|
|
|
2336 const VkDeviceImageMemoryRequirements * pInfo,
|
|
|
2337 uint32_t * pSparseMemoryRequirementCount,
|
|
|
2338 VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
|
|
|
2339 {
|
|
|
2340 return ::vkGetDeviceImageSparseMemoryRequirements( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
|
|
|
2341 }
|
|
|
2342
|
|
|
2343 void vkCmdSetEvent2( VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
2344 {
|
|
|
2345 return ::vkCmdSetEvent2( commandBuffer, event, pDependencyInfo );
|
|
|
2346 }
|
|
|
2347
|
|
|
2348 void vkCmdResetEvent2( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask ) const VULKAN_HPP_NOEXCEPT
|
|
|
2349 {
|
|
|
2350 return ::vkCmdResetEvent2( commandBuffer, event, stageMask );
|
|
|
2351 }
|
|
|
2352
|
|
|
2353 void vkCmdWaitEvents2( VkCommandBuffer commandBuffer,
|
|
|
2354 uint32_t eventCount,
|
|
|
2355 const VkEvent * pEvents,
|
|
|
2356 const VkDependencyInfo * pDependencyInfos ) const VULKAN_HPP_NOEXCEPT
|
|
|
2357 {
|
|
|
2358 return ::vkCmdWaitEvents2( commandBuffer, eventCount, pEvents, pDependencyInfos );
|
|
|
2359 }
|
|
|
2360
|
|
|
2361 void vkCmdBlitImage2( VkCommandBuffer commandBuffer, const VkBlitImageInfo2 * pBlitImageInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
2362 {
|
|
|
2363 return ::vkCmdBlitImage2( commandBuffer, pBlitImageInfo );
|
|
|
2364 }
|
|
|
2365
|
|
|
2366 void vkCmdResolveImage2( VkCommandBuffer commandBuffer, const VkResolveImageInfo2 * pResolveImageInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
2367 {
|
|
|
2368 return ::vkCmdResolveImage2( commandBuffer, pResolveImageInfo );
|
|
|
2369 }
|
|
|
2370
|
|
|
2371 void vkCmdBeginRendering( VkCommandBuffer commandBuffer, const VkRenderingInfo * pRenderingInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
2372 {
|
|
|
2373 return ::vkCmdBeginRendering( commandBuffer, pRenderingInfo );
|
|
|
2374 }
|
|
|
2375
|
|
|
2376 void vkCmdEndRendering( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
|
|
|
2377 {
|
|
|
2378 return ::vkCmdEndRendering( commandBuffer );
|
|
|
2379 }
|
|
|
2380
|
|
|
2381 void vkCmdSetCullMode( VkCommandBuffer commandBuffer, VkCullModeFlags cullMode ) const VULKAN_HPP_NOEXCEPT
|
|
|
2382 {
|
|
|
2383 return ::vkCmdSetCullMode( commandBuffer, cullMode );
|
|
|
2384 }
|
|
|
2385
|
|
|
2386 void vkCmdSetFrontFace( VkCommandBuffer commandBuffer, VkFrontFace frontFace ) const VULKAN_HPP_NOEXCEPT
|
|
|
2387 {
|
|
|
2388 return ::vkCmdSetFrontFace( commandBuffer, frontFace );
|
|
|
2389 }
|
|
|
2390
|
|
|
2391 void vkCmdSetPrimitiveTopology( VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT
|
|
|
2392 {
|
|
|
2393 return ::vkCmdSetPrimitiveTopology( commandBuffer, primitiveTopology );
|
|
|
2394 }
|
|
|
2395
|
|
|
2396 void vkCmdSetViewportWithCount( VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport * pViewports ) const VULKAN_HPP_NOEXCEPT
|
|
|
2397 {
|
|
|
2398 return ::vkCmdSetViewportWithCount( commandBuffer, viewportCount, pViewports );
|
|
|
2399 }
|
|
|
2400
|
|
|
2401 void vkCmdSetScissorWithCount( VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D * pScissors ) const VULKAN_HPP_NOEXCEPT
|
|
|
2402 {
|
|
|
2403 return ::vkCmdSetScissorWithCount( commandBuffer, scissorCount, pScissors );
|
|
|
2404 }
|
|
|
2405
|
|
|
2406 void vkCmdBindVertexBuffers2( VkCommandBuffer commandBuffer,
|
|
|
2407 uint32_t firstBinding,
|
|
|
2408 uint32_t bindingCount,
|
|
|
2409 const VkBuffer * pBuffers,
|
|
|
2410 const VkDeviceSize * pOffsets,
|
|
|
2411 const VkDeviceSize * pSizes,
|
|
|
2412 const VkDeviceSize * pStrides ) const VULKAN_HPP_NOEXCEPT
|
|
|
2413 {
|
|
|
2414 return ::vkCmdBindVertexBuffers2( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides );
|
|
|
2415 }
|
|
|
2416
|
|
|
2417 void vkCmdSetDepthTestEnable( VkCommandBuffer commandBuffer, VkBool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT
|
|
|
2418 {
|
|
|
2419 return ::vkCmdSetDepthTestEnable( commandBuffer, depthTestEnable );
|
|
|
2420 }
|
|
|
2421
|
|
|
2422 void vkCmdSetDepthWriteEnable( VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT
|
|
|
2423 {
|
|
|
2424 return ::vkCmdSetDepthWriteEnable( commandBuffer, depthWriteEnable );
|
|
|
2425 }
|
|
|
2426
|
|
|
2427 void vkCmdSetDepthCompareOp( VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT
|
|
|
2428 {
|
|
|
2429 return ::vkCmdSetDepthCompareOp( commandBuffer, depthCompareOp );
|
|
|
2430 }
|
|
|
2431
|
|
|
2432 void vkCmdSetDepthBoundsTestEnable( VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT
|
|
|
2433 {
|
|
|
2434 return ::vkCmdSetDepthBoundsTestEnable( commandBuffer, depthBoundsTestEnable );
|
|
|
2435 }
|
|
|
2436
|
|
|
2437 void vkCmdSetStencilTestEnable( VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT
|
|
|
2438 {
|
|
|
2439 return ::vkCmdSetStencilTestEnable( commandBuffer, stencilTestEnable );
|
|
|
2440 }
|
|
|
2441
|
|
|
2442 void vkCmdSetStencilOp( VkCommandBuffer commandBuffer,
|
|
|
2443 VkStencilFaceFlags faceMask,
|
|
|
2444 VkStencilOp failOp,
|
|
|
2445 VkStencilOp passOp,
|
|
|
2446 VkStencilOp depthFailOp,
|
|
|
2447 VkCompareOp compareOp ) const VULKAN_HPP_NOEXCEPT
|
|
|
2448 {
|
|
|
2449 return ::vkCmdSetStencilOp( commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp );
|
|
|
2450 }
|
|
|
2451
|
|
|
2452 void vkCmdSetRasterizerDiscardEnable( VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT
|
|
|
2453 {
|
|
|
2454 return ::vkCmdSetRasterizerDiscardEnable( commandBuffer, rasterizerDiscardEnable );
|
|
|
2455 }
|
|
|
2456
|
|
|
2457 void vkCmdSetDepthBiasEnable( VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT
|
|
|
2458 {
|
|
|
2459 return ::vkCmdSetDepthBiasEnable( commandBuffer, depthBiasEnable );
|
|
|
2460 }
|
|
|
2461
|
|
|
2462 void vkCmdSetPrimitiveRestartEnable( VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT
|
|
|
2463 {
|
|
|
2464 return ::vkCmdSetPrimitiveRestartEnable( commandBuffer, primitiveRestartEnable );
|
|
|
2465 }
|
|
|
2466
|
|
|
2467 //=== VK_VERSION_1_4 ===
|
|
|
2468
|
|
|
2469 VkResult vkMapMemory2( VkDevice device, const VkMemoryMapInfo * pMemoryMapInfo, void ** ppData ) const VULKAN_HPP_NOEXCEPT
|
|
|
2470 {
|
|
|
2471 return ::vkMapMemory2( device, pMemoryMapInfo, ppData );
|
|
|
2472 }
|
|
|
2473
|
|
|
2474 VkResult vkUnmapMemory2( VkDevice device, const VkMemoryUnmapInfo * pMemoryUnmapInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
2475 {
|
|
|
2476 return ::vkUnmapMemory2( device, pMemoryUnmapInfo );
|
|
|
2477 }
|
|
|
2478
|
|
|
2479 void vkGetDeviceImageSubresourceLayout( VkDevice device,
|
|
|
2480 const VkDeviceImageSubresourceInfo * pInfo,
|
|
|
2481 VkSubresourceLayout2 * pLayout ) const VULKAN_HPP_NOEXCEPT
|
|
|
2482 {
|
|
|
2483 return ::vkGetDeviceImageSubresourceLayout( device, pInfo, pLayout );
|
|
|
2484 }
|
|
|
2485
|
|
|
2486 void vkGetImageSubresourceLayout2( VkDevice device,
|
|
|
2487 VkImage image,
|
|
|
2488 const VkImageSubresource2 * pSubresource,
|
|
|
2489 VkSubresourceLayout2 * pLayout ) const VULKAN_HPP_NOEXCEPT
|
|
|
2490 {
|
|
|
2491 return ::vkGetImageSubresourceLayout2( device, image, pSubresource, pLayout );
|
|
|
2492 }
|
|
|
2493
|
|
|
2494 VkResult vkCopyMemoryToImage( VkDevice device, const VkCopyMemoryToImageInfo * pCopyMemoryToImageInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
2495 {
|
|
|
2496 return ::vkCopyMemoryToImage( device, pCopyMemoryToImageInfo );
|
|
|
2497 }
|
|
|
2498
|
|
|
2499 VkResult vkCopyImageToMemory( VkDevice device, const VkCopyImageToMemoryInfo * pCopyImageToMemoryInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
2500 {
|
|
|
2501 return ::vkCopyImageToMemory( device, pCopyImageToMemoryInfo );
|
|
|
2502 }
|
|
|
2503
|
|
|
2504 VkResult vkCopyImageToImage( VkDevice device, const VkCopyImageToImageInfo * pCopyImageToImageInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
2505 {
|
|
|
2506 return ::vkCopyImageToImage( device, pCopyImageToImageInfo );
|
|
|
2507 }
|
|
|
2508
|
|
|
2509 VkResult
|
|
|
2510 vkTransitionImageLayout( VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfo * pTransitions ) const VULKAN_HPP_NOEXCEPT
|
|
|
2511 {
|
|
|
2512 return ::vkTransitionImageLayout( device, transitionCount, pTransitions );
|
|
|
2513 }
|
|
|
2514
|
|
|
2515 void vkCmdPushDescriptorSet( VkCommandBuffer commandBuffer,
|
|
|
2516 VkPipelineBindPoint pipelineBindPoint,
|
|
|
2517 VkPipelineLayout layout,
|
|
|
2518 uint32_t set,
|
|
|
2519 uint32_t descriptorWriteCount,
|
|
|
2520 const VkWriteDescriptorSet * pDescriptorWrites ) const VULKAN_HPP_NOEXCEPT
|
|
|
2521 {
|
|
|
2522 return ::vkCmdPushDescriptorSet( commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites );
|
|
|
2523 }
|
|
|
2524
|
|
|
2525 void vkCmdPushDescriptorSetWithTemplate( VkCommandBuffer commandBuffer,
|
|
|
2526 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
|
|
|
2527 VkPipelineLayout layout,
|
|
|
2528 uint32_t set,
|
|
|
2529 const void * pData ) const VULKAN_HPP_NOEXCEPT
|
|
|
2530 {
|
|
|
2531 return ::vkCmdPushDescriptorSetWithTemplate( commandBuffer, descriptorUpdateTemplate, layout, set, pData );
|
|
|
2532 }
|
|
|
2533
|
|
|
2534 void vkCmdBindDescriptorSets2( VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfo * pBindDescriptorSetsInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
2535 {
|
|
|
2536 return ::vkCmdBindDescriptorSets2( commandBuffer, pBindDescriptorSetsInfo );
|
|
|
2537 }
|
|
|
2538
|
|
|
2539 void vkCmdPushConstants2( VkCommandBuffer commandBuffer, const VkPushConstantsInfo * pPushConstantsInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
2540 {
|
|
|
2541 return ::vkCmdPushConstants2( commandBuffer, pPushConstantsInfo );
|
|
|
2542 }
|
|
|
2543
|
|
|
2544 void vkCmdPushDescriptorSet2( VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfo * pPushDescriptorSetInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
2545 {
|
|
|
2546 return ::vkCmdPushDescriptorSet2( commandBuffer, pPushDescriptorSetInfo );
|
|
|
2547 }
|
|
|
2548
|
|
|
2549 void vkCmdPushDescriptorSetWithTemplate2( VkCommandBuffer commandBuffer,
|
|
|
2550 const VkPushDescriptorSetWithTemplateInfo * pPushDescriptorSetWithTemplateInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
2551 {
|
|
|
2552 return ::vkCmdPushDescriptorSetWithTemplate2( commandBuffer, pPushDescriptorSetWithTemplateInfo );
|
|
|
2553 }
|
|
|
2554
|
|
|
2555 void vkCmdSetLineStipple( VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT
|
|
|
2556 {
|
|
|
2557 return ::vkCmdSetLineStipple( commandBuffer, lineStippleFactor, lineStipplePattern );
|
|
|
2558 }
|
|
|
2559
|
|
|
2560 void vkCmdBindIndexBuffer2( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType ) const
|
|
|
2561 VULKAN_HPP_NOEXCEPT
|
|
|
2562 {
|
|
|
2563 return ::vkCmdBindIndexBuffer2( commandBuffer, buffer, offset, size, indexType );
|
|
|
2564 }
|
|
|
2565
|
|
|
2566 void vkGetRenderingAreaGranularity( VkDevice device, const VkRenderingAreaInfo * pRenderingAreaInfo, VkExtent2D * pGranularity ) const VULKAN_HPP_NOEXCEPT
|
|
|
2567 {
|
|
|
2568 return ::vkGetRenderingAreaGranularity( device, pRenderingAreaInfo, pGranularity );
|
|
|
2569 }
|
|
|
2570
|
|
|
2571 void vkCmdSetRenderingAttachmentLocations( VkCommandBuffer commandBuffer,
|
|
|
2572 const VkRenderingAttachmentLocationInfo * pLocationInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
2573 {
|
|
|
2574 return ::vkCmdSetRenderingAttachmentLocations( commandBuffer, pLocationInfo );
|
|
|
2575 }
|
|
|
2576
|
|
|
2577 void vkCmdSetRenderingInputAttachmentIndices( VkCommandBuffer commandBuffer,
|
|
|
2578 const VkRenderingInputAttachmentIndexInfo * pInputAttachmentIndexInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
2579 {
|
|
|
2580 return ::vkCmdSetRenderingInputAttachmentIndices( commandBuffer, pInputAttachmentIndexInfo );
|
|
|
2581 }
|
|
|
2582
|
|
|
2583 //=== VK_KHR_surface ===
|
|
|
2584
|
|
|
2585 void vkDestroySurfaceKHR( VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
2586 {
|
|
|
2587 return ::vkDestroySurfaceKHR( instance, surface, pAllocator );
|
|
|
2588 }
|
|
|
2589
|
|
|
2590 VkResult vkGetPhysicalDeviceSurfaceSupportKHR( VkPhysicalDevice physicalDevice,
|
|
|
2591 uint32_t queueFamilyIndex,
|
|
|
2592 VkSurfaceKHR surface,
|
|
|
2593 VkBool32 * pSupported ) const VULKAN_HPP_NOEXCEPT
|
|
|
2594 {
|
|
|
2595 return ::vkGetPhysicalDeviceSurfaceSupportKHR( physicalDevice, queueFamilyIndex, surface, pSupported );
|
|
|
2596 }
|
|
|
2597
|
|
|
2598 VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR( VkPhysicalDevice physicalDevice,
|
|
|
2599 VkSurfaceKHR surface,
|
|
|
2600 VkSurfaceCapabilitiesKHR * pSurfaceCapabilities ) const VULKAN_HPP_NOEXCEPT
|
|
|
2601 {
|
|
|
2602 return ::vkGetPhysicalDeviceSurfaceCapabilitiesKHR( physicalDevice, surface, pSurfaceCapabilities );
|
|
|
2603 }
|
|
|
2604
|
|
|
2605 VkResult vkGetPhysicalDeviceSurfaceFormatsKHR( VkPhysicalDevice physicalDevice,
|
|
|
2606 VkSurfaceKHR surface,
|
|
|
2607 uint32_t * pSurfaceFormatCount,
|
|
|
2608 VkSurfaceFormatKHR * pSurfaceFormats ) const VULKAN_HPP_NOEXCEPT
|
|
|
2609 {
|
|
|
2610 return ::vkGetPhysicalDeviceSurfaceFormatsKHR( physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats );
|
|
|
2611 }
|
|
|
2612
|
|
|
2613 VkResult vkGetPhysicalDeviceSurfacePresentModesKHR( VkPhysicalDevice physicalDevice,
|
|
|
2614 VkSurfaceKHR surface,
|
|
|
2615 uint32_t * pPresentModeCount,
|
|
|
2616 VkPresentModeKHR * pPresentModes ) const VULKAN_HPP_NOEXCEPT
|
|
|
2617 {
|
|
|
2618 return ::vkGetPhysicalDeviceSurfacePresentModesKHR( physicalDevice, surface, pPresentModeCount, pPresentModes );
|
|
|
2619 }
|
|
|
2620
|
|
|
2621 //=== VK_KHR_swapchain ===
|
|
|
2622
|
|
|
2623 VkResult vkCreateSwapchainKHR( VkDevice device,
|
|
|
2624 const VkSwapchainCreateInfoKHR * pCreateInfo,
|
|
|
2625 const VkAllocationCallbacks * pAllocator,
|
|
|
2626 VkSwapchainKHR * pSwapchain ) const VULKAN_HPP_NOEXCEPT
|
|
|
2627 {
|
|
|
2628 return ::vkCreateSwapchainKHR( device, pCreateInfo, pAllocator, pSwapchain );
|
|
|
2629 }
|
|
|
2630
|
|
|
2631 void vkDestroySwapchainKHR( VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
2632 {
|
|
|
2633 return ::vkDestroySwapchainKHR( device, swapchain, pAllocator );
|
|
|
2634 }
|
|
|
2635
|
|
|
2636 VkResult vkGetSwapchainImagesKHR( VkDevice device,
|
|
|
2637 VkSwapchainKHR swapchain,
|
|
|
2638 uint32_t * pSwapchainImageCount,
|
|
|
2639 VkImage * pSwapchainImages ) const VULKAN_HPP_NOEXCEPT
|
|
|
2640 {
|
|
|
2641 return ::vkGetSwapchainImagesKHR( device, swapchain, pSwapchainImageCount, pSwapchainImages );
|
|
|
2642 }
|
|
|
2643
|
|
|
2644 VkResult vkAcquireNextImageKHR(
|
|
|
2645 VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t * pImageIndex ) const VULKAN_HPP_NOEXCEPT
|
|
|
2646 {
|
|
|
2647 return ::vkAcquireNextImageKHR( device, swapchain, timeout, semaphore, fence, pImageIndex );
|
|
|
2648 }
|
|
|
2649
|
|
|
2650 VkResult vkQueuePresentKHR( VkQueue queue, const VkPresentInfoKHR * pPresentInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
2651 {
|
|
|
2652 return ::vkQueuePresentKHR( queue, pPresentInfo );
|
|
|
2653 }
|
|
|
2654
|
|
|
2655 VkResult vkGetDeviceGroupPresentCapabilitiesKHR( VkDevice device,
|
|
|
2656 VkDeviceGroupPresentCapabilitiesKHR * pDeviceGroupPresentCapabilities ) const VULKAN_HPP_NOEXCEPT
|
|
|
2657 {
|
|
|
2658 return ::vkGetDeviceGroupPresentCapabilitiesKHR( device, pDeviceGroupPresentCapabilities );
|
|
|
2659 }
|
|
|
2660
|
|
|
2661 VkResult
|
|
|
2662 vkGetDeviceGroupSurfacePresentModesKHR( VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR * pModes ) const VULKAN_HPP_NOEXCEPT
|
|
|
2663 {
|
|
|
2664 return ::vkGetDeviceGroupSurfacePresentModesKHR( device, surface, pModes );
|
|
|
2665 }
|
|
|
2666
|
|
|
2667 VkResult vkGetPhysicalDevicePresentRectanglesKHR( VkPhysicalDevice physicalDevice,
|
|
|
2668 VkSurfaceKHR surface,
|
|
|
2669 uint32_t * pRectCount,
|
|
|
2670 VkRect2D * pRects ) const VULKAN_HPP_NOEXCEPT
|
|
|
2671 {
|
|
|
2672 return ::vkGetPhysicalDevicePresentRectanglesKHR( physicalDevice, surface, pRectCount, pRects );
|
|
|
2673 }
|
|
|
2674
|
|
|
2675 VkResult vkAcquireNextImage2KHR( VkDevice device, const VkAcquireNextImageInfoKHR * pAcquireInfo, uint32_t * pImageIndex ) const VULKAN_HPP_NOEXCEPT
|
|
|
2676 {
|
|
|
2677 return ::vkAcquireNextImage2KHR( device, pAcquireInfo, pImageIndex );
|
|
|
2678 }
|
|
|
2679
|
|
|
2680 //=== VK_KHR_display ===
|
|
|
2681
|
|
|
2682 VkResult vkGetPhysicalDeviceDisplayPropertiesKHR( VkPhysicalDevice physicalDevice,
|
|
|
2683 uint32_t * pPropertyCount,
|
|
|
2684 VkDisplayPropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
2685 {
|
|
|
2686 return ::vkGetPhysicalDeviceDisplayPropertiesKHR( physicalDevice, pPropertyCount, pProperties );
|
|
|
2687 }
|
|
|
2688
|
|
|
2689 VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR( VkPhysicalDevice physicalDevice,
|
|
|
2690 uint32_t * pPropertyCount,
|
|
|
2691 VkDisplayPlanePropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
2692 {
|
|
|
2693 return ::vkGetPhysicalDeviceDisplayPlanePropertiesKHR( physicalDevice, pPropertyCount, pProperties );
|
|
|
2694 }
|
|
|
2695
|
|
|
2696 VkResult vkGetDisplayPlaneSupportedDisplaysKHR( VkPhysicalDevice physicalDevice,
|
|
|
2697 uint32_t planeIndex,
|
|
|
2698 uint32_t * pDisplayCount,
|
|
|
2699 VkDisplayKHR * pDisplays ) const VULKAN_HPP_NOEXCEPT
|
|
|
2700 {
|
|
|
2701 return ::vkGetDisplayPlaneSupportedDisplaysKHR( physicalDevice, planeIndex, pDisplayCount, pDisplays );
|
|
|
2702 }
|
|
|
2703
|
|
|
2704 VkResult vkGetDisplayModePropertiesKHR( VkPhysicalDevice physicalDevice,
|
|
|
2705 VkDisplayKHR display,
|
|
|
2706 uint32_t * pPropertyCount,
|
|
|
2707 VkDisplayModePropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
2708 {
|
|
|
2709 return ::vkGetDisplayModePropertiesKHR( physicalDevice, display, pPropertyCount, pProperties );
|
|
|
2710 }
|
|
|
2711
|
|
|
2712 VkResult vkCreateDisplayModeKHR( VkPhysicalDevice physicalDevice,
|
|
|
2713 VkDisplayKHR display,
|
|
|
2714 const VkDisplayModeCreateInfoKHR * pCreateInfo,
|
|
|
2715 const VkAllocationCallbacks * pAllocator,
|
|
|
2716 VkDisplayModeKHR * pMode ) const VULKAN_HPP_NOEXCEPT
|
|
|
2717 {
|
|
|
2718 return ::vkCreateDisplayModeKHR( physicalDevice, display, pCreateInfo, pAllocator, pMode );
|
|
|
2719 }
|
|
|
2720
|
|
|
2721 VkResult vkGetDisplayPlaneCapabilitiesKHR( VkPhysicalDevice physicalDevice,
|
|
|
2722 VkDisplayModeKHR mode,
|
|
|
2723 uint32_t planeIndex,
|
|
|
2724 VkDisplayPlaneCapabilitiesKHR * pCapabilities ) const VULKAN_HPP_NOEXCEPT
|
|
|
2725 {
|
|
|
2726 return ::vkGetDisplayPlaneCapabilitiesKHR( physicalDevice, mode, planeIndex, pCapabilities );
|
|
|
2727 }
|
|
|
2728
|
|
|
2729 VkResult vkCreateDisplayPlaneSurfaceKHR( VkInstance instance,
|
|
|
2730 const VkDisplaySurfaceCreateInfoKHR * pCreateInfo,
|
|
|
2731 const VkAllocationCallbacks * pAllocator,
|
|
|
2732 VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
|
|
|
2733 {
|
|
|
2734 return ::vkCreateDisplayPlaneSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
|
|
|
2735 }
|
|
|
2736
|
|
|
2737 //=== VK_KHR_display_swapchain ===
|
|
|
2738
|
|
|
2739 VkResult vkCreateSharedSwapchainsKHR( VkDevice device,
|
|
|
2740 uint32_t swapchainCount,
|
|
|
2741 const VkSwapchainCreateInfoKHR * pCreateInfos,
|
|
|
2742 const VkAllocationCallbacks * pAllocator,
|
|
|
2743 VkSwapchainKHR * pSwapchains ) const VULKAN_HPP_NOEXCEPT
|
|
|
2744 {
|
|
|
2745 return ::vkCreateSharedSwapchainsKHR( device, swapchainCount, pCreateInfos, pAllocator, pSwapchains );
|
|
|
2746 }
|
|
|
2747
|
|
|
2748 # if defined( VK_USE_PLATFORM_XLIB_KHR )
|
|
|
2749 //=== VK_KHR_xlib_surface ===
|
|
|
2750
|
|
|
2751 VkResult vkCreateXlibSurfaceKHR( VkInstance instance,
|
|
|
2752 const VkXlibSurfaceCreateInfoKHR * pCreateInfo,
|
|
|
2753 const VkAllocationCallbacks * pAllocator,
|
|
|
2754 VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
|
|
|
2755 {
|
|
|
2756 return ::vkCreateXlibSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
|
|
|
2757 }
|
|
|
2758
|
|
|
2759 VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR( VkPhysicalDevice physicalDevice,
|
|
|
2760 uint32_t queueFamilyIndex,
|
|
|
2761 Display * dpy,
|
|
|
2762 VisualID visualID ) const VULKAN_HPP_NOEXCEPT
|
|
|
2763 {
|
|
|
2764 return ::vkGetPhysicalDeviceXlibPresentationSupportKHR( physicalDevice, queueFamilyIndex, dpy, visualID );
|
|
|
2765 }
|
|
|
2766 # endif /*VK_USE_PLATFORM_XLIB_KHR*/
|
|
|
2767
|
|
|
2768 # if defined( VK_USE_PLATFORM_XCB_KHR )
|
|
|
2769 //=== VK_KHR_xcb_surface ===
|
|
|
2770
|
|
|
2771 VkResult vkCreateXcbSurfaceKHR( VkInstance instance,
|
|
|
2772 const VkXcbSurfaceCreateInfoKHR * pCreateInfo,
|
|
|
2773 const VkAllocationCallbacks * pAllocator,
|
|
|
2774 VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
|
|
|
2775 {
|
|
|
2776 return ::vkCreateXcbSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
|
|
|
2777 }
|
|
|
2778
|
|
|
2779 VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR( VkPhysicalDevice physicalDevice,
|
|
|
2780 uint32_t queueFamilyIndex,
|
|
|
2781 xcb_connection_t * connection,
|
|
|
2782 xcb_visualid_t visual_id ) const VULKAN_HPP_NOEXCEPT
|
|
|
2783 {
|
|
|
2784 return ::vkGetPhysicalDeviceXcbPresentationSupportKHR( physicalDevice, queueFamilyIndex, connection, visual_id );
|
|
|
2785 }
|
|
|
2786 # endif /*VK_USE_PLATFORM_XCB_KHR*/
|
|
|
2787
|
|
|
2788 # if defined( VK_USE_PLATFORM_WAYLAND_KHR )
|
|
|
2789 //=== VK_KHR_wayland_surface ===
|
|
|
2790
|
|
|
2791 VkResult vkCreateWaylandSurfaceKHR( VkInstance instance,
|
|
|
2792 const VkWaylandSurfaceCreateInfoKHR * pCreateInfo,
|
|
|
2793 const VkAllocationCallbacks * pAllocator,
|
|
|
2794 VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
|
|
|
2795 {
|
|
|
2796 return ::vkCreateWaylandSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
|
|
|
2797 }
|
|
|
2798
|
|
|
2799 VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR( VkPhysicalDevice physicalDevice,
|
|
|
2800 uint32_t queueFamilyIndex,
|
|
|
2801 struct wl_display * display ) const VULKAN_HPP_NOEXCEPT
|
|
|
2802 {
|
|
|
2803 return ::vkGetPhysicalDeviceWaylandPresentationSupportKHR( physicalDevice, queueFamilyIndex, display );
|
|
|
2804 }
|
|
|
2805 # endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
|
|
|
2806
|
|
|
2807 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
|
|
2808 //=== VK_KHR_android_surface ===
|
|
|
2809
|
|
|
2810 VkResult vkCreateAndroidSurfaceKHR( VkInstance instance,
|
|
|
2811 const VkAndroidSurfaceCreateInfoKHR * pCreateInfo,
|
|
|
2812 const VkAllocationCallbacks * pAllocator,
|
|
|
2813 VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
|
|
|
2814 {
|
|
|
2815 return ::vkCreateAndroidSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
|
|
|
2816 }
|
|
|
2817 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
|
|
2818
|
|
|
2819 # if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
2820 //=== VK_KHR_win32_surface ===
|
|
|
2821
|
|
|
2822 VkResult vkCreateWin32SurfaceKHR( VkInstance instance,
|
|
|
2823 const VkWin32SurfaceCreateInfoKHR * pCreateInfo,
|
|
|
2824 const VkAllocationCallbacks * pAllocator,
|
|
|
2825 VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
|
|
|
2826 {
|
|
|
2827 return ::vkCreateWin32SurfaceKHR( instance, pCreateInfo, pAllocator, pSurface );
|
|
|
2828 }
|
|
|
2829
|
|
|
2830 VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex ) const VULKAN_HPP_NOEXCEPT
|
|
|
2831 {
|
|
|
2832 return ::vkGetPhysicalDeviceWin32PresentationSupportKHR( physicalDevice, queueFamilyIndex );
|
|
|
2833 }
|
|
|
2834 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
2835
|
|
|
2836 //=== VK_EXT_debug_report ===
|
|
|
2837
|
|
|
2838 VkResult vkCreateDebugReportCallbackEXT( VkInstance instance,
|
|
|
2839 const VkDebugReportCallbackCreateInfoEXT * pCreateInfo,
|
|
|
2840 const VkAllocationCallbacks * pAllocator,
|
|
|
2841 VkDebugReportCallbackEXT * pCallback ) const VULKAN_HPP_NOEXCEPT
|
|
|
2842 {
|
|
|
2843 return ::vkCreateDebugReportCallbackEXT( instance, pCreateInfo, pAllocator, pCallback );
|
|
|
2844 }
|
|
|
2845
|
|
|
2846 void vkDestroyDebugReportCallbackEXT( VkInstance instance,
|
|
|
2847 VkDebugReportCallbackEXT callback,
|
|
|
2848 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
2849 {
|
|
|
2850 return ::vkDestroyDebugReportCallbackEXT( instance, callback, pAllocator );
|
|
|
2851 }
|
|
|
2852
|
|
|
2853 void vkDebugReportMessageEXT( VkInstance instance,
|
|
|
2854 VkDebugReportFlagsEXT flags,
|
|
|
2855 VkDebugReportObjectTypeEXT objectType,
|
|
|
2856 uint64_t object,
|
|
|
2857 size_t location,
|
|
|
2858 int32_t messageCode,
|
|
|
2859 const char * pLayerPrefix,
|
|
|
2860 const char * pMessage ) const VULKAN_HPP_NOEXCEPT
|
|
|
2861 {
|
|
|
2862 return ::vkDebugReportMessageEXT( instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage );
|
|
|
2863 }
|
|
|
2864
|
|
|
2865 //=== VK_EXT_debug_marker ===
|
|
|
2866
|
|
|
2867 VkResult vkDebugMarkerSetObjectTagEXT( VkDevice device, const VkDebugMarkerObjectTagInfoEXT * pTagInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
2868 {
|
|
|
2869 return ::vkDebugMarkerSetObjectTagEXT( device, pTagInfo );
|
|
|
2870 }
|
|
|
2871
|
|
|
2872 VkResult vkDebugMarkerSetObjectNameEXT( VkDevice device, const VkDebugMarkerObjectNameInfoEXT * pNameInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
2873 {
|
|
|
2874 return ::vkDebugMarkerSetObjectNameEXT( device, pNameInfo );
|
|
|
2875 }
|
|
|
2876
|
|
|
2877 void vkCmdDebugMarkerBeginEXT( VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
2878 {
|
|
|
2879 return ::vkCmdDebugMarkerBeginEXT( commandBuffer, pMarkerInfo );
|
|
|
2880 }
|
|
|
2881
|
|
|
2882 void vkCmdDebugMarkerEndEXT( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
|
|
|
2883 {
|
|
|
2884 return ::vkCmdDebugMarkerEndEXT( commandBuffer );
|
|
|
2885 }
|
|
|
2886
|
|
|
2887 void vkCmdDebugMarkerInsertEXT( VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
2888 {
|
|
|
2889 return ::vkCmdDebugMarkerInsertEXT( commandBuffer, pMarkerInfo );
|
|
|
2890 }
|
|
|
2891
|
|
|
2892 //=== VK_KHR_video_queue ===
|
|
|
2893
|
|
|
2894 VkResult vkGetPhysicalDeviceVideoCapabilitiesKHR( VkPhysicalDevice physicalDevice,
|
|
|
2895 const VkVideoProfileInfoKHR * pVideoProfile,
|
|
|
2896 VkVideoCapabilitiesKHR * pCapabilities ) const VULKAN_HPP_NOEXCEPT
|
|
|
2897 {
|
|
|
2898 return ::vkGetPhysicalDeviceVideoCapabilitiesKHR( physicalDevice, pVideoProfile, pCapabilities );
|
|
|
2899 }
|
|
|
2900
|
|
|
2901 VkResult vkGetPhysicalDeviceVideoFormatPropertiesKHR( VkPhysicalDevice physicalDevice,
|
|
|
2902 const VkPhysicalDeviceVideoFormatInfoKHR * pVideoFormatInfo,
|
|
|
2903 uint32_t * pVideoFormatPropertyCount,
|
|
|
2904 VkVideoFormatPropertiesKHR * pVideoFormatProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
2905 {
|
|
|
2906 return ::vkGetPhysicalDeviceVideoFormatPropertiesKHR( physicalDevice, pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties );
|
|
|
2907 }
|
|
|
2908
|
|
|
2909 VkResult vkCreateVideoSessionKHR( VkDevice device,
|
|
|
2910 const VkVideoSessionCreateInfoKHR * pCreateInfo,
|
|
|
2911 const VkAllocationCallbacks * pAllocator,
|
|
|
2912 VkVideoSessionKHR * pVideoSession ) const VULKAN_HPP_NOEXCEPT
|
|
|
2913 {
|
|
|
2914 return ::vkCreateVideoSessionKHR( device, pCreateInfo, pAllocator, pVideoSession );
|
|
|
2915 }
|
|
|
2916
|
|
|
2917 void vkDestroyVideoSessionKHR( VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
2918 {
|
|
|
2919 return ::vkDestroyVideoSessionKHR( device, videoSession, pAllocator );
|
|
|
2920 }
|
|
|
2921
|
|
|
2922 VkResult vkGetVideoSessionMemoryRequirementsKHR( VkDevice device,
|
|
|
2923 VkVideoSessionKHR videoSession,
|
|
|
2924 uint32_t * pMemoryRequirementsCount,
|
|
|
2925 VkVideoSessionMemoryRequirementsKHR * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
|
|
|
2926 {
|
|
|
2927 return ::vkGetVideoSessionMemoryRequirementsKHR( device, videoSession, pMemoryRequirementsCount, pMemoryRequirements );
|
|
|
2928 }
|
|
|
2929
|
|
|
2930 VkResult vkBindVideoSessionMemoryKHR( VkDevice device,
|
|
|
2931 VkVideoSessionKHR videoSession,
|
|
|
2932 uint32_t bindSessionMemoryInfoCount,
|
|
|
2933 const VkBindVideoSessionMemoryInfoKHR * pBindSessionMemoryInfos ) const VULKAN_HPP_NOEXCEPT
|
|
|
2934 {
|
|
|
2935 return ::vkBindVideoSessionMemoryKHR( device, videoSession, bindSessionMemoryInfoCount, pBindSessionMemoryInfos );
|
|
|
2936 }
|
|
|
2937
|
|
|
2938 VkResult vkCreateVideoSessionParametersKHR( VkDevice device,
|
|
|
2939 const VkVideoSessionParametersCreateInfoKHR * pCreateInfo,
|
|
|
2940 const VkAllocationCallbacks * pAllocator,
|
|
|
2941 VkVideoSessionParametersKHR * pVideoSessionParameters ) const VULKAN_HPP_NOEXCEPT
|
|
|
2942 {
|
|
|
2943 return ::vkCreateVideoSessionParametersKHR( device, pCreateInfo, pAllocator, pVideoSessionParameters );
|
|
|
2944 }
|
|
|
2945
|
|
|
2946 VkResult vkUpdateVideoSessionParametersKHR( VkDevice device,
|
|
|
2947 VkVideoSessionParametersKHR videoSessionParameters,
|
|
|
2948 const VkVideoSessionParametersUpdateInfoKHR * pUpdateInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
2949 {
|
|
|
2950 return ::vkUpdateVideoSessionParametersKHR( device, videoSessionParameters, pUpdateInfo );
|
|
|
2951 }
|
|
|
2952
|
|
|
2953 void vkDestroyVideoSessionParametersKHR( VkDevice device,
|
|
|
2954 VkVideoSessionParametersKHR videoSessionParameters,
|
|
|
2955 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
2956 {
|
|
|
2957 return ::vkDestroyVideoSessionParametersKHR( device, videoSessionParameters, pAllocator );
|
|
|
2958 }
|
|
|
2959
|
|
|
2960 void vkCmdBeginVideoCodingKHR( VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR * pBeginInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
2961 {
|
|
|
2962 return ::vkCmdBeginVideoCodingKHR( commandBuffer, pBeginInfo );
|
|
|
2963 }
|
|
|
2964
|
|
|
2965 void vkCmdEndVideoCodingKHR( VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR * pEndCodingInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
2966 {
|
|
|
2967 return ::vkCmdEndVideoCodingKHR( commandBuffer, pEndCodingInfo );
|
|
|
2968 }
|
|
|
2969
|
|
|
2970 void vkCmdControlVideoCodingKHR( VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR * pCodingControlInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
2971 {
|
|
|
2972 return ::vkCmdControlVideoCodingKHR( commandBuffer, pCodingControlInfo );
|
|
|
2973 }
|
|
|
2974
|
|
|
2975 //=== VK_KHR_video_decode_queue ===
|
|
|
2976
|
|
|
2977 void vkCmdDecodeVideoKHR( VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR * pDecodeInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
2978 {
|
|
|
2979 return ::vkCmdDecodeVideoKHR( commandBuffer, pDecodeInfo );
|
|
|
2980 }
|
|
|
2981
|
|
|
2982 //=== VK_EXT_transform_feedback ===
|
|
|
2983
|
|
|
2984 void vkCmdBindTransformFeedbackBuffersEXT( VkCommandBuffer commandBuffer,
|
|
|
2985 uint32_t firstBinding,
|
|
|
2986 uint32_t bindingCount,
|
|
|
2987 const VkBuffer * pBuffers,
|
|
|
2988 const VkDeviceSize * pOffsets,
|
|
|
2989 const VkDeviceSize * pSizes ) const VULKAN_HPP_NOEXCEPT
|
|
|
2990 {
|
|
|
2991 return ::vkCmdBindTransformFeedbackBuffersEXT( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes );
|
|
|
2992 }
|
|
|
2993
|
|
|
2994 void vkCmdBeginTransformFeedbackEXT( VkCommandBuffer commandBuffer,
|
|
|
2995 uint32_t firstCounterBuffer,
|
|
|
2996 uint32_t counterBufferCount,
|
|
|
2997 const VkBuffer * pCounterBuffers,
|
|
|
2998 const VkDeviceSize * pCounterBufferOffsets ) const VULKAN_HPP_NOEXCEPT
|
|
|
2999 {
|
|
|
3000 return ::vkCmdBeginTransformFeedbackEXT( commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets );
|
|
|
3001 }
|
|
|
3002
|
|
|
3003 void vkCmdEndTransformFeedbackEXT( VkCommandBuffer commandBuffer,
|
|
|
3004 uint32_t firstCounterBuffer,
|
|
|
3005 uint32_t counterBufferCount,
|
|
|
3006 const VkBuffer * pCounterBuffers,
|
|
|
3007 const VkDeviceSize * pCounterBufferOffsets ) const VULKAN_HPP_NOEXCEPT
|
|
|
3008 {
|
|
|
3009 return ::vkCmdEndTransformFeedbackEXT( commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets );
|
|
|
3010 }
|
|
|
3011
|
|
|
3012 void vkCmdBeginQueryIndexedEXT( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index ) const
|
|
|
3013 VULKAN_HPP_NOEXCEPT
|
|
|
3014 {
|
|
|
3015 return ::vkCmdBeginQueryIndexedEXT( commandBuffer, queryPool, query, flags, index );
|
|
|
3016 }
|
|
|
3017
|
|
|
3018 void vkCmdEndQueryIndexedEXT( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index ) const VULKAN_HPP_NOEXCEPT
|
|
|
3019 {
|
|
|
3020 return ::vkCmdEndQueryIndexedEXT( commandBuffer, queryPool, query, index );
|
|
|
3021 }
|
|
|
3022
|
|
|
3023 void vkCmdDrawIndirectByteCountEXT( VkCommandBuffer commandBuffer,
|
|
|
3024 uint32_t instanceCount,
|
|
|
3025 uint32_t firstInstance,
|
|
|
3026 VkBuffer counterBuffer,
|
|
|
3027 VkDeviceSize counterBufferOffset,
|
|
|
3028 uint32_t counterOffset,
|
|
|
3029 uint32_t vertexStride ) const VULKAN_HPP_NOEXCEPT
|
|
|
3030 {
|
|
|
3031 return ::vkCmdDrawIndirectByteCountEXT( commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride );
|
|
|
3032 }
|
|
|
3033
|
|
|
3034 //=== VK_NVX_binary_import ===
|
|
|
3035
|
|
|
3036 VkResult vkCreateCuModuleNVX( VkDevice device,
|
|
|
3037 const VkCuModuleCreateInfoNVX * pCreateInfo,
|
|
|
3038 const VkAllocationCallbacks * pAllocator,
|
|
|
3039 VkCuModuleNVX * pModule ) const VULKAN_HPP_NOEXCEPT
|
|
|
3040 {
|
|
|
3041 return ::vkCreateCuModuleNVX( device, pCreateInfo, pAllocator, pModule );
|
|
|
3042 }
|
|
|
3043
|
|
|
3044 VkResult vkCreateCuFunctionNVX( VkDevice device,
|
|
|
3045 const VkCuFunctionCreateInfoNVX * pCreateInfo,
|
|
|
3046 const VkAllocationCallbacks * pAllocator,
|
|
|
3047 VkCuFunctionNVX * pFunction ) const VULKAN_HPP_NOEXCEPT
|
|
|
3048 {
|
|
|
3049 return ::vkCreateCuFunctionNVX( device, pCreateInfo, pAllocator, pFunction );
|
|
|
3050 }
|
|
|
3051
|
|
|
3052 void vkDestroyCuModuleNVX( VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
3053 {
|
|
|
3054 return ::vkDestroyCuModuleNVX( device, module, pAllocator );
|
|
|
3055 }
|
|
|
3056
|
|
|
3057 void vkDestroyCuFunctionNVX( VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
3058 {
|
|
|
3059 return ::vkDestroyCuFunctionNVX( device, function, pAllocator );
|
|
|
3060 }
|
|
|
3061
|
|
|
3062 void vkCmdCuLaunchKernelNVX( VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX * pLaunchInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
3063 {
|
|
|
3064 return ::vkCmdCuLaunchKernelNVX( commandBuffer, pLaunchInfo );
|
|
|
3065 }
|
|
|
3066
|
|
|
3067 //=== VK_NVX_image_view_handle ===
|
|
|
3068
|
|
|
3069 uint32_t vkGetImageViewHandleNVX( VkDevice device, const VkImageViewHandleInfoNVX * pInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
3070 {
|
|
|
3071 return ::vkGetImageViewHandleNVX( device, pInfo );
|
|
|
3072 }
|
|
|
3073
|
|
|
3074 uint64_t vkGetImageViewHandle64NVX( VkDevice device, const VkImageViewHandleInfoNVX * pInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
3075 {
|
|
|
3076 return ::vkGetImageViewHandle64NVX( device, pInfo );
|
|
|
3077 }
|
|
|
3078
|
|
|
3079 VkResult vkGetImageViewAddressNVX( VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX * pProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
3080 {
|
|
|
3081 return ::vkGetImageViewAddressNVX( device, imageView, pProperties );
|
|
|
3082 }
|
|
|
3083
|
|
|
3084 //=== VK_AMD_draw_indirect_count ===
|
|
|
3085
|
|
|
3086 void vkCmdDrawIndirectCountAMD( VkCommandBuffer commandBuffer,
|
|
|
3087 VkBuffer buffer,
|
|
|
3088 VkDeviceSize offset,
|
|
|
3089 VkBuffer countBuffer,
|
|
|
3090 VkDeviceSize countBufferOffset,
|
|
|
3091 uint32_t maxDrawCount,
|
|
|
3092 uint32_t stride ) const VULKAN_HPP_NOEXCEPT
|
|
|
3093 {
|
|
|
3094 return ::vkCmdDrawIndirectCountAMD( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
|
|
|
3095 }
|
|
|
3096
|
|
|
3097 void vkCmdDrawIndexedIndirectCountAMD( VkCommandBuffer commandBuffer,
|
|
|
3098 VkBuffer buffer,
|
|
|
3099 VkDeviceSize offset,
|
|
|
3100 VkBuffer countBuffer,
|
|
|
3101 VkDeviceSize countBufferOffset,
|
|
|
3102 uint32_t maxDrawCount,
|
|
|
3103 uint32_t stride ) const VULKAN_HPP_NOEXCEPT
|
|
|
3104 {
|
|
|
3105 return ::vkCmdDrawIndexedIndirectCountAMD( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
|
|
|
3106 }
|
|
|
3107
|
|
|
3108 //=== VK_AMD_shader_info ===
|
|
|
3109
|
|
|
3110 VkResult vkGetShaderInfoAMD( VkDevice device,
|
|
|
3111 VkPipeline pipeline,
|
|
|
3112 VkShaderStageFlagBits shaderStage,
|
|
|
3113 VkShaderInfoTypeAMD infoType,
|
|
|
3114 size_t * pInfoSize,
|
|
|
3115 void * pInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
3116 {
|
|
|
3117 return ::vkGetShaderInfoAMD( device, pipeline, shaderStage, infoType, pInfoSize, pInfo );
|
|
|
3118 }
|
|
|
3119
|
|
|
3120 //=== VK_KHR_dynamic_rendering ===
|
|
|
3121
|
|
|
3122 void vkCmdBeginRenderingKHR( VkCommandBuffer commandBuffer, const VkRenderingInfo * pRenderingInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
3123 {
|
|
|
3124 return ::vkCmdBeginRenderingKHR( commandBuffer, pRenderingInfo );
|
|
|
3125 }
|
|
|
3126
|
|
|
3127 void vkCmdEndRenderingKHR( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
|
|
|
3128 {
|
|
|
3129 return ::vkCmdEndRenderingKHR( commandBuffer );
|
|
|
3130 }
|
|
|
3131
|
|
|
3132 # if defined( VK_USE_PLATFORM_GGP )
|
|
|
3133 //=== VK_GGP_stream_descriptor_surface ===
|
|
|
3134
|
|
|
3135 VkResult vkCreateStreamDescriptorSurfaceGGP( VkInstance instance,
|
|
|
3136 const VkStreamDescriptorSurfaceCreateInfoGGP * pCreateInfo,
|
|
|
3137 const VkAllocationCallbacks * pAllocator,
|
|
|
3138 VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
|
|
|
3139 {
|
|
|
3140 return ::vkCreateStreamDescriptorSurfaceGGP( instance, pCreateInfo, pAllocator, pSurface );
|
|
|
3141 }
|
|
|
3142 # endif /*VK_USE_PLATFORM_GGP*/
|
|
|
3143
|
|
|
3144 //=== VK_NV_external_memory_capabilities ===
|
|
|
3145
|
|
|
3146 VkResult
|
|
|
3147 vkGetPhysicalDeviceExternalImageFormatPropertiesNV( VkPhysicalDevice physicalDevice,
|
|
|
3148 VkFormat format,
|
|
|
3149 VkImageType type,
|
|
|
3150 VkImageTiling tiling,
|
|
|
3151 VkImageUsageFlags usage,
|
|
|
3152 VkImageCreateFlags flags,
|
|
|
3153 VkExternalMemoryHandleTypeFlagsNV externalHandleType,
|
|
|
3154 VkExternalImageFormatPropertiesNV * pExternalImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
3155 {
|
|
|
3156 return ::vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
|
|
|
3157 physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties );
|
|
|
3158 }
|
|
|
3159
|
|
|
3160 # if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
3161 //=== VK_NV_external_memory_win32 ===
|
|
|
3162
|
|
|
3163 VkResult vkGetMemoryWin32HandleNV( VkDevice device,
|
|
|
3164 VkDeviceMemory memory,
|
|
|
3165 VkExternalMemoryHandleTypeFlagsNV handleType,
|
|
|
3166 HANDLE * pHandle ) const VULKAN_HPP_NOEXCEPT
|
|
|
3167 {
|
|
|
3168 return ::vkGetMemoryWin32HandleNV( device, memory, handleType, pHandle );
|
|
|
3169 }
|
|
|
3170 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
3171
|
|
|
3172 //=== VK_KHR_get_physical_device_properties2 ===
|
|
|
3173
|
|
|
3174 void vkGetPhysicalDeviceFeatures2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 * pFeatures ) const VULKAN_HPP_NOEXCEPT
|
|
|
3175 {
|
|
|
3176 return ::vkGetPhysicalDeviceFeatures2KHR( physicalDevice, pFeatures );
|
|
|
3177 }
|
|
|
3178
|
|
|
3179 void vkGetPhysicalDeviceProperties2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 * pProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
3180 {
|
|
|
3181 return ::vkGetPhysicalDeviceProperties2KHR( physicalDevice, pProperties );
|
|
|
3182 }
|
|
|
3183
|
|
|
3184 void vkGetPhysicalDeviceFormatProperties2KHR( VkPhysicalDevice physicalDevice,
|
|
|
3185 VkFormat format,
|
|
|
3186 VkFormatProperties2 * pFormatProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
3187 {
|
|
|
3188 return ::vkGetPhysicalDeviceFormatProperties2KHR( physicalDevice, format, pFormatProperties );
|
|
|
3189 }
|
|
|
3190
|
|
|
3191 VkResult vkGetPhysicalDeviceImageFormatProperties2KHR( VkPhysicalDevice physicalDevice,
|
|
|
3192 const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo,
|
|
|
3193 VkImageFormatProperties2 * pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
3194 {
|
|
|
3195 return ::vkGetPhysicalDeviceImageFormatProperties2KHR( physicalDevice, pImageFormatInfo, pImageFormatProperties );
|
|
|
3196 }
|
|
|
3197
|
|
|
3198 void vkGetPhysicalDeviceQueueFamilyProperties2KHR( VkPhysicalDevice physicalDevice,
|
|
|
3199 uint32_t * pQueueFamilyPropertyCount,
|
|
|
3200 VkQueueFamilyProperties2 * pQueueFamilyProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
3201 {
|
|
|
3202 return ::vkGetPhysicalDeviceQueueFamilyProperties2KHR( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties );
|
|
|
3203 }
|
|
|
3204
|
|
|
3205 void vkGetPhysicalDeviceMemoryProperties2KHR( VkPhysicalDevice physicalDevice,
|
|
|
3206 VkPhysicalDeviceMemoryProperties2 * pMemoryProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
3207 {
|
|
|
3208 return ::vkGetPhysicalDeviceMemoryProperties2KHR( physicalDevice, pMemoryProperties );
|
|
|
3209 }
|
|
|
3210
|
|
|
3211 void vkGetPhysicalDeviceSparseImageFormatProperties2KHR( VkPhysicalDevice physicalDevice,
|
|
|
3212 const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo,
|
|
|
3213 uint32_t * pPropertyCount,
|
|
|
3214 VkSparseImageFormatProperties2 * pProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
3215 {
|
|
|
3216 return ::vkGetPhysicalDeviceSparseImageFormatProperties2KHR( physicalDevice, pFormatInfo, pPropertyCount, pProperties );
|
|
|
3217 }
|
|
|
3218
|
|
|
3219 //=== VK_KHR_device_group ===
|
|
|
3220
|
|
|
3221 void vkGetDeviceGroupPeerMemoryFeaturesKHR( VkDevice device,
|
|
|
3222 uint32_t heapIndex,
|
|
|
3223 uint32_t localDeviceIndex,
|
|
|
3224 uint32_t remoteDeviceIndex,
|
|
|
3225 VkPeerMemoryFeatureFlags * pPeerMemoryFeatures ) const VULKAN_HPP_NOEXCEPT
|
|
|
3226 {
|
|
|
3227 return ::vkGetDeviceGroupPeerMemoryFeaturesKHR( device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures );
|
|
|
3228 }
|
|
|
3229
|
|
|
3230 void vkCmdSetDeviceMaskKHR( VkCommandBuffer commandBuffer, uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT
|
|
|
3231 {
|
|
|
3232 return ::vkCmdSetDeviceMaskKHR( commandBuffer, deviceMask );
|
|
|
3233 }
|
|
|
3234
|
|
|
3235 void vkCmdDispatchBaseKHR( VkCommandBuffer commandBuffer,
|
|
|
3236 uint32_t baseGroupX,
|
|
|
3237 uint32_t baseGroupY,
|
|
|
3238 uint32_t baseGroupZ,
|
|
|
3239 uint32_t groupCountX,
|
|
|
3240 uint32_t groupCountY,
|
|
|
3241 uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
|
|
|
3242 {
|
|
|
3243 return ::vkCmdDispatchBaseKHR( commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
|
|
|
3244 }
|
|
|
3245
|
|
|
3246 # if defined( VK_USE_PLATFORM_VI_NN )
|
|
|
3247 //=== VK_NN_vi_surface ===
|
|
|
3248
|
|
|
3249 VkResult vkCreateViSurfaceNN( VkInstance instance,
|
|
|
3250 const VkViSurfaceCreateInfoNN * pCreateInfo,
|
|
|
3251 const VkAllocationCallbacks * pAllocator,
|
|
|
3252 VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
|
|
|
3253 {
|
|
|
3254 return ::vkCreateViSurfaceNN( instance, pCreateInfo, pAllocator, pSurface );
|
|
|
3255 }
|
|
|
3256 # endif /*VK_USE_PLATFORM_VI_NN*/
|
|
|
3257
|
|
|
3258 //=== VK_KHR_maintenance1 ===
|
|
|
3259
|
|
|
3260 void vkTrimCommandPoolKHR( VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags ) const VULKAN_HPP_NOEXCEPT
|
|
|
3261 {
|
|
|
3262 return ::vkTrimCommandPoolKHR( device, commandPool, flags );
|
|
|
3263 }
|
|
|
3264
|
|
|
3265 //=== VK_KHR_device_group_creation ===
|
|
|
3266
|
|
|
3267 VkResult vkEnumeratePhysicalDeviceGroupsKHR( VkInstance instance,
|
|
|
3268 uint32_t * pPhysicalDeviceGroupCount,
|
|
|
3269 VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
3270 {
|
|
|
3271 return ::vkEnumeratePhysicalDeviceGroupsKHR( instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties );
|
|
|
3272 }
|
|
|
3273
|
|
|
3274 //=== VK_KHR_external_memory_capabilities ===
|
|
|
3275
|
|
|
3276 void vkGetPhysicalDeviceExternalBufferPropertiesKHR( VkPhysicalDevice physicalDevice,
|
|
|
3277 const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo,
|
|
|
3278 VkExternalBufferProperties * pExternalBufferProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
3279 {
|
|
|
3280 return ::vkGetPhysicalDeviceExternalBufferPropertiesKHR( physicalDevice, pExternalBufferInfo, pExternalBufferProperties );
|
|
|
3281 }
|
|
|
3282
|
|
|
3283 # if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
3284 //=== VK_KHR_external_memory_win32 ===
|
|
|
3285
|
|
|
3286 VkResult
|
|
|
3287 vkGetMemoryWin32HandleKHR( VkDevice device, const VkMemoryGetWin32HandleInfoKHR * pGetWin32HandleInfo, HANDLE * pHandle ) const VULKAN_HPP_NOEXCEPT
|
|
|
3288 {
|
|
|
3289 return ::vkGetMemoryWin32HandleKHR( device, pGetWin32HandleInfo, pHandle );
|
|
|
3290 }
|
|
|
3291
|
|
|
3292 VkResult vkGetMemoryWin32HandlePropertiesKHR( VkDevice device,
|
|
|
3293 VkExternalMemoryHandleTypeFlagBits handleType,
|
|
|
3294 HANDLE handle,
|
|
|
3295 VkMemoryWin32HandlePropertiesKHR * pMemoryWin32HandleProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
3296 {
|
|
|
3297 return ::vkGetMemoryWin32HandlePropertiesKHR( device, handleType, handle, pMemoryWin32HandleProperties );
|
|
|
3298 }
|
|
|
3299 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
3300
|
|
|
3301 //=== VK_KHR_external_memory_fd ===
|
|
|
3302
|
|
|
3303 VkResult vkGetMemoryFdKHR( VkDevice device, const VkMemoryGetFdInfoKHR * pGetFdInfo, int * pFd ) const VULKAN_HPP_NOEXCEPT
|
|
|
3304 {
|
|
|
3305 return ::vkGetMemoryFdKHR( device, pGetFdInfo, pFd );
|
|
|
3306 }
|
|
|
3307
|
|
|
3308 VkResult vkGetMemoryFdPropertiesKHR( VkDevice device,
|
|
|
3309 VkExternalMemoryHandleTypeFlagBits handleType,
|
|
|
3310 int fd,
|
|
|
3311 VkMemoryFdPropertiesKHR * pMemoryFdProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
3312 {
|
|
|
3313 return ::vkGetMemoryFdPropertiesKHR( device, handleType, fd, pMemoryFdProperties );
|
|
|
3314 }
|
|
|
3315
|
|
|
3316 //=== VK_KHR_external_semaphore_capabilities ===
|
|
|
3317
|
|
|
3318 void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( VkPhysicalDevice physicalDevice,
|
|
|
3319 const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo,
|
|
|
3320 VkExternalSemaphoreProperties * pExternalSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
3321 {
|
|
|
3322 return ::vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties );
|
|
|
3323 }
|
|
|
3324
|
|
|
3325 # if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
3326 //=== VK_KHR_external_semaphore_win32 ===
|
|
|
3327
|
|
|
3328 VkResult vkImportSemaphoreWin32HandleKHR( VkDevice device,
|
|
|
3329 const VkImportSemaphoreWin32HandleInfoKHR * pImportSemaphoreWin32HandleInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
3330 {
|
|
|
3331 return ::vkImportSemaphoreWin32HandleKHR( device, pImportSemaphoreWin32HandleInfo );
|
|
|
3332 }
|
|
|
3333
|
|
|
3334 VkResult vkGetSemaphoreWin32HandleKHR( VkDevice device,
|
|
|
3335 const VkSemaphoreGetWin32HandleInfoKHR * pGetWin32HandleInfo,
|
|
|
3336 HANDLE * pHandle ) const VULKAN_HPP_NOEXCEPT
|
|
|
3337 {
|
|
|
3338 return ::vkGetSemaphoreWin32HandleKHR( device, pGetWin32HandleInfo, pHandle );
|
|
|
3339 }
|
|
|
3340 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
3341
|
|
|
3342 //=== VK_KHR_external_semaphore_fd ===
|
|
|
3343
|
|
|
3344 VkResult vkImportSemaphoreFdKHR( VkDevice device, const VkImportSemaphoreFdInfoKHR * pImportSemaphoreFdInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
3345 {
|
|
|
3346 return ::vkImportSemaphoreFdKHR( device, pImportSemaphoreFdInfo );
|
|
|
3347 }
|
|
|
3348
|
|
|
3349 VkResult vkGetSemaphoreFdKHR( VkDevice device, const VkSemaphoreGetFdInfoKHR * pGetFdInfo, int * pFd ) const VULKAN_HPP_NOEXCEPT
|
|
|
3350 {
|
|
|
3351 return ::vkGetSemaphoreFdKHR( device, pGetFdInfo, pFd );
|
|
|
3352 }
|
|
|
3353
|
|
|
3354 //=== VK_KHR_push_descriptor ===
|
|
|
3355
|
|
|
3356 void vkCmdPushDescriptorSetKHR( VkCommandBuffer commandBuffer,
|
|
|
3357 VkPipelineBindPoint pipelineBindPoint,
|
|
|
3358 VkPipelineLayout layout,
|
|
|
3359 uint32_t set,
|
|
|
3360 uint32_t descriptorWriteCount,
|
|
|
3361 const VkWriteDescriptorSet * pDescriptorWrites ) const VULKAN_HPP_NOEXCEPT
|
|
|
3362 {
|
|
|
3363 return ::vkCmdPushDescriptorSetKHR( commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites );
|
|
|
3364 }
|
|
|
3365
|
|
|
3366 void vkCmdPushDescriptorSetWithTemplateKHR( VkCommandBuffer commandBuffer,
|
|
|
3367 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
|
|
|
3368 VkPipelineLayout layout,
|
|
|
3369 uint32_t set,
|
|
|
3370 const void * pData ) const VULKAN_HPP_NOEXCEPT
|
|
|
3371 {
|
|
|
3372 return ::vkCmdPushDescriptorSetWithTemplateKHR( commandBuffer, descriptorUpdateTemplate, layout, set, pData );
|
|
|
3373 }
|
|
|
3374
|
|
|
3375 //=== VK_EXT_conditional_rendering ===
|
|
|
3376
|
|
|
3377 void vkCmdBeginConditionalRenderingEXT( VkCommandBuffer commandBuffer,
|
|
|
3378 const VkConditionalRenderingBeginInfoEXT * pConditionalRenderingBegin ) const VULKAN_HPP_NOEXCEPT
|
|
|
3379 {
|
|
|
3380 return ::vkCmdBeginConditionalRenderingEXT( commandBuffer, pConditionalRenderingBegin );
|
|
|
3381 }
|
|
|
3382
|
|
|
3383 void vkCmdEndConditionalRenderingEXT( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
|
|
|
3384 {
|
|
|
3385 return ::vkCmdEndConditionalRenderingEXT( commandBuffer );
|
|
|
3386 }
|
|
|
3387
|
|
|
3388 //=== VK_KHR_descriptor_update_template ===
|
|
|
3389
|
|
|
3390 VkResult vkCreateDescriptorUpdateTemplateKHR( VkDevice device,
|
|
|
3391 const VkDescriptorUpdateTemplateCreateInfo * pCreateInfo,
|
|
|
3392 const VkAllocationCallbacks * pAllocator,
|
|
|
3393 VkDescriptorUpdateTemplate * pDescriptorUpdateTemplate ) const VULKAN_HPP_NOEXCEPT
|
|
|
3394 {
|
|
|
3395 return ::vkCreateDescriptorUpdateTemplateKHR( device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate );
|
|
|
3396 }
|
|
|
3397
|
|
|
3398 void vkDestroyDescriptorUpdateTemplateKHR( VkDevice device,
|
|
|
3399 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
|
|
|
3400 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
3401 {
|
|
|
3402 return ::vkDestroyDescriptorUpdateTemplateKHR( device, descriptorUpdateTemplate, pAllocator );
|
|
|
3403 }
|
|
|
3404
|
|
|
3405 void vkUpdateDescriptorSetWithTemplateKHR( VkDevice device,
|
|
|
3406 VkDescriptorSet descriptorSet,
|
|
|
3407 VkDescriptorUpdateTemplate descriptorUpdateTemplate,
|
|
|
3408 const void * pData ) const VULKAN_HPP_NOEXCEPT
|
|
|
3409 {
|
|
|
3410 return ::vkUpdateDescriptorSetWithTemplateKHR( device, descriptorSet, descriptorUpdateTemplate, pData );
|
|
|
3411 }
|
|
|
3412
|
|
|
3413 //=== VK_NV_clip_space_w_scaling ===
|
|
|
3414
|
|
|
3415 void vkCmdSetViewportWScalingNV( VkCommandBuffer commandBuffer,
|
|
|
3416 uint32_t firstViewport,
|
|
|
3417 uint32_t viewportCount,
|
|
|
3418 const VkViewportWScalingNV * pViewportWScalings ) const VULKAN_HPP_NOEXCEPT
|
|
|
3419 {
|
|
|
3420 return ::vkCmdSetViewportWScalingNV( commandBuffer, firstViewport, viewportCount, pViewportWScalings );
|
|
|
3421 }
|
|
|
3422
|
|
|
3423 //=== VK_EXT_direct_mode_display ===
|
|
|
3424
|
|
|
3425 VkResult vkReleaseDisplayEXT( VkPhysicalDevice physicalDevice, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT
|
|
|
3426 {
|
|
|
3427 return ::vkReleaseDisplayEXT( physicalDevice, display );
|
|
|
3428 }
|
|
|
3429
|
|
|
3430 # if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
|
|
|
3431 //=== VK_EXT_acquire_xlib_display ===
|
|
|
3432
|
|
|
3433 VkResult vkAcquireXlibDisplayEXT( VkPhysicalDevice physicalDevice, Display * dpy, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT
|
|
|
3434 {
|
|
|
3435 return ::vkAcquireXlibDisplayEXT( physicalDevice, dpy, display );
|
|
|
3436 }
|
|
|
3437
|
|
|
3438 VkResult
|
|
|
3439 vkGetRandROutputDisplayEXT( VkPhysicalDevice physicalDevice, Display * dpy, RROutput rrOutput, VkDisplayKHR * pDisplay ) const VULKAN_HPP_NOEXCEPT
|
|
|
3440 {
|
|
|
3441 return ::vkGetRandROutputDisplayEXT( physicalDevice, dpy, rrOutput, pDisplay );
|
|
|
3442 }
|
|
|
3443 # endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
|
|
|
3444
|
|
|
3445 //=== VK_EXT_display_surface_counter ===
|
|
|
3446
|
|
|
3447 VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT( VkPhysicalDevice physicalDevice,
|
|
|
3448 VkSurfaceKHR surface,
|
|
|
3449 VkSurfaceCapabilities2EXT * pSurfaceCapabilities ) const VULKAN_HPP_NOEXCEPT
|
|
|
3450 {
|
|
|
3451 return ::vkGetPhysicalDeviceSurfaceCapabilities2EXT( physicalDevice, surface, pSurfaceCapabilities );
|
|
|
3452 }
|
|
|
3453
|
|
|
3454 //=== VK_EXT_display_control ===
|
|
|
3455
|
|
|
3456 VkResult vkDisplayPowerControlEXT( VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT * pDisplayPowerInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
3457 {
|
|
|
3458 return ::vkDisplayPowerControlEXT( device, display, pDisplayPowerInfo );
|
|
|
3459 }
|
|
|
3460
|
|
|
3461 VkResult vkRegisterDeviceEventEXT( VkDevice device,
|
|
|
3462 const VkDeviceEventInfoEXT * pDeviceEventInfo,
|
|
|
3463 const VkAllocationCallbacks * pAllocator,
|
|
|
3464 VkFence * pFence ) const VULKAN_HPP_NOEXCEPT
|
|
|
3465 {
|
|
|
3466 return ::vkRegisterDeviceEventEXT( device, pDeviceEventInfo, pAllocator, pFence );
|
|
|
3467 }
|
|
|
3468
|
|
|
3469 VkResult vkRegisterDisplayEventEXT( VkDevice device,
|
|
|
3470 VkDisplayKHR display,
|
|
|
3471 const VkDisplayEventInfoEXT * pDisplayEventInfo,
|
|
|
3472 const VkAllocationCallbacks * pAllocator,
|
|
|
3473 VkFence * pFence ) const VULKAN_HPP_NOEXCEPT
|
|
|
3474 {
|
|
|
3475 return ::vkRegisterDisplayEventEXT( device, display, pDisplayEventInfo, pAllocator, pFence );
|
|
|
3476 }
|
|
|
3477
|
|
|
3478 VkResult vkGetSwapchainCounterEXT( VkDevice device,
|
|
|
3479 VkSwapchainKHR swapchain,
|
|
|
3480 VkSurfaceCounterFlagBitsEXT counter,
|
|
|
3481 uint64_t * pCounterValue ) const VULKAN_HPP_NOEXCEPT
|
|
|
3482 {
|
|
|
3483 return ::vkGetSwapchainCounterEXT( device, swapchain, counter, pCounterValue );
|
|
|
3484 }
|
|
|
3485
|
|
|
3486 //=== VK_GOOGLE_display_timing ===
|
|
|
3487
|
|
|
3488 VkResult vkGetRefreshCycleDurationGOOGLE( VkDevice device,
|
|
|
3489 VkSwapchainKHR swapchain,
|
|
|
3490 VkRefreshCycleDurationGOOGLE * pDisplayTimingProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
3491 {
|
|
|
3492 return ::vkGetRefreshCycleDurationGOOGLE( device, swapchain, pDisplayTimingProperties );
|
|
|
3493 }
|
|
|
3494
|
|
|
3495 VkResult vkGetPastPresentationTimingGOOGLE( VkDevice device,
|
|
|
3496 VkSwapchainKHR swapchain,
|
|
|
3497 uint32_t * pPresentationTimingCount,
|
|
|
3498 VkPastPresentationTimingGOOGLE * pPresentationTimings ) const VULKAN_HPP_NOEXCEPT
|
|
|
3499 {
|
|
|
3500 return ::vkGetPastPresentationTimingGOOGLE( device, swapchain, pPresentationTimingCount, pPresentationTimings );
|
|
|
3501 }
|
|
|
3502
|
|
|
3503 //=== VK_EXT_discard_rectangles ===
|
|
|
3504
|
|
|
3505 void vkCmdSetDiscardRectangleEXT( VkCommandBuffer commandBuffer,
|
|
|
3506 uint32_t firstDiscardRectangle,
|
|
|
3507 uint32_t discardRectangleCount,
|
|
|
3508 const VkRect2D * pDiscardRectangles ) const VULKAN_HPP_NOEXCEPT
|
|
|
3509 {
|
|
|
3510 return ::vkCmdSetDiscardRectangleEXT( commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles );
|
|
|
3511 }
|
|
|
3512
|
|
|
3513 void vkCmdSetDiscardRectangleEnableEXT( VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable ) const VULKAN_HPP_NOEXCEPT
|
|
|
3514 {
|
|
|
3515 return ::vkCmdSetDiscardRectangleEnableEXT( commandBuffer, discardRectangleEnable );
|
|
|
3516 }
|
|
|
3517
|
|
|
3518 void vkCmdSetDiscardRectangleModeEXT( VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode ) const VULKAN_HPP_NOEXCEPT
|
|
|
3519 {
|
|
|
3520 return ::vkCmdSetDiscardRectangleModeEXT( commandBuffer, discardRectangleMode );
|
|
|
3521 }
|
|
|
3522
|
|
|
3523 //=== VK_EXT_hdr_metadata ===
|
|
|
3524
|
|
|
3525 void vkSetHdrMetadataEXT( VkDevice device,
|
|
|
3526 uint32_t swapchainCount,
|
|
|
3527 const VkSwapchainKHR * pSwapchains,
|
|
|
3528 const VkHdrMetadataEXT * pMetadata ) const VULKAN_HPP_NOEXCEPT
|
|
|
3529 {
|
|
|
3530 return ::vkSetHdrMetadataEXT( device, swapchainCount, pSwapchains, pMetadata );
|
|
|
3531 }
|
|
|
3532
|
|
|
3533 //=== VK_KHR_create_renderpass2 ===
|
|
|
3534
|
|
|
3535 VkResult vkCreateRenderPass2KHR( VkDevice device,
|
|
|
3536 const VkRenderPassCreateInfo2 * pCreateInfo,
|
|
|
3537 const VkAllocationCallbacks * pAllocator,
|
|
|
3538 VkRenderPass * pRenderPass ) const VULKAN_HPP_NOEXCEPT
|
|
|
3539 {
|
|
|
3540 return ::vkCreateRenderPass2KHR( device, pCreateInfo, pAllocator, pRenderPass );
|
|
|
3541 }
|
|
|
3542
|
|
|
3543 void vkCmdBeginRenderPass2KHR( VkCommandBuffer commandBuffer,
|
|
|
3544 const VkRenderPassBeginInfo * pRenderPassBegin,
|
|
|
3545 const VkSubpassBeginInfo * pSubpassBeginInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
3546 {
|
|
|
3547 return ::vkCmdBeginRenderPass2KHR( commandBuffer, pRenderPassBegin, pSubpassBeginInfo );
|
|
|
3548 }
|
|
|
3549
|
|
|
3550 void vkCmdNextSubpass2KHR( VkCommandBuffer commandBuffer,
|
|
|
3551 const VkSubpassBeginInfo * pSubpassBeginInfo,
|
|
|
3552 const VkSubpassEndInfo * pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
3553 {
|
|
|
3554 return ::vkCmdNextSubpass2KHR( commandBuffer, pSubpassBeginInfo, pSubpassEndInfo );
|
|
|
3555 }
|
|
|
3556
|
|
|
3557 void vkCmdEndRenderPass2KHR( VkCommandBuffer commandBuffer, const VkSubpassEndInfo * pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
3558 {
|
|
|
3559 return ::vkCmdEndRenderPass2KHR( commandBuffer, pSubpassEndInfo );
|
|
|
3560 }
|
|
|
3561
|
|
|
3562 //=== VK_KHR_shared_presentable_image ===
|
|
|
3563
|
|
|
3564 VkResult vkGetSwapchainStatusKHR( VkDevice device, VkSwapchainKHR swapchain ) const VULKAN_HPP_NOEXCEPT
|
|
|
3565 {
|
|
|
3566 return ::vkGetSwapchainStatusKHR( device, swapchain );
|
|
|
3567 }
|
|
|
3568
|
|
|
3569 //=== VK_KHR_external_fence_capabilities ===
|
|
|
3570
|
|
|
3571 void vkGetPhysicalDeviceExternalFencePropertiesKHR( VkPhysicalDevice physicalDevice,
|
|
|
3572 const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo,
|
|
|
3573 VkExternalFenceProperties * pExternalFenceProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
3574 {
|
|
|
3575 return ::vkGetPhysicalDeviceExternalFencePropertiesKHR( physicalDevice, pExternalFenceInfo, pExternalFenceProperties );
|
|
|
3576 }
|
|
|
3577
|
|
|
3578 # if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
3579 //=== VK_KHR_external_fence_win32 ===
|
|
|
3580
|
|
|
3581 VkResult vkImportFenceWin32HandleKHR( VkDevice device, const VkImportFenceWin32HandleInfoKHR * pImportFenceWin32HandleInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
3582 {
|
|
|
3583 return ::vkImportFenceWin32HandleKHR( device, pImportFenceWin32HandleInfo );
|
|
|
3584 }
|
|
|
3585
|
|
|
3586 VkResult vkGetFenceWin32HandleKHR( VkDevice device, const VkFenceGetWin32HandleInfoKHR * pGetWin32HandleInfo, HANDLE * pHandle ) const VULKAN_HPP_NOEXCEPT
|
|
|
3587 {
|
|
|
3588 return ::vkGetFenceWin32HandleKHR( device, pGetWin32HandleInfo, pHandle );
|
|
|
3589 }
|
|
|
3590 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
3591
|
|
|
3592 //=== VK_KHR_external_fence_fd ===
|
|
|
3593
|
|
|
3594 VkResult vkImportFenceFdKHR( VkDevice device, const VkImportFenceFdInfoKHR * pImportFenceFdInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
3595 {
|
|
|
3596 return ::vkImportFenceFdKHR( device, pImportFenceFdInfo );
|
|
|
3597 }
|
|
|
3598
|
|
|
3599 VkResult vkGetFenceFdKHR( VkDevice device, const VkFenceGetFdInfoKHR * pGetFdInfo, int * pFd ) const VULKAN_HPP_NOEXCEPT
|
|
|
3600 {
|
|
|
3601 return ::vkGetFenceFdKHR( device, pGetFdInfo, pFd );
|
|
|
3602 }
|
|
|
3603
|
|
|
3604 //=== VK_KHR_performance_query ===
|
|
|
3605
|
|
|
3606 VkResult
|
|
|
3607 vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( VkPhysicalDevice physicalDevice,
|
|
|
3608 uint32_t queueFamilyIndex,
|
|
|
3609 uint32_t * pCounterCount,
|
|
|
3610 VkPerformanceCounterKHR * pCounters,
|
|
|
3611 VkPerformanceCounterDescriptionKHR * pCounterDescriptions ) const VULKAN_HPP_NOEXCEPT
|
|
|
3612 {
|
|
|
3613 return ::vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
|
|
|
3614 physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions );
|
|
|
3615 }
|
|
|
3616
|
|
|
3617 void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( VkPhysicalDevice physicalDevice,
|
|
|
3618 const VkQueryPoolPerformanceCreateInfoKHR * pPerformanceQueryCreateInfo,
|
|
|
3619 uint32_t * pNumPasses ) const VULKAN_HPP_NOEXCEPT
|
|
|
3620 {
|
|
|
3621 return ::vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( physicalDevice, pPerformanceQueryCreateInfo, pNumPasses );
|
|
|
3622 }
|
|
|
3623
|
|
|
3624 VkResult vkAcquireProfilingLockKHR( VkDevice device, const VkAcquireProfilingLockInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
3625 {
|
|
|
3626 return ::vkAcquireProfilingLockKHR( device, pInfo );
|
|
|
3627 }
|
|
|
3628
|
|
|
3629 void vkReleaseProfilingLockKHR( VkDevice device ) const VULKAN_HPP_NOEXCEPT
|
|
|
3630 {
|
|
|
3631 return ::vkReleaseProfilingLockKHR( device );
|
|
|
3632 }
|
|
|
3633
|
|
|
3634 //=== VK_KHR_get_surface_capabilities2 ===
|
|
|
3635
|
|
|
3636 VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR( VkPhysicalDevice physicalDevice,
|
|
|
3637 const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
|
|
|
3638 VkSurfaceCapabilities2KHR * pSurfaceCapabilities ) const VULKAN_HPP_NOEXCEPT
|
|
|
3639 {
|
|
|
3640 return ::vkGetPhysicalDeviceSurfaceCapabilities2KHR( physicalDevice, pSurfaceInfo, pSurfaceCapabilities );
|
|
|
3641 }
|
|
|
3642
|
|
|
3643 VkResult vkGetPhysicalDeviceSurfaceFormats2KHR( VkPhysicalDevice physicalDevice,
|
|
|
3644 const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
|
|
|
3645 uint32_t * pSurfaceFormatCount,
|
|
|
3646 VkSurfaceFormat2KHR * pSurfaceFormats ) const VULKAN_HPP_NOEXCEPT
|
|
|
3647 {
|
|
|
3648 return ::vkGetPhysicalDeviceSurfaceFormats2KHR( physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats );
|
|
|
3649 }
|
|
|
3650
|
|
|
3651 //=== VK_KHR_get_display_properties2 ===
|
|
|
3652
|
|
|
3653 VkResult vkGetPhysicalDeviceDisplayProperties2KHR( VkPhysicalDevice physicalDevice,
|
|
|
3654 uint32_t * pPropertyCount,
|
|
|
3655 VkDisplayProperties2KHR * pProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
3656 {
|
|
|
3657 return ::vkGetPhysicalDeviceDisplayProperties2KHR( physicalDevice, pPropertyCount, pProperties );
|
|
|
3658 }
|
|
|
3659
|
|
|
3660 VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR( VkPhysicalDevice physicalDevice,
|
|
|
3661 uint32_t * pPropertyCount,
|
|
|
3662 VkDisplayPlaneProperties2KHR * pProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
3663 {
|
|
|
3664 return ::vkGetPhysicalDeviceDisplayPlaneProperties2KHR( physicalDevice, pPropertyCount, pProperties );
|
|
|
3665 }
|
|
|
3666
|
|
|
3667 VkResult vkGetDisplayModeProperties2KHR( VkPhysicalDevice physicalDevice,
|
|
|
3668 VkDisplayKHR display,
|
|
|
3669 uint32_t * pPropertyCount,
|
|
|
3670 VkDisplayModeProperties2KHR * pProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
3671 {
|
|
|
3672 return ::vkGetDisplayModeProperties2KHR( physicalDevice, display, pPropertyCount, pProperties );
|
|
|
3673 }
|
|
|
3674
|
|
|
3675 VkResult vkGetDisplayPlaneCapabilities2KHR( VkPhysicalDevice physicalDevice,
|
|
|
3676 const VkDisplayPlaneInfo2KHR * pDisplayPlaneInfo,
|
|
|
3677 VkDisplayPlaneCapabilities2KHR * pCapabilities ) const VULKAN_HPP_NOEXCEPT
|
|
|
3678 {
|
|
|
3679 return ::vkGetDisplayPlaneCapabilities2KHR( physicalDevice, pDisplayPlaneInfo, pCapabilities );
|
|
|
3680 }
|
|
|
3681
|
|
|
3682 # if defined( VK_USE_PLATFORM_IOS_MVK )
|
|
|
3683 //=== VK_MVK_ios_surface ===
|
|
|
3684
|
|
|
3685 VkResult vkCreateIOSSurfaceMVK( VkInstance instance,
|
|
|
3686 const VkIOSSurfaceCreateInfoMVK * pCreateInfo,
|
|
|
3687 const VkAllocationCallbacks * pAllocator,
|
|
|
3688 VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
|
|
|
3689 {
|
|
|
3690 return ::vkCreateIOSSurfaceMVK( instance, pCreateInfo, pAllocator, pSurface );
|
|
|
3691 }
|
|
|
3692 # endif /*VK_USE_PLATFORM_IOS_MVK*/
|
|
|
3693
|
|
|
3694 # if defined( VK_USE_PLATFORM_MACOS_MVK )
|
|
|
3695 //=== VK_MVK_macos_surface ===
|
|
|
3696
|
|
|
3697 VkResult vkCreateMacOSSurfaceMVK( VkInstance instance,
|
|
|
3698 const VkMacOSSurfaceCreateInfoMVK * pCreateInfo,
|
|
|
3699 const VkAllocationCallbacks * pAllocator,
|
|
|
3700 VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
|
|
|
3701 {
|
|
|
3702 return ::vkCreateMacOSSurfaceMVK( instance, pCreateInfo, pAllocator, pSurface );
|
|
|
3703 }
|
|
|
3704 # endif /*VK_USE_PLATFORM_MACOS_MVK*/
|
|
|
3705
|
|
|
3706 //=== VK_EXT_debug_utils ===
|
|
|
3707
|
|
|
3708 VkResult vkSetDebugUtilsObjectNameEXT( VkDevice device, const VkDebugUtilsObjectNameInfoEXT * pNameInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
3709 {
|
|
|
3710 return ::vkSetDebugUtilsObjectNameEXT( device, pNameInfo );
|
|
|
3711 }
|
|
|
3712
|
|
|
3713 VkResult vkSetDebugUtilsObjectTagEXT( VkDevice device, const VkDebugUtilsObjectTagInfoEXT * pTagInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
3714 {
|
|
|
3715 return ::vkSetDebugUtilsObjectTagEXT( device, pTagInfo );
|
|
|
3716 }
|
|
|
3717
|
|
|
3718 void vkQueueBeginDebugUtilsLabelEXT( VkQueue queue, const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
3719 {
|
|
|
3720 return ::vkQueueBeginDebugUtilsLabelEXT( queue, pLabelInfo );
|
|
|
3721 }
|
|
|
3722
|
|
|
3723 void vkQueueEndDebugUtilsLabelEXT( VkQueue queue ) const VULKAN_HPP_NOEXCEPT
|
|
|
3724 {
|
|
|
3725 return ::vkQueueEndDebugUtilsLabelEXT( queue );
|
|
|
3726 }
|
|
|
3727
|
|
|
3728 void vkQueueInsertDebugUtilsLabelEXT( VkQueue queue, const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
3729 {
|
|
|
3730 return ::vkQueueInsertDebugUtilsLabelEXT( queue, pLabelInfo );
|
|
|
3731 }
|
|
|
3732
|
|
|
3733 void vkCmdBeginDebugUtilsLabelEXT( VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
3734 {
|
|
|
3735 return ::vkCmdBeginDebugUtilsLabelEXT( commandBuffer, pLabelInfo );
|
|
|
3736 }
|
|
|
3737
|
|
|
3738 void vkCmdEndDebugUtilsLabelEXT( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
|
|
|
3739 {
|
|
|
3740 return ::vkCmdEndDebugUtilsLabelEXT( commandBuffer );
|
|
|
3741 }
|
|
|
3742
|
|
|
3743 void vkCmdInsertDebugUtilsLabelEXT( VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
3744 {
|
|
|
3745 return ::vkCmdInsertDebugUtilsLabelEXT( commandBuffer, pLabelInfo );
|
|
|
3746 }
|
|
|
3747
|
|
|
3748 VkResult vkCreateDebugUtilsMessengerEXT( VkInstance instance,
|
|
|
3749 const VkDebugUtilsMessengerCreateInfoEXT * pCreateInfo,
|
|
|
3750 const VkAllocationCallbacks * pAllocator,
|
|
|
3751 VkDebugUtilsMessengerEXT * pMessenger ) const VULKAN_HPP_NOEXCEPT
|
|
|
3752 {
|
|
|
3753 return ::vkCreateDebugUtilsMessengerEXT( instance, pCreateInfo, pAllocator, pMessenger );
|
|
|
3754 }
|
|
|
3755
|
|
|
3756 void vkDestroyDebugUtilsMessengerEXT( VkInstance instance,
|
|
|
3757 VkDebugUtilsMessengerEXT messenger,
|
|
|
3758 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
3759 {
|
|
|
3760 return ::vkDestroyDebugUtilsMessengerEXT( instance, messenger, pAllocator );
|
|
|
3761 }
|
|
|
3762
|
|
|
3763 void vkSubmitDebugUtilsMessageEXT( VkInstance instance,
|
|
|
3764 VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
|
|
|
3765 VkDebugUtilsMessageTypeFlagsEXT messageTypes,
|
|
|
3766 const VkDebugUtilsMessengerCallbackDataEXT * pCallbackData ) const VULKAN_HPP_NOEXCEPT
|
|
|
3767 {
|
|
|
3768 return ::vkSubmitDebugUtilsMessageEXT( instance, messageSeverity, messageTypes, pCallbackData );
|
|
|
3769 }
|
|
|
3770
|
|
|
3771 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
|
|
3772 //=== VK_ANDROID_external_memory_android_hardware_buffer ===
|
|
|
3773
|
|
|
3774 VkResult vkGetAndroidHardwareBufferPropertiesANDROID( VkDevice device,
|
|
|
3775 const struct AHardwareBuffer * buffer,
|
|
|
3776 VkAndroidHardwareBufferPropertiesANDROID * pProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
3777 {
|
|
|
3778 return ::vkGetAndroidHardwareBufferPropertiesANDROID( device, buffer, pProperties );
|
|
|
3779 }
|
|
|
3780
|
|
|
3781 VkResult vkGetMemoryAndroidHardwareBufferANDROID( VkDevice device,
|
|
|
3782 const VkMemoryGetAndroidHardwareBufferInfoANDROID * pInfo,
|
|
|
3783 struct AHardwareBuffer ** pBuffer ) const VULKAN_HPP_NOEXCEPT
|
|
|
3784 {
|
|
|
3785 return ::vkGetMemoryAndroidHardwareBufferANDROID( device, pInfo, pBuffer );
|
|
|
3786 }
|
|
|
3787 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
|
|
3788
|
|
|
3789 # if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
3790 //=== VK_AMDX_shader_enqueue ===
|
|
|
3791
|
|
|
3792 VkResult vkCreateExecutionGraphPipelinesAMDX( VkDevice device,
|
|
|
3793 VkPipelineCache pipelineCache,
|
|
|
3794 uint32_t createInfoCount,
|
|
|
3795 const VkExecutionGraphPipelineCreateInfoAMDX * pCreateInfos,
|
|
|
3796 const VkAllocationCallbacks * pAllocator,
|
|
|
3797 VkPipeline * pPipelines ) const VULKAN_HPP_NOEXCEPT
|
|
|
3798 {
|
|
|
3799 return ::vkCreateExecutionGraphPipelinesAMDX( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
|
|
|
3800 }
|
|
|
3801
|
|
|
3802 VkResult vkGetExecutionGraphPipelineScratchSizeAMDX( VkDevice device,
|
|
|
3803 VkPipeline executionGraph,
|
|
|
3804 VkExecutionGraphPipelineScratchSizeAMDX * pSizeInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
3805 {
|
|
|
3806 return ::vkGetExecutionGraphPipelineScratchSizeAMDX( device, executionGraph, pSizeInfo );
|
|
|
3807 }
|
|
|
3808
|
|
|
3809 VkResult vkGetExecutionGraphPipelineNodeIndexAMDX( VkDevice device,
|
|
|
3810 VkPipeline executionGraph,
|
|
|
3811 const VkPipelineShaderStageNodeCreateInfoAMDX * pNodeInfo,
|
|
|
3812 uint32_t * pNodeIndex ) const VULKAN_HPP_NOEXCEPT
|
|
|
3813 {
|
|
|
3814 return ::vkGetExecutionGraphPipelineNodeIndexAMDX( device, executionGraph, pNodeInfo, pNodeIndex );
|
|
|
3815 }
|
|
|
3816
|
|
|
3817 void vkCmdInitializeGraphScratchMemoryAMDX( VkCommandBuffer commandBuffer,
|
|
|
3818 VkPipeline executionGraph,
|
|
|
3819 VkDeviceAddress scratch,
|
|
|
3820 VkDeviceSize scratchSize ) const VULKAN_HPP_NOEXCEPT
|
|
|
3821 {
|
|
|
3822 return ::vkCmdInitializeGraphScratchMemoryAMDX( commandBuffer, executionGraph, scratch, scratchSize );
|
|
|
3823 }
|
|
|
3824
|
|
|
3825 void vkCmdDispatchGraphAMDX( VkCommandBuffer commandBuffer,
|
|
|
3826 VkDeviceAddress scratch,
|
|
|
3827 VkDeviceSize scratchSize,
|
|
|
3828 const VkDispatchGraphCountInfoAMDX * pCountInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
3829 {
|
|
|
3830 return ::vkCmdDispatchGraphAMDX( commandBuffer, scratch, scratchSize, pCountInfo );
|
|
|
3831 }
|
|
|
3832
|
|
|
3833 void vkCmdDispatchGraphIndirectAMDX( VkCommandBuffer commandBuffer,
|
|
|
3834 VkDeviceAddress scratch,
|
|
|
3835 VkDeviceSize scratchSize,
|
|
|
3836 const VkDispatchGraphCountInfoAMDX * pCountInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
3837 {
|
|
|
3838 return ::vkCmdDispatchGraphIndirectAMDX( commandBuffer, scratch, scratchSize, pCountInfo );
|
|
|
3839 }
|
|
|
3840
|
|
|
3841 void vkCmdDispatchGraphIndirectCountAMDX( VkCommandBuffer commandBuffer,
|
|
|
3842 VkDeviceAddress scratch,
|
|
|
3843 VkDeviceSize scratchSize,
|
|
|
3844 VkDeviceAddress countInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
3845 {
|
|
|
3846 return ::vkCmdDispatchGraphIndirectCountAMDX( commandBuffer, scratch, scratchSize, countInfo );
|
|
|
3847 }
|
|
|
3848 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
3849
|
|
|
3850 //=== VK_EXT_sample_locations ===
|
|
|
3851
|
|
|
3852 void vkCmdSetSampleLocationsEXT( VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT * pSampleLocationsInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
3853 {
|
|
|
3854 return ::vkCmdSetSampleLocationsEXT( commandBuffer, pSampleLocationsInfo );
|
|
|
3855 }
|
|
|
3856
|
|
|
3857 void vkGetPhysicalDeviceMultisamplePropertiesEXT( VkPhysicalDevice physicalDevice,
|
|
|
3858 VkSampleCountFlagBits samples,
|
|
|
3859 VkMultisamplePropertiesEXT * pMultisampleProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
3860 {
|
|
|
3861 return ::vkGetPhysicalDeviceMultisamplePropertiesEXT( physicalDevice, samples, pMultisampleProperties );
|
|
|
3862 }
|
|
|
3863
|
|
|
3864 //=== VK_KHR_get_memory_requirements2 ===
|
|
|
3865
|
|
|
3866 void vkGetImageMemoryRequirements2KHR( VkDevice device,
|
|
|
3867 const VkImageMemoryRequirementsInfo2 * pInfo,
|
|
|
3868 VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
|
|
|
3869 {
|
|
|
3870 return ::vkGetImageMemoryRequirements2KHR( device, pInfo, pMemoryRequirements );
|
|
|
3871 }
|
|
|
3872
|
|
|
3873 void vkGetBufferMemoryRequirements2KHR( VkDevice device,
|
|
|
3874 const VkBufferMemoryRequirementsInfo2 * pInfo,
|
|
|
3875 VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
|
|
|
3876 {
|
|
|
3877 return ::vkGetBufferMemoryRequirements2KHR( device, pInfo, pMemoryRequirements );
|
|
|
3878 }
|
|
|
3879
|
|
|
3880 void vkGetImageSparseMemoryRequirements2KHR( VkDevice device,
|
|
|
3881 const VkImageSparseMemoryRequirementsInfo2 * pInfo,
|
|
|
3882 uint32_t * pSparseMemoryRequirementCount,
|
|
|
3883 VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
|
|
|
3884 {
|
|
|
3885 return ::vkGetImageSparseMemoryRequirements2KHR( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
|
|
|
3886 }
|
|
|
3887
|
|
|
3888 //=== VK_KHR_acceleration_structure ===
|
|
|
3889
|
|
|
3890 VkResult vkCreateAccelerationStructureKHR( VkDevice device,
|
|
|
3891 const VkAccelerationStructureCreateInfoKHR * pCreateInfo,
|
|
|
3892 const VkAllocationCallbacks * pAllocator,
|
|
|
3893 VkAccelerationStructureKHR * pAccelerationStructure ) const VULKAN_HPP_NOEXCEPT
|
|
|
3894 {
|
|
|
3895 return ::vkCreateAccelerationStructureKHR( device, pCreateInfo, pAllocator, pAccelerationStructure );
|
|
|
3896 }
|
|
|
3897
|
|
|
3898 void vkDestroyAccelerationStructureKHR( VkDevice device,
|
|
|
3899 VkAccelerationStructureKHR accelerationStructure,
|
|
|
3900 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
3901 {
|
|
|
3902 return ::vkDestroyAccelerationStructureKHR( device, accelerationStructure, pAllocator );
|
|
|
3903 }
|
|
|
3904
|
|
|
3905 void vkCmdBuildAccelerationStructuresKHR( VkCommandBuffer commandBuffer,
|
|
|
3906 uint32_t infoCount,
|
|
|
3907 const VkAccelerationStructureBuildGeometryInfoKHR * pInfos,
|
|
|
3908 const VkAccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos ) const VULKAN_HPP_NOEXCEPT
|
|
|
3909 {
|
|
|
3910 return ::vkCmdBuildAccelerationStructuresKHR( commandBuffer, infoCount, pInfos, ppBuildRangeInfos );
|
|
|
3911 }
|
|
|
3912
|
|
|
3913 void vkCmdBuildAccelerationStructuresIndirectKHR( VkCommandBuffer commandBuffer,
|
|
|
3914 uint32_t infoCount,
|
|
|
3915 const VkAccelerationStructureBuildGeometryInfoKHR * pInfos,
|
|
|
3916 const VkDeviceAddress * pIndirectDeviceAddresses,
|
|
|
3917 const uint32_t * pIndirectStrides,
|
|
|
3918 const uint32_t * const * ppMaxPrimitiveCounts ) const VULKAN_HPP_NOEXCEPT
|
|
|
3919 {
|
|
|
3920 return ::vkCmdBuildAccelerationStructuresIndirectKHR(
|
|
|
3921 commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts );
|
|
|
3922 }
|
|
|
3923
|
|
|
3924 VkResult vkBuildAccelerationStructuresKHR( VkDevice device,
|
|
|
3925 VkDeferredOperationKHR deferredOperation,
|
|
|
3926 uint32_t infoCount,
|
|
|
3927 const VkAccelerationStructureBuildGeometryInfoKHR * pInfos,
|
|
|
3928 const VkAccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos ) const VULKAN_HPP_NOEXCEPT
|
|
|
3929 {
|
|
|
3930 return ::vkBuildAccelerationStructuresKHR( device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos );
|
|
|
3931 }
|
|
|
3932
|
|
|
3933 VkResult vkCopyAccelerationStructureKHR( VkDevice device,
|
|
|
3934 VkDeferredOperationKHR deferredOperation,
|
|
|
3935 const VkCopyAccelerationStructureInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
3936 {
|
|
|
3937 return ::vkCopyAccelerationStructureKHR( device, deferredOperation, pInfo );
|
|
|
3938 }
|
|
|
3939
|
|
|
3940 VkResult vkCopyAccelerationStructureToMemoryKHR( VkDevice device,
|
|
|
3941 VkDeferredOperationKHR deferredOperation,
|
|
|
3942 const VkCopyAccelerationStructureToMemoryInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
3943 {
|
|
|
3944 return ::vkCopyAccelerationStructureToMemoryKHR( device, deferredOperation, pInfo );
|
|
|
3945 }
|
|
|
3946
|
|
|
3947 VkResult vkCopyMemoryToAccelerationStructureKHR( VkDevice device,
|
|
|
3948 VkDeferredOperationKHR deferredOperation,
|
|
|
3949 const VkCopyMemoryToAccelerationStructureInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
3950 {
|
|
|
3951 return ::vkCopyMemoryToAccelerationStructureKHR( device, deferredOperation, pInfo );
|
|
|
3952 }
|
|
|
3953
|
|
|
3954 VkResult vkWriteAccelerationStructuresPropertiesKHR( VkDevice device,
|
|
|
3955 uint32_t accelerationStructureCount,
|
|
|
3956 const VkAccelerationStructureKHR * pAccelerationStructures,
|
|
|
3957 VkQueryType queryType,
|
|
|
3958 size_t dataSize,
|
|
|
3959 void * pData,
|
|
|
3960 size_t stride ) const VULKAN_HPP_NOEXCEPT
|
|
|
3961 {
|
|
|
3962 return ::vkWriteAccelerationStructuresPropertiesKHR( device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride );
|
|
|
3963 }
|
|
|
3964
|
|
|
3965 void vkCmdCopyAccelerationStructureKHR( VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
3966 {
|
|
|
3967 return ::vkCmdCopyAccelerationStructureKHR( commandBuffer, pInfo );
|
|
|
3968 }
|
|
|
3969
|
|
|
3970 void vkCmdCopyAccelerationStructureToMemoryKHR( VkCommandBuffer commandBuffer,
|
|
|
3971 const VkCopyAccelerationStructureToMemoryInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
3972 {
|
|
|
3973 return ::vkCmdCopyAccelerationStructureToMemoryKHR( commandBuffer, pInfo );
|
|
|
3974 }
|
|
|
3975
|
|
|
3976 void vkCmdCopyMemoryToAccelerationStructureKHR( VkCommandBuffer commandBuffer,
|
|
|
3977 const VkCopyMemoryToAccelerationStructureInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
3978 {
|
|
|
3979 return ::vkCmdCopyMemoryToAccelerationStructureKHR( commandBuffer, pInfo );
|
|
|
3980 }
|
|
|
3981
|
|
|
3982 VkDeviceAddress vkGetAccelerationStructureDeviceAddressKHR( VkDevice device,
|
|
|
3983 const VkAccelerationStructureDeviceAddressInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
3984 {
|
|
|
3985 return ::vkGetAccelerationStructureDeviceAddressKHR( device, pInfo );
|
|
|
3986 }
|
|
|
3987
|
|
|
3988 void vkCmdWriteAccelerationStructuresPropertiesKHR( VkCommandBuffer commandBuffer,
|
|
|
3989 uint32_t accelerationStructureCount,
|
|
|
3990 const VkAccelerationStructureKHR * pAccelerationStructures,
|
|
|
3991 VkQueryType queryType,
|
|
|
3992 VkQueryPool queryPool,
|
|
|
3993 uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT
|
|
|
3994 {
|
|
|
3995 return ::vkCmdWriteAccelerationStructuresPropertiesKHR(
|
|
|
3996 commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery );
|
|
|
3997 }
|
|
|
3998
|
|
|
3999 void vkGetDeviceAccelerationStructureCompatibilityKHR( VkDevice device,
|
|
|
4000 const VkAccelerationStructureVersionInfoKHR * pVersionInfo,
|
|
|
4001 VkAccelerationStructureCompatibilityKHR * pCompatibility ) const VULKAN_HPP_NOEXCEPT
|
|
|
4002 {
|
|
|
4003 return ::vkGetDeviceAccelerationStructureCompatibilityKHR( device, pVersionInfo, pCompatibility );
|
|
|
4004 }
|
|
|
4005
|
|
|
4006 void vkGetAccelerationStructureBuildSizesKHR( VkDevice device,
|
|
|
4007 VkAccelerationStructureBuildTypeKHR buildType,
|
|
|
4008 const VkAccelerationStructureBuildGeometryInfoKHR * pBuildInfo,
|
|
|
4009 const uint32_t * pMaxPrimitiveCounts,
|
|
|
4010 VkAccelerationStructureBuildSizesInfoKHR * pSizeInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
4011 {
|
|
|
4012 return ::vkGetAccelerationStructureBuildSizesKHR( device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo );
|
|
|
4013 }
|
|
|
4014
|
|
|
4015 //=== VK_KHR_ray_tracing_pipeline ===
|
|
|
4016
|
|
|
4017 void vkCmdTraceRaysKHR( VkCommandBuffer commandBuffer,
|
|
|
4018 const VkStridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
|
|
|
4019 const VkStridedDeviceAddressRegionKHR * pMissShaderBindingTable,
|
|
|
4020 const VkStridedDeviceAddressRegionKHR * pHitShaderBindingTable,
|
|
|
4021 const VkStridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
|
|
|
4022 uint32_t width,
|
|
|
4023 uint32_t height,
|
|
|
4024 uint32_t depth ) const VULKAN_HPP_NOEXCEPT
|
|
|
4025 {
|
|
|
4026 return ::vkCmdTraceRaysKHR(
|
|
|
4027 commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth );
|
|
|
4028 }
|
|
|
4029
|
|
|
4030 VkResult vkCreateRayTracingPipelinesKHR( VkDevice device,
|
|
|
4031 VkDeferredOperationKHR deferredOperation,
|
|
|
4032 VkPipelineCache pipelineCache,
|
|
|
4033 uint32_t createInfoCount,
|
|
|
4034 const VkRayTracingPipelineCreateInfoKHR * pCreateInfos,
|
|
|
4035 const VkAllocationCallbacks * pAllocator,
|
|
|
4036 VkPipeline * pPipelines ) const VULKAN_HPP_NOEXCEPT
|
|
|
4037 {
|
|
|
4038 return ::vkCreateRayTracingPipelinesKHR( device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
|
|
|
4039 }
|
|
|
4040
|
|
|
4041 VkResult vkGetRayTracingShaderGroupHandlesKHR(
|
|
|
4042 VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
|
|
|
4043 {
|
|
|
4044 return ::vkGetRayTracingShaderGroupHandlesKHR( device, pipeline, firstGroup, groupCount, dataSize, pData );
|
|
|
4045 }
|
|
|
4046
|
|
|
4047 VkResult vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(
|
|
|
4048 VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
|
|
|
4049 {
|
|
|
4050 return ::vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( device, pipeline, firstGroup, groupCount, dataSize, pData );
|
|
|
4051 }
|
|
|
4052
|
|
|
4053 void vkCmdTraceRaysIndirectKHR( VkCommandBuffer commandBuffer,
|
|
|
4054 const VkStridedDeviceAddressRegionKHR * pRaygenShaderBindingTable,
|
|
|
4055 const VkStridedDeviceAddressRegionKHR * pMissShaderBindingTable,
|
|
|
4056 const VkStridedDeviceAddressRegionKHR * pHitShaderBindingTable,
|
|
|
4057 const VkStridedDeviceAddressRegionKHR * pCallableShaderBindingTable,
|
|
|
4058 VkDeviceAddress indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT
|
|
|
4059 {
|
|
|
4060 return ::vkCmdTraceRaysIndirectKHR(
|
|
|
4061 commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress );
|
|
|
4062 }
|
|
|
4063
|
|
|
4064 VkDeviceSize vkGetRayTracingShaderGroupStackSizeKHR( VkDevice device,
|
|
|
4065 VkPipeline pipeline,
|
|
|
4066 uint32_t group,
|
|
|
4067 VkShaderGroupShaderKHR groupShader ) const VULKAN_HPP_NOEXCEPT
|
|
|
4068 {
|
|
|
4069 return ::vkGetRayTracingShaderGroupStackSizeKHR( device, pipeline, group, groupShader );
|
|
|
4070 }
|
|
|
4071
|
|
|
4072 void vkCmdSetRayTracingPipelineStackSizeKHR( VkCommandBuffer commandBuffer, uint32_t pipelineStackSize ) const VULKAN_HPP_NOEXCEPT
|
|
|
4073 {
|
|
|
4074 return ::vkCmdSetRayTracingPipelineStackSizeKHR( commandBuffer, pipelineStackSize );
|
|
|
4075 }
|
|
|
4076
|
|
|
4077 //=== VK_KHR_sampler_ycbcr_conversion ===
|
|
|
4078
|
|
|
4079 VkResult vkCreateSamplerYcbcrConversionKHR( VkDevice device,
|
|
|
4080 const VkSamplerYcbcrConversionCreateInfo * pCreateInfo,
|
|
|
4081 const VkAllocationCallbacks * pAllocator,
|
|
|
4082 VkSamplerYcbcrConversion * pYcbcrConversion ) const VULKAN_HPP_NOEXCEPT
|
|
|
4083 {
|
|
|
4084 return ::vkCreateSamplerYcbcrConversionKHR( device, pCreateInfo, pAllocator, pYcbcrConversion );
|
|
|
4085 }
|
|
|
4086
|
|
|
4087 void vkDestroySamplerYcbcrConversionKHR( VkDevice device,
|
|
|
4088 VkSamplerYcbcrConversion ycbcrConversion,
|
|
|
4089 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
4090 {
|
|
|
4091 return ::vkDestroySamplerYcbcrConversionKHR( device, ycbcrConversion, pAllocator );
|
|
|
4092 }
|
|
|
4093
|
|
|
4094 //=== VK_KHR_bind_memory2 ===
|
|
|
4095
|
|
|
4096 VkResult vkBindBufferMemory2KHR( VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT
|
|
|
4097 {
|
|
|
4098 return ::vkBindBufferMemory2KHR( device, bindInfoCount, pBindInfos );
|
|
|
4099 }
|
|
|
4100
|
|
|
4101 VkResult vkBindImageMemory2KHR( VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT
|
|
|
4102 {
|
|
|
4103 return ::vkBindImageMemory2KHR( device, bindInfoCount, pBindInfos );
|
|
|
4104 }
|
|
|
4105
|
|
|
4106 //=== VK_EXT_image_drm_format_modifier ===
|
|
|
4107
|
|
|
4108 VkResult vkGetImageDrmFormatModifierPropertiesEXT( VkDevice device,
|
|
|
4109 VkImage image,
|
|
|
4110 VkImageDrmFormatModifierPropertiesEXT * pProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
4111 {
|
|
|
4112 return ::vkGetImageDrmFormatModifierPropertiesEXT( device, image, pProperties );
|
|
|
4113 }
|
|
|
4114
|
|
|
4115 //=== VK_EXT_validation_cache ===
|
|
|
4116
|
|
|
4117 VkResult vkCreateValidationCacheEXT( VkDevice device,
|
|
|
4118 const VkValidationCacheCreateInfoEXT * pCreateInfo,
|
|
|
4119 const VkAllocationCallbacks * pAllocator,
|
|
|
4120 VkValidationCacheEXT * pValidationCache ) const VULKAN_HPP_NOEXCEPT
|
|
|
4121 {
|
|
|
4122 return ::vkCreateValidationCacheEXT( device, pCreateInfo, pAllocator, pValidationCache );
|
|
|
4123 }
|
|
|
4124
|
|
|
4125 void
|
|
|
4126 vkDestroyValidationCacheEXT( VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
4127 {
|
|
|
4128 return ::vkDestroyValidationCacheEXT( device, validationCache, pAllocator );
|
|
|
4129 }
|
|
|
4130
|
|
|
4131 VkResult vkMergeValidationCachesEXT( VkDevice device,
|
|
|
4132 VkValidationCacheEXT dstCache,
|
|
|
4133 uint32_t srcCacheCount,
|
|
|
4134 const VkValidationCacheEXT * pSrcCaches ) const VULKAN_HPP_NOEXCEPT
|
|
|
4135 {
|
|
|
4136 return ::vkMergeValidationCachesEXT( device, dstCache, srcCacheCount, pSrcCaches );
|
|
|
4137 }
|
|
|
4138
|
|
|
4139 VkResult vkGetValidationCacheDataEXT( VkDevice device, VkValidationCacheEXT validationCache, size_t * pDataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
|
|
|
4140 {
|
|
|
4141 return ::vkGetValidationCacheDataEXT( device, validationCache, pDataSize, pData );
|
|
|
4142 }
|
|
|
4143
|
|
|
4144 //=== VK_NV_shading_rate_image ===
|
|
|
4145
|
|
|
4146 void vkCmdBindShadingRateImageNV( VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT
|
|
|
4147 {
|
|
|
4148 return ::vkCmdBindShadingRateImageNV( commandBuffer, imageView, imageLayout );
|
|
|
4149 }
|
|
|
4150
|
|
|
4151 void vkCmdSetViewportShadingRatePaletteNV( VkCommandBuffer commandBuffer,
|
|
|
4152 uint32_t firstViewport,
|
|
|
4153 uint32_t viewportCount,
|
|
|
4154 const VkShadingRatePaletteNV * pShadingRatePalettes ) const VULKAN_HPP_NOEXCEPT
|
|
|
4155 {
|
|
|
4156 return ::vkCmdSetViewportShadingRatePaletteNV( commandBuffer, firstViewport, viewportCount, pShadingRatePalettes );
|
|
|
4157 }
|
|
|
4158
|
|
|
4159 void vkCmdSetCoarseSampleOrderNV( VkCommandBuffer commandBuffer,
|
|
|
4160 VkCoarseSampleOrderTypeNV sampleOrderType,
|
|
|
4161 uint32_t customSampleOrderCount,
|
|
|
4162 const VkCoarseSampleOrderCustomNV * pCustomSampleOrders ) const VULKAN_HPP_NOEXCEPT
|
|
|
4163 {
|
|
|
4164 return ::vkCmdSetCoarseSampleOrderNV( commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders );
|
|
|
4165 }
|
|
|
4166
|
|
|
4167 //=== VK_NV_ray_tracing ===
|
|
|
4168
|
|
|
4169 VkResult vkCreateAccelerationStructureNV( VkDevice device,
|
|
|
4170 const VkAccelerationStructureCreateInfoNV * pCreateInfo,
|
|
|
4171 const VkAllocationCallbacks * pAllocator,
|
|
|
4172 VkAccelerationStructureNV * pAccelerationStructure ) const VULKAN_HPP_NOEXCEPT
|
|
|
4173 {
|
|
|
4174 return ::vkCreateAccelerationStructureNV( device, pCreateInfo, pAllocator, pAccelerationStructure );
|
|
|
4175 }
|
|
|
4176
|
|
|
4177 void vkDestroyAccelerationStructureNV( VkDevice device,
|
|
|
4178 VkAccelerationStructureNV accelerationStructure,
|
|
|
4179 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
4180 {
|
|
|
4181 return ::vkDestroyAccelerationStructureNV( device, accelerationStructure, pAllocator );
|
|
|
4182 }
|
|
|
4183
|
|
|
4184 void vkGetAccelerationStructureMemoryRequirementsNV( VkDevice device,
|
|
|
4185 const VkAccelerationStructureMemoryRequirementsInfoNV * pInfo,
|
|
|
4186 VkMemoryRequirements2KHR * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
|
|
|
4187 {
|
|
|
4188 return ::vkGetAccelerationStructureMemoryRequirementsNV( device, pInfo, pMemoryRequirements );
|
|
|
4189 }
|
|
|
4190
|
|
|
4191 VkResult vkBindAccelerationStructureMemoryNV( VkDevice device,
|
|
|
4192 uint32_t bindInfoCount,
|
|
|
4193 const VkBindAccelerationStructureMemoryInfoNV * pBindInfos ) const VULKAN_HPP_NOEXCEPT
|
|
|
4194 {
|
|
|
4195 return ::vkBindAccelerationStructureMemoryNV( device, bindInfoCount, pBindInfos );
|
|
|
4196 }
|
|
|
4197
|
|
|
4198 void vkCmdBuildAccelerationStructureNV( VkCommandBuffer commandBuffer,
|
|
|
4199 const VkAccelerationStructureInfoNV * pInfo,
|
|
|
4200 VkBuffer instanceData,
|
|
|
4201 VkDeviceSize instanceOffset,
|
|
|
4202 VkBool32 update,
|
|
|
4203 VkAccelerationStructureNV dst,
|
|
|
4204 VkAccelerationStructureNV src,
|
|
|
4205 VkBuffer scratch,
|
|
|
4206 VkDeviceSize scratchOffset ) const VULKAN_HPP_NOEXCEPT
|
|
|
4207 {
|
|
|
4208 return ::vkCmdBuildAccelerationStructureNV( commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset );
|
|
|
4209 }
|
|
|
4210
|
|
|
4211 void vkCmdCopyAccelerationStructureNV( VkCommandBuffer commandBuffer,
|
|
|
4212 VkAccelerationStructureNV dst,
|
|
|
4213 VkAccelerationStructureNV src,
|
|
|
4214 VkCopyAccelerationStructureModeKHR mode ) const VULKAN_HPP_NOEXCEPT
|
|
|
4215 {
|
|
|
4216 return ::vkCmdCopyAccelerationStructureNV( commandBuffer, dst, src, mode );
|
|
|
4217 }
|
|
|
4218
|
|
|
4219 void vkCmdTraceRaysNV( VkCommandBuffer commandBuffer,
|
|
|
4220 VkBuffer raygenShaderBindingTableBuffer,
|
|
|
4221 VkDeviceSize raygenShaderBindingOffset,
|
|
|
4222 VkBuffer missShaderBindingTableBuffer,
|
|
|
4223 VkDeviceSize missShaderBindingOffset,
|
|
|
4224 VkDeviceSize missShaderBindingStride,
|
|
|
4225 VkBuffer hitShaderBindingTableBuffer,
|
|
|
4226 VkDeviceSize hitShaderBindingOffset,
|
|
|
4227 VkDeviceSize hitShaderBindingStride,
|
|
|
4228 VkBuffer callableShaderBindingTableBuffer,
|
|
|
4229 VkDeviceSize callableShaderBindingOffset,
|
|
|
4230 VkDeviceSize callableShaderBindingStride,
|
|
|
4231 uint32_t width,
|
|
|
4232 uint32_t height,
|
|
|
4233 uint32_t depth ) const VULKAN_HPP_NOEXCEPT
|
|
|
4234 {
|
|
|
4235 return ::vkCmdTraceRaysNV( commandBuffer,
|
|
|
4236 raygenShaderBindingTableBuffer,
|
|
|
4237 raygenShaderBindingOffset,
|
|
|
4238 missShaderBindingTableBuffer,
|
|
|
4239 missShaderBindingOffset,
|
|
|
4240 missShaderBindingStride,
|
|
|
4241 hitShaderBindingTableBuffer,
|
|
|
4242 hitShaderBindingOffset,
|
|
|
4243 hitShaderBindingStride,
|
|
|
4244 callableShaderBindingTableBuffer,
|
|
|
4245 callableShaderBindingOffset,
|
|
|
4246 callableShaderBindingStride,
|
|
|
4247 width,
|
|
|
4248 height,
|
|
|
4249 depth );
|
|
|
4250 }
|
|
|
4251
|
|
|
4252 VkResult vkCreateRayTracingPipelinesNV( VkDevice device,
|
|
|
4253 VkPipelineCache pipelineCache,
|
|
|
4254 uint32_t createInfoCount,
|
|
|
4255 const VkRayTracingPipelineCreateInfoNV * pCreateInfos,
|
|
|
4256 const VkAllocationCallbacks * pAllocator,
|
|
|
4257 VkPipeline * pPipelines ) const VULKAN_HPP_NOEXCEPT
|
|
|
4258 {
|
|
|
4259 return ::vkCreateRayTracingPipelinesNV( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
|
|
|
4260 }
|
|
|
4261
|
|
|
4262 VkResult vkGetRayTracingShaderGroupHandlesNV(
|
|
|
4263 VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
|
|
|
4264 {
|
|
|
4265 return ::vkGetRayTracingShaderGroupHandlesNV( device, pipeline, firstGroup, groupCount, dataSize, pData );
|
|
|
4266 }
|
|
|
4267
|
|
|
4268 VkResult vkGetAccelerationStructureHandleNV( VkDevice device,
|
|
|
4269 VkAccelerationStructureNV accelerationStructure,
|
|
|
4270 size_t dataSize,
|
|
|
4271 void * pData ) const VULKAN_HPP_NOEXCEPT
|
|
|
4272 {
|
|
|
4273 return ::vkGetAccelerationStructureHandleNV( device, accelerationStructure, dataSize, pData );
|
|
|
4274 }
|
|
|
4275
|
|
|
4276 void vkCmdWriteAccelerationStructuresPropertiesNV( VkCommandBuffer commandBuffer,
|
|
|
4277 uint32_t accelerationStructureCount,
|
|
|
4278 const VkAccelerationStructureNV * pAccelerationStructures,
|
|
|
4279 VkQueryType queryType,
|
|
|
4280 VkQueryPool queryPool,
|
|
|
4281 uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT
|
|
|
4282 {
|
|
|
4283 return ::vkCmdWriteAccelerationStructuresPropertiesNV(
|
|
|
4284 commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery );
|
|
|
4285 }
|
|
|
4286
|
|
|
4287 VkResult vkCompileDeferredNV( VkDevice device, VkPipeline pipeline, uint32_t shader ) const VULKAN_HPP_NOEXCEPT
|
|
|
4288 {
|
|
|
4289 return ::vkCompileDeferredNV( device, pipeline, shader );
|
|
|
4290 }
|
|
|
4291
|
|
|
4292 //=== VK_KHR_maintenance3 ===
|
|
|
4293
|
|
|
4294 void vkGetDescriptorSetLayoutSupportKHR( VkDevice device,
|
|
|
4295 const VkDescriptorSetLayoutCreateInfo * pCreateInfo,
|
|
|
4296 VkDescriptorSetLayoutSupport * pSupport ) const VULKAN_HPP_NOEXCEPT
|
|
|
4297 {
|
|
|
4298 return ::vkGetDescriptorSetLayoutSupportKHR( device, pCreateInfo, pSupport );
|
|
|
4299 }
|
|
|
4300
|
|
|
4301 //=== VK_KHR_draw_indirect_count ===
|
|
|
4302
|
|
|
4303 void vkCmdDrawIndirectCountKHR( VkCommandBuffer commandBuffer,
|
|
|
4304 VkBuffer buffer,
|
|
|
4305 VkDeviceSize offset,
|
|
|
4306 VkBuffer countBuffer,
|
|
|
4307 VkDeviceSize countBufferOffset,
|
|
|
4308 uint32_t maxDrawCount,
|
|
|
4309 uint32_t stride ) const VULKAN_HPP_NOEXCEPT
|
|
|
4310 {
|
|
|
4311 return ::vkCmdDrawIndirectCountKHR( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
|
|
|
4312 }
|
|
|
4313
|
|
|
4314 void vkCmdDrawIndexedIndirectCountKHR( VkCommandBuffer commandBuffer,
|
|
|
4315 VkBuffer buffer,
|
|
|
4316 VkDeviceSize offset,
|
|
|
4317 VkBuffer countBuffer,
|
|
|
4318 VkDeviceSize countBufferOffset,
|
|
|
4319 uint32_t maxDrawCount,
|
|
|
4320 uint32_t stride ) const VULKAN_HPP_NOEXCEPT
|
|
|
4321 {
|
|
|
4322 return ::vkCmdDrawIndexedIndirectCountKHR( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
|
|
|
4323 }
|
|
|
4324
|
|
|
4325 //=== VK_EXT_external_memory_host ===
|
|
|
4326
|
|
|
4327 VkResult vkGetMemoryHostPointerPropertiesEXT( VkDevice device,
|
|
|
4328 VkExternalMemoryHandleTypeFlagBits handleType,
|
|
|
4329 const void * pHostPointer,
|
|
|
4330 VkMemoryHostPointerPropertiesEXT * pMemoryHostPointerProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
4331 {
|
|
|
4332 return ::vkGetMemoryHostPointerPropertiesEXT( device, handleType, pHostPointer, pMemoryHostPointerProperties );
|
|
|
4333 }
|
|
|
4334
|
|
|
4335 //=== VK_AMD_buffer_marker ===
|
|
|
4336
|
|
|
4337 void vkCmdWriteBufferMarkerAMD( VkCommandBuffer commandBuffer,
|
|
|
4338 VkPipelineStageFlagBits pipelineStage,
|
|
|
4339 VkBuffer dstBuffer,
|
|
|
4340 VkDeviceSize dstOffset,
|
|
|
4341 uint32_t marker ) const VULKAN_HPP_NOEXCEPT
|
|
|
4342 {
|
|
|
4343 return ::vkCmdWriteBufferMarkerAMD( commandBuffer, pipelineStage, dstBuffer, dstOffset, marker );
|
|
|
4344 }
|
|
|
4345
|
|
|
4346 void vkCmdWriteBufferMarker2AMD(
|
|
|
4347 VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker ) const VULKAN_HPP_NOEXCEPT
|
|
|
4348 {
|
|
|
4349 return ::vkCmdWriteBufferMarker2AMD( commandBuffer, stage, dstBuffer, dstOffset, marker );
|
|
|
4350 }
|
|
|
4351
|
|
|
4352 //=== VK_EXT_calibrated_timestamps ===
|
|
|
4353
|
|
|
4354 VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( VkPhysicalDevice physicalDevice,
|
|
|
4355 uint32_t * pTimeDomainCount,
|
|
|
4356 VkTimeDomainKHR * pTimeDomains ) const VULKAN_HPP_NOEXCEPT
|
|
|
4357 {
|
|
|
4358 return ::vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( physicalDevice, pTimeDomainCount, pTimeDomains );
|
|
|
4359 }
|
|
|
4360
|
|
|
4361 VkResult vkGetCalibratedTimestampsEXT( VkDevice device,
|
|
|
4362 uint32_t timestampCount,
|
|
|
4363 const VkCalibratedTimestampInfoKHR * pTimestampInfos,
|
|
|
4364 uint64_t * pTimestamps,
|
|
|
4365 uint64_t * pMaxDeviation ) const VULKAN_HPP_NOEXCEPT
|
|
|
4366 {
|
|
|
4367 return ::vkGetCalibratedTimestampsEXT( device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation );
|
|
|
4368 }
|
|
|
4369
|
|
|
4370 //=== VK_NV_mesh_shader ===
|
|
|
4371
|
|
|
4372 void vkCmdDrawMeshTasksNV( VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask ) const VULKAN_HPP_NOEXCEPT
|
|
|
4373 {
|
|
|
4374 return ::vkCmdDrawMeshTasksNV( commandBuffer, taskCount, firstTask );
|
|
|
4375 }
|
|
|
4376
|
|
|
4377 void vkCmdDrawMeshTasksIndirectNV( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const
|
|
|
4378 VULKAN_HPP_NOEXCEPT
|
|
|
4379 {
|
|
|
4380 return ::vkCmdDrawMeshTasksIndirectNV( commandBuffer, buffer, offset, drawCount, stride );
|
|
|
4381 }
|
|
|
4382
|
|
|
4383 void vkCmdDrawMeshTasksIndirectCountNV( VkCommandBuffer commandBuffer,
|
|
|
4384 VkBuffer buffer,
|
|
|
4385 VkDeviceSize offset,
|
|
|
4386 VkBuffer countBuffer,
|
|
|
4387 VkDeviceSize countBufferOffset,
|
|
|
4388 uint32_t maxDrawCount,
|
|
|
4389 uint32_t stride ) const VULKAN_HPP_NOEXCEPT
|
|
|
4390 {
|
|
|
4391 return ::vkCmdDrawMeshTasksIndirectCountNV( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
|
|
|
4392 }
|
|
|
4393
|
|
|
4394 //=== VK_NV_scissor_exclusive ===
|
|
|
4395
|
|
|
4396 void vkCmdSetExclusiveScissorEnableNV( VkCommandBuffer commandBuffer,
|
|
|
4397 uint32_t firstExclusiveScissor,
|
|
|
4398 uint32_t exclusiveScissorCount,
|
|
|
4399 const VkBool32 * pExclusiveScissorEnables ) const VULKAN_HPP_NOEXCEPT
|
|
|
4400 {
|
|
|
4401 return ::vkCmdSetExclusiveScissorEnableNV( commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissorEnables );
|
|
|
4402 }
|
|
|
4403
|
|
|
4404 void vkCmdSetExclusiveScissorNV( VkCommandBuffer commandBuffer,
|
|
|
4405 uint32_t firstExclusiveScissor,
|
|
|
4406 uint32_t exclusiveScissorCount,
|
|
|
4407 const VkRect2D * pExclusiveScissors ) const VULKAN_HPP_NOEXCEPT
|
|
|
4408 {
|
|
|
4409 return ::vkCmdSetExclusiveScissorNV( commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors );
|
|
|
4410 }
|
|
|
4411
|
|
|
4412 //=== VK_NV_device_diagnostic_checkpoints ===
|
|
|
4413
|
|
|
4414 void vkCmdSetCheckpointNV( VkCommandBuffer commandBuffer, const void * pCheckpointMarker ) const VULKAN_HPP_NOEXCEPT
|
|
|
4415 {
|
|
|
4416 return ::vkCmdSetCheckpointNV( commandBuffer, pCheckpointMarker );
|
|
|
4417 }
|
|
|
4418
|
|
|
4419 void vkGetQueueCheckpointDataNV( VkQueue queue, uint32_t * pCheckpointDataCount, VkCheckpointDataNV * pCheckpointData ) const VULKAN_HPP_NOEXCEPT
|
|
|
4420 {
|
|
|
4421 return ::vkGetQueueCheckpointDataNV( queue, pCheckpointDataCount, pCheckpointData );
|
|
|
4422 }
|
|
|
4423
|
|
|
4424 void vkGetQueueCheckpointData2NV( VkQueue queue, uint32_t * pCheckpointDataCount, VkCheckpointData2NV * pCheckpointData ) const VULKAN_HPP_NOEXCEPT
|
|
|
4425 {
|
|
|
4426 return ::vkGetQueueCheckpointData2NV( queue, pCheckpointDataCount, pCheckpointData );
|
|
|
4427 }
|
|
|
4428
|
|
|
4429 //=== VK_KHR_timeline_semaphore ===
|
|
|
4430
|
|
|
4431 VkResult vkGetSemaphoreCounterValueKHR( VkDevice device, VkSemaphore semaphore, uint64_t * pValue ) const VULKAN_HPP_NOEXCEPT
|
|
|
4432 {
|
|
|
4433 return ::vkGetSemaphoreCounterValueKHR( device, semaphore, pValue );
|
|
|
4434 }
|
|
|
4435
|
|
|
4436 VkResult vkWaitSemaphoresKHR( VkDevice device, const VkSemaphoreWaitInfo * pWaitInfo, uint64_t timeout ) const VULKAN_HPP_NOEXCEPT
|
|
|
4437 {
|
|
|
4438 return ::vkWaitSemaphoresKHR( device, pWaitInfo, timeout );
|
|
|
4439 }
|
|
|
4440
|
|
|
4441 VkResult vkSignalSemaphoreKHR( VkDevice device, const VkSemaphoreSignalInfo * pSignalInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
4442 {
|
|
|
4443 return ::vkSignalSemaphoreKHR( device, pSignalInfo );
|
|
|
4444 }
|
|
|
4445
|
|
|
4446 //=== VK_INTEL_performance_query ===
|
|
|
4447
|
|
|
4448 VkResult vkInitializePerformanceApiINTEL( VkDevice device, const VkInitializePerformanceApiInfoINTEL * pInitializeInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
4449 {
|
|
|
4450 return ::vkInitializePerformanceApiINTEL( device, pInitializeInfo );
|
|
|
4451 }
|
|
|
4452
|
|
|
4453 void vkUninitializePerformanceApiINTEL( VkDevice device ) const VULKAN_HPP_NOEXCEPT
|
|
|
4454 {
|
|
|
4455 return ::vkUninitializePerformanceApiINTEL( device );
|
|
|
4456 }
|
|
|
4457
|
|
|
4458 VkResult vkCmdSetPerformanceMarkerINTEL( VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
4459 {
|
|
|
4460 return ::vkCmdSetPerformanceMarkerINTEL( commandBuffer, pMarkerInfo );
|
|
|
4461 }
|
|
|
4462
|
|
|
4463 VkResult vkCmdSetPerformanceStreamMarkerINTEL( VkCommandBuffer commandBuffer,
|
|
|
4464 const VkPerformanceStreamMarkerInfoINTEL * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
4465 {
|
|
|
4466 return ::vkCmdSetPerformanceStreamMarkerINTEL( commandBuffer, pMarkerInfo );
|
|
|
4467 }
|
|
|
4468
|
|
|
4469 VkResult vkCmdSetPerformanceOverrideINTEL( VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL * pOverrideInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
4470 {
|
|
|
4471 return ::vkCmdSetPerformanceOverrideINTEL( commandBuffer, pOverrideInfo );
|
|
|
4472 }
|
|
|
4473
|
|
|
4474 VkResult vkAcquirePerformanceConfigurationINTEL( VkDevice device,
|
|
|
4475 const VkPerformanceConfigurationAcquireInfoINTEL * pAcquireInfo,
|
|
|
4476 VkPerformanceConfigurationINTEL * pConfiguration ) const VULKAN_HPP_NOEXCEPT
|
|
|
4477 {
|
|
|
4478 return ::vkAcquirePerformanceConfigurationINTEL( device, pAcquireInfo, pConfiguration );
|
|
|
4479 }
|
|
|
4480
|
|
|
4481 VkResult vkReleasePerformanceConfigurationINTEL( VkDevice device, VkPerformanceConfigurationINTEL configuration ) const VULKAN_HPP_NOEXCEPT
|
|
|
4482 {
|
|
|
4483 return ::vkReleasePerformanceConfigurationINTEL( device, configuration );
|
|
|
4484 }
|
|
|
4485
|
|
|
4486 VkResult vkQueueSetPerformanceConfigurationINTEL( VkQueue queue, VkPerformanceConfigurationINTEL configuration ) const VULKAN_HPP_NOEXCEPT
|
|
|
4487 {
|
|
|
4488 return ::vkQueueSetPerformanceConfigurationINTEL( queue, configuration );
|
|
|
4489 }
|
|
|
4490
|
|
|
4491 VkResult
|
|
|
4492 vkGetPerformanceParameterINTEL( VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL * pValue ) const VULKAN_HPP_NOEXCEPT
|
|
|
4493 {
|
|
|
4494 return ::vkGetPerformanceParameterINTEL( device, parameter, pValue );
|
|
|
4495 }
|
|
|
4496
|
|
|
4497 //=== VK_AMD_display_native_hdr ===
|
|
|
4498
|
|
|
4499 void vkSetLocalDimmingAMD( VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable ) const VULKAN_HPP_NOEXCEPT
|
|
|
4500 {
|
|
|
4501 return ::vkSetLocalDimmingAMD( device, swapChain, localDimmingEnable );
|
|
|
4502 }
|
|
|
4503
|
|
|
4504 # if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
|
4505 //=== VK_FUCHSIA_imagepipe_surface ===
|
|
|
4506
|
|
|
4507 VkResult vkCreateImagePipeSurfaceFUCHSIA( VkInstance instance,
|
|
|
4508 const VkImagePipeSurfaceCreateInfoFUCHSIA * pCreateInfo,
|
|
|
4509 const VkAllocationCallbacks * pAllocator,
|
|
|
4510 VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
|
|
|
4511 {
|
|
|
4512 return ::vkCreateImagePipeSurfaceFUCHSIA( instance, pCreateInfo, pAllocator, pSurface );
|
|
|
4513 }
|
|
|
4514 # endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
4515
|
|
|
4516 # if defined( VK_USE_PLATFORM_METAL_EXT )
|
|
|
4517 //=== VK_EXT_metal_surface ===
|
|
|
4518
|
|
|
4519 VkResult vkCreateMetalSurfaceEXT( VkInstance instance,
|
|
|
4520 const VkMetalSurfaceCreateInfoEXT * pCreateInfo,
|
|
|
4521 const VkAllocationCallbacks * pAllocator,
|
|
|
4522 VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
|
|
|
4523 {
|
|
|
4524 return ::vkCreateMetalSurfaceEXT( instance, pCreateInfo, pAllocator, pSurface );
|
|
|
4525 }
|
|
|
4526 # endif /*VK_USE_PLATFORM_METAL_EXT*/
|
|
|
4527
|
|
|
4528 //=== VK_KHR_fragment_shading_rate ===
|
|
|
4529
|
|
|
4530 VkResult vkGetPhysicalDeviceFragmentShadingRatesKHR( VkPhysicalDevice physicalDevice,
|
|
|
4531 uint32_t * pFragmentShadingRateCount,
|
|
|
4532 VkPhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates ) const VULKAN_HPP_NOEXCEPT
|
|
|
4533 {
|
|
|
4534 return ::vkGetPhysicalDeviceFragmentShadingRatesKHR( physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates );
|
|
|
4535 }
|
|
|
4536
|
|
|
4537 void vkCmdSetFragmentShadingRateKHR( VkCommandBuffer commandBuffer,
|
|
|
4538 const VkExtent2D * pFragmentSize,
|
|
|
4539 const VkFragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT
|
|
|
4540 {
|
|
|
4541 return ::vkCmdSetFragmentShadingRateKHR( commandBuffer, pFragmentSize, combinerOps );
|
|
|
4542 }
|
|
|
4543
|
|
|
4544 //=== VK_KHR_dynamic_rendering_local_read ===
|
|
|
4545
|
|
|
4546 void vkCmdSetRenderingAttachmentLocationsKHR( VkCommandBuffer commandBuffer,
|
|
|
4547 const VkRenderingAttachmentLocationInfo * pLocationInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
4548 {
|
|
|
4549 return ::vkCmdSetRenderingAttachmentLocationsKHR( commandBuffer, pLocationInfo );
|
|
|
4550 }
|
|
|
4551
|
|
|
4552 void vkCmdSetRenderingInputAttachmentIndicesKHR( VkCommandBuffer commandBuffer,
|
|
|
4553 const VkRenderingInputAttachmentIndexInfo * pInputAttachmentIndexInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
4554 {
|
|
|
4555 return ::vkCmdSetRenderingInputAttachmentIndicesKHR( commandBuffer, pInputAttachmentIndexInfo );
|
|
|
4556 }
|
|
|
4557
|
|
|
4558 //=== VK_EXT_buffer_device_address ===
|
|
|
4559
|
|
|
4560 VkDeviceAddress vkGetBufferDeviceAddressEXT( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
4561 {
|
|
|
4562 return ::vkGetBufferDeviceAddressEXT( device, pInfo );
|
|
|
4563 }
|
|
|
4564
|
|
|
4565 //=== VK_EXT_tooling_info ===
|
|
|
4566
|
|
|
4567 VkResult vkGetPhysicalDeviceToolPropertiesEXT( VkPhysicalDevice physicalDevice,
|
|
|
4568 uint32_t * pToolCount,
|
|
|
4569 VkPhysicalDeviceToolProperties * pToolProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
4570 {
|
|
|
4571 return ::vkGetPhysicalDeviceToolPropertiesEXT( physicalDevice, pToolCount, pToolProperties );
|
|
|
4572 }
|
|
|
4573
|
|
|
4574 //=== VK_KHR_present_wait ===
|
|
|
4575
|
|
|
4576 VkResult vkWaitForPresentKHR( VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout ) const VULKAN_HPP_NOEXCEPT
|
|
|
4577 {
|
|
|
4578 return ::vkWaitForPresentKHR( device, swapchain, presentId, timeout );
|
|
|
4579 }
|
|
|
4580
|
|
|
4581 //=== VK_NV_cooperative_matrix ===
|
|
|
4582
|
|
|
4583 VkResult vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( VkPhysicalDevice physicalDevice,
|
|
|
4584 uint32_t * pPropertyCount,
|
|
|
4585 VkCooperativeMatrixPropertiesNV * pProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
4586 {
|
|
|
4587 return ::vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( physicalDevice, pPropertyCount, pProperties );
|
|
|
4588 }
|
|
|
4589
|
|
|
4590 //=== VK_NV_coverage_reduction_mode ===
|
|
|
4591
|
|
|
4592 VkResult vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
|
|
|
4593 VkPhysicalDevice physicalDevice, uint32_t * pCombinationCount, VkFramebufferMixedSamplesCombinationNV * pCombinations ) const VULKAN_HPP_NOEXCEPT
|
|
|
4594 {
|
|
|
4595 return ::vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( physicalDevice, pCombinationCount, pCombinations );
|
|
|
4596 }
|
|
|
4597
|
|
|
4598 # if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
4599 //=== VK_EXT_full_screen_exclusive ===
|
|
|
4600
|
|
|
4601 VkResult vkGetPhysicalDeviceSurfacePresentModes2EXT( VkPhysicalDevice physicalDevice,
|
|
|
4602 const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
|
|
|
4603 uint32_t * pPresentModeCount,
|
|
|
4604 VkPresentModeKHR * pPresentModes ) const VULKAN_HPP_NOEXCEPT
|
|
|
4605 {
|
|
|
4606 return ::vkGetPhysicalDeviceSurfacePresentModes2EXT( physicalDevice, pSurfaceInfo, pPresentModeCount, pPresentModes );
|
|
|
4607 }
|
|
|
4608
|
|
|
4609 VkResult vkAcquireFullScreenExclusiveModeEXT( VkDevice device, VkSwapchainKHR swapchain ) const VULKAN_HPP_NOEXCEPT
|
|
|
4610 {
|
|
|
4611 return ::vkAcquireFullScreenExclusiveModeEXT( device, swapchain );
|
|
|
4612 }
|
|
|
4613
|
|
|
4614 VkResult vkReleaseFullScreenExclusiveModeEXT( VkDevice device, VkSwapchainKHR swapchain ) const VULKAN_HPP_NOEXCEPT
|
|
|
4615 {
|
|
|
4616 return ::vkReleaseFullScreenExclusiveModeEXT( device, swapchain );
|
|
|
4617 }
|
|
|
4618
|
|
|
4619 VkResult vkGetDeviceGroupSurfacePresentModes2EXT( VkDevice device,
|
|
|
4620 const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo,
|
|
|
4621 VkDeviceGroupPresentModeFlagsKHR * pModes ) const VULKAN_HPP_NOEXCEPT
|
|
|
4622 {
|
|
|
4623 return ::vkGetDeviceGroupSurfacePresentModes2EXT( device, pSurfaceInfo, pModes );
|
|
|
4624 }
|
|
|
4625 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
4626
|
|
|
4627 //=== VK_EXT_headless_surface ===
|
|
|
4628
|
|
|
4629 VkResult vkCreateHeadlessSurfaceEXT( VkInstance instance,
|
|
|
4630 const VkHeadlessSurfaceCreateInfoEXT * pCreateInfo,
|
|
|
4631 const VkAllocationCallbacks * pAllocator,
|
|
|
4632 VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
|
|
|
4633 {
|
|
|
4634 return ::vkCreateHeadlessSurfaceEXT( instance, pCreateInfo, pAllocator, pSurface );
|
|
|
4635 }
|
|
|
4636
|
|
|
4637 //=== VK_KHR_buffer_device_address ===
|
|
|
4638
|
|
|
4639 VkDeviceAddress vkGetBufferDeviceAddressKHR( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
4640 {
|
|
|
4641 return ::vkGetBufferDeviceAddressKHR( device, pInfo );
|
|
|
4642 }
|
|
|
4643
|
|
|
4644 uint64_t vkGetBufferOpaqueCaptureAddressKHR( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
4645 {
|
|
|
4646 return ::vkGetBufferOpaqueCaptureAddressKHR( device, pInfo );
|
|
|
4647 }
|
|
|
4648
|
|
|
4649 uint64_t vkGetDeviceMemoryOpaqueCaptureAddressKHR( VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
4650 {
|
|
|
4651 return ::vkGetDeviceMemoryOpaqueCaptureAddressKHR( device, pInfo );
|
|
|
4652 }
|
|
|
4653
|
|
|
4654 //=== VK_EXT_line_rasterization ===
|
|
|
4655
|
|
|
4656 void vkCmdSetLineStippleEXT( VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT
|
|
|
4657 {
|
|
|
4658 return ::vkCmdSetLineStippleEXT( commandBuffer, lineStippleFactor, lineStipplePattern );
|
|
|
4659 }
|
|
|
4660
|
|
|
4661 //=== VK_EXT_host_query_reset ===
|
|
|
4662
|
|
|
4663 void vkResetQueryPoolEXT( VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT
|
|
|
4664 {
|
|
|
4665 return ::vkResetQueryPoolEXT( device, queryPool, firstQuery, queryCount );
|
|
|
4666 }
|
|
|
4667
|
|
|
4668 //=== VK_EXT_extended_dynamic_state ===
|
|
|
4669
|
|
|
4670 void vkCmdSetCullModeEXT( VkCommandBuffer commandBuffer, VkCullModeFlags cullMode ) const VULKAN_HPP_NOEXCEPT
|
|
|
4671 {
|
|
|
4672 return ::vkCmdSetCullModeEXT( commandBuffer, cullMode );
|
|
|
4673 }
|
|
|
4674
|
|
|
4675 void vkCmdSetFrontFaceEXT( VkCommandBuffer commandBuffer, VkFrontFace frontFace ) const VULKAN_HPP_NOEXCEPT
|
|
|
4676 {
|
|
|
4677 return ::vkCmdSetFrontFaceEXT( commandBuffer, frontFace );
|
|
|
4678 }
|
|
|
4679
|
|
|
4680 void vkCmdSetPrimitiveTopologyEXT( VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT
|
|
|
4681 {
|
|
|
4682 return ::vkCmdSetPrimitiveTopologyEXT( commandBuffer, primitiveTopology );
|
|
|
4683 }
|
|
|
4684
|
|
|
4685 void vkCmdSetViewportWithCountEXT( VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport * pViewports ) const VULKAN_HPP_NOEXCEPT
|
|
|
4686 {
|
|
|
4687 return ::vkCmdSetViewportWithCountEXT( commandBuffer, viewportCount, pViewports );
|
|
|
4688 }
|
|
|
4689
|
|
|
4690 void vkCmdSetScissorWithCountEXT( VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D * pScissors ) const VULKAN_HPP_NOEXCEPT
|
|
|
4691 {
|
|
|
4692 return ::vkCmdSetScissorWithCountEXT( commandBuffer, scissorCount, pScissors );
|
|
|
4693 }
|
|
|
4694
|
|
|
4695 void vkCmdBindVertexBuffers2EXT( VkCommandBuffer commandBuffer,
|
|
|
4696 uint32_t firstBinding,
|
|
|
4697 uint32_t bindingCount,
|
|
|
4698 const VkBuffer * pBuffers,
|
|
|
4699 const VkDeviceSize * pOffsets,
|
|
|
4700 const VkDeviceSize * pSizes,
|
|
|
4701 const VkDeviceSize * pStrides ) const VULKAN_HPP_NOEXCEPT
|
|
|
4702 {
|
|
|
4703 return ::vkCmdBindVertexBuffers2EXT( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides );
|
|
|
4704 }
|
|
|
4705
|
|
|
4706 void vkCmdSetDepthTestEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT
|
|
|
4707 {
|
|
|
4708 return ::vkCmdSetDepthTestEnableEXT( commandBuffer, depthTestEnable );
|
|
|
4709 }
|
|
|
4710
|
|
|
4711 void vkCmdSetDepthWriteEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT
|
|
|
4712 {
|
|
|
4713 return ::vkCmdSetDepthWriteEnableEXT( commandBuffer, depthWriteEnable );
|
|
|
4714 }
|
|
|
4715
|
|
|
4716 void vkCmdSetDepthCompareOpEXT( VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT
|
|
|
4717 {
|
|
|
4718 return ::vkCmdSetDepthCompareOpEXT( commandBuffer, depthCompareOp );
|
|
|
4719 }
|
|
|
4720
|
|
|
4721 void vkCmdSetDepthBoundsTestEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT
|
|
|
4722 {
|
|
|
4723 return ::vkCmdSetDepthBoundsTestEnableEXT( commandBuffer, depthBoundsTestEnable );
|
|
|
4724 }
|
|
|
4725
|
|
|
4726 void vkCmdSetStencilTestEnableEXT( VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT
|
|
|
4727 {
|
|
|
4728 return ::vkCmdSetStencilTestEnableEXT( commandBuffer, stencilTestEnable );
|
|
|
4729 }
|
|
|
4730
|
|
|
4731 void vkCmdSetStencilOpEXT( VkCommandBuffer commandBuffer,
|
|
|
4732 VkStencilFaceFlags faceMask,
|
|
|
4733 VkStencilOp failOp,
|
|
|
4734 VkStencilOp passOp,
|
|
|
4735 VkStencilOp depthFailOp,
|
|
|
4736 VkCompareOp compareOp ) const VULKAN_HPP_NOEXCEPT
|
|
|
4737 {
|
|
|
4738 return ::vkCmdSetStencilOpEXT( commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp );
|
|
|
4739 }
|
|
|
4740
|
|
|
4741 //=== VK_KHR_deferred_host_operations ===
|
|
|
4742
|
|
|
4743 VkResult vkCreateDeferredOperationKHR( VkDevice device,
|
|
|
4744 const VkAllocationCallbacks * pAllocator,
|
|
|
4745 VkDeferredOperationKHR * pDeferredOperation ) const VULKAN_HPP_NOEXCEPT
|
|
|
4746 {
|
|
|
4747 return ::vkCreateDeferredOperationKHR( device, pAllocator, pDeferredOperation );
|
|
|
4748 }
|
|
|
4749
|
|
|
4750 void
|
|
|
4751 vkDestroyDeferredOperationKHR( VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
4752 {
|
|
|
4753 return ::vkDestroyDeferredOperationKHR( device, operation, pAllocator );
|
|
|
4754 }
|
|
|
4755
|
|
|
4756 uint32_t vkGetDeferredOperationMaxConcurrencyKHR( VkDevice device, VkDeferredOperationKHR operation ) const VULKAN_HPP_NOEXCEPT
|
|
|
4757 {
|
|
|
4758 return ::vkGetDeferredOperationMaxConcurrencyKHR( device, operation );
|
|
|
4759 }
|
|
|
4760
|
|
|
4761 VkResult vkGetDeferredOperationResultKHR( VkDevice device, VkDeferredOperationKHR operation ) const VULKAN_HPP_NOEXCEPT
|
|
|
4762 {
|
|
|
4763 return ::vkGetDeferredOperationResultKHR( device, operation );
|
|
|
4764 }
|
|
|
4765
|
|
|
4766 VkResult vkDeferredOperationJoinKHR( VkDevice device, VkDeferredOperationKHR operation ) const VULKAN_HPP_NOEXCEPT
|
|
|
4767 {
|
|
|
4768 return ::vkDeferredOperationJoinKHR( device, operation );
|
|
|
4769 }
|
|
|
4770
|
|
|
4771 //=== VK_KHR_pipeline_executable_properties ===
|
|
|
4772
|
|
|
4773 VkResult vkGetPipelineExecutablePropertiesKHR( VkDevice device,
|
|
|
4774 const VkPipelineInfoKHR * pPipelineInfo,
|
|
|
4775 uint32_t * pExecutableCount,
|
|
|
4776 VkPipelineExecutablePropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
4777 {
|
|
|
4778 return ::vkGetPipelineExecutablePropertiesKHR( device, pPipelineInfo, pExecutableCount, pProperties );
|
|
|
4779 }
|
|
|
4780
|
|
|
4781 VkResult vkGetPipelineExecutableStatisticsKHR( VkDevice device,
|
|
|
4782 const VkPipelineExecutableInfoKHR * pExecutableInfo,
|
|
|
4783 uint32_t * pStatisticCount,
|
|
|
4784 VkPipelineExecutableStatisticKHR * pStatistics ) const VULKAN_HPP_NOEXCEPT
|
|
|
4785 {
|
|
|
4786 return ::vkGetPipelineExecutableStatisticsKHR( device, pExecutableInfo, pStatisticCount, pStatistics );
|
|
|
4787 }
|
|
|
4788
|
|
|
4789 VkResult
|
|
|
4790 vkGetPipelineExecutableInternalRepresentationsKHR( VkDevice device,
|
|
|
4791 const VkPipelineExecutableInfoKHR * pExecutableInfo,
|
|
|
4792 uint32_t * pInternalRepresentationCount,
|
|
|
4793 VkPipelineExecutableInternalRepresentationKHR * pInternalRepresentations ) const VULKAN_HPP_NOEXCEPT
|
|
|
4794 {
|
|
|
4795 return ::vkGetPipelineExecutableInternalRepresentationsKHR( device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations );
|
|
|
4796 }
|
|
|
4797
|
|
|
4798 //=== VK_EXT_host_image_copy ===
|
|
|
4799
|
|
|
4800 VkResult vkCopyMemoryToImageEXT( VkDevice device, const VkCopyMemoryToImageInfo * pCopyMemoryToImageInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
4801 {
|
|
|
4802 return ::vkCopyMemoryToImageEXT( device, pCopyMemoryToImageInfo );
|
|
|
4803 }
|
|
|
4804
|
|
|
4805 VkResult vkCopyImageToMemoryEXT( VkDevice device, const VkCopyImageToMemoryInfo * pCopyImageToMemoryInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
4806 {
|
|
|
4807 return ::vkCopyImageToMemoryEXT( device, pCopyImageToMemoryInfo );
|
|
|
4808 }
|
|
|
4809
|
|
|
4810 VkResult vkCopyImageToImageEXT( VkDevice device, const VkCopyImageToImageInfo * pCopyImageToImageInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
4811 {
|
|
|
4812 return ::vkCopyImageToImageEXT( device, pCopyImageToImageInfo );
|
|
|
4813 }
|
|
|
4814
|
|
|
4815 VkResult
|
|
|
4816 vkTransitionImageLayoutEXT( VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfo * pTransitions ) const VULKAN_HPP_NOEXCEPT
|
|
|
4817 {
|
|
|
4818 return ::vkTransitionImageLayoutEXT( device, transitionCount, pTransitions );
|
|
|
4819 }
|
|
|
4820
|
|
|
4821 void vkGetImageSubresourceLayout2EXT( VkDevice device,
|
|
|
4822 VkImage image,
|
|
|
4823 const VkImageSubresource2 * pSubresource,
|
|
|
4824 VkSubresourceLayout2 * pLayout ) const VULKAN_HPP_NOEXCEPT
|
|
|
4825 {
|
|
|
4826 return ::vkGetImageSubresourceLayout2EXT( device, image, pSubresource, pLayout );
|
|
|
4827 }
|
|
|
4828
|
|
|
4829 //=== VK_KHR_map_memory2 ===
|
|
|
4830
|
|
|
4831 VkResult vkMapMemory2KHR( VkDevice device, const VkMemoryMapInfo * pMemoryMapInfo, void ** ppData ) const VULKAN_HPP_NOEXCEPT
|
|
|
4832 {
|
|
|
4833 return ::vkMapMemory2KHR( device, pMemoryMapInfo, ppData );
|
|
|
4834 }
|
|
|
4835
|
|
|
4836 VkResult vkUnmapMemory2KHR( VkDevice device, const VkMemoryUnmapInfo * pMemoryUnmapInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
4837 {
|
|
|
4838 return ::vkUnmapMemory2KHR( device, pMemoryUnmapInfo );
|
|
|
4839 }
|
|
|
4840
|
|
|
4841 //=== VK_EXT_swapchain_maintenance1 ===
|
|
|
4842
|
|
|
4843 VkResult vkReleaseSwapchainImagesEXT( VkDevice device, const VkReleaseSwapchainImagesInfoKHR * pReleaseInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
4844 {
|
|
|
4845 return ::vkReleaseSwapchainImagesEXT( device, pReleaseInfo );
|
|
|
4846 }
|
|
|
4847
|
|
|
4848 //=== VK_NV_device_generated_commands ===
|
|
|
4849
|
|
|
4850 void vkGetGeneratedCommandsMemoryRequirementsNV( VkDevice device,
|
|
|
4851 const VkGeneratedCommandsMemoryRequirementsInfoNV * pInfo,
|
|
|
4852 VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
|
|
|
4853 {
|
|
|
4854 return ::vkGetGeneratedCommandsMemoryRequirementsNV( device, pInfo, pMemoryRequirements );
|
|
|
4855 }
|
|
|
4856
|
|
|
4857 void vkCmdPreprocessGeneratedCommandsNV( VkCommandBuffer commandBuffer,
|
|
|
4858 const VkGeneratedCommandsInfoNV * pGeneratedCommandsInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
4859 {
|
|
|
4860 return ::vkCmdPreprocessGeneratedCommandsNV( commandBuffer, pGeneratedCommandsInfo );
|
|
|
4861 }
|
|
|
4862
|
|
|
4863 void vkCmdExecuteGeneratedCommandsNV( VkCommandBuffer commandBuffer,
|
|
|
4864 VkBool32 isPreprocessed,
|
|
|
4865 const VkGeneratedCommandsInfoNV * pGeneratedCommandsInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
4866 {
|
|
|
4867 return ::vkCmdExecuteGeneratedCommandsNV( commandBuffer, isPreprocessed, pGeneratedCommandsInfo );
|
|
|
4868 }
|
|
|
4869
|
|
|
4870 void vkCmdBindPipelineShaderGroupNV( VkCommandBuffer commandBuffer,
|
|
|
4871 VkPipelineBindPoint pipelineBindPoint,
|
|
|
4872 VkPipeline pipeline,
|
|
|
4873 uint32_t groupIndex ) const VULKAN_HPP_NOEXCEPT
|
|
|
4874 {
|
|
|
4875 return ::vkCmdBindPipelineShaderGroupNV( commandBuffer, pipelineBindPoint, pipeline, groupIndex );
|
|
|
4876 }
|
|
|
4877
|
|
|
4878 VkResult vkCreateIndirectCommandsLayoutNV( VkDevice device,
|
|
|
4879 const VkIndirectCommandsLayoutCreateInfoNV * pCreateInfo,
|
|
|
4880 const VkAllocationCallbacks * pAllocator,
|
|
|
4881 VkIndirectCommandsLayoutNV * pIndirectCommandsLayout ) const VULKAN_HPP_NOEXCEPT
|
|
|
4882 {
|
|
|
4883 return ::vkCreateIndirectCommandsLayoutNV( device, pCreateInfo, pAllocator, pIndirectCommandsLayout );
|
|
|
4884 }
|
|
|
4885
|
|
|
4886 void vkDestroyIndirectCommandsLayoutNV( VkDevice device,
|
|
|
4887 VkIndirectCommandsLayoutNV indirectCommandsLayout,
|
|
|
4888 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
4889 {
|
|
|
4890 return ::vkDestroyIndirectCommandsLayoutNV( device, indirectCommandsLayout, pAllocator );
|
|
|
4891 }
|
|
|
4892
|
|
|
4893 //=== VK_EXT_depth_bias_control ===
|
|
|
4894
|
|
|
4895 void vkCmdSetDepthBias2EXT( VkCommandBuffer commandBuffer, const VkDepthBiasInfoEXT * pDepthBiasInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
4896 {
|
|
|
4897 return ::vkCmdSetDepthBias2EXT( commandBuffer, pDepthBiasInfo );
|
|
|
4898 }
|
|
|
4899
|
|
|
4900 //=== VK_EXT_acquire_drm_display ===
|
|
|
4901
|
|
|
4902 VkResult vkAcquireDrmDisplayEXT( VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT
|
|
|
4903 {
|
|
|
4904 return ::vkAcquireDrmDisplayEXT( physicalDevice, drmFd, display );
|
|
|
4905 }
|
|
|
4906
|
|
|
4907 VkResult vkGetDrmDisplayEXT( VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR * display ) const VULKAN_HPP_NOEXCEPT
|
|
|
4908 {
|
|
|
4909 return ::vkGetDrmDisplayEXT( physicalDevice, drmFd, connectorId, display );
|
|
|
4910 }
|
|
|
4911
|
|
|
4912 //=== VK_EXT_private_data ===
|
|
|
4913
|
|
|
4914 VkResult vkCreatePrivateDataSlotEXT( VkDevice device,
|
|
|
4915 const VkPrivateDataSlotCreateInfo * pCreateInfo,
|
|
|
4916 const VkAllocationCallbacks * pAllocator,
|
|
|
4917 VkPrivateDataSlot * pPrivateDataSlot ) const VULKAN_HPP_NOEXCEPT
|
|
|
4918 {
|
|
|
4919 return ::vkCreatePrivateDataSlotEXT( device, pCreateInfo, pAllocator, pPrivateDataSlot );
|
|
|
4920 }
|
|
|
4921
|
|
|
4922 void vkDestroyPrivateDataSlotEXT( VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
4923 {
|
|
|
4924 return ::vkDestroyPrivateDataSlotEXT( device, privateDataSlot, pAllocator );
|
|
|
4925 }
|
|
|
4926
|
|
|
4927 VkResult vkSetPrivateDataEXT( VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data ) const
|
|
|
4928 VULKAN_HPP_NOEXCEPT
|
|
|
4929 {
|
|
|
4930 return ::vkSetPrivateDataEXT( device, objectType, objectHandle, privateDataSlot, data );
|
|
|
4931 }
|
|
|
4932
|
|
|
4933 void vkGetPrivateDataEXT( VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t * pData ) const
|
|
|
4934 VULKAN_HPP_NOEXCEPT
|
|
|
4935 {
|
|
|
4936 return ::vkGetPrivateDataEXT( device, objectType, objectHandle, privateDataSlot, pData );
|
|
|
4937 }
|
|
|
4938
|
|
|
4939 //=== VK_KHR_video_encode_queue ===
|
|
|
4940
|
|
|
4941 VkResult
|
|
|
4942 vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( VkPhysicalDevice physicalDevice,
|
|
|
4943 const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR * pQualityLevelInfo,
|
|
|
4944 VkVideoEncodeQualityLevelPropertiesKHR * pQualityLevelProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
4945 {
|
|
|
4946 return ::vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( physicalDevice, pQualityLevelInfo, pQualityLevelProperties );
|
|
|
4947 }
|
|
|
4948
|
|
|
4949 VkResult vkGetEncodedVideoSessionParametersKHR( VkDevice device,
|
|
|
4950 const VkVideoEncodeSessionParametersGetInfoKHR * pVideoSessionParametersInfo,
|
|
|
4951 VkVideoEncodeSessionParametersFeedbackInfoKHR * pFeedbackInfo,
|
|
|
4952 size_t * pDataSize,
|
|
|
4953 void * pData ) const VULKAN_HPP_NOEXCEPT
|
|
|
4954 {
|
|
|
4955 return ::vkGetEncodedVideoSessionParametersKHR( device, pVideoSessionParametersInfo, pFeedbackInfo, pDataSize, pData );
|
|
|
4956 }
|
|
|
4957
|
|
|
4958 void vkCmdEncodeVideoKHR( VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR * pEncodeInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
4959 {
|
|
|
4960 return ::vkCmdEncodeVideoKHR( commandBuffer, pEncodeInfo );
|
|
|
4961 }
|
|
|
4962
|
|
|
4963 # if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
4964 //=== VK_NV_cuda_kernel_launch ===
|
|
|
4965
|
|
|
4966 VkResult vkCreateCudaModuleNV( VkDevice device,
|
|
|
4967 const VkCudaModuleCreateInfoNV * pCreateInfo,
|
|
|
4968 const VkAllocationCallbacks * pAllocator,
|
|
|
4969 VkCudaModuleNV * pModule ) const VULKAN_HPP_NOEXCEPT
|
|
|
4970 {
|
|
|
4971 return ::vkCreateCudaModuleNV( device, pCreateInfo, pAllocator, pModule );
|
|
|
4972 }
|
|
|
4973
|
|
|
4974 VkResult vkGetCudaModuleCacheNV( VkDevice device, VkCudaModuleNV module, size_t * pCacheSize, void * pCacheData ) const VULKAN_HPP_NOEXCEPT
|
|
|
4975 {
|
|
|
4976 return ::vkGetCudaModuleCacheNV( device, module, pCacheSize, pCacheData );
|
|
|
4977 }
|
|
|
4978
|
|
|
4979 VkResult vkCreateCudaFunctionNV( VkDevice device,
|
|
|
4980 const VkCudaFunctionCreateInfoNV * pCreateInfo,
|
|
|
4981 const VkAllocationCallbacks * pAllocator,
|
|
|
4982 VkCudaFunctionNV * pFunction ) const VULKAN_HPP_NOEXCEPT
|
|
|
4983 {
|
|
|
4984 return ::vkCreateCudaFunctionNV( device, pCreateInfo, pAllocator, pFunction );
|
|
|
4985 }
|
|
|
4986
|
|
|
4987 void vkDestroyCudaModuleNV( VkDevice device, VkCudaModuleNV module, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
4988 {
|
|
|
4989 return ::vkDestroyCudaModuleNV( device, module, pAllocator );
|
|
|
4990 }
|
|
|
4991
|
|
|
4992 void vkDestroyCudaFunctionNV( VkDevice device, VkCudaFunctionNV function, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
4993 {
|
|
|
4994 return ::vkDestroyCudaFunctionNV( device, function, pAllocator );
|
|
|
4995 }
|
|
|
4996
|
|
|
4997 void vkCmdCudaLaunchKernelNV( VkCommandBuffer commandBuffer, const VkCudaLaunchInfoNV * pLaunchInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
4998 {
|
|
|
4999 return ::vkCmdCudaLaunchKernelNV( commandBuffer, pLaunchInfo );
|
|
|
5000 }
|
|
|
5001 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
5002
|
|
|
5003 //=== VK_QCOM_tile_shading ===
|
|
|
5004
|
|
|
5005 void vkCmdDispatchTileQCOM( VkCommandBuffer commandBuffer, const VkDispatchTileInfoQCOM * pDispatchTileInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
5006 {
|
|
|
5007 return ::vkCmdDispatchTileQCOM( commandBuffer, pDispatchTileInfo );
|
|
|
5008 }
|
|
|
5009
|
|
|
5010 void vkCmdBeginPerTileExecutionQCOM( VkCommandBuffer commandBuffer, const VkPerTileBeginInfoQCOM * pPerTileBeginInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
5011 {
|
|
|
5012 return ::vkCmdBeginPerTileExecutionQCOM( commandBuffer, pPerTileBeginInfo );
|
|
|
5013 }
|
|
|
5014
|
|
|
5015 void vkCmdEndPerTileExecutionQCOM( VkCommandBuffer commandBuffer, const VkPerTileEndInfoQCOM * pPerTileEndInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
5016 {
|
|
|
5017 return ::vkCmdEndPerTileExecutionQCOM( commandBuffer, pPerTileEndInfo );
|
|
|
5018 }
|
|
|
5019
|
|
|
5020 # if defined( VK_USE_PLATFORM_METAL_EXT )
|
|
|
5021 //=== VK_EXT_metal_objects ===
|
|
|
5022
|
|
|
5023 void vkExportMetalObjectsEXT( VkDevice device, VkExportMetalObjectsInfoEXT * pMetalObjectsInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
5024 {
|
|
|
5025 return ::vkExportMetalObjectsEXT( device, pMetalObjectsInfo );
|
|
|
5026 }
|
|
|
5027 # endif /*VK_USE_PLATFORM_METAL_EXT*/
|
|
|
5028
|
|
|
5029 //=== VK_KHR_synchronization2 ===
|
|
|
5030
|
|
|
5031 void vkCmdSetEvent2KHR( VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
5032 {
|
|
|
5033 return ::vkCmdSetEvent2KHR( commandBuffer, event, pDependencyInfo );
|
|
|
5034 }
|
|
|
5035
|
|
|
5036 void vkCmdResetEvent2KHR( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask ) const VULKAN_HPP_NOEXCEPT
|
|
|
5037 {
|
|
|
5038 return ::vkCmdResetEvent2KHR( commandBuffer, event, stageMask );
|
|
|
5039 }
|
|
|
5040
|
|
|
5041 void vkCmdWaitEvents2KHR( VkCommandBuffer commandBuffer,
|
|
|
5042 uint32_t eventCount,
|
|
|
5043 const VkEvent * pEvents,
|
|
|
5044 const VkDependencyInfo * pDependencyInfos ) const VULKAN_HPP_NOEXCEPT
|
|
|
5045 {
|
|
|
5046 return ::vkCmdWaitEvents2KHR( commandBuffer, eventCount, pEvents, pDependencyInfos );
|
|
|
5047 }
|
|
|
5048
|
|
|
5049 void vkCmdPipelineBarrier2KHR( VkCommandBuffer commandBuffer, const VkDependencyInfo * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
5050 {
|
|
|
5051 return ::vkCmdPipelineBarrier2KHR( commandBuffer, pDependencyInfo );
|
|
|
5052 }
|
|
|
5053
|
|
|
5054 void
|
|
|
5055 vkCmdWriteTimestamp2KHR( VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT
|
|
|
5056 {
|
|
|
5057 return ::vkCmdWriteTimestamp2KHR( commandBuffer, stage, queryPool, query );
|
|
|
5058 }
|
|
|
5059
|
|
|
5060 VkResult vkQueueSubmit2KHR( VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 * pSubmits, VkFence fence ) const VULKAN_HPP_NOEXCEPT
|
|
|
5061 {
|
|
|
5062 return ::vkQueueSubmit2KHR( queue, submitCount, pSubmits, fence );
|
|
|
5063 }
|
|
|
5064
|
|
|
5065 //=== VK_EXT_descriptor_buffer ===
|
|
|
5066
|
|
|
5067 void vkGetDescriptorSetLayoutSizeEXT( VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize * pLayoutSizeInBytes ) const VULKAN_HPP_NOEXCEPT
|
|
|
5068 {
|
|
|
5069 return ::vkGetDescriptorSetLayoutSizeEXT( device, layout, pLayoutSizeInBytes );
|
|
|
5070 }
|
|
|
5071
|
|
|
5072 void vkGetDescriptorSetLayoutBindingOffsetEXT( VkDevice device,
|
|
|
5073 VkDescriptorSetLayout layout,
|
|
|
5074 uint32_t binding,
|
|
|
5075 VkDeviceSize * pOffset ) const VULKAN_HPP_NOEXCEPT
|
|
|
5076 {
|
|
|
5077 return ::vkGetDescriptorSetLayoutBindingOffsetEXT( device, layout, binding, pOffset );
|
|
|
5078 }
|
|
|
5079
|
|
|
5080 void vkGetDescriptorEXT( VkDevice device, const VkDescriptorGetInfoEXT * pDescriptorInfo, size_t dataSize, void * pDescriptor ) const VULKAN_HPP_NOEXCEPT
|
|
|
5081 {
|
|
|
5082 return ::vkGetDescriptorEXT( device, pDescriptorInfo, dataSize, pDescriptor );
|
|
|
5083 }
|
|
|
5084
|
|
|
5085 void vkCmdBindDescriptorBuffersEXT( VkCommandBuffer commandBuffer,
|
|
|
5086 uint32_t bufferCount,
|
|
|
5087 const VkDescriptorBufferBindingInfoEXT * pBindingInfos ) const VULKAN_HPP_NOEXCEPT
|
|
|
5088 {
|
|
|
5089 return ::vkCmdBindDescriptorBuffersEXT( commandBuffer, bufferCount, pBindingInfos );
|
|
|
5090 }
|
|
|
5091
|
|
|
5092 void vkCmdSetDescriptorBufferOffsetsEXT( VkCommandBuffer commandBuffer,
|
|
|
5093 VkPipelineBindPoint pipelineBindPoint,
|
|
|
5094 VkPipelineLayout layout,
|
|
|
5095 uint32_t firstSet,
|
|
|
5096 uint32_t setCount,
|
|
|
5097 const uint32_t * pBufferIndices,
|
|
|
5098 const VkDeviceSize * pOffsets ) const VULKAN_HPP_NOEXCEPT
|
|
|
5099 {
|
|
|
5100 return ::vkCmdSetDescriptorBufferOffsetsEXT( commandBuffer, pipelineBindPoint, layout, firstSet, setCount, pBufferIndices, pOffsets );
|
|
|
5101 }
|
|
|
5102
|
|
|
5103 void vkCmdBindDescriptorBufferEmbeddedSamplersEXT( VkCommandBuffer commandBuffer,
|
|
|
5104 VkPipelineBindPoint pipelineBindPoint,
|
|
|
5105 VkPipelineLayout layout,
|
|
|
5106 uint32_t set ) const VULKAN_HPP_NOEXCEPT
|
|
|
5107 {
|
|
|
5108 return ::vkCmdBindDescriptorBufferEmbeddedSamplersEXT( commandBuffer, pipelineBindPoint, layout, set );
|
|
|
5109 }
|
|
|
5110
|
|
|
5111 VkResult
|
|
|
5112 vkGetBufferOpaqueCaptureDescriptorDataEXT( VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT * pInfo, void * pData ) const VULKAN_HPP_NOEXCEPT
|
|
|
5113 {
|
|
|
5114 return ::vkGetBufferOpaqueCaptureDescriptorDataEXT( device, pInfo, pData );
|
|
|
5115 }
|
|
|
5116
|
|
|
5117 VkResult
|
|
|
5118 vkGetImageOpaqueCaptureDescriptorDataEXT( VkDevice device, const VkImageCaptureDescriptorDataInfoEXT * pInfo, void * pData ) const VULKAN_HPP_NOEXCEPT
|
|
|
5119 {
|
|
|
5120 return ::vkGetImageOpaqueCaptureDescriptorDataEXT( device, pInfo, pData );
|
|
|
5121 }
|
|
|
5122
|
|
|
5123 VkResult vkGetImageViewOpaqueCaptureDescriptorDataEXT( VkDevice device,
|
|
|
5124 const VkImageViewCaptureDescriptorDataInfoEXT * pInfo,
|
|
|
5125 void * pData ) const VULKAN_HPP_NOEXCEPT
|
|
|
5126 {
|
|
|
5127 return ::vkGetImageViewOpaqueCaptureDescriptorDataEXT( device, pInfo, pData );
|
|
|
5128 }
|
|
|
5129
|
|
|
5130 VkResult vkGetSamplerOpaqueCaptureDescriptorDataEXT( VkDevice device,
|
|
|
5131 const VkSamplerCaptureDescriptorDataInfoEXT * pInfo,
|
|
|
5132 void * pData ) const VULKAN_HPP_NOEXCEPT
|
|
|
5133 {
|
|
|
5134 return ::vkGetSamplerOpaqueCaptureDescriptorDataEXT( device, pInfo, pData );
|
|
|
5135 }
|
|
|
5136
|
|
|
5137 VkResult vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT( VkDevice device,
|
|
|
5138 const VkAccelerationStructureCaptureDescriptorDataInfoEXT * pInfo,
|
|
|
5139 void * pData ) const VULKAN_HPP_NOEXCEPT
|
|
|
5140 {
|
|
|
5141 return ::vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT( device, pInfo, pData );
|
|
|
5142 }
|
|
|
5143
|
|
|
5144 //=== VK_NV_fragment_shading_rate_enums ===
|
|
|
5145
|
|
|
5146 void vkCmdSetFragmentShadingRateEnumNV( VkCommandBuffer commandBuffer,
|
|
|
5147 VkFragmentShadingRateNV shadingRate,
|
|
|
5148 const VkFragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT
|
|
|
5149 {
|
|
|
5150 return ::vkCmdSetFragmentShadingRateEnumNV( commandBuffer, shadingRate, combinerOps );
|
|
|
5151 }
|
|
|
5152
|
|
|
5153 //=== VK_EXT_mesh_shader ===
|
|
|
5154
|
|
|
5155 void vkCmdDrawMeshTasksEXT( VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
|
|
|
5156 {
|
|
|
5157 return ::vkCmdDrawMeshTasksEXT( commandBuffer, groupCountX, groupCountY, groupCountZ );
|
|
|
5158 }
|
|
|
5159
|
|
|
5160 void vkCmdDrawMeshTasksIndirectEXT( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const
|
|
|
5161 VULKAN_HPP_NOEXCEPT
|
|
|
5162 {
|
|
|
5163 return ::vkCmdDrawMeshTasksIndirectEXT( commandBuffer, buffer, offset, drawCount, stride );
|
|
|
5164 }
|
|
|
5165
|
|
|
5166 void vkCmdDrawMeshTasksIndirectCountEXT( VkCommandBuffer commandBuffer,
|
|
|
5167 VkBuffer buffer,
|
|
|
5168 VkDeviceSize offset,
|
|
|
5169 VkBuffer countBuffer,
|
|
|
5170 VkDeviceSize countBufferOffset,
|
|
|
5171 uint32_t maxDrawCount,
|
|
|
5172 uint32_t stride ) const VULKAN_HPP_NOEXCEPT
|
|
|
5173 {
|
|
|
5174 return ::vkCmdDrawMeshTasksIndirectCountEXT( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride );
|
|
|
5175 }
|
|
|
5176
|
|
|
5177 //=== VK_KHR_copy_commands2 ===
|
|
|
5178
|
|
|
5179 void vkCmdCopyBuffer2KHR( VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 * pCopyBufferInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
5180 {
|
|
|
5181 return ::vkCmdCopyBuffer2KHR( commandBuffer, pCopyBufferInfo );
|
|
|
5182 }
|
|
|
5183
|
|
|
5184 void vkCmdCopyImage2KHR( VkCommandBuffer commandBuffer, const VkCopyImageInfo2 * pCopyImageInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
5185 {
|
|
|
5186 return ::vkCmdCopyImage2KHR( commandBuffer, pCopyImageInfo );
|
|
|
5187 }
|
|
|
5188
|
|
|
5189 void vkCmdCopyBufferToImage2KHR( VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 * pCopyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
5190 {
|
|
|
5191 return ::vkCmdCopyBufferToImage2KHR( commandBuffer, pCopyBufferToImageInfo );
|
|
|
5192 }
|
|
|
5193
|
|
|
5194 void vkCmdCopyImageToBuffer2KHR( VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 * pCopyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
5195 {
|
|
|
5196 return ::vkCmdCopyImageToBuffer2KHR( commandBuffer, pCopyImageToBufferInfo );
|
|
|
5197 }
|
|
|
5198
|
|
|
5199 void vkCmdBlitImage2KHR( VkCommandBuffer commandBuffer, const VkBlitImageInfo2 * pBlitImageInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
5200 {
|
|
|
5201 return ::vkCmdBlitImage2KHR( commandBuffer, pBlitImageInfo );
|
|
|
5202 }
|
|
|
5203
|
|
|
5204 void vkCmdResolveImage2KHR( VkCommandBuffer commandBuffer, const VkResolveImageInfo2 * pResolveImageInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
5205 {
|
|
|
5206 return ::vkCmdResolveImage2KHR( commandBuffer, pResolveImageInfo );
|
|
|
5207 }
|
|
|
5208
|
|
|
5209 //=== VK_EXT_device_fault ===
|
|
|
5210
|
|
|
5211 VkResult vkGetDeviceFaultInfoEXT( VkDevice device, VkDeviceFaultCountsEXT * pFaultCounts, VkDeviceFaultInfoEXT * pFaultInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
5212 {
|
|
|
5213 return ::vkGetDeviceFaultInfoEXT( device, pFaultCounts, pFaultInfo );
|
|
|
5214 }
|
|
|
5215
|
|
|
5216 # if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
5217 //=== VK_NV_acquire_winrt_display ===
|
|
|
5218
|
|
|
5219 VkResult vkAcquireWinrtDisplayNV( VkPhysicalDevice physicalDevice, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT
|
|
|
5220 {
|
|
|
5221 return ::vkAcquireWinrtDisplayNV( physicalDevice, display );
|
|
|
5222 }
|
|
|
5223
|
|
|
5224 VkResult vkGetWinrtDisplayNV( VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR * pDisplay ) const VULKAN_HPP_NOEXCEPT
|
|
|
5225 {
|
|
|
5226 return ::vkGetWinrtDisplayNV( physicalDevice, deviceRelativeId, pDisplay );
|
|
|
5227 }
|
|
|
5228 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
5229
|
|
|
5230 # if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
|
|
|
5231 //=== VK_EXT_directfb_surface ===
|
|
|
5232
|
|
|
5233 VkResult vkCreateDirectFBSurfaceEXT( VkInstance instance,
|
|
|
5234 const VkDirectFBSurfaceCreateInfoEXT * pCreateInfo,
|
|
|
5235 const VkAllocationCallbacks * pAllocator,
|
|
|
5236 VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
|
|
|
5237 {
|
|
|
5238 return ::vkCreateDirectFBSurfaceEXT( instance, pCreateInfo, pAllocator, pSurface );
|
|
|
5239 }
|
|
|
5240
|
|
|
5241 VkBool32 vkGetPhysicalDeviceDirectFBPresentationSupportEXT( VkPhysicalDevice physicalDevice,
|
|
|
5242 uint32_t queueFamilyIndex,
|
|
|
5243 IDirectFB * dfb ) const VULKAN_HPP_NOEXCEPT
|
|
|
5244 {
|
|
|
5245 return ::vkGetPhysicalDeviceDirectFBPresentationSupportEXT( physicalDevice, queueFamilyIndex, dfb );
|
|
|
5246 }
|
|
|
5247 # endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
|
|
|
5248
|
|
|
5249 //=== VK_EXT_vertex_input_dynamic_state ===
|
|
|
5250
|
|
|
5251 void vkCmdSetVertexInputEXT( VkCommandBuffer commandBuffer,
|
|
|
5252 uint32_t vertexBindingDescriptionCount,
|
|
|
5253 const VkVertexInputBindingDescription2EXT * pVertexBindingDescriptions,
|
|
|
5254 uint32_t vertexAttributeDescriptionCount,
|
|
|
5255 const VkVertexInputAttributeDescription2EXT * pVertexAttributeDescriptions ) const VULKAN_HPP_NOEXCEPT
|
|
|
5256 {
|
|
|
5257 return ::vkCmdSetVertexInputEXT(
|
|
|
5258 commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions );
|
|
|
5259 }
|
|
|
5260
|
|
|
5261 # if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
|
5262 //=== VK_FUCHSIA_external_memory ===
|
|
|
5263
|
|
|
5264 VkResult vkGetMemoryZirconHandleFUCHSIA( VkDevice device,
|
|
|
5265 const VkMemoryGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
|
|
|
5266 zx_handle_t * pZirconHandle ) const VULKAN_HPP_NOEXCEPT
|
|
|
5267 {
|
|
|
5268 return ::vkGetMemoryZirconHandleFUCHSIA( device, pGetZirconHandleInfo, pZirconHandle );
|
|
|
5269 }
|
|
|
5270
|
|
|
5271 VkResult vkGetMemoryZirconHandlePropertiesFUCHSIA( VkDevice device,
|
|
|
5272 VkExternalMemoryHandleTypeFlagBits handleType,
|
|
|
5273 zx_handle_t zirconHandle,
|
|
|
5274 VkMemoryZirconHandlePropertiesFUCHSIA * pMemoryZirconHandleProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
5275 {
|
|
|
5276 return ::vkGetMemoryZirconHandlePropertiesFUCHSIA( device, handleType, zirconHandle, pMemoryZirconHandleProperties );
|
|
|
5277 }
|
|
|
5278 # endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
5279
|
|
|
5280 # if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
|
5281 //=== VK_FUCHSIA_external_semaphore ===
|
|
|
5282
|
|
|
5283 VkResult
|
|
|
5284 vkImportSemaphoreZirconHandleFUCHSIA( VkDevice device,
|
|
|
5285 const VkImportSemaphoreZirconHandleInfoFUCHSIA * pImportSemaphoreZirconHandleInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
5286 {
|
|
|
5287 return ::vkImportSemaphoreZirconHandleFUCHSIA( device, pImportSemaphoreZirconHandleInfo );
|
|
|
5288 }
|
|
|
5289
|
|
|
5290 VkResult vkGetSemaphoreZirconHandleFUCHSIA( VkDevice device,
|
|
|
5291 const VkSemaphoreGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo,
|
|
|
5292 zx_handle_t * pZirconHandle ) const VULKAN_HPP_NOEXCEPT
|
|
|
5293 {
|
|
|
5294 return ::vkGetSemaphoreZirconHandleFUCHSIA( device, pGetZirconHandleInfo, pZirconHandle );
|
|
|
5295 }
|
|
|
5296 # endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
5297
|
|
|
5298 # if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
|
5299 //=== VK_FUCHSIA_buffer_collection ===
|
|
|
5300
|
|
|
5301 VkResult vkCreateBufferCollectionFUCHSIA( VkDevice device,
|
|
|
5302 const VkBufferCollectionCreateInfoFUCHSIA * pCreateInfo,
|
|
|
5303 const VkAllocationCallbacks * pAllocator,
|
|
|
5304 VkBufferCollectionFUCHSIA * pCollection ) const VULKAN_HPP_NOEXCEPT
|
|
|
5305 {
|
|
|
5306 return ::vkCreateBufferCollectionFUCHSIA( device, pCreateInfo, pAllocator, pCollection );
|
|
|
5307 }
|
|
|
5308
|
|
|
5309 VkResult vkSetBufferCollectionImageConstraintsFUCHSIA( VkDevice device,
|
|
|
5310 VkBufferCollectionFUCHSIA collection,
|
|
|
5311 const VkImageConstraintsInfoFUCHSIA * pImageConstraintsInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
5312 {
|
|
|
5313 return ::vkSetBufferCollectionImageConstraintsFUCHSIA( device, collection, pImageConstraintsInfo );
|
|
|
5314 }
|
|
|
5315
|
|
|
5316 VkResult vkSetBufferCollectionBufferConstraintsFUCHSIA( VkDevice device,
|
|
|
5317 VkBufferCollectionFUCHSIA collection,
|
|
|
5318 const VkBufferConstraintsInfoFUCHSIA * pBufferConstraintsInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
5319 {
|
|
|
5320 return ::vkSetBufferCollectionBufferConstraintsFUCHSIA( device, collection, pBufferConstraintsInfo );
|
|
|
5321 }
|
|
|
5322
|
|
|
5323 void vkDestroyBufferCollectionFUCHSIA( VkDevice device,
|
|
|
5324 VkBufferCollectionFUCHSIA collection,
|
|
|
5325 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
5326 {
|
|
|
5327 return ::vkDestroyBufferCollectionFUCHSIA( device, collection, pAllocator );
|
|
|
5328 }
|
|
|
5329
|
|
|
5330 VkResult vkGetBufferCollectionPropertiesFUCHSIA( VkDevice device,
|
|
|
5331 VkBufferCollectionFUCHSIA collection,
|
|
|
5332 VkBufferCollectionPropertiesFUCHSIA * pProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
5333 {
|
|
|
5334 return ::vkGetBufferCollectionPropertiesFUCHSIA( device, collection, pProperties );
|
|
|
5335 }
|
|
|
5336 # endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
5337
|
|
|
5338 //=== VK_HUAWEI_subpass_shading ===
|
|
|
5339
|
|
|
5340 VkResult
|
|
|
5341 vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( VkDevice device, VkRenderPass renderpass, VkExtent2D * pMaxWorkgroupSize ) const VULKAN_HPP_NOEXCEPT
|
|
|
5342 {
|
|
|
5343 return ::vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( device, renderpass, pMaxWorkgroupSize );
|
|
|
5344 }
|
|
|
5345
|
|
|
5346 void vkCmdSubpassShadingHUAWEI( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT
|
|
|
5347 {
|
|
|
5348 return ::vkCmdSubpassShadingHUAWEI( commandBuffer );
|
|
|
5349 }
|
|
|
5350
|
|
|
5351 //=== VK_HUAWEI_invocation_mask ===
|
|
|
5352
|
|
|
5353 void vkCmdBindInvocationMaskHUAWEI( VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT
|
|
|
5354 {
|
|
|
5355 return ::vkCmdBindInvocationMaskHUAWEI( commandBuffer, imageView, imageLayout );
|
|
|
5356 }
|
|
|
5357
|
|
|
5358 //=== VK_NV_external_memory_rdma ===
|
|
|
5359
|
|
|
5360 VkResult vkGetMemoryRemoteAddressNV( VkDevice device,
|
|
|
5361 const VkMemoryGetRemoteAddressInfoNV * pMemoryGetRemoteAddressInfo,
|
|
|
5362 VkRemoteAddressNV * pAddress ) const VULKAN_HPP_NOEXCEPT
|
|
|
5363 {
|
|
|
5364 return ::vkGetMemoryRemoteAddressNV( device, pMemoryGetRemoteAddressInfo, pAddress );
|
|
|
5365 }
|
|
|
5366
|
|
|
5367 //=== VK_EXT_pipeline_properties ===
|
|
|
5368
|
|
|
5369 VkResult vkGetPipelinePropertiesEXT( VkDevice device,
|
|
|
5370 const VkPipelineInfoEXT * pPipelineInfo,
|
|
|
5371 VkBaseOutStructure * pPipelineProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
5372 {
|
|
|
5373 return ::vkGetPipelinePropertiesEXT( device, pPipelineInfo, pPipelineProperties );
|
|
|
5374 }
|
|
|
5375
|
|
|
5376 //=== VK_EXT_extended_dynamic_state2 ===
|
|
|
5377
|
|
|
5378 void vkCmdSetPatchControlPointsEXT( VkCommandBuffer commandBuffer, uint32_t patchControlPoints ) const VULKAN_HPP_NOEXCEPT
|
|
|
5379 {
|
|
|
5380 return ::vkCmdSetPatchControlPointsEXT( commandBuffer, patchControlPoints );
|
|
|
5381 }
|
|
|
5382
|
|
|
5383 void vkCmdSetRasterizerDiscardEnableEXT( VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT
|
|
|
5384 {
|
|
|
5385 return ::vkCmdSetRasterizerDiscardEnableEXT( commandBuffer, rasterizerDiscardEnable );
|
|
|
5386 }
|
|
|
5387
|
|
|
5388 void vkCmdSetDepthBiasEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT
|
|
|
5389 {
|
|
|
5390 return ::vkCmdSetDepthBiasEnableEXT( commandBuffer, depthBiasEnable );
|
|
|
5391 }
|
|
|
5392
|
|
|
5393 void vkCmdSetLogicOpEXT( VkCommandBuffer commandBuffer, VkLogicOp logicOp ) const VULKAN_HPP_NOEXCEPT
|
|
|
5394 {
|
|
|
5395 return ::vkCmdSetLogicOpEXT( commandBuffer, logicOp );
|
|
|
5396 }
|
|
|
5397
|
|
|
5398 void vkCmdSetPrimitiveRestartEnableEXT( VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT
|
|
|
5399 {
|
|
|
5400 return ::vkCmdSetPrimitiveRestartEnableEXT( commandBuffer, primitiveRestartEnable );
|
|
|
5401 }
|
|
|
5402
|
|
|
5403 # if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
|
|
5404 //=== VK_QNX_screen_surface ===
|
|
|
5405
|
|
|
5406 VkResult vkCreateScreenSurfaceQNX( VkInstance instance,
|
|
|
5407 const VkScreenSurfaceCreateInfoQNX * pCreateInfo,
|
|
|
5408 const VkAllocationCallbacks * pAllocator,
|
|
|
5409 VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
|
|
|
5410 {
|
|
|
5411 return ::vkCreateScreenSurfaceQNX( instance, pCreateInfo, pAllocator, pSurface );
|
|
|
5412 }
|
|
|
5413
|
|
|
5414 VkBool32 vkGetPhysicalDeviceScreenPresentationSupportQNX( VkPhysicalDevice physicalDevice,
|
|
|
5415 uint32_t queueFamilyIndex,
|
|
|
5416 struct _screen_window * window ) const VULKAN_HPP_NOEXCEPT
|
|
|
5417 {
|
|
|
5418 return ::vkGetPhysicalDeviceScreenPresentationSupportQNX( physicalDevice, queueFamilyIndex, window );
|
|
|
5419 }
|
|
|
5420 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
|
|
5421
|
|
|
5422 //=== VK_EXT_color_write_enable ===
|
|
|
5423
|
|
|
5424 void vkCmdSetColorWriteEnableEXT( VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32 * pColorWriteEnables ) const VULKAN_HPP_NOEXCEPT
|
|
|
5425 {
|
|
|
5426 return ::vkCmdSetColorWriteEnableEXT( commandBuffer, attachmentCount, pColorWriteEnables );
|
|
|
5427 }
|
|
|
5428
|
|
|
5429 //=== VK_KHR_ray_tracing_maintenance1 ===
|
|
|
5430
|
|
|
5431 void vkCmdTraceRaysIndirect2KHR( VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT
|
|
|
5432 {
|
|
|
5433 return ::vkCmdTraceRaysIndirect2KHR( commandBuffer, indirectDeviceAddress );
|
|
|
5434 }
|
|
|
5435
|
|
|
5436 //=== VK_EXT_multi_draw ===
|
|
|
5437
|
|
|
5438 void vkCmdDrawMultiEXT( VkCommandBuffer commandBuffer,
|
|
|
5439 uint32_t drawCount,
|
|
|
5440 const VkMultiDrawInfoEXT * pVertexInfo,
|
|
|
5441 uint32_t instanceCount,
|
|
|
5442 uint32_t firstInstance,
|
|
|
5443 uint32_t stride ) const VULKAN_HPP_NOEXCEPT
|
|
|
5444 {
|
|
|
5445 return ::vkCmdDrawMultiEXT( commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride );
|
|
|
5446 }
|
|
|
5447
|
|
|
5448 void vkCmdDrawMultiIndexedEXT( VkCommandBuffer commandBuffer,
|
|
|
5449 uint32_t drawCount,
|
|
|
5450 const VkMultiDrawIndexedInfoEXT * pIndexInfo,
|
|
|
5451 uint32_t instanceCount,
|
|
|
5452 uint32_t firstInstance,
|
|
|
5453 uint32_t stride,
|
|
|
5454 const int32_t * pVertexOffset ) const VULKAN_HPP_NOEXCEPT
|
|
|
5455 {
|
|
|
5456 return ::vkCmdDrawMultiIndexedEXT( commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset );
|
|
|
5457 }
|
|
|
5458
|
|
|
5459 //=== VK_EXT_opacity_micromap ===
|
|
|
5460
|
|
|
5461 VkResult vkCreateMicromapEXT( VkDevice device,
|
|
|
5462 const VkMicromapCreateInfoEXT * pCreateInfo,
|
|
|
5463 const VkAllocationCallbacks * pAllocator,
|
|
|
5464 VkMicromapEXT * pMicromap ) const VULKAN_HPP_NOEXCEPT
|
|
|
5465 {
|
|
|
5466 return ::vkCreateMicromapEXT( device, pCreateInfo, pAllocator, pMicromap );
|
|
|
5467 }
|
|
|
5468
|
|
|
5469 void vkDestroyMicromapEXT( VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
5470 {
|
|
|
5471 return ::vkDestroyMicromapEXT( device, micromap, pAllocator );
|
|
|
5472 }
|
|
|
5473
|
|
|
5474 void vkCmdBuildMicromapsEXT( VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT * pInfos ) const VULKAN_HPP_NOEXCEPT
|
|
|
5475 {
|
|
|
5476 return ::vkCmdBuildMicromapsEXT( commandBuffer, infoCount, pInfos );
|
|
|
5477 }
|
|
|
5478
|
|
|
5479 VkResult vkBuildMicromapsEXT( VkDevice device,
|
|
|
5480 VkDeferredOperationKHR deferredOperation,
|
|
|
5481 uint32_t infoCount,
|
|
|
5482 const VkMicromapBuildInfoEXT * pInfos ) const VULKAN_HPP_NOEXCEPT
|
|
|
5483 {
|
|
|
5484 return ::vkBuildMicromapsEXT( device, deferredOperation, infoCount, pInfos );
|
|
|
5485 }
|
|
|
5486
|
|
|
5487 VkResult vkCopyMicromapEXT( VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
5488 {
|
|
|
5489 return ::vkCopyMicromapEXT( device, deferredOperation, pInfo );
|
|
|
5490 }
|
|
|
5491
|
|
|
5492 VkResult vkCopyMicromapToMemoryEXT( VkDevice device,
|
|
|
5493 VkDeferredOperationKHR deferredOperation,
|
|
|
5494 const VkCopyMicromapToMemoryInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
5495 {
|
|
|
5496 return ::vkCopyMicromapToMemoryEXT( device, deferredOperation, pInfo );
|
|
|
5497 }
|
|
|
5498
|
|
|
5499 VkResult vkCopyMemoryToMicromapEXT( VkDevice device,
|
|
|
5500 VkDeferredOperationKHR deferredOperation,
|
|
|
5501 const VkCopyMemoryToMicromapInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
5502 {
|
|
|
5503 return ::vkCopyMemoryToMicromapEXT( device, deferredOperation, pInfo );
|
|
|
5504 }
|
|
|
5505
|
|
|
5506 VkResult vkWriteMicromapsPropertiesEXT( VkDevice device,
|
|
|
5507 uint32_t micromapCount,
|
|
|
5508 const VkMicromapEXT * pMicromaps,
|
|
|
5509 VkQueryType queryType,
|
|
|
5510 size_t dataSize,
|
|
|
5511 void * pData,
|
|
|
5512 size_t stride ) const VULKAN_HPP_NOEXCEPT
|
|
|
5513 {
|
|
|
5514 return ::vkWriteMicromapsPropertiesEXT( device, micromapCount, pMicromaps, queryType, dataSize, pData, stride );
|
|
|
5515 }
|
|
|
5516
|
|
|
5517 void vkCmdCopyMicromapEXT( VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
5518 {
|
|
|
5519 return ::vkCmdCopyMicromapEXT( commandBuffer, pInfo );
|
|
|
5520 }
|
|
|
5521
|
|
|
5522 void vkCmdCopyMicromapToMemoryEXT( VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
5523 {
|
|
|
5524 return ::vkCmdCopyMicromapToMemoryEXT( commandBuffer, pInfo );
|
|
|
5525 }
|
|
|
5526
|
|
|
5527 void vkCmdCopyMemoryToMicromapEXT( VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
5528 {
|
|
|
5529 return ::vkCmdCopyMemoryToMicromapEXT( commandBuffer, pInfo );
|
|
|
5530 }
|
|
|
5531
|
|
|
5532 void vkCmdWriteMicromapsPropertiesEXT( VkCommandBuffer commandBuffer,
|
|
|
5533 uint32_t micromapCount,
|
|
|
5534 const VkMicromapEXT * pMicromaps,
|
|
|
5535 VkQueryType queryType,
|
|
|
5536 VkQueryPool queryPool,
|
|
|
5537 uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT
|
|
|
5538 {
|
|
|
5539 return ::vkCmdWriteMicromapsPropertiesEXT( commandBuffer, micromapCount, pMicromaps, queryType, queryPool, firstQuery );
|
|
|
5540 }
|
|
|
5541
|
|
|
5542 void vkGetDeviceMicromapCompatibilityEXT( VkDevice device,
|
|
|
5543 const VkMicromapVersionInfoEXT * pVersionInfo,
|
|
|
5544 VkAccelerationStructureCompatibilityKHR * pCompatibility ) const VULKAN_HPP_NOEXCEPT
|
|
|
5545 {
|
|
|
5546 return ::vkGetDeviceMicromapCompatibilityEXT( device, pVersionInfo, pCompatibility );
|
|
|
5547 }
|
|
|
5548
|
|
|
5549 void vkGetMicromapBuildSizesEXT( VkDevice device,
|
|
|
5550 VkAccelerationStructureBuildTypeKHR buildType,
|
|
|
5551 const VkMicromapBuildInfoEXT * pBuildInfo,
|
|
|
5552 VkMicromapBuildSizesInfoEXT * pSizeInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
5553 {
|
|
|
5554 return ::vkGetMicromapBuildSizesEXT( device, buildType, pBuildInfo, pSizeInfo );
|
|
|
5555 }
|
|
|
5556
|
|
|
5557 //=== VK_HUAWEI_cluster_culling_shader ===
|
|
|
5558
|
|
|
5559 void vkCmdDrawClusterHUAWEI( VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
|
|
|
5560 {
|
|
|
5561 return ::vkCmdDrawClusterHUAWEI( commandBuffer, groupCountX, groupCountY, groupCountZ );
|
|
|
5562 }
|
|
|
5563
|
|
|
5564 void vkCmdDrawClusterIndirectHUAWEI( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset ) const VULKAN_HPP_NOEXCEPT
|
|
|
5565 {
|
|
|
5566 return ::vkCmdDrawClusterIndirectHUAWEI( commandBuffer, buffer, offset );
|
|
|
5567 }
|
|
|
5568
|
|
|
5569 //=== VK_EXT_pageable_device_local_memory ===
|
|
|
5570
|
|
|
5571 void vkSetDeviceMemoryPriorityEXT( VkDevice device, VkDeviceMemory memory, float priority ) const VULKAN_HPP_NOEXCEPT
|
|
|
5572 {
|
|
|
5573 return ::vkSetDeviceMemoryPriorityEXT( device, memory, priority );
|
|
|
5574 }
|
|
|
5575
|
|
|
5576 //=== VK_KHR_maintenance4 ===
|
|
|
5577
|
|
|
5578 void vkGetDeviceBufferMemoryRequirementsKHR( VkDevice device,
|
|
|
5579 const VkDeviceBufferMemoryRequirements * pInfo,
|
|
|
5580 VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
|
|
|
5581 {
|
|
|
5582 return ::vkGetDeviceBufferMemoryRequirementsKHR( device, pInfo, pMemoryRequirements );
|
|
|
5583 }
|
|
|
5584
|
|
|
5585 void vkGetDeviceImageMemoryRequirementsKHR( VkDevice device,
|
|
|
5586 const VkDeviceImageMemoryRequirements * pInfo,
|
|
|
5587 VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
|
|
|
5588 {
|
|
|
5589 return ::vkGetDeviceImageMemoryRequirementsKHR( device, pInfo, pMemoryRequirements );
|
|
|
5590 }
|
|
|
5591
|
|
|
5592 void vkGetDeviceImageSparseMemoryRequirementsKHR( VkDevice device,
|
|
|
5593 const VkDeviceImageMemoryRequirements * pInfo,
|
|
|
5594 uint32_t * pSparseMemoryRequirementCount,
|
|
|
5595 VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
|
|
|
5596 {
|
|
|
5597 return ::vkGetDeviceImageSparseMemoryRequirementsKHR( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements );
|
|
|
5598 }
|
|
|
5599
|
|
|
5600 //=== VK_VALVE_descriptor_set_host_mapping ===
|
|
|
5601
|
|
|
5602 void vkGetDescriptorSetLayoutHostMappingInfoVALVE( VkDevice device,
|
|
|
5603 const VkDescriptorSetBindingReferenceVALVE * pBindingReference,
|
|
|
5604 VkDescriptorSetLayoutHostMappingInfoVALVE * pHostMapping ) const VULKAN_HPP_NOEXCEPT
|
|
|
5605 {
|
|
|
5606 return ::vkGetDescriptorSetLayoutHostMappingInfoVALVE( device, pBindingReference, pHostMapping );
|
|
|
5607 }
|
|
|
5608
|
|
|
5609 void vkGetDescriptorSetHostMappingVALVE( VkDevice device, VkDescriptorSet descriptorSet, void ** ppData ) const VULKAN_HPP_NOEXCEPT
|
|
|
5610 {
|
|
|
5611 return ::vkGetDescriptorSetHostMappingVALVE( device, descriptorSet, ppData );
|
|
|
5612 }
|
|
|
5613
|
|
|
5614 //=== VK_NV_copy_memory_indirect ===
|
|
|
5615
|
|
|
5616 void vkCmdCopyMemoryIndirectNV( VkCommandBuffer commandBuffer,
|
|
|
5617 VkDeviceAddress copyBufferAddress,
|
|
|
5618 uint32_t copyCount,
|
|
|
5619 uint32_t stride ) const VULKAN_HPP_NOEXCEPT
|
|
|
5620 {
|
|
|
5621 return ::vkCmdCopyMemoryIndirectNV( commandBuffer, copyBufferAddress, copyCount, stride );
|
|
|
5622 }
|
|
|
5623
|
|
|
5624 void vkCmdCopyMemoryToImageIndirectNV( VkCommandBuffer commandBuffer,
|
|
|
5625 VkDeviceAddress copyBufferAddress,
|
|
|
5626 uint32_t copyCount,
|
|
|
5627 uint32_t stride,
|
|
|
5628 VkImage dstImage,
|
|
|
5629 VkImageLayout dstImageLayout,
|
|
|
5630 const VkImageSubresourceLayers * pImageSubresources ) const VULKAN_HPP_NOEXCEPT
|
|
|
5631 {
|
|
|
5632 return ::vkCmdCopyMemoryToImageIndirectNV( commandBuffer, copyBufferAddress, copyCount, stride, dstImage, dstImageLayout, pImageSubresources );
|
|
|
5633 }
|
|
|
5634
|
|
|
5635 //=== VK_NV_memory_decompression ===
|
|
|
5636
|
|
|
5637 void vkCmdDecompressMemoryNV( VkCommandBuffer commandBuffer,
|
|
|
5638 uint32_t decompressRegionCount,
|
|
|
5639 const VkDecompressMemoryRegionNV * pDecompressMemoryRegions ) const VULKAN_HPP_NOEXCEPT
|
|
|
5640 {
|
|
|
5641 return ::vkCmdDecompressMemoryNV( commandBuffer, decompressRegionCount, pDecompressMemoryRegions );
|
|
|
5642 }
|
|
|
5643
|
|
|
5644 void vkCmdDecompressMemoryIndirectCountNV( VkCommandBuffer commandBuffer,
|
|
|
5645 VkDeviceAddress indirectCommandsAddress,
|
|
|
5646 VkDeviceAddress indirectCommandsCountAddress,
|
|
|
5647 uint32_t stride ) const VULKAN_HPP_NOEXCEPT
|
|
|
5648 {
|
|
|
5649 return ::vkCmdDecompressMemoryIndirectCountNV( commandBuffer, indirectCommandsAddress, indirectCommandsCountAddress, stride );
|
|
|
5650 }
|
|
|
5651
|
|
|
5652 //=== VK_NV_device_generated_commands_compute ===
|
|
|
5653
|
|
|
5654 void vkGetPipelineIndirectMemoryRequirementsNV( VkDevice device,
|
|
|
5655 const VkComputePipelineCreateInfo * pCreateInfo,
|
|
|
5656 VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
|
|
|
5657 {
|
|
|
5658 return ::vkGetPipelineIndirectMemoryRequirementsNV( device, pCreateInfo, pMemoryRequirements );
|
|
|
5659 }
|
|
|
5660
|
|
|
5661 void vkCmdUpdatePipelineIndirectBufferNV( VkCommandBuffer commandBuffer,
|
|
|
5662 VkPipelineBindPoint pipelineBindPoint,
|
|
|
5663 VkPipeline pipeline ) const VULKAN_HPP_NOEXCEPT
|
|
|
5664 {
|
|
|
5665 return ::vkCmdUpdatePipelineIndirectBufferNV( commandBuffer, pipelineBindPoint, pipeline );
|
|
|
5666 }
|
|
|
5667
|
|
|
5668 VkDeviceAddress vkGetPipelineIndirectDeviceAddressNV( VkDevice device, const VkPipelineIndirectDeviceAddressInfoNV * pInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
5669 {
|
|
|
5670 return ::vkGetPipelineIndirectDeviceAddressNV( device, pInfo );
|
|
|
5671 }
|
|
|
5672
|
|
|
5673 # if defined( VK_USE_PLATFORM_OHOS )
|
|
|
5674 //=== VK_OHOS_external_memory ===
|
|
|
5675
|
|
|
5676 VkResult vkGetNativeBufferPropertiesOHOS( VkDevice device,
|
|
|
5677 const struct OH_NativeBuffer * buffer,
|
|
|
5678 VkNativeBufferPropertiesOHOS * pProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
5679 {
|
|
|
5680 return ::vkGetNativeBufferPropertiesOHOS( device, buffer, pProperties );
|
|
|
5681 }
|
|
|
5682
|
|
|
5683 VkResult vkGetMemoryNativeBufferOHOS( VkDevice device,
|
|
|
5684 const VkMemoryGetNativeBufferInfoOHOS * pInfo,
|
|
|
5685 struct OH_NativeBuffer ** pBuffer ) const VULKAN_HPP_NOEXCEPT
|
|
|
5686 {
|
|
|
5687 return ::vkGetMemoryNativeBufferOHOS( device, pInfo, pBuffer );
|
|
|
5688 }
|
|
|
5689 # endif /*VK_USE_PLATFORM_OHOS*/
|
|
|
5690
|
|
|
5691 //=== VK_EXT_extended_dynamic_state3 ===
|
|
|
5692
|
|
|
5693 void vkCmdSetDepthClampEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthClampEnable ) const VULKAN_HPP_NOEXCEPT
|
|
|
5694 {
|
|
|
5695 return ::vkCmdSetDepthClampEnableEXT( commandBuffer, depthClampEnable );
|
|
|
5696 }
|
|
|
5697
|
|
|
5698 void vkCmdSetPolygonModeEXT( VkCommandBuffer commandBuffer, VkPolygonMode polygonMode ) const VULKAN_HPP_NOEXCEPT
|
|
|
5699 {
|
|
|
5700 return ::vkCmdSetPolygonModeEXT( commandBuffer, polygonMode );
|
|
|
5701 }
|
|
|
5702
|
|
|
5703 void vkCmdSetRasterizationSamplesEXT( VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples ) const VULKAN_HPP_NOEXCEPT
|
|
|
5704 {
|
|
|
5705 return ::vkCmdSetRasterizationSamplesEXT( commandBuffer, rasterizationSamples );
|
|
|
5706 }
|
|
|
5707
|
|
|
5708 void vkCmdSetSampleMaskEXT( VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask * pSampleMask ) const VULKAN_HPP_NOEXCEPT
|
|
|
5709 {
|
|
|
5710 return ::vkCmdSetSampleMaskEXT( commandBuffer, samples, pSampleMask );
|
|
|
5711 }
|
|
|
5712
|
|
|
5713 void vkCmdSetAlphaToCoverageEnableEXT( VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable ) const VULKAN_HPP_NOEXCEPT
|
|
|
5714 {
|
|
|
5715 return ::vkCmdSetAlphaToCoverageEnableEXT( commandBuffer, alphaToCoverageEnable );
|
|
|
5716 }
|
|
|
5717
|
|
|
5718 void vkCmdSetAlphaToOneEnableEXT( VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable ) const VULKAN_HPP_NOEXCEPT
|
|
|
5719 {
|
|
|
5720 return ::vkCmdSetAlphaToOneEnableEXT( commandBuffer, alphaToOneEnable );
|
|
|
5721 }
|
|
|
5722
|
|
|
5723 void vkCmdSetLogicOpEnableEXT( VkCommandBuffer commandBuffer, VkBool32 logicOpEnable ) const VULKAN_HPP_NOEXCEPT
|
|
|
5724 {
|
|
|
5725 return ::vkCmdSetLogicOpEnableEXT( commandBuffer, logicOpEnable );
|
|
|
5726 }
|
|
|
5727
|
|
|
5728 void vkCmdSetColorBlendEnableEXT( VkCommandBuffer commandBuffer,
|
|
|
5729 uint32_t firstAttachment,
|
|
|
5730 uint32_t attachmentCount,
|
|
|
5731 const VkBool32 * pColorBlendEnables ) const VULKAN_HPP_NOEXCEPT
|
|
|
5732 {
|
|
|
5733 return ::vkCmdSetColorBlendEnableEXT( commandBuffer, firstAttachment, attachmentCount, pColorBlendEnables );
|
|
|
5734 }
|
|
|
5735
|
|
|
5736 void vkCmdSetColorBlendEquationEXT( VkCommandBuffer commandBuffer,
|
|
|
5737 uint32_t firstAttachment,
|
|
|
5738 uint32_t attachmentCount,
|
|
|
5739 const VkColorBlendEquationEXT * pColorBlendEquations ) const VULKAN_HPP_NOEXCEPT
|
|
|
5740 {
|
|
|
5741 return ::vkCmdSetColorBlendEquationEXT( commandBuffer, firstAttachment, attachmentCount, pColorBlendEquations );
|
|
|
5742 }
|
|
|
5743
|
|
|
5744 void vkCmdSetColorWriteMaskEXT( VkCommandBuffer commandBuffer,
|
|
|
5745 uint32_t firstAttachment,
|
|
|
5746 uint32_t attachmentCount,
|
|
|
5747 const VkColorComponentFlags * pColorWriteMasks ) const VULKAN_HPP_NOEXCEPT
|
|
|
5748 {
|
|
|
5749 return ::vkCmdSetColorWriteMaskEXT( commandBuffer, firstAttachment, attachmentCount, pColorWriteMasks );
|
|
|
5750 }
|
|
|
5751
|
|
|
5752 void vkCmdSetTessellationDomainOriginEXT( VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin ) const VULKAN_HPP_NOEXCEPT
|
|
|
5753 {
|
|
|
5754 return ::vkCmdSetTessellationDomainOriginEXT( commandBuffer, domainOrigin );
|
|
|
5755 }
|
|
|
5756
|
|
|
5757 void vkCmdSetRasterizationStreamEXT( VkCommandBuffer commandBuffer, uint32_t rasterizationStream ) const VULKAN_HPP_NOEXCEPT
|
|
|
5758 {
|
|
|
5759 return ::vkCmdSetRasterizationStreamEXT( commandBuffer, rasterizationStream );
|
|
|
5760 }
|
|
|
5761
|
|
|
5762 void vkCmdSetConservativeRasterizationModeEXT( VkCommandBuffer commandBuffer,
|
|
|
5763 VkConservativeRasterizationModeEXT conservativeRasterizationMode ) const VULKAN_HPP_NOEXCEPT
|
|
|
5764 {
|
|
|
5765 return ::vkCmdSetConservativeRasterizationModeEXT( commandBuffer, conservativeRasterizationMode );
|
|
|
5766 }
|
|
|
5767
|
|
|
5768 void vkCmdSetExtraPrimitiveOverestimationSizeEXT( VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize ) const VULKAN_HPP_NOEXCEPT
|
|
|
5769 {
|
|
|
5770 return ::vkCmdSetExtraPrimitiveOverestimationSizeEXT( commandBuffer, extraPrimitiveOverestimationSize );
|
|
|
5771 }
|
|
|
5772
|
|
|
5773 void vkCmdSetDepthClipEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthClipEnable ) const VULKAN_HPP_NOEXCEPT
|
|
|
5774 {
|
|
|
5775 return ::vkCmdSetDepthClipEnableEXT( commandBuffer, depthClipEnable );
|
|
|
5776 }
|
|
|
5777
|
|
|
5778 void vkCmdSetSampleLocationsEnableEXT( VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable ) const VULKAN_HPP_NOEXCEPT
|
|
|
5779 {
|
|
|
5780 return ::vkCmdSetSampleLocationsEnableEXT( commandBuffer, sampleLocationsEnable );
|
|
|
5781 }
|
|
|
5782
|
|
|
5783 void vkCmdSetColorBlendAdvancedEXT( VkCommandBuffer commandBuffer,
|
|
|
5784 uint32_t firstAttachment,
|
|
|
5785 uint32_t attachmentCount,
|
|
|
5786 const VkColorBlendAdvancedEXT * pColorBlendAdvanced ) const VULKAN_HPP_NOEXCEPT
|
|
|
5787 {
|
|
|
5788 return ::vkCmdSetColorBlendAdvancedEXT( commandBuffer, firstAttachment, attachmentCount, pColorBlendAdvanced );
|
|
|
5789 }
|
|
|
5790
|
|
|
5791 void vkCmdSetProvokingVertexModeEXT( VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode ) const VULKAN_HPP_NOEXCEPT
|
|
|
5792 {
|
|
|
5793 return ::vkCmdSetProvokingVertexModeEXT( commandBuffer, provokingVertexMode );
|
|
|
5794 }
|
|
|
5795
|
|
|
5796 void vkCmdSetLineRasterizationModeEXT( VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode ) const VULKAN_HPP_NOEXCEPT
|
|
|
5797 {
|
|
|
5798 return ::vkCmdSetLineRasterizationModeEXT( commandBuffer, lineRasterizationMode );
|
|
|
5799 }
|
|
|
5800
|
|
|
5801 void vkCmdSetLineStippleEnableEXT( VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable ) const VULKAN_HPP_NOEXCEPT
|
|
|
5802 {
|
|
|
5803 return ::vkCmdSetLineStippleEnableEXT( commandBuffer, stippledLineEnable );
|
|
|
5804 }
|
|
|
5805
|
|
|
5806 void vkCmdSetDepthClipNegativeOneToOneEXT( VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne ) const VULKAN_HPP_NOEXCEPT
|
|
|
5807 {
|
|
|
5808 return ::vkCmdSetDepthClipNegativeOneToOneEXT( commandBuffer, negativeOneToOne );
|
|
|
5809 }
|
|
|
5810
|
|
|
5811 void vkCmdSetViewportWScalingEnableNV( VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable ) const VULKAN_HPP_NOEXCEPT
|
|
|
5812 {
|
|
|
5813 return ::vkCmdSetViewportWScalingEnableNV( commandBuffer, viewportWScalingEnable );
|
|
|
5814 }
|
|
|
5815
|
|
|
5816 void vkCmdSetViewportSwizzleNV( VkCommandBuffer commandBuffer,
|
|
|
5817 uint32_t firstViewport,
|
|
|
5818 uint32_t viewportCount,
|
|
|
5819 const VkViewportSwizzleNV * pViewportSwizzles ) const VULKAN_HPP_NOEXCEPT
|
|
|
5820 {
|
|
|
5821 return ::vkCmdSetViewportSwizzleNV( commandBuffer, firstViewport, viewportCount, pViewportSwizzles );
|
|
|
5822 }
|
|
|
5823
|
|
|
5824 void vkCmdSetCoverageToColorEnableNV( VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable ) const VULKAN_HPP_NOEXCEPT
|
|
|
5825 {
|
|
|
5826 return ::vkCmdSetCoverageToColorEnableNV( commandBuffer, coverageToColorEnable );
|
|
|
5827 }
|
|
|
5828
|
|
|
5829 void vkCmdSetCoverageToColorLocationNV( VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation ) const VULKAN_HPP_NOEXCEPT
|
|
|
5830 {
|
|
|
5831 return ::vkCmdSetCoverageToColorLocationNV( commandBuffer, coverageToColorLocation );
|
|
|
5832 }
|
|
|
5833
|
|
|
5834 void vkCmdSetCoverageModulationModeNV( VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode ) const VULKAN_HPP_NOEXCEPT
|
|
|
5835 {
|
|
|
5836 return ::vkCmdSetCoverageModulationModeNV( commandBuffer, coverageModulationMode );
|
|
|
5837 }
|
|
|
5838
|
|
|
5839 void vkCmdSetCoverageModulationTableEnableNV( VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable ) const VULKAN_HPP_NOEXCEPT
|
|
|
5840 {
|
|
|
5841 return ::vkCmdSetCoverageModulationTableEnableNV( commandBuffer, coverageModulationTableEnable );
|
|
|
5842 }
|
|
|
5843
|
|
|
5844 void vkCmdSetCoverageModulationTableNV( VkCommandBuffer commandBuffer,
|
|
|
5845 uint32_t coverageModulationTableCount,
|
|
|
5846 const float * pCoverageModulationTable ) const VULKAN_HPP_NOEXCEPT
|
|
|
5847 {
|
|
|
5848 return ::vkCmdSetCoverageModulationTableNV( commandBuffer, coverageModulationTableCount, pCoverageModulationTable );
|
|
|
5849 }
|
|
|
5850
|
|
|
5851 void vkCmdSetShadingRateImageEnableNV( VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable ) const VULKAN_HPP_NOEXCEPT
|
|
|
5852 {
|
|
|
5853 return ::vkCmdSetShadingRateImageEnableNV( commandBuffer, shadingRateImageEnable );
|
|
|
5854 }
|
|
|
5855
|
|
|
5856 void vkCmdSetRepresentativeFragmentTestEnableNV( VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable ) const VULKAN_HPP_NOEXCEPT
|
|
|
5857 {
|
|
|
5858 return ::vkCmdSetRepresentativeFragmentTestEnableNV( commandBuffer, representativeFragmentTestEnable );
|
|
|
5859 }
|
|
|
5860
|
|
|
5861 void vkCmdSetCoverageReductionModeNV( VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode ) const VULKAN_HPP_NOEXCEPT
|
|
|
5862 {
|
|
|
5863 return ::vkCmdSetCoverageReductionModeNV( commandBuffer, coverageReductionMode );
|
|
|
5864 }
|
|
|
5865
|
|
|
5866 //=== VK_ARM_tensors ===
|
|
|
5867
|
|
|
5868 VkResult vkCreateTensorARM( VkDevice device,
|
|
|
5869 const VkTensorCreateInfoARM * pCreateInfo,
|
|
|
5870 const VkAllocationCallbacks * pAllocator,
|
|
|
5871 VkTensorARM * pTensor ) const VULKAN_HPP_NOEXCEPT
|
|
|
5872 {
|
|
|
5873 return ::vkCreateTensorARM( device, pCreateInfo, pAllocator, pTensor );
|
|
|
5874 }
|
|
|
5875
|
|
|
5876 void vkDestroyTensorARM( VkDevice device, VkTensorARM tensor, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
5877 {
|
|
|
5878 return ::vkDestroyTensorARM( device, tensor, pAllocator );
|
|
|
5879 }
|
|
|
5880
|
|
|
5881 VkResult vkCreateTensorViewARM( VkDevice device,
|
|
|
5882 const VkTensorViewCreateInfoARM * pCreateInfo,
|
|
|
5883 const VkAllocationCallbacks * pAllocator,
|
|
|
5884 VkTensorViewARM * pView ) const VULKAN_HPP_NOEXCEPT
|
|
|
5885 {
|
|
|
5886 return ::vkCreateTensorViewARM( device, pCreateInfo, pAllocator, pView );
|
|
|
5887 }
|
|
|
5888
|
|
|
5889 void vkDestroyTensorViewARM( VkDevice device, VkTensorViewARM tensorView, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
5890 {
|
|
|
5891 return ::vkDestroyTensorViewARM( device, tensorView, pAllocator );
|
|
|
5892 }
|
|
|
5893
|
|
|
5894 void vkGetTensorMemoryRequirementsARM( VkDevice device,
|
|
|
5895 const VkTensorMemoryRequirementsInfoARM * pInfo,
|
|
|
5896 VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
|
|
|
5897 {
|
|
|
5898 return ::vkGetTensorMemoryRequirementsARM( device, pInfo, pMemoryRequirements );
|
|
|
5899 }
|
|
|
5900
|
|
|
5901 VkResult vkBindTensorMemoryARM( VkDevice device, uint32_t bindInfoCount, const VkBindTensorMemoryInfoARM * pBindInfos ) const VULKAN_HPP_NOEXCEPT
|
|
|
5902 {
|
|
|
5903 return ::vkBindTensorMemoryARM( device, bindInfoCount, pBindInfos );
|
|
|
5904 }
|
|
|
5905
|
|
|
5906 void vkGetDeviceTensorMemoryRequirementsARM( VkDevice device,
|
|
|
5907 const VkDeviceTensorMemoryRequirementsARM * pInfo,
|
|
|
5908 VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
|
|
|
5909 {
|
|
|
5910 return ::vkGetDeviceTensorMemoryRequirementsARM( device, pInfo, pMemoryRequirements );
|
|
|
5911 }
|
|
|
5912
|
|
|
5913 void vkCmdCopyTensorARM( VkCommandBuffer commandBuffer, const VkCopyTensorInfoARM * pCopyTensorInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
5914 {
|
|
|
5915 return ::vkCmdCopyTensorARM( commandBuffer, pCopyTensorInfo );
|
|
|
5916 }
|
|
|
5917
|
|
|
5918 void vkGetPhysicalDeviceExternalTensorPropertiesARM( VkPhysicalDevice physicalDevice,
|
|
|
5919 const VkPhysicalDeviceExternalTensorInfoARM * pExternalTensorInfo,
|
|
|
5920 VkExternalTensorPropertiesARM * pExternalTensorProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
5921 {
|
|
|
5922 return ::vkGetPhysicalDeviceExternalTensorPropertiesARM( physicalDevice, pExternalTensorInfo, pExternalTensorProperties );
|
|
|
5923 }
|
|
|
5924
|
|
|
5925 VkResult
|
|
|
5926 vkGetTensorOpaqueCaptureDescriptorDataARM( VkDevice device, const VkTensorCaptureDescriptorDataInfoARM * pInfo, void * pData ) const VULKAN_HPP_NOEXCEPT
|
|
|
5927 {
|
|
|
5928 return ::vkGetTensorOpaqueCaptureDescriptorDataARM( device, pInfo, pData );
|
|
|
5929 }
|
|
|
5930
|
|
|
5931 VkResult vkGetTensorViewOpaqueCaptureDescriptorDataARM( VkDevice device,
|
|
|
5932 const VkTensorViewCaptureDescriptorDataInfoARM * pInfo,
|
|
|
5933 void * pData ) const VULKAN_HPP_NOEXCEPT
|
|
|
5934 {
|
|
|
5935 return ::vkGetTensorViewOpaqueCaptureDescriptorDataARM( device, pInfo, pData );
|
|
|
5936 }
|
|
|
5937
|
|
|
5938 //=== VK_EXT_shader_module_identifier ===
|
|
|
5939
|
|
|
5940 void vkGetShaderModuleIdentifierEXT( VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT * pIdentifier ) const VULKAN_HPP_NOEXCEPT
|
|
|
5941 {
|
|
|
5942 return ::vkGetShaderModuleIdentifierEXT( device, shaderModule, pIdentifier );
|
|
|
5943 }
|
|
|
5944
|
|
|
5945 void vkGetShaderModuleCreateInfoIdentifierEXT( VkDevice device,
|
|
|
5946 const VkShaderModuleCreateInfo * pCreateInfo,
|
|
|
5947 VkShaderModuleIdentifierEXT * pIdentifier ) const VULKAN_HPP_NOEXCEPT
|
|
|
5948 {
|
|
|
5949 return ::vkGetShaderModuleCreateInfoIdentifierEXT( device, pCreateInfo, pIdentifier );
|
|
|
5950 }
|
|
|
5951
|
|
|
5952 //=== VK_NV_optical_flow ===
|
|
|
5953
|
|
|
5954 VkResult vkGetPhysicalDeviceOpticalFlowImageFormatsNV( VkPhysicalDevice physicalDevice,
|
|
|
5955 const VkOpticalFlowImageFormatInfoNV * pOpticalFlowImageFormatInfo,
|
|
|
5956 uint32_t * pFormatCount,
|
|
|
5957 VkOpticalFlowImageFormatPropertiesNV * pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
5958 {
|
|
|
5959 return ::vkGetPhysicalDeviceOpticalFlowImageFormatsNV( physicalDevice, pOpticalFlowImageFormatInfo, pFormatCount, pImageFormatProperties );
|
|
|
5960 }
|
|
|
5961
|
|
|
5962 VkResult vkCreateOpticalFlowSessionNV( VkDevice device,
|
|
|
5963 const VkOpticalFlowSessionCreateInfoNV * pCreateInfo,
|
|
|
5964 const VkAllocationCallbacks * pAllocator,
|
|
|
5965 VkOpticalFlowSessionNV * pSession ) const VULKAN_HPP_NOEXCEPT
|
|
|
5966 {
|
|
|
5967 return ::vkCreateOpticalFlowSessionNV( device, pCreateInfo, pAllocator, pSession );
|
|
|
5968 }
|
|
|
5969
|
|
|
5970 void vkDestroyOpticalFlowSessionNV( VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
5971 {
|
|
|
5972 return ::vkDestroyOpticalFlowSessionNV( device, session, pAllocator );
|
|
|
5973 }
|
|
|
5974
|
|
|
5975 VkResult vkBindOpticalFlowSessionImageNV( VkDevice device,
|
|
|
5976 VkOpticalFlowSessionNV session,
|
|
|
5977 VkOpticalFlowSessionBindingPointNV bindingPoint,
|
|
|
5978 VkImageView view,
|
|
|
5979 VkImageLayout layout ) const VULKAN_HPP_NOEXCEPT
|
|
|
5980 {
|
|
|
5981 return ::vkBindOpticalFlowSessionImageNV( device, session, bindingPoint, view, layout );
|
|
|
5982 }
|
|
|
5983
|
|
|
5984 void vkCmdOpticalFlowExecuteNV( VkCommandBuffer commandBuffer,
|
|
|
5985 VkOpticalFlowSessionNV session,
|
|
|
5986 const VkOpticalFlowExecuteInfoNV * pExecuteInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
5987 {
|
|
|
5988 return ::vkCmdOpticalFlowExecuteNV( commandBuffer, session, pExecuteInfo );
|
|
|
5989 }
|
|
|
5990
|
|
|
5991 //=== VK_KHR_maintenance5 ===
|
|
|
5992
|
|
|
5993 void vkCmdBindIndexBuffer2KHR( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType ) const
|
|
|
5994 VULKAN_HPP_NOEXCEPT
|
|
|
5995 {
|
|
|
5996 return ::vkCmdBindIndexBuffer2KHR( commandBuffer, buffer, offset, size, indexType );
|
|
|
5997 }
|
|
|
5998
|
|
|
5999 void
|
|
|
6000 vkGetRenderingAreaGranularityKHR( VkDevice device, const VkRenderingAreaInfo * pRenderingAreaInfo, VkExtent2D * pGranularity ) const VULKAN_HPP_NOEXCEPT
|
|
|
6001 {
|
|
|
6002 return ::vkGetRenderingAreaGranularityKHR( device, pRenderingAreaInfo, pGranularity );
|
|
|
6003 }
|
|
|
6004
|
|
|
6005 void vkGetDeviceImageSubresourceLayoutKHR( VkDevice device,
|
|
|
6006 const VkDeviceImageSubresourceInfo * pInfo,
|
|
|
6007 VkSubresourceLayout2 * pLayout ) const VULKAN_HPP_NOEXCEPT
|
|
|
6008 {
|
|
|
6009 return ::vkGetDeviceImageSubresourceLayoutKHR( device, pInfo, pLayout );
|
|
|
6010 }
|
|
|
6011
|
|
|
6012 void vkGetImageSubresourceLayout2KHR( VkDevice device,
|
|
|
6013 VkImage image,
|
|
|
6014 const VkImageSubresource2 * pSubresource,
|
|
|
6015 VkSubresourceLayout2 * pLayout ) const VULKAN_HPP_NOEXCEPT
|
|
|
6016 {
|
|
|
6017 return ::vkGetImageSubresourceLayout2KHR( device, image, pSubresource, pLayout );
|
|
|
6018 }
|
|
|
6019
|
|
|
6020 //=== VK_AMD_anti_lag ===
|
|
|
6021
|
|
|
6022 void vkAntiLagUpdateAMD( VkDevice device, const VkAntiLagDataAMD * pData ) const VULKAN_HPP_NOEXCEPT
|
|
|
6023 {
|
|
|
6024 return ::vkAntiLagUpdateAMD( device, pData );
|
|
|
6025 }
|
|
|
6026
|
|
|
6027 //=== VK_KHR_present_wait2 ===
|
|
|
6028
|
|
|
6029 VkResult vkWaitForPresent2KHR( VkDevice device, VkSwapchainKHR swapchain, const VkPresentWait2InfoKHR * pPresentWait2Info ) const VULKAN_HPP_NOEXCEPT
|
|
|
6030 {
|
|
|
6031 return ::vkWaitForPresent2KHR( device, swapchain, pPresentWait2Info );
|
|
|
6032 }
|
|
|
6033
|
|
|
6034 //=== VK_EXT_shader_object ===
|
|
|
6035
|
|
|
6036 VkResult vkCreateShadersEXT( VkDevice device,
|
|
|
6037 uint32_t createInfoCount,
|
|
|
6038 const VkShaderCreateInfoEXT * pCreateInfos,
|
|
|
6039 const VkAllocationCallbacks * pAllocator,
|
|
|
6040 VkShaderEXT * pShaders ) const VULKAN_HPP_NOEXCEPT
|
|
|
6041 {
|
|
|
6042 return ::vkCreateShadersEXT( device, createInfoCount, pCreateInfos, pAllocator, pShaders );
|
|
|
6043 }
|
|
|
6044
|
|
|
6045 void vkDestroyShaderEXT( VkDevice device, VkShaderEXT shader, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
6046 {
|
|
|
6047 return ::vkDestroyShaderEXT( device, shader, pAllocator );
|
|
|
6048 }
|
|
|
6049
|
|
|
6050 VkResult vkGetShaderBinaryDataEXT( VkDevice device, VkShaderEXT shader, size_t * pDataSize, void * pData ) const VULKAN_HPP_NOEXCEPT
|
|
|
6051 {
|
|
|
6052 return ::vkGetShaderBinaryDataEXT( device, shader, pDataSize, pData );
|
|
|
6053 }
|
|
|
6054
|
|
|
6055 void vkCmdBindShadersEXT( VkCommandBuffer commandBuffer,
|
|
|
6056 uint32_t stageCount,
|
|
|
6057 const VkShaderStageFlagBits * pStages,
|
|
|
6058 const VkShaderEXT * pShaders ) const VULKAN_HPP_NOEXCEPT
|
|
|
6059 {
|
|
|
6060 return ::vkCmdBindShadersEXT( commandBuffer, stageCount, pStages, pShaders );
|
|
|
6061 }
|
|
|
6062
|
|
|
6063 void vkCmdSetDepthClampRangeEXT( VkCommandBuffer commandBuffer,
|
|
|
6064 VkDepthClampModeEXT depthClampMode,
|
|
|
6065 const VkDepthClampRangeEXT * pDepthClampRange ) const VULKAN_HPP_NOEXCEPT
|
|
|
6066 {
|
|
|
6067 return ::vkCmdSetDepthClampRangeEXT( commandBuffer, depthClampMode, pDepthClampRange );
|
|
|
6068 }
|
|
|
6069
|
|
|
6070 //=== VK_KHR_pipeline_binary ===
|
|
|
6071
|
|
|
6072 VkResult vkCreatePipelineBinariesKHR( VkDevice device,
|
|
|
6073 const VkPipelineBinaryCreateInfoKHR * pCreateInfo,
|
|
|
6074 const VkAllocationCallbacks * pAllocator,
|
|
|
6075 VkPipelineBinaryHandlesInfoKHR * pBinaries ) const VULKAN_HPP_NOEXCEPT
|
|
|
6076 {
|
|
|
6077 return ::vkCreatePipelineBinariesKHR( device, pCreateInfo, pAllocator, pBinaries );
|
|
|
6078 }
|
|
|
6079
|
|
|
6080 void vkDestroyPipelineBinaryKHR( VkDevice device, VkPipelineBinaryKHR pipelineBinary, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
6081 {
|
|
|
6082 return ::vkDestroyPipelineBinaryKHR( device, pipelineBinary, pAllocator );
|
|
|
6083 }
|
|
|
6084
|
|
|
6085 VkResult vkGetPipelineKeyKHR( VkDevice device,
|
|
|
6086 const VkPipelineCreateInfoKHR * pPipelineCreateInfo,
|
|
|
6087 VkPipelineBinaryKeyKHR * pPipelineKey ) const VULKAN_HPP_NOEXCEPT
|
|
|
6088 {
|
|
|
6089 return ::vkGetPipelineKeyKHR( device, pPipelineCreateInfo, pPipelineKey );
|
|
|
6090 }
|
|
|
6091
|
|
|
6092 VkResult vkGetPipelineBinaryDataKHR( VkDevice device,
|
|
|
6093 const VkPipelineBinaryDataInfoKHR * pInfo,
|
|
|
6094 VkPipelineBinaryKeyKHR * pPipelineBinaryKey,
|
|
|
6095 size_t * pPipelineBinaryDataSize,
|
|
|
6096 void * pPipelineBinaryData ) const VULKAN_HPP_NOEXCEPT
|
|
|
6097 {
|
|
|
6098 return ::vkGetPipelineBinaryDataKHR( device, pInfo, pPipelineBinaryKey, pPipelineBinaryDataSize, pPipelineBinaryData );
|
|
|
6099 }
|
|
|
6100
|
|
|
6101 VkResult vkReleaseCapturedPipelineDataKHR( VkDevice device,
|
|
|
6102 const VkReleaseCapturedPipelineDataInfoKHR * pInfo,
|
|
|
6103 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
6104 {
|
|
|
6105 return ::vkReleaseCapturedPipelineDataKHR( device, pInfo, pAllocator );
|
|
|
6106 }
|
|
|
6107
|
|
|
6108 //=== VK_QCOM_tile_properties ===
|
|
|
6109
|
|
|
6110 VkResult vkGetFramebufferTilePropertiesQCOM( VkDevice device,
|
|
|
6111 VkFramebuffer framebuffer,
|
|
|
6112 uint32_t * pPropertiesCount,
|
|
|
6113 VkTilePropertiesQCOM * pProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
6114 {
|
|
|
6115 return ::vkGetFramebufferTilePropertiesQCOM( device, framebuffer, pPropertiesCount, pProperties );
|
|
|
6116 }
|
|
|
6117
|
|
|
6118 VkResult vkGetDynamicRenderingTilePropertiesQCOM( VkDevice device,
|
|
|
6119 const VkRenderingInfo * pRenderingInfo,
|
|
|
6120 VkTilePropertiesQCOM * pProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
6121 {
|
|
|
6122 return ::vkGetDynamicRenderingTilePropertiesQCOM( device, pRenderingInfo, pProperties );
|
|
|
6123 }
|
|
|
6124
|
|
|
6125 //=== VK_KHR_swapchain_maintenance1 ===
|
|
|
6126
|
|
|
6127 VkResult vkReleaseSwapchainImagesKHR( VkDevice device, const VkReleaseSwapchainImagesInfoKHR * pReleaseInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
6128 {
|
|
|
6129 return ::vkReleaseSwapchainImagesKHR( device, pReleaseInfo );
|
|
|
6130 }
|
|
|
6131
|
|
|
6132 //=== VK_NV_cooperative_vector ===
|
|
|
6133
|
|
|
6134 VkResult vkGetPhysicalDeviceCooperativeVectorPropertiesNV( VkPhysicalDevice physicalDevice,
|
|
|
6135 uint32_t * pPropertyCount,
|
|
|
6136 VkCooperativeVectorPropertiesNV * pProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
6137 {
|
|
|
6138 return ::vkGetPhysicalDeviceCooperativeVectorPropertiesNV( physicalDevice, pPropertyCount, pProperties );
|
|
|
6139 }
|
|
|
6140
|
|
|
6141 VkResult vkConvertCooperativeVectorMatrixNV( VkDevice device, const VkConvertCooperativeVectorMatrixInfoNV * pInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
6142 {
|
|
|
6143 return ::vkConvertCooperativeVectorMatrixNV( device, pInfo );
|
|
|
6144 }
|
|
|
6145
|
|
|
6146 void vkCmdConvertCooperativeVectorMatrixNV( VkCommandBuffer commandBuffer,
|
|
|
6147 uint32_t infoCount,
|
|
|
6148 const VkConvertCooperativeVectorMatrixInfoNV * pInfos ) const VULKAN_HPP_NOEXCEPT
|
|
|
6149 {
|
|
|
6150 return ::vkCmdConvertCooperativeVectorMatrixNV( commandBuffer, infoCount, pInfos );
|
|
|
6151 }
|
|
|
6152
|
|
|
6153 //=== VK_NV_low_latency2 ===
|
|
|
6154
|
|
|
6155 VkResult vkSetLatencySleepModeNV( VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepModeInfoNV * pSleepModeInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
6156 {
|
|
|
6157 return ::vkSetLatencySleepModeNV( device, swapchain, pSleepModeInfo );
|
|
|
6158 }
|
|
|
6159
|
|
|
6160 VkResult vkLatencySleepNV( VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepInfoNV * pSleepInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
6161 {
|
|
|
6162 return ::vkLatencySleepNV( device, swapchain, pSleepInfo );
|
|
|
6163 }
|
|
|
6164
|
|
|
6165 void vkSetLatencyMarkerNV( VkDevice device, VkSwapchainKHR swapchain, const VkSetLatencyMarkerInfoNV * pLatencyMarkerInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
6166 {
|
|
|
6167 return ::vkSetLatencyMarkerNV( device, swapchain, pLatencyMarkerInfo );
|
|
|
6168 }
|
|
|
6169
|
|
|
6170 void vkGetLatencyTimingsNV( VkDevice device, VkSwapchainKHR swapchain, VkGetLatencyMarkerInfoNV * pLatencyMarkerInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
6171 {
|
|
|
6172 return ::vkGetLatencyTimingsNV( device, swapchain, pLatencyMarkerInfo );
|
|
|
6173 }
|
|
|
6174
|
|
|
6175 void vkQueueNotifyOutOfBandNV( VkQueue queue, const VkOutOfBandQueueTypeInfoNV * pQueueTypeInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
6176 {
|
|
|
6177 return ::vkQueueNotifyOutOfBandNV( queue, pQueueTypeInfo );
|
|
|
6178 }
|
|
|
6179
|
|
|
6180 //=== VK_KHR_cooperative_matrix ===
|
|
|
6181
|
|
|
6182 VkResult vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( VkPhysicalDevice physicalDevice,
|
|
|
6183 uint32_t * pPropertyCount,
|
|
|
6184 VkCooperativeMatrixPropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
6185 {
|
|
|
6186 return ::vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( physicalDevice, pPropertyCount, pProperties );
|
|
|
6187 }
|
|
|
6188
|
|
|
6189 //=== VK_ARM_data_graph ===
|
|
|
6190
|
|
|
6191 VkResult vkCreateDataGraphPipelinesARM( VkDevice device,
|
|
|
6192 VkDeferredOperationKHR deferredOperation,
|
|
|
6193 VkPipelineCache pipelineCache,
|
|
|
6194 uint32_t createInfoCount,
|
|
|
6195 const VkDataGraphPipelineCreateInfoARM * pCreateInfos,
|
|
|
6196 const VkAllocationCallbacks * pAllocator,
|
|
|
6197 VkPipeline * pPipelines ) const VULKAN_HPP_NOEXCEPT
|
|
|
6198 {
|
|
|
6199 return ::vkCreateDataGraphPipelinesARM( device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines );
|
|
|
6200 }
|
|
|
6201
|
|
|
6202 VkResult vkCreateDataGraphPipelineSessionARM( VkDevice device,
|
|
|
6203 const VkDataGraphPipelineSessionCreateInfoARM * pCreateInfo,
|
|
|
6204 const VkAllocationCallbacks * pAllocator,
|
|
|
6205 VkDataGraphPipelineSessionARM * pSession ) const VULKAN_HPP_NOEXCEPT
|
|
|
6206 {
|
|
|
6207 return ::vkCreateDataGraphPipelineSessionARM( device, pCreateInfo, pAllocator, pSession );
|
|
|
6208 }
|
|
|
6209
|
|
|
6210 VkResult vkGetDataGraphPipelineSessionBindPointRequirementsARM( VkDevice device,
|
|
|
6211 const VkDataGraphPipelineSessionBindPointRequirementsInfoARM * pInfo,
|
|
|
6212 uint32_t * pBindPointRequirementCount,
|
|
|
6213 VkDataGraphPipelineSessionBindPointRequirementARM * pBindPointRequirements ) const
|
|
|
6214 VULKAN_HPP_NOEXCEPT
|
|
|
6215 {
|
|
|
6216 return ::vkGetDataGraphPipelineSessionBindPointRequirementsARM( device, pInfo, pBindPointRequirementCount, pBindPointRequirements );
|
|
|
6217 }
|
|
|
6218
|
|
|
6219 void vkGetDataGraphPipelineSessionMemoryRequirementsARM( VkDevice device,
|
|
|
6220 const VkDataGraphPipelineSessionMemoryRequirementsInfoARM * pInfo,
|
|
|
6221 VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
|
|
|
6222 {
|
|
|
6223 return ::vkGetDataGraphPipelineSessionMemoryRequirementsARM( device, pInfo, pMemoryRequirements );
|
|
|
6224 }
|
|
|
6225
|
|
|
6226 VkResult vkBindDataGraphPipelineSessionMemoryARM( VkDevice device,
|
|
|
6227 uint32_t bindInfoCount,
|
|
|
6228 const VkBindDataGraphPipelineSessionMemoryInfoARM * pBindInfos ) const VULKAN_HPP_NOEXCEPT
|
|
|
6229 {
|
|
|
6230 return ::vkBindDataGraphPipelineSessionMemoryARM( device, bindInfoCount, pBindInfos );
|
|
|
6231 }
|
|
|
6232
|
|
|
6233 void vkDestroyDataGraphPipelineSessionARM( VkDevice device,
|
|
|
6234 VkDataGraphPipelineSessionARM session,
|
|
|
6235 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
6236 {
|
|
|
6237 return ::vkDestroyDataGraphPipelineSessionARM( device, session, pAllocator );
|
|
|
6238 }
|
|
|
6239
|
|
|
6240 void vkCmdDispatchDataGraphARM( VkCommandBuffer commandBuffer,
|
|
|
6241 VkDataGraphPipelineSessionARM session,
|
|
|
6242 const VkDataGraphPipelineDispatchInfoARM * pInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
6243 {
|
|
|
6244 return ::vkCmdDispatchDataGraphARM( commandBuffer, session, pInfo );
|
|
|
6245 }
|
|
|
6246
|
|
|
6247 VkResult vkGetDataGraphPipelineAvailablePropertiesARM( VkDevice device,
|
|
|
6248 const VkDataGraphPipelineInfoARM * pPipelineInfo,
|
|
|
6249 uint32_t * pPropertiesCount,
|
|
|
6250 VkDataGraphPipelinePropertyARM * pProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
6251 {
|
|
|
6252 return ::vkGetDataGraphPipelineAvailablePropertiesARM( device, pPipelineInfo, pPropertiesCount, pProperties );
|
|
|
6253 }
|
|
|
6254
|
|
|
6255 VkResult vkGetDataGraphPipelinePropertiesARM( VkDevice device,
|
|
|
6256 const VkDataGraphPipelineInfoARM * pPipelineInfo,
|
|
|
6257 uint32_t propertiesCount,
|
|
|
6258 VkDataGraphPipelinePropertyQueryResultARM * pProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
6259 {
|
|
|
6260 return ::vkGetDataGraphPipelinePropertiesARM( device, pPipelineInfo, propertiesCount, pProperties );
|
|
|
6261 }
|
|
|
6262
|
|
|
6263 VkResult
|
|
|
6264 vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM( VkPhysicalDevice physicalDevice,
|
|
|
6265 uint32_t queueFamilyIndex,
|
|
|
6266 uint32_t * pQueueFamilyDataGraphPropertyCount,
|
|
|
6267 VkQueueFamilyDataGraphPropertiesARM * pQueueFamilyDataGraphProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
6268 {
|
|
|
6269 return ::vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM(
|
|
|
6270 physicalDevice, queueFamilyIndex, pQueueFamilyDataGraphPropertyCount, pQueueFamilyDataGraphProperties );
|
|
|
6271 }
|
|
|
6272
|
|
|
6273 void vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM(
|
|
|
6274 VkPhysicalDevice physicalDevice,
|
|
|
6275 const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM * pQueueFamilyDataGraphProcessingEngineInfo,
|
|
|
6276 VkQueueFamilyDataGraphProcessingEnginePropertiesARM * pQueueFamilyDataGraphProcessingEngineProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
6277 {
|
|
|
6278 return ::vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM(
|
|
|
6279 physicalDevice, pQueueFamilyDataGraphProcessingEngineInfo, pQueueFamilyDataGraphProcessingEngineProperties );
|
|
|
6280 }
|
|
|
6281
|
|
|
6282 //=== VK_EXT_attachment_feedback_loop_dynamic_state ===
|
|
|
6283
|
|
|
6284 void vkCmdSetAttachmentFeedbackLoopEnableEXT( VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask ) const VULKAN_HPP_NOEXCEPT
|
|
|
6285 {
|
|
|
6286 return ::vkCmdSetAttachmentFeedbackLoopEnableEXT( commandBuffer, aspectMask );
|
|
|
6287 }
|
|
|
6288
|
|
|
6289 # if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
|
|
6290 //=== VK_QNX_external_memory_screen_buffer ===
|
|
|
6291
|
|
|
6292 VkResult vkGetScreenBufferPropertiesQNX( VkDevice device,
|
|
|
6293 const struct _screen_buffer * buffer,
|
|
|
6294 VkScreenBufferPropertiesQNX * pProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
6295 {
|
|
|
6296 return ::vkGetScreenBufferPropertiesQNX( device, buffer, pProperties );
|
|
|
6297 }
|
|
|
6298 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
|
|
6299
|
|
|
6300 //=== VK_KHR_line_rasterization ===
|
|
|
6301
|
|
|
6302 void vkCmdSetLineStippleKHR( VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT
|
|
|
6303 {
|
|
|
6304 return ::vkCmdSetLineStippleKHR( commandBuffer, lineStippleFactor, lineStipplePattern );
|
|
|
6305 }
|
|
|
6306
|
|
|
6307 //=== VK_KHR_calibrated_timestamps ===
|
|
|
6308
|
|
|
6309 VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( VkPhysicalDevice physicalDevice,
|
|
|
6310 uint32_t * pTimeDomainCount,
|
|
|
6311 VkTimeDomainKHR * pTimeDomains ) const VULKAN_HPP_NOEXCEPT
|
|
|
6312 {
|
|
|
6313 return ::vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( physicalDevice, pTimeDomainCount, pTimeDomains );
|
|
|
6314 }
|
|
|
6315
|
|
|
6316 VkResult vkGetCalibratedTimestampsKHR( VkDevice device,
|
|
|
6317 uint32_t timestampCount,
|
|
|
6318 const VkCalibratedTimestampInfoKHR * pTimestampInfos,
|
|
|
6319 uint64_t * pTimestamps,
|
|
|
6320 uint64_t * pMaxDeviation ) const VULKAN_HPP_NOEXCEPT
|
|
|
6321 {
|
|
|
6322 return ::vkGetCalibratedTimestampsKHR( device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation );
|
|
|
6323 }
|
|
|
6324
|
|
|
6325 //=== VK_KHR_maintenance6 ===
|
|
|
6326
|
|
|
6327 void vkCmdBindDescriptorSets2KHR( VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfo * pBindDescriptorSetsInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
6328 {
|
|
|
6329 return ::vkCmdBindDescriptorSets2KHR( commandBuffer, pBindDescriptorSetsInfo );
|
|
|
6330 }
|
|
|
6331
|
|
|
6332 void vkCmdPushConstants2KHR( VkCommandBuffer commandBuffer, const VkPushConstantsInfo * pPushConstantsInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
6333 {
|
|
|
6334 return ::vkCmdPushConstants2KHR( commandBuffer, pPushConstantsInfo );
|
|
|
6335 }
|
|
|
6336
|
|
|
6337 void vkCmdPushDescriptorSet2KHR( VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfo * pPushDescriptorSetInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
6338 {
|
|
|
6339 return ::vkCmdPushDescriptorSet2KHR( commandBuffer, pPushDescriptorSetInfo );
|
|
|
6340 }
|
|
|
6341
|
|
|
6342 void vkCmdPushDescriptorSetWithTemplate2KHR( VkCommandBuffer commandBuffer,
|
|
|
6343 const VkPushDescriptorSetWithTemplateInfo * pPushDescriptorSetWithTemplateInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
6344 {
|
|
|
6345 return ::vkCmdPushDescriptorSetWithTemplate2KHR( commandBuffer, pPushDescriptorSetWithTemplateInfo );
|
|
|
6346 }
|
|
|
6347
|
|
|
6348 void vkCmdSetDescriptorBufferOffsets2EXT( VkCommandBuffer commandBuffer,
|
|
|
6349 const VkSetDescriptorBufferOffsetsInfoEXT * pSetDescriptorBufferOffsetsInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
6350 {
|
|
|
6351 return ::vkCmdSetDescriptorBufferOffsets2EXT( commandBuffer, pSetDescriptorBufferOffsetsInfo );
|
|
|
6352 }
|
|
|
6353
|
|
|
6354 void vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(
|
|
|
6355 VkCommandBuffer commandBuffer,
|
|
|
6356 const VkBindDescriptorBufferEmbeddedSamplersInfoEXT * pBindDescriptorBufferEmbeddedSamplersInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
6357 {
|
|
|
6358 return ::vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( commandBuffer, pBindDescriptorBufferEmbeddedSamplersInfo );
|
|
|
6359 }
|
|
|
6360
|
|
|
6361 //=== VK_QCOM_tile_memory_heap ===
|
|
|
6362
|
|
|
6363 void vkCmdBindTileMemoryQCOM( VkCommandBuffer commandBuffer, const VkTileMemoryBindInfoQCOM * pTileMemoryBindInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
6364 {
|
|
|
6365 return ::vkCmdBindTileMemoryQCOM( commandBuffer, pTileMemoryBindInfo );
|
|
|
6366 }
|
|
|
6367
|
|
|
6368 //=== VK_KHR_copy_memory_indirect ===
|
|
|
6369
|
|
|
6370 void vkCmdCopyMemoryIndirectKHR( VkCommandBuffer commandBuffer, const VkCopyMemoryIndirectInfoKHR * pCopyMemoryIndirectInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
6371 {
|
|
|
6372 return ::vkCmdCopyMemoryIndirectKHR( commandBuffer, pCopyMemoryIndirectInfo );
|
|
|
6373 }
|
|
|
6374
|
|
|
6375 void vkCmdCopyMemoryToImageIndirectKHR( VkCommandBuffer commandBuffer,
|
|
|
6376 const VkCopyMemoryToImageIndirectInfoKHR * pCopyMemoryToImageIndirectInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
6377 {
|
|
|
6378 return ::vkCmdCopyMemoryToImageIndirectKHR( commandBuffer, pCopyMemoryToImageIndirectInfo );
|
|
|
6379 }
|
|
|
6380
|
|
|
6381 //=== VK_EXT_memory_decompression ===
|
|
|
6382
|
|
|
6383 void vkCmdDecompressMemoryEXT( VkCommandBuffer commandBuffer, const VkDecompressMemoryInfoEXT * pDecompressMemoryInfoEXT ) const VULKAN_HPP_NOEXCEPT
|
|
|
6384 {
|
|
|
6385 return ::vkCmdDecompressMemoryEXT( commandBuffer, pDecompressMemoryInfoEXT );
|
|
|
6386 }
|
|
|
6387
|
|
|
6388 void vkCmdDecompressMemoryIndirectCountEXT( VkCommandBuffer commandBuffer,
|
|
|
6389 VkMemoryDecompressionMethodFlagsEXT decompressionMethod,
|
|
|
6390 VkDeviceAddress indirectCommandsAddress,
|
|
|
6391 VkDeviceAddress indirectCommandsCountAddress,
|
|
|
6392 uint32_t maxDecompressionCount,
|
|
|
6393 uint32_t stride ) const VULKAN_HPP_NOEXCEPT
|
|
|
6394 {
|
|
|
6395 return ::vkCmdDecompressMemoryIndirectCountEXT(
|
|
|
6396 commandBuffer, decompressionMethod, indirectCommandsAddress, indirectCommandsCountAddress, maxDecompressionCount, stride );
|
|
|
6397 }
|
|
|
6398
|
|
|
6399 //=== VK_NV_external_compute_queue ===
|
|
|
6400
|
|
|
6401 VkResult vkCreateExternalComputeQueueNV( VkDevice device,
|
|
|
6402 const VkExternalComputeQueueCreateInfoNV * pCreateInfo,
|
|
|
6403 const VkAllocationCallbacks * pAllocator,
|
|
|
6404 VkExternalComputeQueueNV * pExternalQueue ) const VULKAN_HPP_NOEXCEPT
|
|
|
6405 {
|
|
|
6406 return ::vkCreateExternalComputeQueueNV( device, pCreateInfo, pAllocator, pExternalQueue );
|
|
|
6407 }
|
|
|
6408
|
|
|
6409 void vkDestroyExternalComputeQueueNV( VkDevice device,
|
|
|
6410 VkExternalComputeQueueNV externalQueue,
|
|
|
6411 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
6412 {
|
|
|
6413 return ::vkDestroyExternalComputeQueueNV( device, externalQueue, pAllocator );
|
|
|
6414 }
|
|
|
6415
|
|
|
6416 void vkGetExternalComputeQueueDataNV( VkExternalComputeQueueNV externalQueue,
|
|
|
6417 VkExternalComputeQueueDataParamsNV * params,
|
|
|
6418 void * pData ) const VULKAN_HPP_NOEXCEPT
|
|
|
6419 {
|
|
|
6420 return ::vkGetExternalComputeQueueDataNV( externalQueue, params, pData );
|
|
|
6421 }
|
|
|
6422
|
|
|
6423 //=== VK_NV_cluster_acceleration_structure ===
|
|
|
6424
|
|
|
6425 void vkGetClusterAccelerationStructureBuildSizesNV( VkDevice device,
|
|
|
6426 const VkClusterAccelerationStructureInputInfoNV * pInfo,
|
|
|
6427 VkAccelerationStructureBuildSizesInfoKHR * pSizeInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
6428 {
|
|
|
6429 return ::vkGetClusterAccelerationStructureBuildSizesNV( device, pInfo, pSizeInfo );
|
|
|
6430 }
|
|
|
6431
|
|
|
6432 void vkCmdBuildClusterAccelerationStructureIndirectNV( VkCommandBuffer commandBuffer,
|
|
|
6433 const VkClusterAccelerationStructureCommandsInfoNV * pCommandInfos ) const VULKAN_HPP_NOEXCEPT
|
|
|
6434 {
|
|
|
6435 return ::vkCmdBuildClusterAccelerationStructureIndirectNV( commandBuffer, pCommandInfos );
|
|
|
6436 }
|
|
|
6437
|
|
|
6438 //=== VK_NV_partitioned_acceleration_structure ===
|
|
|
6439
|
|
|
6440 void vkGetPartitionedAccelerationStructuresBuildSizesNV( VkDevice device,
|
|
|
6441 const VkPartitionedAccelerationStructureInstancesInputNV * pInfo,
|
|
|
6442 VkAccelerationStructureBuildSizesInfoKHR * pSizeInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
6443 {
|
|
|
6444 return ::vkGetPartitionedAccelerationStructuresBuildSizesNV( device, pInfo, pSizeInfo );
|
|
|
6445 }
|
|
|
6446
|
|
|
6447 void vkCmdBuildPartitionedAccelerationStructuresNV( VkCommandBuffer commandBuffer,
|
|
|
6448 const VkBuildPartitionedAccelerationStructureInfoNV * pBuildInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
6449 {
|
|
|
6450 return ::vkCmdBuildPartitionedAccelerationStructuresNV( commandBuffer, pBuildInfo );
|
|
|
6451 }
|
|
|
6452
|
|
|
6453 //=== VK_EXT_device_generated_commands ===
|
|
|
6454
|
|
|
6455 void vkGetGeneratedCommandsMemoryRequirementsEXT( VkDevice device,
|
|
|
6456 const VkGeneratedCommandsMemoryRequirementsInfoEXT * pInfo,
|
|
|
6457 VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT
|
|
|
6458 {
|
|
|
6459 return ::vkGetGeneratedCommandsMemoryRequirementsEXT( device, pInfo, pMemoryRequirements );
|
|
|
6460 }
|
|
|
6461
|
|
|
6462 void vkCmdPreprocessGeneratedCommandsEXT( VkCommandBuffer commandBuffer,
|
|
|
6463 const VkGeneratedCommandsInfoEXT * pGeneratedCommandsInfo,
|
|
|
6464 VkCommandBuffer stateCommandBuffer ) const VULKAN_HPP_NOEXCEPT
|
|
|
6465 {
|
|
|
6466 return ::vkCmdPreprocessGeneratedCommandsEXT( commandBuffer, pGeneratedCommandsInfo, stateCommandBuffer );
|
|
|
6467 }
|
|
|
6468
|
|
|
6469 void vkCmdExecuteGeneratedCommandsEXT( VkCommandBuffer commandBuffer,
|
|
|
6470 VkBool32 isPreprocessed,
|
|
|
6471 const VkGeneratedCommandsInfoEXT * pGeneratedCommandsInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
6472 {
|
|
|
6473 return ::vkCmdExecuteGeneratedCommandsEXT( commandBuffer, isPreprocessed, pGeneratedCommandsInfo );
|
|
|
6474 }
|
|
|
6475
|
|
|
6476 VkResult vkCreateIndirectCommandsLayoutEXT( VkDevice device,
|
|
|
6477 const VkIndirectCommandsLayoutCreateInfoEXT * pCreateInfo,
|
|
|
6478 const VkAllocationCallbacks * pAllocator,
|
|
|
6479 VkIndirectCommandsLayoutEXT * pIndirectCommandsLayout ) const VULKAN_HPP_NOEXCEPT
|
|
|
6480 {
|
|
|
6481 return ::vkCreateIndirectCommandsLayoutEXT( device, pCreateInfo, pAllocator, pIndirectCommandsLayout );
|
|
|
6482 }
|
|
|
6483
|
|
|
6484 void vkDestroyIndirectCommandsLayoutEXT( VkDevice device,
|
|
|
6485 VkIndirectCommandsLayoutEXT indirectCommandsLayout,
|
|
|
6486 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
6487 {
|
|
|
6488 return ::vkDestroyIndirectCommandsLayoutEXT( device, indirectCommandsLayout, pAllocator );
|
|
|
6489 }
|
|
|
6490
|
|
|
6491 VkResult vkCreateIndirectExecutionSetEXT( VkDevice device,
|
|
|
6492 const VkIndirectExecutionSetCreateInfoEXT * pCreateInfo,
|
|
|
6493 const VkAllocationCallbacks * pAllocator,
|
|
|
6494 VkIndirectExecutionSetEXT * pIndirectExecutionSet ) const VULKAN_HPP_NOEXCEPT
|
|
|
6495 {
|
|
|
6496 return ::vkCreateIndirectExecutionSetEXT( device, pCreateInfo, pAllocator, pIndirectExecutionSet );
|
|
|
6497 }
|
|
|
6498
|
|
|
6499 void vkDestroyIndirectExecutionSetEXT( VkDevice device,
|
|
|
6500 VkIndirectExecutionSetEXT indirectExecutionSet,
|
|
|
6501 const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT
|
|
|
6502 {
|
|
|
6503 return ::vkDestroyIndirectExecutionSetEXT( device, indirectExecutionSet, pAllocator );
|
|
|
6504 }
|
|
|
6505
|
|
|
6506 void vkUpdateIndirectExecutionSetPipelineEXT( VkDevice device,
|
|
|
6507 VkIndirectExecutionSetEXT indirectExecutionSet,
|
|
|
6508 uint32_t executionSetWriteCount,
|
|
|
6509 const VkWriteIndirectExecutionSetPipelineEXT * pExecutionSetWrites ) const VULKAN_HPP_NOEXCEPT
|
|
|
6510 {
|
|
|
6511 return ::vkUpdateIndirectExecutionSetPipelineEXT( device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites );
|
|
|
6512 }
|
|
|
6513
|
|
|
6514 void vkUpdateIndirectExecutionSetShaderEXT( VkDevice device,
|
|
|
6515 VkIndirectExecutionSetEXT indirectExecutionSet,
|
|
|
6516 uint32_t executionSetWriteCount,
|
|
|
6517 const VkWriteIndirectExecutionSetShaderEXT * pExecutionSetWrites ) const VULKAN_HPP_NOEXCEPT
|
|
|
6518 {
|
|
|
6519 return ::vkUpdateIndirectExecutionSetShaderEXT( device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites );
|
|
|
6520 }
|
|
|
6521
|
|
|
6522 # if defined( VK_USE_PLATFORM_OHOS )
|
|
|
6523 //=== VK_OHOS_surface ===
|
|
|
6524
|
|
|
6525 VkResult vkCreateSurfaceOHOS( VkInstance instance,
|
|
|
6526 const VkSurfaceCreateInfoOHOS * pCreateInfo,
|
|
|
6527 const VkAllocationCallbacks * pAllocator,
|
|
|
6528 VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT
|
|
|
6529 {
|
|
|
6530 return ::vkCreateSurfaceOHOS( instance, pCreateInfo, pAllocator, pSurface );
|
|
|
6531 }
|
|
|
6532 # endif /*VK_USE_PLATFORM_OHOS*/
|
|
|
6533
|
|
|
6534 # if defined( VK_USE_PLATFORM_OHOS )
|
|
|
6535 //=== VK_OHOS_native_buffer ===
|
|
|
6536
|
|
|
6537 VkResult
|
|
|
6538 vkGetSwapchainGrallocUsageOHOS( VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, uint64_t * grallocUsage ) const VULKAN_HPP_NOEXCEPT
|
|
|
6539 {
|
|
|
6540 return ::vkGetSwapchainGrallocUsageOHOS( device, format, imageUsage, grallocUsage );
|
|
|
6541 }
|
|
|
6542
|
|
|
6543 VkResult vkAcquireImageOHOS( VkDevice device, VkImage image, int32_t nativeFenceFd, VkSemaphore semaphore, VkFence fence ) const VULKAN_HPP_NOEXCEPT
|
|
|
6544 {
|
|
|
6545 return ::vkAcquireImageOHOS( device, image, nativeFenceFd, semaphore, fence );
|
|
|
6546 }
|
|
|
6547
|
|
|
6548 VkResult vkQueueSignalReleaseImageOHOS(
|
|
|
6549 VkQueue queue, uint32_t waitSemaphoreCount, const VkSemaphore * pWaitSemaphores, VkImage image, int32_t * pNativeFenceFd ) const VULKAN_HPP_NOEXCEPT
|
|
|
6550 {
|
|
|
6551 return ::vkQueueSignalReleaseImageOHOS( queue, waitSemaphoreCount, pWaitSemaphores, image, pNativeFenceFd );
|
|
|
6552 }
|
|
|
6553 # endif /*VK_USE_PLATFORM_OHOS*/
|
|
|
6554
|
|
|
6555 //=== VK_NV_cooperative_matrix2 ===
|
|
|
6556
|
|
|
6557 VkResult vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(
|
|
|
6558 VkPhysicalDevice physicalDevice, uint32_t * pPropertyCount, VkCooperativeMatrixFlexibleDimensionsPropertiesNV * pProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
6559 {
|
|
|
6560 return ::vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV( physicalDevice, pPropertyCount, pProperties );
|
|
|
6561 }
|
|
|
6562
|
|
|
6563 # if defined( VK_USE_PLATFORM_METAL_EXT )
|
|
|
6564 //=== VK_EXT_external_memory_metal ===
|
|
|
6565
|
|
|
6566 VkResult
|
|
|
6567 vkGetMemoryMetalHandleEXT( VkDevice device, const VkMemoryGetMetalHandleInfoEXT * pGetMetalHandleInfo, void ** pHandle ) const VULKAN_HPP_NOEXCEPT
|
|
|
6568 {
|
|
|
6569 return ::vkGetMemoryMetalHandleEXT( device, pGetMetalHandleInfo, pHandle );
|
|
|
6570 }
|
|
|
6571
|
|
|
6572 VkResult vkGetMemoryMetalHandlePropertiesEXT( VkDevice device,
|
|
|
6573 VkExternalMemoryHandleTypeFlagBits handleType,
|
|
|
6574 const void * pHandle,
|
|
|
6575 VkMemoryMetalHandlePropertiesEXT * pMemoryMetalHandleProperties ) const VULKAN_HPP_NOEXCEPT
|
|
|
6576 {
|
|
|
6577 return ::vkGetMemoryMetalHandlePropertiesEXT( device, handleType, pHandle, pMemoryMetalHandleProperties );
|
|
|
6578 }
|
|
|
6579 # endif /*VK_USE_PLATFORM_METAL_EXT*/
|
|
|
6580
|
|
|
6581 //=== VK_ARM_performance_counters_by_region ===
|
|
|
6582
|
|
|
6583 VkResult vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM( VkPhysicalDevice physicalDevice,
|
|
|
6584 uint32_t queueFamilyIndex,
|
|
|
6585 uint32_t * pCounterCount,
|
|
|
6586 VkPerformanceCounterARM * pCounters,
|
|
|
6587 VkPerformanceCounterDescriptionARM * pCounterDescriptions ) const
|
|
|
6588 VULKAN_HPP_NOEXCEPT
|
|
|
6589 {
|
|
|
6590 return ::vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM(
|
|
|
6591 physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions );
|
|
|
6592 }
|
|
|
6593
|
|
|
6594 //=== VK_EXT_fragment_density_map_offset ===
|
|
|
6595
|
|
|
6596 void vkCmdEndRendering2EXT( VkCommandBuffer commandBuffer, const VkRenderingEndInfoKHR * pRenderingEndInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
6597 {
|
|
|
6598 return ::vkCmdEndRendering2EXT( commandBuffer, pRenderingEndInfo );
|
|
|
6599 }
|
|
|
6600
|
|
|
6601 //=== VK_EXT_custom_resolve ===
|
|
|
6602
|
|
|
6603 void vkCmdBeginCustomResolveEXT( VkCommandBuffer commandBuffer, const VkBeginCustomResolveInfoEXT * pBeginCustomResolveInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
6604 {
|
|
|
6605 return ::vkCmdBeginCustomResolveEXT( commandBuffer, pBeginCustomResolveInfo );
|
|
|
6606 }
|
|
|
6607
|
|
|
6608 //=== VK_KHR_maintenance10 ===
|
|
|
6609
|
|
|
6610 void vkCmdEndRendering2KHR( VkCommandBuffer commandBuffer, const VkRenderingEndInfoKHR * pRenderingEndInfo ) const VULKAN_HPP_NOEXCEPT
|
|
|
6611 {
|
|
|
6612 return ::vkCmdEndRendering2KHR( commandBuffer, pRenderingEndInfo );
|
|
|
6613 }
|
|
|
6614 };
|
|
|
6615
|
|
|
6616 template <>
|
|
|
6617 struct isDispatchLoader<DispatchLoaderStatic>
|
|
|
6618 {
|
|
|
6619 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
6620 };
|
|
|
6621
|
|
|
6622 inline DispatchLoaderStatic & getDispatchLoaderStatic()
|
|
|
6623 {
|
|
|
6624 static DispatchLoaderStatic dls;
|
|
|
6625 return dls;
|
|
|
6626 }
|
|
|
6627 #endif
|
|
|
6628
|
|
|
6629 } // namespace detail
|
|
|
6630 #if ( 14 <= VULKAN_HPP_CPP_VERSION )
|
|
|
6631 using std::exchange;
|
|
|
6632 #else
|
|
|
6633 template <class T, class U = T>
|
|
|
6634 VULKAN_HPP_CONSTEXPR_14 VULKAN_HPP_INLINE T exchange( T & obj, U && newValue )
|
|
|
6635 {
|
|
|
6636 T oldValue = std::move( obj );
|
|
|
6637 obj = std::forward<U>( newValue );
|
|
|
6638 return oldValue;
|
|
|
6639 }
|
|
|
6640 #endif
|
|
|
6641
|
|
|
6642 #if !defined( VULKAN_HPP_NO_SMART_HANDLE )
|
|
|
6643 struct AllocationCallbacks;
|
|
|
6644
|
|
|
6645 namespace detail
|
|
|
6646 {
|
|
|
6647 template <typename OwnerType, typename Dispatch>
|
|
|
6648 class ObjectDestroy
|
|
|
6649 {
|
|
|
6650 public:
|
|
|
6651 ObjectDestroy() = default;
|
|
|
6652
|
|
|
6653 ObjectDestroy( OwnerType owner,
|
|
|
6654 Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
6655 Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
|
|
|
6656 : m_owner( owner )
|
|
|
6657 , m_allocationCallbacks( allocationCallbacks )
|
|
|
6658 , m_dispatch( &dispatch )
|
|
|
6659 {
|
|
|
6660 }
|
|
|
6661
|
|
|
6662 OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
|
|
|
6663 {
|
|
|
6664 return m_owner;
|
|
|
6665 }
|
|
|
6666
|
|
|
6667 Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT
|
|
|
6668 {
|
|
|
6669 return m_allocationCallbacks;
|
|
|
6670 }
|
|
|
6671
|
|
|
6672 Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT
|
|
|
6673 {
|
|
|
6674 return *m_dispatch;
|
|
|
6675 }
|
|
|
6676
|
|
|
6677 protected:
|
|
|
6678 template <typename T>
|
|
|
6679 void destroy( T t ) VULKAN_HPP_NOEXCEPT
|
|
|
6680 {
|
|
|
6681 VULKAN_HPP_ASSERT( m_owner && m_dispatch );
|
|
|
6682 m_owner.destroy( t, m_allocationCallbacks, *m_dispatch );
|
|
|
6683 }
|
|
|
6684
|
|
|
6685 private:
|
|
|
6686 OwnerType m_owner = {};
|
|
|
6687 Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
|
|
|
6688 Dispatch const * m_dispatch = nullptr;
|
|
|
6689 };
|
|
|
6690
|
|
|
6691 class NoParent;
|
|
|
6692
|
|
|
6693 template <typename Dispatch>
|
|
|
6694 class ObjectDestroy<NoParent, Dispatch>
|
|
|
6695 {
|
|
|
6696 public:
|
|
|
6697 ObjectDestroy() = default;
|
|
|
6698
|
|
|
6699 ObjectDestroy( Optional<const AllocationCallbacks> allocationCallbacks,
|
|
|
6700 Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
|
|
|
6701 : m_allocationCallbacks( allocationCallbacks )
|
|
|
6702 , m_dispatch( &dispatch )
|
|
|
6703 {
|
|
|
6704 }
|
|
|
6705
|
|
|
6706 Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT
|
|
|
6707 {
|
|
|
6708 return m_allocationCallbacks;
|
|
|
6709 }
|
|
|
6710
|
|
|
6711 Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT
|
|
|
6712 {
|
|
|
6713 return *m_dispatch;
|
|
|
6714 }
|
|
|
6715
|
|
|
6716 protected:
|
|
|
6717 template <typename T>
|
|
|
6718 void destroy( T t ) VULKAN_HPP_NOEXCEPT
|
|
|
6719 {
|
|
|
6720 VULKAN_HPP_ASSERT( m_dispatch );
|
|
|
6721 t.destroy( m_allocationCallbacks, *m_dispatch );
|
|
|
6722 }
|
|
|
6723
|
|
|
6724 private:
|
|
|
6725 Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
|
|
|
6726 Dispatch const * m_dispatch = nullptr;
|
|
|
6727 };
|
|
|
6728
|
|
|
6729 template <typename OwnerType, typename Dispatch>
|
|
|
6730 class ObjectFree
|
|
|
6731 {
|
|
|
6732 public:
|
|
|
6733 ObjectFree() = default;
|
|
|
6734
|
|
|
6735 ObjectFree( OwnerType owner,
|
|
|
6736 Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
|
|
|
6737 Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
|
|
|
6738 : m_owner( owner )
|
|
|
6739 , m_allocationCallbacks( allocationCallbacks )
|
|
|
6740 , m_dispatch( &dispatch )
|
|
|
6741 {
|
|
|
6742 }
|
|
|
6743
|
|
|
6744 OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
|
|
|
6745 {
|
|
|
6746 return m_owner;
|
|
|
6747 }
|
|
|
6748
|
|
|
6749 Optional<const AllocationCallbacks> getAllocator() const VULKAN_HPP_NOEXCEPT
|
|
|
6750 {
|
|
|
6751 return m_allocationCallbacks;
|
|
|
6752 }
|
|
|
6753
|
|
|
6754 Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT
|
|
|
6755 {
|
|
|
6756 return *m_dispatch;
|
|
|
6757 }
|
|
|
6758
|
|
|
6759 protected:
|
|
|
6760 template <typename T>
|
|
|
6761 void destroy( T t ) VULKAN_HPP_NOEXCEPT
|
|
|
6762 {
|
|
|
6763 VULKAN_HPP_ASSERT( m_owner && m_dispatch );
|
|
|
6764 ( m_owner.free )( t, m_allocationCallbacks, *m_dispatch );
|
|
|
6765 }
|
|
|
6766
|
|
|
6767 private:
|
|
|
6768 OwnerType m_owner = {};
|
|
|
6769 Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
|
|
|
6770 Dispatch const * m_dispatch = nullptr;
|
|
|
6771 };
|
|
|
6772
|
|
|
6773 template <typename OwnerType, typename Dispatch>
|
|
|
6774 class ObjectRelease
|
|
|
6775 {
|
|
|
6776 public:
|
|
|
6777 ObjectRelease() = default;
|
|
|
6778
|
|
|
6779 ObjectRelease( OwnerType owner, Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
|
|
|
6780 : m_owner( owner )
|
|
|
6781 , m_dispatch( &dispatch )
|
|
|
6782 {
|
|
|
6783 }
|
|
|
6784
|
|
|
6785 OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
|
|
|
6786 {
|
|
|
6787 return m_owner;
|
|
|
6788 }
|
|
|
6789
|
|
|
6790 Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT
|
|
|
6791 {
|
|
|
6792 return *m_dispatch;
|
|
|
6793 }
|
|
|
6794
|
|
|
6795 protected:
|
|
|
6796 template <typename T>
|
|
|
6797 void destroy( T t ) VULKAN_HPP_NOEXCEPT
|
|
|
6798 {
|
|
|
6799 VULKAN_HPP_ASSERT( m_owner && m_dispatch );
|
|
|
6800 m_owner.release( t, *m_dispatch );
|
|
|
6801 }
|
|
|
6802
|
|
|
6803 private:
|
|
|
6804 OwnerType m_owner = {};
|
|
|
6805 Dispatch const * m_dispatch = nullptr;
|
|
|
6806 };
|
|
|
6807
|
|
|
6808 template <typename OwnerType, typename PoolType, typename Dispatch>
|
|
|
6809 class PoolFree
|
|
|
6810 {
|
|
|
6811 public:
|
|
|
6812 PoolFree() = default;
|
|
|
6813
|
|
|
6814 PoolFree( OwnerType owner, PoolType pool, Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
|
|
|
6815 : m_owner( owner )
|
|
|
6816 , m_pool( pool )
|
|
|
6817 , m_dispatch( &dispatch )
|
|
|
6818 {
|
|
|
6819 }
|
|
|
6820
|
|
|
6821 OwnerType getOwner() const VULKAN_HPP_NOEXCEPT
|
|
|
6822 {
|
|
|
6823 return m_owner;
|
|
|
6824 }
|
|
|
6825
|
|
|
6826 PoolType getPool() const VULKAN_HPP_NOEXCEPT
|
|
|
6827 {
|
|
|
6828 return m_pool;
|
|
|
6829 }
|
|
|
6830
|
|
|
6831 Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT
|
|
|
6832 {
|
|
|
6833 return *m_dispatch;
|
|
|
6834 }
|
|
|
6835
|
|
|
6836 protected:
|
|
|
6837 template <typename T>
|
|
|
6838 void destroy( T t ) VULKAN_HPP_NOEXCEPT
|
|
|
6839 {
|
|
|
6840 ( m_owner.free )( m_pool, t, *m_dispatch );
|
|
|
6841 }
|
|
|
6842
|
|
|
6843 private:
|
|
|
6844 OwnerType m_owner = OwnerType();
|
|
|
6845 PoolType m_pool = PoolType();
|
|
|
6846 Dispatch const * m_dispatch = nullptr;
|
|
|
6847 };
|
|
|
6848
|
|
|
6849 } // namespace detail
|
|
|
6850 #endif // !VULKAN_HPP_NO_SMART_HANDLE
|
|
|
6851
|
|
|
6852 //==================
|
|
|
6853 //=== BASE TYPEs ===
|
|
|
6854 //==================
|
|
|
6855
|
|
|
6856 using Bool32 = uint32_t;
|
|
|
6857 using DeviceAddress = uint64_t;
|
|
|
6858 using DeviceSize = uint64_t;
|
|
|
6859 using RemoteAddressNV = void *;
|
|
|
6860 using SampleMask = uint32_t;
|
|
|
6861
|
|
|
6862 template <typename Type, Type value = Type{}>
|
|
|
6863 struct CppType
|
|
|
6864 {
|
|
|
6865 };
|
|
|
6866 } // namespace VULKAN_HPP_NAMESPACE
|
|
|
6867
|
|
|
6868 #include <vulkan/vulkan_enums.hpp>
|
|
|
6869 #if !defined( VULKAN_HPP_NO_TO_STRING )
|
|
|
6870 # include <vulkan/vulkan_to_string.hpp>
|
|
|
6871 #endif
|
|
|
6872
|
|
|
6873 #ifndef VULKAN_HPP_NO_EXCEPTIONS
|
|
|
6874 namespace std
|
|
|
6875 {
|
|
|
6876 template <>
|
|
|
6877 struct is_error_code_enum<VULKAN_HPP_NAMESPACE::Result> : public true_type
|
|
|
6878 {
|
|
|
6879 };
|
|
|
6880 } // namespace std
|
|
|
6881 #endif
|
|
|
6882
|
|
|
6883 namespace VULKAN_HPP_NAMESPACE
|
|
|
6884 {
|
|
|
6885 #ifndef VULKAN_HPP_NO_EXCEPTIONS
|
|
|
6886 class ErrorCategoryImpl : public std::error_category
|
|
|
6887 {
|
|
|
6888 public:
|
|
|
6889 virtual const char * name() const VULKAN_HPP_NOEXCEPT override
|
|
|
6890 {
|
|
|
6891 return VULKAN_HPP_NAMESPACE_STRING "::Result";
|
|
|
6892 }
|
|
|
6893
|
|
|
6894 virtual std::string message( int ev ) const override
|
|
|
6895 {
|
|
|
6896 # if defined( VULKAN_HPP_NO_TO_STRING )
|
|
|
6897 return std::to_string( ev );
|
|
|
6898 # else
|
|
|
6899 return to_string( static_cast<Result>( ev ) );
|
|
|
6900 # endif
|
|
|
6901 }
|
|
|
6902 };
|
|
|
6903
|
|
|
6904 class Error
|
|
|
6905 {
|
|
|
6906 public:
|
|
|
6907 Error() VULKAN_HPP_NOEXCEPT = default;
|
|
|
6908 Error( const Error & ) VULKAN_HPP_NOEXCEPT = default;
|
|
|
6909 virtual ~Error() VULKAN_HPP_NOEXCEPT = default;
|
|
|
6910
|
|
|
6911 virtual const char * what() const VULKAN_HPP_NOEXCEPT = 0;
|
|
|
6912 };
|
|
|
6913
|
|
|
6914 class LogicError
|
|
|
6915 : public Error
|
|
|
6916 , public std::logic_error
|
|
|
6917 {
|
|
|
6918 public:
|
|
|
6919 explicit LogicError( const std::string & what ) : Error(), std::logic_error( what ) {}
|
|
|
6920
|
|
|
6921 explicit LogicError( char const * what ) : Error(), std::logic_error( what ) {}
|
|
|
6922
|
|
|
6923 virtual const char * what() const VULKAN_HPP_NOEXCEPT
|
|
|
6924 {
|
|
|
6925 return std::logic_error::what();
|
|
|
6926 }
|
|
|
6927 };
|
|
|
6928
|
|
|
6929 class SystemError
|
|
|
6930 : public Error
|
|
|
6931 , public std::system_error
|
|
|
6932 {
|
|
|
6933 public:
|
|
|
6934 SystemError( std::error_code ec ) : Error(), std::system_error( ec ) {}
|
|
|
6935
|
|
|
6936 SystemError( std::error_code ec, std::string const & what ) : Error(), std::system_error( ec, what ) {}
|
|
|
6937
|
|
|
6938 SystemError( std::error_code ec, char const * what ) : Error(), std::system_error( ec, what ) {}
|
|
|
6939
|
|
|
6940 SystemError( int ev, std::error_category const & ecat ) : Error(), std::system_error( ev, ecat ) {}
|
|
|
6941
|
|
|
6942 SystemError( int ev, std::error_category const & ecat, std::string const & what ) : Error(), std::system_error( ev, ecat, what ) {}
|
|
|
6943
|
|
|
6944 SystemError( int ev, std::error_category const & ecat, char const * what ) : Error(), std::system_error( ev, ecat, what ) {}
|
|
|
6945
|
|
|
6946 virtual const char * what() const VULKAN_HPP_NOEXCEPT
|
|
|
6947 {
|
|
|
6948 return std::system_error::what();
|
|
|
6949 }
|
|
|
6950 };
|
|
|
6951
|
|
|
6952 VULKAN_HPP_INLINE const std::error_category & errorCategory() VULKAN_HPP_NOEXCEPT
|
|
|
6953 {
|
|
|
6954 static ErrorCategoryImpl instance;
|
|
|
6955 return instance;
|
|
|
6956 }
|
|
|
6957
|
|
|
6958 VULKAN_HPP_INLINE std::error_code make_error_code( Result e ) VULKAN_HPP_NOEXCEPT
|
|
|
6959 {
|
|
|
6960 return std::error_code( static_cast<int>( e ), errorCategory() );
|
|
|
6961 }
|
|
|
6962
|
|
|
6963 VULKAN_HPP_INLINE std::error_condition make_error_condition( Result e ) VULKAN_HPP_NOEXCEPT
|
|
|
6964 {
|
|
|
6965 return std::error_condition( static_cast<int>( e ), errorCategory() );
|
|
|
6966 }
|
|
|
6967
|
|
|
6968 class OutOfHostMemoryError : public SystemError
|
|
|
6969 {
|
|
|
6970 public:
|
|
|
6971 OutOfHostMemoryError( std::string const & message ) : SystemError( make_error_code( Result::eErrorOutOfHostMemory ), message ) {}
|
|
|
6972
|
|
|
6973 OutOfHostMemoryError( char const * message ) : SystemError( make_error_code( Result::eErrorOutOfHostMemory ), message ) {}
|
|
|
6974 };
|
|
|
6975
|
|
|
6976 class OutOfDeviceMemoryError : public SystemError
|
|
|
6977 {
|
|
|
6978 public:
|
|
|
6979 OutOfDeviceMemoryError( std::string const & message ) : SystemError( make_error_code( Result::eErrorOutOfDeviceMemory ), message ) {}
|
|
|
6980
|
|
|
6981 OutOfDeviceMemoryError( char const * message ) : SystemError( make_error_code( Result::eErrorOutOfDeviceMemory ), message ) {}
|
|
|
6982 };
|
|
|
6983
|
|
|
6984 class InitializationFailedError : public SystemError
|
|
|
6985 {
|
|
|
6986 public:
|
|
|
6987 InitializationFailedError( std::string const & message ) : SystemError( make_error_code( Result::eErrorInitializationFailed ), message ) {}
|
|
|
6988
|
|
|
6989 InitializationFailedError( char const * message ) : SystemError( make_error_code( Result::eErrorInitializationFailed ), message ) {}
|
|
|
6990 };
|
|
|
6991
|
|
|
6992 class DeviceLostError : public SystemError
|
|
|
6993 {
|
|
|
6994 public:
|
|
|
6995 DeviceLostError( std::string const & message ) : SystemError( make_error_code( Result::eErrorDeviceLost ), message ) {}
|
|
|
6996
|
|
|
6997 DeviceLostError( char const * message ) : SystemError( make_error_code( Result::eErrorDeviceLost ), message ) {}
|
|
|
6998 };
|
|
|
6999
|
|
|
7000 class MemoryMapFailedError : public SystemError
|
|
|
7001 {
|
|
|
7002 public:
|
|
|
7003 MemoryMapFailedError( std::string const & message ) : SystemError( make_error_code( Result::eErrorMemoryMapFailed ), message ) {}
|
|
|
7004
|
|
|
7005 MemoryMapFailedError( char const * message ) : SystemError( make_error_code( Result::eErrorMemoryMapFailed ), message ) {}
|
|
|
7006 };
|
|
|
7007
|
|
|
7008 class LayerNotPresentError : public SystemError
|
|
|
7009 {
|
|
|
7010 public:
|
|
|
7011 LayerNotPresentError( std::string const & message ) : SystemError( make_error_code( Result::eErrorLayerNotPresent ), message ) {}
|
|
|
7012
|
|
|
7013 LayerNotPresentError( char const * message ) : SystemError( make_error_code( Result::eErrorLayerNotPresent ), message ) {}
|
|
|
7014 };
|
|
|
7015
|
|
|
7016 class ExtensionNotPresentError : public SystemError
|
|
|
7017 {
|
|
|
7018 public:
|
|
|
7019 ExtensionNotPresentError( std::string const & message ) : SystemError( make_error_code( Result::eErrorExtensionNotPresent ), message ) {}
|
|
|
7020
|
|
|
7021 ExtensionNotPresentError( char const * message ) : SystemError( make_error_code( Result::eErrorExtensionNotPresent ), message ) {}
|
|
|
7022 };
|
|
|
7023
|
|
|
7024 class FeatureNotPresentError : public SystemError
|
|
|
7025 {
|
|
|
7026 public:
|
|
|
7027 FeatureNotPresentError( std::string const & message ) : SystemError( make_error_code( Result::eErrorFeatureNotPresent ), message ) {}
|
|
|
7028
|
|
|
7029 FeatureNotPresentError( char const * message ) : SystemError( make_error_code( Result::eErrorFeatureNotPresent ), message ) {}
|
|
|
7030 };
|
|
|
7031
|
|
|
7032 class IncompatibleDriverError : public SystemError
|
|
|
7033 {
|
|
|
7034 public:
|
|
|
7035 IncompatibleDriverError( std::string const & message ) : SystemError( make_error_code( Result::eErrorIncompatibleDriver ), message ) {}
|
|
|
7036
|
|
|
7037 IncompatibleDriverError( char const * message ) : SystemError( make_error_code( Result::eErrorIncompatibleDriver ), message ) {}
|
|
|
7038 };
|
|
|
7039
|
|
|
7040 class TooManyObjectsError : public SystemError
|
|
|
7041 {
|
|
|
7042 public:
|
|
|
7043 TooManyObjectsError( std::string const & message ) : SystemError( make_error_code( Result::eErrorTooManyObjects ), message ) {}
|
|
|
7044
|
|
|
7045 TooManyObjectsError( char const * message ) : SystemError( make_error_code( Result::eErrorTooManyObjects ), message ) {}
|
|
|
7046 };
|
|
|
7047
|
|
|
7048 class FormatNotSupportedError : public SystemError
|
|
|
7049 {
|
|
|
7050 public:
|
|
|
7051 FormatNotSupportedError( std::string const & message ) : SystemError( make_error_code( Result::eErrorFormatNotSupported ), message ) {}
|
|
|
7052
|
|
|
7053 FormatNotSupportedError( char const * message ) : SystemError( make_error_code( Result::eErrorFormatNotSupported ), message ) {}
|
|
|
7054 };
|
|
|
7055
|
|
|
7056 class FragmentedPoolError : public SystemError
|
|
|
7057 {
|
|
|
7058 public:
|
|
|
7059 FragmentedPoolError( std::string const & message ) : SystemError( make_error_code( Result::eErrorFragmentedPool ), message ) {}
|
|
|
7060
|
|
|
7061 FragmentedPoolError( char const * message ) : SystemError( make_error_code( Result::eErrorFragmentedPool ), message ) {}
|
|
|
7062 };
|
|
|
7063
|
|
|
7064 class UnknownError : public SystemError
|
|
|
7065 {
|
|
|
7066 public:
|
|
|
7067 UnknownError( std::string const & message ) : SystemError( make_error_code( Result::eErrorUnknown ), message ) {}
|
|
|
7068
|
|
|
7069 UnknownError( char const * message ) : SystemError( make_error_code( Result::eErrorUnknown ), message ) {}
|
|
|
7070 };
|
|
|
7071
|
|
|
7072 class ValidationFailedError : public SystemError
|
|
|
7073 {
|
|
|
7074 public:
|
|
|
7075 ValidationFailedError( std::string const & message ) : SystemError( make_error_code( Result::eErrorValidationFailed ), message ) {}
|
|
|
7076
|
|
|
7077 ValidationFailedError( char const * message ) : SystemError( make_error_code( Result::eErrorValidationFailed ), message ) {}
|
|
|
7078 };
|
|
|
7079
|
|
|
7080 class OutOfPoolMemoryError : public SystemError
|
|
|
7081 {
|
|
|
7082 public:
|
|
|
7083 OutOfPoolMemoryError( std::string const & message ) : SystemError( make_error_code( Result::eErrorOutOfPoolMemory ), message ) {}
|
|
|
7084
|
|
|
7085 OutOfPoolMemoryError( char const * message ) : SystemError( make_error_code( Result::eErrorOutOfPoolMemory ), message ) {}
|
|
|
7086 };
|
|
|
7087
|
|
|
7088 class InvalidExternalHandleError : public SystemError
|
|
|
7089 {
|
|
|
7090 public:
|
|
|
7091 InvalidExternalHandleError( std::string const & message ) : SystemError( make_error_code( Result::eErrorInvalidExternalHandle ), message ) {}
|
|
|
7092
|
|
|
7093 InvalidExternalHandleError( char const * message ) : SystemError( make_error_code( Result::eErrorInvalidExternalHandle ), message ) {}
|
|
|
7094 };
|
|
|
7095
|
|
|
7096 class InvalidOpaqueCaptureAddressError : public SystemError
|
|
|
7097 {
|
|
|
7098 public:
|
|
|
7099 InvalidOpaqueCaptureAddressError( std::string const & message ) : SystemError( make_error_code( Result::eErrorInvalidOpaqueCaptureAddress ), message ) {}
|
|
|
7100
|
|
|
7101 InvalidOpaqueCaptureAddressError( char const * message ) : SystemError( make_error_code( Result::eErrorInvalidOpaqueCaptureAddress ), message ) {}
|
|
|
7102 };
|
|
|
7103
|
|
|
7104 class FragmentationError : public SystemError
|
|
|
7105 {
|
|
|
7106 public:
|
|
|
7107 FragmentationError( std::string const & message ) : SystemError( make_error_code( Result::eErrorFragmentation ), message ) {}
|
|
|
7108
|
|
|
7109 FragmentationError( char const * message ) : SystemError( make_error_code( Result::eErrorFragmentation ), message ) {}
|
|
|
7110 };
|
|
|
7111
|
|
|
7112 class NotPermittedError : public SystemError
|
|
|
7113 {
|
|
|
7114 public:
|
|
|
7115 NotPermittedError( std::string const & message ) : SystemError( make_error_code( Result::eErrorNotPermitted ), message ) {}
|
|
|
7116
|
|
|
7117 NotPermittedError( char const * message ) : SystemError( make_error_code( Result::eErrorNotPermitted ), message ) {}
|
|
|
7118 };
|
|
|
7119
|
|
|
7120 class SurfaceLostKHRError : public SystemError
|
|
|
7121 {
|
|
|
7122 public:
|
|
|
7123 SurfaceLostKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorSurfaceLostKHR ), message ) {}
|
|
|
7124
|
|
|
7125 SurfaceLostKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorSurfaceLostKHR ), message ) {}
|
|
|
7126 };
|
|
|
7127
|
|
|
7128 class NativeWindowInUseKHRError : public SystemError
|
|
|
7129 {
|
|
|
7130 public:
|
|
|
7131 NativeWindowInUseKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorNativeWindowInUseKHR ), message ) {}
|
|
|
7132
|
|
|
7133 NativeWindowInUseKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorNativeWindowInUseKHR ), message ) {}
|
|
|
7134 };
|
|
|
7135
|
|
|
7136 class OutOfDateKHRError : public SystemError
|
|
|
7137 {
|
|
|
7138 public:
|
|
|
7139 OutOfDateKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorOutOfDateKHR ), message ) {}
|
|
|
7140
|
|
|
7141 OutOfDateKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorOutOfDateKHR ), message ) {}
|
|
|
7142 };
|
|
|
7143
|
|
|
7144 class IncompatibleDisplayKHRError : public SystemError
|
|
|
7145 {
|
|
|
7146 public:
|
|
|
7147 IncompatibleDisplayKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorIncompatibleDisplayKHR ), message ) {}
|
|
|
7148
|
|
|
7149 IncompatibleDisplayKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorIncompatibleDisplayKHR ), message ) {}
|
|
|
7150 };
|
|
|
7151
|
|
|
7152 class InvalidShaderNVError : public SystemError
|
|
|
7153 {
|
|
|
7154 public:
|
|
|
7155 InvalidShaderNVError( std::string const & message ) : SystemError( make_error_code( Result::eErrorInvalidShaderNV ), message ) {}
|
|
|
7156
|
|
|
7157 InvalidShaderNVError( char const * message ) : SystemError( make_error_code( Result::eErrorInvalidShaderNV ), message ) {}
|
|
|
7158 };
|
|
|
7159
|
|
|
7160 class ImageUsageNotSupportedKHRError : public SystemError
|
|
|
7161 {
|
|
|
7162 public:
|
|
|
7163 ImageUsageNotSupportedKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorImageUsageNotSupportedKHR ), message ) {}
|
|
|
7164
|
|
|
7165 ImageUsageNotSupportedKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorImageUsageNotSupportedKHR ), message ) {}
|
|
|
7166 };
|
|
|
7167
|
|
|
7168 class VideoPictureLayoutNotSupportedKHRError : public SystemError
|
|
|
7169 {
|
|
|
7170 public:
|
|
|
7171 VideoPictureLayoutNotSupportedKHRError( std::string const & message )
|
|
|
7172 : SystemError( make_error_code( Result::eErrorVideoPictureLayoutNotSupportedKHR ), message )
|
|
|
7173 {
|
|
|
7174 }
|
|
|
7175
|
|
|
7176 VideoPictureLayoutNotSupportedKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorVideoPictureLayoutNotSupportedKHR ), message )
|
|
|
7177 {
|
|
|
7178 }
|
|
|
7179 };
|
|
|
7180
|
|
|
7181 class VideoProfileOperationNotSupportedKHRError : public SystemError
|
|
|
7182 {
|
|
|
7183 public:
|
|
|
7184 VideoProfileOperationNotSupportedKHRError( std::string const & message )
|
|
|
7185 : SystemError( make_error_code( Result::eErrorVideoProfileOperationNotSupportedKHR ), message )
|
|
|
7186 {
|
|
|
7187 }
|
|
|
7188
|
|
|
7189 VideoProfileOperationNotSupportedKHRError( char const * message )
|
|
|
7190 : SystemError( make_error_code( Result::eErrorVideoProfileOperationNotSupportedKHR ), message )
|
|
|
7191 {
|
|
|
7192 }
|
|
|
7193 };
|
|
|
7194
|
|
|
7195 class VideoProfileFormatNotSupportedKHRError : public SystemError
|
|
|
7196 {
|
|
|
7197 public:
|
|
|
7198 VideoProfileFormatNotSupportedKHRError( std::string const & message )
|
|
|
7199 : SystemError( make_error_code( Result::eErrorVideoProfileFormatNotSupportedKHR ), message )
|
|
|
7200 {
|
|
|
7201 }
|
|
|
7202
|
|
|
7203 VideoProfileFormatNotSupportedKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorVideoProfileFormatNotSupportedKHR ), message )
|
|
|
7204 {
|
|
|
7205 }
|
|
|
7206 };
|
|
|
7207
|
|
|
7208 class VideoProfileCodecNotSupportedKHRError : public SystemError
|
|
|
7209 {
|
|
|
7210 public:
|
|
|
7211 VideoProfileCodecNotSupportedKHRError( std::string const & message )
|
|
|
7212 : SystemError( make_error_code( Result::eErrorVideoProfileCodecNotSupportedKHR ), message )
|
|
|
7213 {
|
|
|
7214 }
|
|
|
7215
|
|
|
7216 VideoProfileCodecNotSupportedKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorVideoProfileCodecNotSupportedKHR ), message ) {}
|
|
|
7217 };
|
|
|
7218
|
|
|
7219 class VideoStdVersionNotSupportedKHRError : public SystemError
|
|
|
7220 {
|
|
|
7221 public:
|
|
|
7222 VideoStdVersionNotSupportedKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorVideoStdVersionNotSupportedKHR ), message )
|
|
|
7223 {
|
|
|
7224 }
|
|
|
7225
|
|
|
7226 VideoStdVersionNotSupportedKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorVideoStdVersionNotSupportedKHR ), message ) {}
|
|
|
7227 };
|
|
|
7228
|
|
|
7229 class InvalidDrmFormatModifierPlaneLayoutEXTError : public SystemError
|
|
|
7230 {
|
|
|
7231 public:
|
|
|
7232 InvalidDrmFormatModifierPlaneLayoutEXTError( std::string const & message )
|
|
|
7233 : SystemError( make_error_code( Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT ), message )
|
|
|
7234 {
|
|
|
7235 }
|
|
|
7236
|
|
|
7237 InvalidDrmFormatModifierPlaneLayoutEXTError( char const * message )
|
|
|
7238 : SystemError( make_error_code( Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT ), message )
|
|
|
7239 {
|
|
|
7240 }
|
|
|
7241 };
|
|
|
7242
|
|
|
7243 # if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
7244 class FullScreenExclusiveModeLostEXTError : public SystemError
|
|
|
7245 {
|
|
|
7246 public:
|
|
|
7247 FullScreenExclusiveModeLostEXTError( std::string const & message ) : SystemError( make_error_code( Result::eErrorFullScreenExclusiveModeLostEXT ), message )
|
|
|
7248 {
|
|
|
7249 }
|
|
|
7250
|
|
|
7251 FullScreenExclusiveModeLostEXTError( char const * message ) : SystemError( make_error_code( Result::eErrorFullScreenExclusiveModeLostEXT ), message ) {}
|
|
|
7252 };
|
|
|
7253 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
7254
|
|
|
7255 class InvalidVideoStdParametersKHRError : public SystemError
|
|
|
7256 {
|
|
|
7257 public:
|
|
|
7258 InvalidVideoStdParametersKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorInvalidVideoStdParametersKHR ), message ) {}
|
|
|
7259
|
|
|
7260 InvalidVideoStdParametersKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorInvalidVideoStdParametersKHR ), message ) {}
|
|
|
7261 };
|
|
|
7262
|
|
|
7263 class CompressionExhaustedEXTError : public SystemError
|
|
|
7264 {
|
|
|
7265 public:
|
|
|
7266 CompressionExhaustedEXTError( std::string const & message ) : SystemError( make_error_code( Result::eErrorCompressionExhaustedEXT ), message ) {}
|
|
|
7267
|
|
|
7268 CompressionExhaustedEXTError( char const * message ) : SystemError( make_error_code( Result::eErrorCompressionExhaustedEXT ), message ) {}
|
|
|
7269 };
|
|
|
7270
|
|
|
7271 class NotEnoughSpaceKHRError : public SystemError
|
|
|
7272 {
|
|
|
7273 public:
|
|
|
7274 NotEnoughSpaceKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorNotEnoughSpaceKHR ), message ) {}
|
|
|
7275
|
|
|
7276 NotEnoughSpaceKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorNotEnoughSpaceKHR ), message ) {}
|
|
|
7277 };
|
|
|
7278
|
|
|
7279 namespace detail
|
|
|
7280 {
|
|
|
7281 [[noreturn]] VULKAN_HPP_INLINE void throwResultException( Result result, char const * message )
|
|
|
7282 {
|
|
|
7283 switch ( result )
|
|
|
7284 {
|
|
|
7285 case Result::eErrorOutOfHostMemory : throw OutOfHostMemoryError( message );
|
|
|
7286 case Result::eErrorOutOfDeviceMemory : throw OutOfDeviceMemoryError( message );
|
|
|
7287 case Result::eErrorInitializationFailed : throw InitializationFailedError( message );
|
|
|
7288 case Result::eErrorDeviceLost : throw DeviceLostError( message );
|
|
|
7289 case Result::eErrorMemoryMapFailed : throw MemoryMapFailedError( message );
|
|
|
7290 case Result::eErrorLayerNotPresent : throw LayerNotPresentError( message );
|
|
|
7291 case Result::eErrorExtensionNotPresent : throw ExtensionNotPresentError( message );
|
|
|
7292 case Result::eErrorFeatureNotPresent : throw FeatureNotPresentError( message );
|
|
|
7293 case Result::eErrorIncompatibleDriver : throw IncompatibleDriverError( message );
|
|
|
7294 case Result::eErrorTooManyObjects : throw TooManyObjectsError( message );
|
|
|
7295 case Result::eErrorFormatNotSupported : throw FormatNotSupportedError( message );
|
|
|
7296 case Result::eErrorFragmentedPool : throw FragmentedPoolError( message );
|
|
|
7297 case Result::eErrorUnknown : throw UnknownError( message );
|
|
|
7298 case Result::eErrorValidationFailed : throw ValidationFailedError( message );
|
|
|
7299 case Result::eErrorOutOfPoolMemory : throw OutOfPoolMemoryError( message );
|
|
|
7300 case Result::eErrorInvalidExternalHandle : throw InvalidExternalHandleError( message );
|
|
|
7301 case Result::eErrorInvalidOpaqueCaptureAddress : throw InvalidOpaqueCaptureAddressError( message );
|
|
|
7302 case Result::eErrorFragmentation : throw FragmentationError( message );
|
|
|
7303 case Result::eErrorNotPermitted : throw NotPermittedError( message );
|
|
|
7304 case Result::eErrorSurfaceLostKHR : throw SurfaceLostKHRError( message );
|
|
|
7305 case Result::eErrorNativeWindowInUseKHR : throw NativeWindowInUseKHRError( message );
|
|
|
7306 case Result::eErrorOutOfDateKHR : throw OutOfDateKHRError( message );
|
|
|
7307 case Result::eErrorIncompatibleDisplayKHR : throw IncompatibleDisplayKHRError( message );
|
|
|
7308 case Result::eErrorInvalidShaderNV : throw InvalidShaderNVError( message );
|
|
|
7309 case Result::eErrorImageUsageNotSupportedKHR : throw ImageUsageNotSupportedKHRError( message );
|
|
|
7310 case Result::eErrorVideoPictureLayoutNotSupportedKHR : throw VideoPictureLayoutNotSupportedKHRError( message );
|
|
|
7311 case Result::eErrorVideoProfileOperationNotSupportedKHR : throw VideoProfileOperationNotSupportedKHRError( message );
|
|
|
7312 case Result::eErrorVideoProfileFormatNotSupportedKHR : throw VideoProfileFormatNotSupportedKHRError( message );
|
|
|
7313 case Result::eErrorVideoProfileCodecNotSupportedKHR : throw VideoProfileCodecNotSupportedKHRError( message );
|
|
|
7314 case Result::eErrorVideoStdVersionNotSupportedKHR : throw VideoStdVersionNotSupportedKHRError( message );
|
|
|
7315 case Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT: throw InvalidDrmFormatModifierPlaneLayoutEXTError( message );
|
|
|
7316 # if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
7317 case Result::eErrorFullScreenExclusiveModeLostEXT: throw FullScreenExclusiveModeLostEXTError( message );
|
|
|
7318 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
7319 case Result::eErrorInvalidVideoStdParametersKHR: throw InvalidVideoStdParametersKHRError( message );
|
|
|
7320 case Result::eErrorCompressionExhaustedEXT : throw CompressionExhaustedEXTError( message );
|
|
|
7321 case Result::eErrorNotEnoughSpaceKHR : throw NotEnoughSpaceKHRError( message );
|
|
|
7322 default : throw SystemError( make_error_code( result ), message );
|
|
|
7323 }
|
|
|
7324 }
|
|
|
7325 } // namespace detail
|
|
|
7326 #endif
|
|
|
7327
|
|
|
7328 template <typename T>
|
|
|
7329 struct ResultValue
|
|
|
7330 {
|
|
|
7331 #ifdef VULKAN_HPP_HAS_NOEXCEPT
|
|
|
7332 ResultValue( Result r, T & v ) VULKAN_HPP_NOEXCEPT( VULKAN_HPP_NOEXCEPT( T( v ) ) )
|
|
|
7333 #else
|
|
|
7334 ResultValue( Result r, T & v )
|
|
|
7335 #endif
|
|
|
7336 : result( r ), value( v )
|
|
|
7337 {
|
|
|
7338 }
|
|
|
7339
|
|
|
7340 #ifdef VULKAN_HPP_HAS_NOEXCEPT
|
|
|
7341 ResultValue( Result r, T && v ) VULKAN_HPP_NOEXCEPT( VULKAN_HPP_NOEXCEPT( T( std::move( v ) ) ) )
|
|
|
7342 #else
|
|
|
7343 ResultValue( Result r, T && v )
|
|
|
7344 #endif
|
|
|
7345 : result( r ), value( std::move( v ) )
|
|
|
7346 {
|
|
|
7347 }
|
|
|
7348
|
|
|
7349 Result result;
|
|
|
7350 T value;
|
|
|
7351
|
|
|
7352 operator std::tuple<Result &, T &>() VULKAN_HPP_NOEXCEPT
|
|
|
7353 {
|
|
|
7354 return std::tuple<Result &, T &>( result, value );
|
|
|
7355 }
|
|
|
7356
|
|
|
7357 // std::expected-look alike
|
|
|
7358 bool has_value() const VULKAN_HPP_NOEXCEPT
|
|
|
7359 {
|
|
|
7360 return result == vk::Result::eSuccess;
|
|
|
7361 }
|
|
|
7362
|
|
|
7363 T const * operator->() const VULKAN_HPP_NOEXCEPT
|
|
|
7364 {
|
|
|
7365 VULKAN_HPP_ASSERT( has_value() );
|
|
|
7366 return &value;
|
|
|
7367 }
|
|
|
7368
|
|
|
7369 T * operator->() VULKAN_HPP_NOEXCEPT
|
|
|
7370 {
|
|
|
7371 VULKAN_HPP_ASSERT( has_value() );
|
|
|
7372 return &value;
|
|
|
7373 }
|
|
|
7374
|
|
|
7375 T const & operator*() const VULKAN_HPP_NOEXCEPT
|
|
|
7376 {
|
|
|
7377 VULKAN_HPP_ASSERT( has_value() );
|
|
|
7378 return value;
|
|
|
7379 }
|
|
|
7380
|
|
|
7381 T & operator*() VULKAN_HPP_NOEXCEPT
|
|
|
7382 {
|
|
|
7383 VULKAN_HPP_ASSERT( has_value() );
|
|
|
7384 return value;
|
|
|
7385 }
|
|
|
7386 };
|
|
|
7387
|
|
|
7388 #if !defined( VULKAN_HPP_NO_SMART_HANDLE )
|
|
|
7389 template <typename Type, typename Dispatch>
|
|
|
7390 struct ResultValue<UniqueHandle<Type, Dispatch>>
|
|
|
7391 {
|
|
|
7392 # ifdef VULKAN_HPP_HAS_NOEXCEPT
|
|
|
7393 ResultValue( Result r, UniqueHandle<Type, Dispatch> && v ) VULKAN_HPP_NOEXCEPT
|
|
|
7394 # else
|
|
|
7395 ResultValue( Result r, UniqueHandle<Type, Dispatch> && v )
|
|
|
7396 # endif
|
|
|
7397 : result( r )
|
|
|
7398 , value( std::move( v ) )
|
|
|
7399 {
|
|
|
7400 }
|
|
|
7401
|
|
|
7402 VULKAN_HPP_DEPRECATED(
|
|
|
7403 "asTuple() on an l-value is deprecated, as it implicitly moves the UniqueHandle out of the ResultValue. Use asTuple() on an r-value instead, requiring to explicitly move the UniqueHandle." )
|
|
|
7404
|
|
|
7405 std::tuple<Result, UniqueHandle<Type, Dispatch>> asTuple() &
|
|
|
7406 {
|
|
|
7407 return std::make_tuple( result, std::move( value ) );
|
|
|
7408 }
|
|
|
7409
|
|
|
7410 std::tuple<Result, UniqueHandle<Type, Dispatch>> asTuple() &&
|
|
|
7411 {
|
|
|
7412 return std::make_tuple( result, std::move( value ) );
|
|
|
7413 }
|
|
|
7414
|
|
|
7415 Result result;
|
|
|
7416 UniqueHandle<Type, Dispatch> value;
|
|
|
7417 };
|
|
|
7418
|
|
|
7419 template <typename Type, typename Dispatch>
|
|
|
7420 struct ResultValue<std::vector<UniqueHandle<Type, Dispatch>>>
|
|
|
7421 {
|
|
|
7422 # ifdef VULKAN_HPP_HAS_NOEXCEPT
|
|
|
7423 ResultValue( Result r, std::vector<UniqueHandle<Type, Dispatch>> && v ) VULKAN_HPP_NOEXCEPT
|
|
|
7424 # else
|
|
|
7425 ResultValue( Result r, std::vector<UniqueHandle<Type, Dispatch>> && v )
|
|
|
7426 # endif
|
|
|
7427 : result( r )
|
|
|
7428 , value( std::move( v ) )
|
|
|
7429 {
|
|
|
7430 }
|
|
|
7431
|
|
|
7432 VULKAN_HPP_DEPRECATED(
|
|
|
7433 "asTuple() on an l-value is deprecated, as it implicitly moves the UniqueHandle out of the ResultValue. Use asTuple() on an r-value instead, requiring to explicitly move the UniqueHandle." )
|
|
|
7434
|
|
|
7435 std::tuple<Result, std::vector<UniqueHandle<Type, Dispatch>>> asTuple() &
|
|
|
7436 {
|
|
|
7437 return std::make_tuple( result, std::move( value ) );
|
|
|
7438 }
|
|
|
7439
|
|
|
7440 std::tuple<Result, std::vector<UniqueHandle<Type, Dispatch>>> asTuple() &&
|
|
|
7441 {
|
|
|
7442 return std::make_tuple( result, std::move( value ) );
|
|
|
7443 }
|
|
|
7444
|
|
|
7445 Result result;
|
|
|
7446 std::vector<UniqueHandle<Type, Dispatch>> value;
|
|
|
7447 };
|
|
|
7448 #endif
|
|
|
7449
|
|
|
7450 template <typename T>
|
|
|
7451 struct ResultValueType
|
|
|
7452 {
|
|
|
7453 #ifdef VULKAN_HPP_NO_EXCEPTIONS
|
|
|
7454 using type = ResultValue<T>;
|
|
|
7455 #else
|
|
|
7456 using type = T;
|
|
|
7457 #endif
|
|
|
7458 };
|
|
|
7459
|
|
|
7460 template <>
|
|
|
7461 struct ResultValueType<void>
|
|
|
7462 {
|
|
|
7463 #ifdef VULKAN_HPP_NO_EXCEPTIONS
|
|
|
7464 using type = Result;
|
|
|
7465 #else
|
|
|
7466 using type = void;
|
|
|
7467 #endif
|
|
|
7468 };
|
|
|
7469
|
|
|
7470 namespace detail
|
|
|
7471 {
|
|
|
7472 template <typename T>
|
|
|
7473 VULKAN_HPP_CONSTEXPR bool ignore( T const & ) VULKAN_HPP_NOEXCEPT
|
|
|
7474 {
|
|
|
7475 return true;
|
|
|
7476 }
|
|
|
7477
|
|
|
7478 VULKAN_HPP_INLINE typename ResultValueType<void>::type createResultValueType( Result result )
|
|
|
7479 {
|
|
|
7480 #if defined( VULKAN_HPP_NO_EXCEPTIONS )
|
|
|
7481 return result;
|
|
|
7482 #else
|
|
|
7483 ignore( result );
|
|
|
7484 #endif
|
|
|
7485 }
|
|
|
7486
|
|
|
7487 template <typename T>
|
|
|
7488 VULKAN_HPP_INLINE typename ResultValueType<T>::type createResultValueType( Result result, T & data )
|
|
|
7489 {
|
|
|
7490 #if defined( VULKAN_HPP_NO_EXCEPTIONS )
|
|
|
7491 return ResultValue<T>( result, data );
|
|
|
7492 #else
|
|
|
7493 ignore( result );
|
|
|
7494 return data;
|
|
|
7495 #endif
|
|
|
7496 }
|
|
|
7497
|
|
|
7498 template <typename T>
|
|
|
7499 VULKAN_HPP_INLINE typename ResultValueType<T>::type createResultValueType( Result result, T && data )
|
|
|
7500 {
|
|
|
7501 #if defined( VULKAN_HPP_NO_EXCEPTIONS )
|
|
|
7502 return ResultValue<T>( result, std::move( data ) );
|
|
|
7503 #else
|
|
|
7504 ignore( result );
|
|
|
7505 return std::move( data );
|
|
|
7506 #endif
|
|
|
7507 }
|
|
|
7508 } // namespace detail
|
|
|
7509
|
|
|
7510 namespace detail
|
|
|
7511 {
|
|
|
7512 VULKAN_HPP_INLINE void resultCheck( Result result, char const * message )
|
|
|
7513 {
|
|
|
7514 #ifdef VULKAN_HPP_NO_EXCEPTIONS
|
|
|
7515 ignore( result ); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
|
|
|
7516 ignore( message );
|
|
|
7517 VULKAN_HPP_ASSERT_ON_RESULT( result == Result::eSuccess );
|
|
|
7518 #else
|
|
|
7519 if ( result != Result::eSuccess )
|
|
|
7520 {
|
|
|
7521 throwResultException( result, message );
|
|
|
7522 }
|
|
|
7523 #endif
|
|
|
7524 }
|
|
|
7525
|
|
|
7526 VULKAN_HPP_INLINE void resultCheck( Result result, char const * message, std::initializer_list<Result> successCodes )
|
|
|
7527 {
|
|
|
7528 #ifdef VULKAN_HPP_NO_EXCEPTIONS
|
|
|
7529 ignore( result ); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
|
|
|
7530 ignore( message );
|
|
|
7531 ignore( successCodes ); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty
|
|
|
7532 VULKAN_HPP_ASSERT_ON_RESULT( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() );
|
|
|
7533 #else
|
|
|
7534 if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() )
|
|
|
7535 {
|
|
|
7536 throwResultException( result, message );
|
|
|
7537 }
|
|
|
7538 #endif
|
|
|
7539 }
|
|
|
7540 } // namespace detail
|
|
|
7541
|
|
|
7542 //===========================
|
|
|
7543 //=== CONSTEXPR CONSTANTs ===
|
|
|
7544 //===========================
|
|
|
7545
|
|
|
7546 //=== VK_VERSION_1_0 ===
|
|
|
7547 VULKAN_HPP_CONSTEXPR_INLINE uint32_t False = VK_FALSE;
|
|
|
7548 VULKAN_HPP_CONSTEXPR_INLINE float LodClampNone = VK_LOD_CLAMP_NONE;
|
|
|
7549 VULKAN_HPP_CONSTEXPR_INLINE uint32_t QueueFamilyIgnored = VK_QUEUE_FAMILY_IGNORED;
|
|
|
7550 VULKAN_HPP_CONSTEXPR_INLINE uint32_t RemainingArrayLayers = VK_REMAINING_ARRAY_LAYERS;
|
|
|
7551 VULKAN_HPP_CONSTEXPR_INLINE uint32_t RemainingMipLevels = VK_REMAINING_MIP_LEVELS;
|
|
|
7552 VULKAN_HPP_CONSTEXPR_INLINE uint32_t True = VK_TRUE;
|
|
|
7553 VULKAN_HPP_CONSTEXPR_INLINE uint64_t WholeSize = VK_WHOLE_SIZE;
|
|
|
7554 VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxMemoryTypes = VK_MAX_MEMORY_TYPES;
|
|
|
7555 VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxPhysicalDeviceNameSize = VK_MAX_PHYSICAL_DEVICE_NAME_SIZE;
|
|
|
7556 VULKAN_HPP_CONSTEXPR_INLINE uint32_t UuidSize = VK_UUID_SIZE;
|
|
|
7557 VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxExtensionNameSize = VK_MAX_EXTENSION_NAME_SIZE;
|
|
|
7558 VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxDescriptionSize = VK_MAX_DESCRIPTION_SIZE;
|
|
|
7559 VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxMemoryHeaps = VK_MAX_MEMORY_HEAPS;
|
|
|
7560 VULKAN_HPP_CONSTEXPR_INLINE uint32_t AttachmentUnused = VK_ATTACHMENT_UNUSED;
|
|
|
7561 VULKAN_HPP_CONSTEXPR_INLINE uint32_t SubpassExternal = VK_SUBPASS_EXTERNAL;
|
|
|
7562
|
|
|
7563 //=== VK_VERSION_1_1 ===
|
|
|
7564 VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxDeviceGroupSize = VK_MAX_DEVICE_GROUP_SIZE;
|
|
|
7565 VULKAN_HPP_CONSTEXPR_INLINE uint32_t LuidSize = VK_LUID_SIZE;
|
|
|
7566 VULKAN_HPP_CONSTEXPR_INLINE uint32_t QueueFamilyExternal = VK_QUEUE_FAMILY_EXTERNAL;
|
|
|
7567
|
|
|
7568 //=== VK_VERSION_1_2 ===
|
|
|
7569 VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxDriverNameSize = VK_MAX_DRIVER_NAME_SIZE;
|
|
|
7570 VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxDriverInfoSize = VK_MAX_DRIVER_INFO_SIZE;
|
|
|
7571
|
|
|
7572 //=== VK_VERSION_1_4 ===
|
|
|
7573 VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxGlobalPrioritySize = VK_MAX_GLOBAL_PRIORITY_SIZE;
|
|
|
7574
|
|
|
7575 //=== VK_KHR_device_group_creation ===
|
|
|
7576 VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxDeviceGroupSizeKHR = VK_MAX_DEVICE_GROUP_SIZE_KHR;
|
|
|
7577
|
|
|
7578 //=== VK_KHR_external_memory_capabilities ===
|
|
|
7579 VULKAN_HPP_CONSTEXPR_INLINE uint32_t LuidSizeKHR = VK_LUID_SIZE_KHR;
|
|
|
7580
|
|
|
7581 //=== VK_KHR_external_memory ===
|
|
|
7582 VULKAN_HPP_CONSTEXPR_INLINE uint32_t QueueFamilyExternalKHR = VK_QUEUE_FAMILY_EXTERNAL_KHR;
|
|
|
7583
|
|
|
7584 //=== VK_EXT_queue_family_foreign ===
|
|
|
7585 VULKAN_HPP_CONSTEXPR_INLINE uint32_t QueueFamilyForeignEXT = VK_QUEUE_FAMILY_FOREIGN_EXT;
|
|
|
7586
|
|
|
7587 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
7588 //=== VK_AMDX_shader_enqueue ===
|
|
|
7589 VULKAN_HPP_CONSTEXPR_INLINE uint32_t ShaderIndexUnusedAMDX = VK_SHADER_INDEX_UNUSED_AMDX;
|
|
|
7590 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
7591
|
|
|
7592 //=== VK_KHR_ray_tracing_pipeline ===
|
|
|
7593 VULKAN_HPP_CONSTEXPR_INLINE uint32_t ShaderUnusedKHR = VK_SHADER_UNUSED_KHR;
|
|
|
7594
|
|
|
7595 //=== VK_NV_ray_tracing ===
|
|
|
7596 VULKAN_HPP_CONSTEXPR_INLINE uint32_t ShaderUnusedNV = VK_SHADER_UNUSED_NV;
|
|
|
7597
|
|
|
7598 //=== VK_KHR_global_priority ===
|
|
|
7599 VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxGlobalPrioritySizeKHR = VK_MAX_GLOBAL_PRIORITY_SIZE_KHR;
|
|
|
7600
|
|
|
7601 //=== VK_KHR_driver_properties ===
|
|
|
7602 VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxDriverNameSizeKHR = VK_MAX_DRIVER_NAME_SIZE_KHR;
|
|
|
7603 VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxDriverInfoSizeKHR = VK_MAX_DRIVER_INFO_SIZE_KHR;
|
|
|
7604
|
|
|
7605 //=== VK_EXT_global_priority_query ===
|
|
|
7606 VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxGlobalPrioritySizeEXT = VK_MAX_GLOBAL_PRIORITY_SIZE_EXT;
|
|
|
7607
|
|
|
7608 //=== VK_EXT_image_sliced_view_of_3d ===
|
|
|
7609 VULKAN_HPP_CONSTEXPR_INLINE uint32_t Remaining3DSlicesEXT = VK_REMAINING_3D_SLICES_EXT;
|
|
|
7610
|
|
|
7611 //=== VK_EXT_shader_module_identifier ===
|
|
|
7612 VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxShaderModuleIdentifierSizeEXT = VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT;
|
|
|
7613
|
|
|
7614 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
7615 //=== VK_AMDX_dense_geometry_format ===
|
|
|
7616 VULKAN_HPP_CONSTEXPR_INLINE uint32_t CompressedTriangleFormatDgf1ByteAlignmentAMDX = VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_BYTE_ALIGNMENT_AMDX;
|
|
|
7617 VULKAN_HPP_CONSTEXPR_INLINE uint32_t CompressedTriangleFormatDgf1ByteStrideAMDX = VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_BYTE_STRIDE_AMDX;
|
|
|
7618 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
7619
|
|
|
7620 //=== VK_KHR_pipeline_binary ===
|
|
|
7621 VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxPipelineBinaryKeySizeKHR = VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR;
|
|
|
7622
|
|
|
7623 //=== VK_ARM_data_graph ===
|
|
|
7624 VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxPhysicalDeviceDataGraphOperationSetNameSizeARM = VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM;
|
|
|
7625
|
|
|
7626 //=== VK_KHR_video_decode_av1 ===
|
|
|
7627 VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxVideoAv1ReferencesPerFrameKHR = VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR;
|
|
|
7628
|
|
|
7629 //=== VK_KHR_video_decode_vp9 ===
|
|
|
7630 VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxVideoVp9ReferencesPerFrameKHR = VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR;
|
|
|
7631
|
|
|
7632 //=== VK_NV_partitioned_acceleration_structure ===
|
|
|
7633 VULKAN_HPP_CONSTEXPR_INLINE uint32_t PartitionedAccelerationStructurePartitionIndexGlobalNV = VK_PARTITIONED_ACCELERATION_STRUCTURE_PARTITION_INDEX_GLOBAL_NV;
|
|
|
7634
|
|
|
7635 //=== VK_QCOM_data_graph_model ===
|
|
|
7636 VULKAN_HPP_CONSTEXPR_INLINE uint32_t DataGraphModelToolchainVersionLengthQCOM = VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM;
|
|
|
7637
|
|
|
7638 //========================
|
|
|
7639 //=== CONSTEXPR VALUEs ===
|
|
|
7640 //========================
|
|
|
7641 VULKAN_HPP_CONSTEXPR_INLINE uint32_t HeaderVersion = VK_HEADER_VERSION;
|
|
|
7642 VULKAN_HPP_CONSTEXPR_INLINE uint32_t Use64BitPtrDefines = VK_USE_64_BIT_PTR_DEFINES;
|
|
|
7643
|
|
|
7644 //=========================
|
|
|
7645 //=== CONSTEXPR CALLEEs ===
|
|
|
7646 //=========================
|
|
|
7647 template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
|
|
|
7648 VULKAN_HPP_CONSTEXPR uint32_t apiVersionMajor( T const version )
|
|
|
7649 {
|
|
|
7650 return ( ( (uint32_t)( version ) >> 22U ) & 0x7FU );
|
|
|
7651 }
|
|
|
7652
|
|
|
7653 template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
|
|
|
7654 VULKAN_HPP_CONSTEXPR uint32_t apiVersionMinor( T const version )
|
|
|
7655 {
|
|
|
7656 return ( ( (uint32_t)( version ) >> 12U ) & 0x3FFU );
|
|
|
7657 }
|
|
|
7658
|
|
|
7659 template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
|
|
|
7660 VULKAN_HPP_CONSTEXPR uint32_t apiVersionPatch( T const version )
|
|
|
7661 {
|
|
|
7662 return ( (uint32_t)( version ) & 0xFFFU );
|
|
|
7663 }
|
|
|
7664
|
|
|
7665 template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
|
|
|
7666 VULKAN_HPP_CONSTEXPR uint32_t apiVersionVariant( T const version )
|
|
|
7667 {
|
|
|
7668 return ( (uint32_t)( version ) >> 29U );
|
|
|
7669 }
|
|
|
7670
|
|
|
7671 template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
|
|
|
7672 VULKAN_HPP_CONSTEXPR uint32_t makeApiVersion( T const variant, T const major, T const minor, T const patch )
|
|
|
7673 {
|
|
|
7674 return ( ( ( (uint32_t)( variant ) ) << 29U ) | ( ( (uint32_t)( major ) ) << 22U ) | ( ( (uint32_t)( minor ) ) << 12U ) | ( (uint32_t)( patch ) ) );
|
|
|
7675 }
|
|
|
7676
|
|
|
7677 template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
|
|
|
7678 VULKAN_HPP_CONSTEXPR uint32_t makeVersion( T const major, T const minor, T const patch )
|
|
|
7679 {
|
|
|
7680 return ( ( ( (uint32_t)( major ) ) << 22U ) | ( ( (uint32_t)( minor ) ) << 12U ) | ( (uint32_t)( patch ) ) );
|
|
|
7681 }
|
|
|
7682
|
|
|
7683 template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
|
|
|
7684 VULKAN_HPP_CONSTEXPR uint32_t versionMajor( T const version )
|
|
|
7685 {
|
|
|
7686 return ( (uint32_t)( version ) >> 22U );
|
|
|
7687 }
|
|
|
7688
|
|
|
7689 template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
|
|
|
7690 VULKAN_HPP_CONSTEXPR uint32_t versionMinor( T const version )
|
|
|
7691 {
|
|
|
7692 return ( ( (uint32_t)( version ) >> 12U ) & 0x3FFU );
|
|
|
7693 }
|
|
|
7694
|
|
|
7695 template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type>
|
|
|
7696 VULKAN_HPP_CONSTEXPR uint32_t versionPatch( T const version )
|
|
|
7697 {
|
|
|
7698 return ( (uint32_t)( version ) & 0xFFFU );
|
|
|
7699 }
|
|
|
7700
|
|
|
7701 //=========================
|
|
|
7702 //=== CONSTEXPR CALLERs ===
|
|
|
7703 //=========================
|
|
|
7704 VULKAN_HPP_CONSTEXPR_INLINE auto ApiVersion = makeApiVersion( 0, 1, 0, 0 );
|
|
|
7705 VULKAN_HPP_CONSTEXPR_INLINE auto ApiVersion10 = makeApiVersion( 0, 1, 0, 0 );
|
|
|
7706 VULKAN_HPP_CONSTEXPR_INLINE auto ApiVersion11 = makeApiVersion( 0, 1, 1, 0 );
|
|
|
7707 VULKAN_HPP_CONSTEXPR_INLINE auto ApiVersion12 = makeApiVersion( 0, 1, 2, 0 );
|
|
|
7708 VULKAN_HPP_CONSTEXPR_INLINE auto ApiVersion13 = makeApiVersion( 0, 1, 3, 0 );
|
|
|
7709 VULKAN_HPP_CONSTEXPR_INLINE auto ApiVersion14 = makeApiVersion( 0, 1, 4, 0 );
|
|
|
7710 VULKAN_HPP_CONSTEXPR_INLINE auto HeaderVersionComplete = makeApiVersion( 0, 1, 4, VK_HEADER_VERSION );
|
|
|
7711
|
|
|
7712 //=================================
|
|
|
7713 //=== CONSTEXPR EXTENSION NAMEs ===
|
|
|
7714 //=================================
|
|
|
7715
|
|
|
7716 //=== VK_KHR_surface ===
|
|
|
7717 VULKAN_HPP_CONSTEXPR_INLINE auto KHRSurfaceExtensionName = VK_KHR_SURFACE_EXTENSION_NAME;
|
|
|
7718 VULKAN_HPP_CONSTEXPR_INLINE auto KHRSurfaceSpecVersion = VK_KHR_SURFACE_SPEC_VERSION;
|
|
|
7719
|
|
|
7720 //=== VK_KHR_swapchain ===
|
|
|
7721 VULKAN_HPP_CONSTEXPR_INLINE auto KHRSwapchainExtensionName = VK_KHR_SWAPCHAIN_EXTENSION_NAME;
|
|
|
7722 VULKAN_HPP_CONSTEXPR_INLINE auto KHRSwapchainSpecVersion = VK_KHR_SWAPCHAIN_SPEC_VERSION;
|
|
|
7723
|
|
|
7724 //=== VK_KHR_display ===
|
|
|
7725 VULKAN_HPP_CONSTEXPR_INLINE auto KHRDisplayExtensionName = VK_KHR_DISPLAY_EXTENSION_NAME;
|
|
|
7726 VULKAN_HPP_CONSTEXPR_INLINE auto KHRDisplaySpecVersion = VK_KHR_DISPLAY_SPEC_VERSION;
|
|
|
7727
|
|
|
7728 //=== VK_KHR_display_swapchain ===
|
|
|
7729 VULKAN_HPP_CONSTEXPR_INLINE auto KHRDisplaySwapchainExtensionName = VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME;
|
|
|
7730 VULKAN_HPP_CONSTEXPR_INLINE auto KHRDisplaySwapchainSpecVersion = VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION;
|
|
|
7731
|
|
|
7732 #if defined( VK_USE_PLATFORM_XLIB_KHR )
|
|
|
7733 //=== VK_KHR_xlib_surface ===
|
|
|
7734 VULKAN_HPP_CONSTEXPR_INLINE auto KHRXlibSurfaceExtensionName = VK_KHR_XLIB_SURFACE_EXTENSION_NAME;
|
|
|
7735 VULKAN_HPP_CONSTEXPR_INLINE auto KHRXlibSurfaceSpecVersion = VK_KHR_XLIB_SURFACE_SPEC_VERSION;
|
|
|
7736 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
|
|
|
7737
|
|
|
7738 #if defined( VK_USE_PLATFORM_XCB_KHR )
|
|
|
7739 //=== VK_KHR_xcb_surface ===
|
|
|
7740 VULKAN_HPP_CONSTEXPR_INLINE auto KHRXcbSurfaceExtensionName = VK_KHR_XCB_SURFACE_EXTENSION_NAME;
|
|
|
7741 VULKAN_HPP_CONSTEXPR_INLINE auto KHRXcbSurfaceSpecVersion = VK_KHR_XCB_SURFACE_SPEC_VERSION;
|
|
|
7742 #endif /*VK_USE_PLATFORM_XCB_KHR*/
|
|
|
7743
|
|
|
7744 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )
|
|
|
7745 //=== VK_KHR_wayland_surface ===
|
|
|
7746 VULKAN_HPP_CONSTEXPR_INLINE auto KHRWaylandSurfaceExtensionName = VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME;
|
|
|
7747 VULKAN_HPP_CONSTEXPR_INLINE auto KHRWaylandSurfaceSpecVersion = VK_KHR_WAYLAND_SURFACE_SPEC_VERSION;
|
|
|
7748 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
|
|
|
7749
|
|
|
7750 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
|
|
7751 //=== VK_KHR_android_surface ===
|
|
|
7752 VULKAN_HPP_CONSTEXPR_INLINE auto KHRAndroidSurfaceExtensionName = VK_KHR_ANDROID_SURFACE_EXTENSION_NAME;
|
|
|
7753 VULKAN_HPP_CONSTEXPR_INLINE auto KHRAndroidSurfaceSpecVersion = VK_KHR_ANDROID_SURFACE_SPEC_VERSION;
|
|
|
7754 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
|
|
7755
|
|
|
7756 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
7757 //=== VK_KHR_win32_surface ===
|
|
|
7758 VULKAN_HPP_CONSTEXPR_INLINE auto KHRWin32SurfaceExtensionName = VK_KHR_WIN32_SURFACE_EXTENSION_NAME;
|
|
|
7759 VULKAN_HPP_CONSTEXPR_INLINE auto KHRWin32SurfaceSpecVersion = VK_KHR_WIN32_SURFACE_SPEC_VERSION;
|
|
|
7760 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
7761
|
|
|
7762 //=== VK_EXT_debug_report ===
|
|
|
7763 VULKAN_HPP_DEPRECATED( "The VK_EXT_debug_report extension has been deprecated by VK_EXT_debug_utils." )
|
|
|
7764 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDebugReportExtensionName = VK_EXT_DEBUG_REPORT_EXTENSION_NAME;
|
|
|
7765 VULKAN_HPP_DEPRECATED( "The VK_EXT_debug_report extension has been deprecated by VK_EXT_debug_utils." )
|
|
|
7766 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDebugReportSpecVersion = VK_EXT_DEBUG_REPORT_SPEC_VERSION;
|
|
|
7767
|
|
|
7768 //=== VK_NV_glsl_shader ===
|
|
|
7769 VULKAN_HPP_DEPRECATED( "The VK_NV_glsl_shader extension has been deprecated." )
|
|
|
7770 VULKAN_HPP_CONSTEXPR_INLINE auto NVGlslShaderExtensionName = VK_NV_GLSL_SHADER_EXTENSION_NAME;
|
|
|
7771 VULKAN_HPP_DEPRECATED( "The VK_NV_glsl_shader extension has been deprecated." )
|
|
|
7772 VULKAN_HPP_CONSTEXPR_INLINE auto NVGlslShaderSpecVersion = VK_NV_GLSL_SHADER_SPEC_VERSION;
|
|
|
7773
|
|
|
7774 //=== VK_EXT_depth_range_unrestricted ===
|
|
|
7775 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthRangeUnrestrictedExtensionName = VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME;
|
|
|
7776 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthRangeUnrestrictedSpecVersion = VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION;
|
|
|
7777
|
|
|
7778 //=== VK_KHR_sampler_mirror_clamp_to_edge ===
|
|
|
7779 VULKAN_HPP_CONSTEXPR_INLINE auto KHRSamplerMirrorClampToEdgeExtensionName = VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME;
|
|
|
7780 VULKAN_HPP_CONSTEXPR_INLINE auto KHRSamplerMirrorClampToEdgeSpecVersion = VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION;
|
|
|
7781
|
|
|
7782 //=== VK_IMG_filter_cubic ===
|
|
|
7783 VULKAN_HPP_CONSTEXPR_INLINE auto IMGFilterCubicExtensionName = VK_IMG_FILTER_CUBIC_EXTENSION_NAME;
|
|
|
7784 VULKAN_HPP_CONSTEXPR_INLINE auto IMGFilterCubicSpecVersion = VK_IMG_FILTER_CUBIC_SPEC_VERSION;
|
|
|
7785
|
|
|
7786 //=== VK_AMD_rasterization_order ===
|
|
|
7787 VULKAN_HPP_CONSTEXPR_INLINE auto AMDRasterizationOrderExtensionName = VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME;
|
|
|
7788 VULKAN_HPP_CONSTEXPR_INLINE auto AMDRasterizationOrderSpecVersion = VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION;
|
|
|
7789
|
|
|
7790 //=== VK_AMD_shader_trinary_minmax ===
|
|
|
7791 VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderTrinaryMinmaxExtensionName = VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME;
|
|
|
7792 VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderTrinaryMinmaxSpecVersion = VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION;
|
|
|
7793
|
|
|
7794 //=== VK_AMD_shader_explicit_vertex_parameter ===
|
|
|
7795 VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderExplicitVertexParameterExtensionName = VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME;
|
|
|
7796 VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderExplicitVertexParameterSpecVersion = VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION;
|
|
|
7797
|
|
|
7798 //=== VK_EXT_debug_marker ===
|
|
|
7799 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDebugMarkerExtensionName = VK_EXT_DEBUG_MARKER_EXTENSION_NAME;
|
|
|
7800 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDebugMarkerSpecVersion = VK_EXT_DEBUG_MARKER_SPEC_VERSION;
|
|
|
7801
|
|
|
7802 //=== VK_KHR_video_queue ===
|
|
|
7803 VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoQueueExtensionName = VK_KHR_VIDEO_QUEUE_EXTENSION_NAME;
|
|
|
7804 VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoQueueSpecVersion = VK_KHR_VIDEO_QUEUE_SPEC_VERSION;
|
|
|
7805
|
|
|
7806 //=== VK_KHR_video_decode_queue ===
|
|
|
7807 VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoDecodeQueueExtensionName = VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME;
|
|
|
7808 VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoDecodeQueueSpecVersion = VK_KHR_VIDEO_DECODE_QUEUE_SPEC_VERSION;
|
|
|
7809
|
|
|
7810 //=== VK_AMD_gcn_shader ===
|
|
|
7811 VULKAN_HPP_CONSTEXPR_INLINE auto AMDGcnShaderExtensionName = VK_AMD_GCN_SHADER_EXTENSION_NAME;
|
|
|
7812 VULKAN_HPP_CONSTEXPR_INLINE auto AMDGcnShaderSpecVersion = VK_AMD_GCN_SHADER_SPEC_VERSION;
|
|
|
7813
|
|
|
7814 //=== VK_NV_dedicated_allocation ===
|
|
|
7815 VULKAN_HPP_DEPRECATED( "The VK_NV_dedicated_allocation extension has been deprecated by VK_KHR_dedicated_allocation." )
|
|
|
7816 VULKAN_HPP_CONSTEXPR_INLINE auto NVDedicatedAllocationExtensionName = VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME;
|
|
|
7817 VULKAN_HPP_DEPRECATED( "The VK_NV_dedicated_allocation extension has been deprecated by VK_KHR_dedicated_allocation." )
|
|
|
7818 VULKAN_HPP_CONSTEXPR_INLINE auto NVDedicatedAllocationSpecVersion = VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION;
|
|
|
7819
|
|
|
7820 //=== VK_EXT_transform_feedback ===
|
|
|
7821 VULKAN_HPP_CONSTEXPR_INLINE auto EXTTransformFeedbackExtensionName = VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME;
|
|
|
7822 VULKAN_HPP_CONSTEXPR_INLINE auto EXTTransformFeedbackSpecVersion = VK_EXT_TRANSFORM_FEEDBACK_SPEC_VERSION;
|
|
|
7823
|
|
|
7824 //=== VK_NVX_binary_import ===
|
|
|
7825 VULKAN_HPP_CONSTEXPR_INLINE auto NVXBinaryImportExtensionName = VK_NVX_BINARY_IMPORT_EXTENSION_NAME;
|
|
|
7826 VULKAN_HPP_CONSTEXPR_INLINE auto NVXBinaryImportSpecVersion = VK_NVX_BINARY_IMPORT_SPEC_VERSION;
|
|
|
7827
|
|
|
7828 //=== VK_NVX_image_view_handle ===
|
|
|
7829 VULKAN_HPP_CONSTEXPR_INLINE auto NVXImageViewHandleExtensionName = VK_NVX_IMAGE_VIEW_HANDLE_EXTENSION_NAME;
|
|
|
7830 VULKAN_HPP_CONSTEXPR_INLINE auto NVXImageViewHandleSpecVersion = VK_NVX_IMAGE_VIEW_HANDLE_SPEC_VERSION;
|
|
|
7831
|
|
|
7832 //=== VK_AMD_draw_indirect_count ===
|
|
|
7833 VULKAN_HPP_CONSTEXPR_INLINE auto AMDDrawIndirectCountExtensionName = VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME;
|
|
|
7834 VULKAN_HPP_CONSTEXPR_INLINE auto AMDDrawIndirectCountSpecVersion = VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION;
|
|
|
7835
|
|
|
7836 //=== VK_AMD_negative_viewport_height ===
|
|
|
7837 VULKAN_HPP_DEPRECATED( "The VK_AMD_negative_viewport_height extension has been obsoleted by VK_KHR_maintenance1." )
|
|
|
7838 VULKAN_HPP_CONSTEXPR_INLINE auto AMDNegativeViewportHeightExtensionName = VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME;
|
|
|
7839 VULKAN_HPP_DEPRECATED( "The VK_AMD_negative_viewport_height extension has been obsoleted by VK_KHR_maintenance1." )
|
|
|
7840 VULKAN_HPP_CONSTEXPR_INLINE auto AMDNegativeViewportHeightSpecVersion = VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION;
|
|
|
7841
|
|
|
7842 //=== VK_AMD_gpu_shader_half_float ===
|
|
|
7843 VULKAN_HPP_DEPRECATED( "The VK_AMD_gpu_shader_half_float extension has been deprecated by VK_KHR_shader_float16_int8." )
|
|
|
7844 VULKAN_HPP_CONSTEXPR_INLINE auto AMDGpuShaderHalfFloatExtensionName = VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME;
|
|
|
7845 VULKAN_HPP_DEPRECATED( "The VK_AMD_gpu_shader_half_float extension has been deprecated by VK_KHR_shader_float16_int8." )
|
|
|
7846 VULKAN_HPP_CONSTEXPR_INLINE auto AMDGpuShaderHalfFloatSpecVersion = VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION;
|
|
|
7847
|
|
|
7848 //=== VK_AMD_shader_ballot ===
|
|
|
7849 VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderBallotExtensionName = VK_AMD_SHADER_BALLOT_EXTENSION_NAME;
|
|
|
7850 VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderBallotSpecVersion = VK_AMD_SHADER_BALLOT_SPEC_VERSION;
|
|
|
7851
|
|
|
7852 //=== VK_KHR_video_encode_h264 ===
|
|
|
7853 VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoEncodeH264ExtensionName = VK_KHR_VIDEO_ENCODE_H264_EXTENSION_NAME;
|
|
|
7854 VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoEncodeH264SpecVersion = VK_KHR_VIDEO_ENCODE_H264_SPEC_VERSION;
|
|
|
7855
|
|
|
7856 //=== VK_KHR_video_encode_h265 ===
|
|
|
7857 VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoEncodeH265ExtensionName = VK_KHR_VIDEO_ENCODE_H265_EXTENSION_NAME;
|
|
|
7858 VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoEncodeH265SpecVersion = VK_KHR_VIDEO_ENCODE_H265_SPEC_VERSION;
|
|
|
7859
|
|
|
7860 //=== VK_KHR_video_decode_h264 ===
|
|
|
7861 VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoDecodeH264ExtensionName = VK_KHR_VIDEO_DECODE_H264_EXTENSION_NAME;
|
|
|
7862 VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoDecodeH264SpecVersion = VK_KHR_VIDEO_DECODE_H264_SPEC_VERSION;
|
|
|
7863
|
|
|
7864 //=== VK_AMD_texture_gather_bias_lod ===
|
|
|
7865 VULKAN_HPP_CONSTEXPR_INLINE auto AMDTextureGatherBiasLodExtensionName = VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME;
|
|
|
7866 VULKAN_HPP_CONSTEXPR_INLINE auto AMDTextureGatherBiasLodSpecVersion = VK_AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION;
|
|
|
7867
|
|
|
7868 //=== VK_AMD_shader_info ===
|
|
|
7869 VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderInfoExtensionName = VK_AMD_SHADER_INFO_EXTENSION_NAME;
|
|
|
7870 VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderInfoSpecVersion = VK_AMD_SHADER_INFO_SPEC_VERSION;
|
|
|
7871
|
|
|
7872 //=== VK_KHR_dynamic_rendering ===
|
|
|
7873 VULKAN_HPP_CONSTEXPR_INLINE auto KHRDynamicRenderingExtensionName = VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME;
|
|
|
7874 VULKAN_HPP_CONSTEXPR_INLINE auto KHRDynamicRenderingSpecVersion = VK_KHR_DYNAMIC_RENDERING_SPEC_VERSION;
|
|
|
7875
|
|
|
7876 //=== VK_AMD_shader_image_load_store_lod ===
|
|
|
7877 VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderImageLoadStoreLodExtensionName = VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME;
|
|
|
7878 VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderImageLoadStoreLodSpecVersion = VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION;
|
|
|
7879
|
|
|
7880 #if defined( VK_USE_PLATFORM_GGP )
|
|
|
7881 //=== VK_GGP_stream_descriptor_surface ===
|
|
|
7882 VULKAN_HPP_CONSTEXPR_INLINE auto GGPStreamDescriptorSurfaceExtensionName = VK_GGP_STREAM_DESCRIPTOR_SURFACE_EXTENSION_NAME;
|
|
|
7883 VULKAN_HPP_CONSTEXPR_INLINE auto GGPStreamDescriptorSurfaceSpecVersion = VK_GGP_STREAM_DESCRIPTOR_SURFACE_SPEC_VERSION;
|
|
|
7884 #endif /*VK_USE_PLATFORM_GGP*/
|
|
|
7885
|
|
|
7886 //=== VK_NV_corner_sampled_image ===
|
|
|
7887 VULKAN_HPP_CONSTEXPR_INLINE auto NVCornerSampledImageExtensionName = VK_NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME;
|
|
|
7888 VULKAN_HPP_CONSTEXPR_INLINE auto NVCornerSampledImageSpecVersion = VK_NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION;
|
|
|
7889
|
|
|
7890 //=== VK_KHR_multiview ===
|
|
|
7891 VULKAN_HPP_CONSTEXPR_INLINE auto KHRMultiviewExtensionName = VK_KHR_MULTIVIEW_EXTENSION_NAME;
|
|
|
7892 VULKAN_HPP_CONSTEXPR_INLINE auto KHRMultiviewSpecVersion = VK_KHR_MULTIVIEW_SPEC_VERSION;
|
|
|
7893
|
|
|
7894 //=== VK_IMG_format_pvrtc ===
|
|
|
7895 VULKAN_HPP_DEPRECATED( "The VK_IMG_format_pvrtc extension has been deprecated." )
|
|
|
7896 VULKAN_HPP_CONSTEXPR_INLINE auto IMGFormatPvrtcExtensionName = VK_IMG_FORMAT_PVRTC_EXTENSION_NAME;
|
|
|
7897 VULKAN_HPP_DEPRECATED( "The VK_IMG_format_pvrtc extension has been deprecated." )
|
|
|
7898 VULKAN_HPP_CONSTEXPR_INLINE auto IMGFormatPvrtcSpecVersion = VK_IMG_FORMAT_PVRTC_SPEC_VERSION;
|
|
|
7899
|
|
|
7900 //=== VK_NV_external_memory_capabilities ===
|
|
|
7901 VULKAN_HPP_DEPRECATED( "The VK_NV_external_memory_capabilities extension has been deprecated by VK_KHR_external_memory_capabilities." )
|
|
|
7902 VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalMemoryCapabilitiesExtensionName = VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME;
|
|
|
7903 VULKAN_HPP_DEPRECATED( "The VK_NV_external_memory_capabilities extension has been deprecated by VK_KHR_external_memory_capabilities." )
|
|
|
7904 VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalMemoryCapabilitiesSpecVersion = VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION;
|
|
|
7905
|
|
|
7906 //=== VK_NV_external_memory ===
|
|
|
7907 VULKAN_HPP_DEPRECATED( "The VK_NV_external_memory extension has been deprecated by VK_KHR_external_memory." )
|
|
|
7908 VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalMemoryExtensionName = VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME;
|
|
|
7909 VULKAN_HPP_DEPRECATED( "The VK_NV_external_memory extension has been deprecated by VK_KHR_external_memory." )
|
|
|
7910 VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalMemorySpecVersion = VK_NV_EXTERNAL_MEMORY_SPEC_VERSION;
|
|
|
7911
|
|
|
7912 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
7913 //=== VK_NV_external_memory_win32 ===
|
|
|
7914 VULKAN_HPP_DEPRECATED( "The VK_NV_external_memory_win32 extension has been deprecated by VK_KHR_external_memory_win32." )
|
|
|
7915 VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalMemoryWin32ExtensionName = VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME;
|
|
|
7916 VULKAN_HPP_DEPRECATED( "The VK_NV_external_memory_win32 extension has been deprecated by VK_KHR_external_memory_win32." )
|
|
|
7917 VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalMemoryWin32SpecVersion = VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION;
|
|
|
7918 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
7919
|
|
|
7920 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
7921 //=== VK_NV_win32_keyed_mutex ===
|
|
|
7922 VULKAN_HPP_CONSTEXPR_INLINE auto NVWin32KeyedMutexExtensionName = VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME;
|
|
|
7923 VULKAN_HPP_CONSTEXPR_INLINE auto NVWin32KeyedMutexSpecVersion = VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION;
|
|
|
7924 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
7925
|
|
|
7926 //=== VK_KHR_get_physical_device_properties2 ===
|
|
|
7927 VULKAN_HPP_CONSTEXPR_INLINE auto KHRGetPhysicalDeviceProperties2ExtensionName = VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME;
|
|
|
7928 VULKAN_HPP_CONSTEXPR_INLINE auto KHRGetPhysicalDeviceProperties2SpecVersion = VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION;
|
|
|
7929
|
|
|
7930 //=== VK_KHR_device_group ===
|
|
|
7931 VULKAN_HPP_CONSTEXPR_INLINE auto KHRDeviceGroupExtensionName = VK_KHR_DEVICE_GROUP_EXTENSION_NAME;
|
|
|
7932 VULKAN_HPP_CONSTEXPR_INLINE auto KHRDeviceGroupSpecVersion = VK_KHR_DEVICE_GROUP_SPEC_VERSION;
|
|
|
7933
|
|
|
7934 //=== VK_EXT_validation_flags ===
|
|
|
7935 VULKAN_HPP_DEPRECATED( "The VK_EXT_validation_flags extension has been deprecated by VK_EXT_layer_settings." )
|
|
|
7936 VULKAN_HPP_CONSTEXPR_INLINE auto EXTValidationFlagsExtensionName = VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME;
|
|
|
7937 VULKAN_HPP_DEPRECATED( "The VK_EXT_validation_flags extension has been deprecated by VK_EXT_layer_settings." )
|
|
|
7938 VULKAN_HPP_CONSTEXPR_INLINE auto EXTValidationFlagsSpecVersion = VK_EXT_VALIDATION_FLAGS_SPEC_VERSION;
|
|
|
7939
|
|
|
7940 #if defined( VK_USE_PLATFORM_VI_NN )
|
|
|
7941 //=== VK_NN_vi_surface ===
|
|
|
7942 VULKAN_HPP_CONSTEXPR_INLINE auto NNViSurfaceExtensionName = VK_NN_VI_SURFACE_EXTENSION_NAME;
|
|
|
7943 VULKAN_HPP_CONSTEXPR_INLINE auto NNViSurfaceSpecVersion = VK_NN_VI_SURFACE_SPEC_VERSION;
|
|
|
7944 #endif /*VK_USE_PLATFORM_VI_NN*/
|
|
|
7945
|
|
|
7946 //=== VK_KHR_shader_draw_parameters ===
|
|
|
7947 VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderDrawParametersExtensionName = VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME;
|
|
|
7948 VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderDrawParametersSpecVersion = VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION;
|
|
|
7949
|
|
|
7950 //=== VK_EXT_shader_subgroup_ballot ===
|
|
|
7951 VULKAN_HPP_DEPRECATED( "The VK_EXT_shader_subgroup_ballot extension has been deprecated by VK_VERSION_1_2." )
|
|
|
7952 VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderSubgroupBallotExtensionName = VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME;
|
|
|
7953 VULKAN_HPP_DEPRECATED( "The VK_EXT_shader_subgroup_ballot extension has been deprecated by VK_VERSION_1_2." )
|
|
|
7954 VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderSubgroupBallotSpecVersion = VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION;
|
|
|
7955
|
|
|
7956 //=== VK_EXT_shader_subgroup_vote ===
|
|
|
7957 VULKAN_HPP_DEPRECATED( "The VK_EXT_shader_subgroup_vote extension has been deprecated by VK_VERSION_1_1." )
|
|
|
7958 VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderSubgroupVoteExtensionName = VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME;
|
|
|
7959 VULKAN_HPP_DEPRECATED( "The VK_EXT_shader_subgroup_vote extension has been deprecated by VK_VERSION_1_1." )
|
|
|
7960 VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderSubgroupVoteSpecVersion = VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION;
|
|
|
7961
|
|
|
7962 //=== VK_EXT_texture_compression_astc_hdr ===
|
|
|
7963 VULKAN_HPP_CONSTEXPR_INLINE auto EXTTextureCompressionAstcHdrExtensionName = VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME;
|
|
|
7964 VULKAN_HPP_CONSTEXPR_INLINE auto EXTTextureCompressionAstcHdrSpecVersion = VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_SPEC_VERSION;
|
|
|
7965
|
|
|
7966 //=== VK_EXT_astc_decode_mode ===
|
|
|
7967 VULKAN_HPP_CONSTEXPR_INLINE auto EXTAstcDecodeModeExtensionName = VK_EXT_ASTC_DECODE_MODE_EXTENSION_NAME;
|
|
|
7968 VULKAN_HPP_CONSTEXPR_INLINE auto EXTAstcDecodeModeSpecVersion = VK_EXT_ASTC_DECODE_MODE_SPEC_VERSION;
|
|
|
7969
|
|
|
7970 //=== VK_EXT_pipeline_robustness ===
|
|
|
7971 VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelineRobustnessExtensionName = VK_EXT_PIPELINE_ROBUSTNESS_EXTENSION_NAME;
|
|
|
7972 VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelineRobustnessSpecVersion = VK_EXT_PIPELINE_ROBUSTNESS_SPEC_VERSION;
|
|
|
7973
|
|
|
7974 //=== VK_KHR_maintenance1 ===
|
|
|
7975 VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance1ExtensionName = VK_KHR_MAINTENANCE_1_EXTENSION_NAME;
|
|
|
7976 VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance1SpecVersion = VK_KHR_MAINTENANCE_1_SPEC_VERSION;
|
|
|
7977
|
|
|
7978 //=== VK_KHR_device_group_creation ===
|
|
|
7979 VULKAN_HPP_CONSTEXPR_INLINE auto KHRDeviceGroupCreationExtensionName = VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME;
|
|
|
7980 VULKAN_HPP_CONSTEXPR_INLINE auto KHRDeviceGroupCreationSpecVersion = VK_KHR_DEVICE_GROUP_CREATION_SPEC_VERSION;
|
|
|
7981
|
|
|
7982 //=== VK_KHR_external_memory_capabilities ===
|
|
|
7983 VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalMemoryCapabilitiesExtensionName = VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME;
|
|
|
7984 VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalMemoryCapabilitiesSpecVersion = VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION;
|
|
|
7985
|
|
|
7986 //=== VK_KHR_external_memory ===
|
|
|
7987 VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalMemoryExtensionName = VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME;
|
|
|
7988 VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalMemorySpecVersion = VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION;
|
|
|
7989
|
|
|
7990 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
7991 //=== VK_KHR_external_memory_win32 ===
|
|
|
7992 VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalMemoryWin32ExtensionName = VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME;
|
|
|
7993 VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalMemoryWin32SpecVersion = VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION;
|
|
|
7994 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
7995
|
|
|
7996 //=== VK_KHR_external_memory_fd ===
|
|
|
7997 VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalMemoryFdExtensionName = VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME;
|
|
|
7998 VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalMemoryFdSpecVersion = VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION;
|
|
|
7999
|
|
|
8000 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
8001 //=== VK_KHR_win32_keyed_mutex ===
|
|
|
8002 VULKAN_HPP_CONSTEXPR_INLINE auto KHRWin32KeyedMutexExtensionName = VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME;
|
|
|
8003 VULKAN_HPP_CONSTEXPR_INLINE auto KHRWin32KeyedMutexSpecVersion = VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION;
|
|
|
8004 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
8005
|
|
|
8006 //=== VK_KHR_external_semaphore_capabilities ===
|
|
|
8007 VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalSemaphoreCapabilitiesExtensionName = VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME;
|
|
|
8008 VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalSemaphoreCapabilitiesSpecVersion = VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION;
|
|
|
8009
|
|
|
8010 //=== VK_KHR_external_semaphore ===
|
|
|
8011 VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalSemaphoreExtensionName = VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME;
|
|
|
8012 VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalSemaphoreSpecVersion = VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION;
|
|
|
8013
|
|
|
8014 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
8015 //=== VK_KHR_external_semaphore_win32 ===
|
|
|
8016 VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalSemaphoreWin32ExtensionName = VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME;
|
|
|
8017 VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalSemaphoreWin32SpecVersion = VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION;
|
|
|
8018 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
8019
|
|
|
8020 //=== VK_KHR_external_semaphore_fd ===
|
|
|
8021 VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalSemaphoreFdExtensionName = VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME;
|
|
|
8022 VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalSemaphoreFdSpecVersion = VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION;
|
|
|
8023
|
|
|
8024 //=== VK_KHR_push_descriptor ===
|
|
|
8025 VULKAN_HPP_CONSTEXPR_INLINE auto KHRPushDescriptorExtensionName = VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME;
|
|
|
8026 VULKAN_HPP_CONSTEXPR_INLINE auto KHRPushDescriptorSpecVersion = VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION;
|
|
|
8027
|
|
|
8028 //=== VK_EXT_conditional_rendering ===
|
|
|
8029 VULKAN_HPP_CONSTEXPR_INLINE auto EXTConditionalRenderingExtensionName = VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME;
|
|
|
8030 VULKAN_HPP_CONSTEXPR_INLINE auto EXTConditionalRenderingSpecVersion = VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION;
|
|
|
8031
|
|
|
8032 //=== VK_KHR_shader_float16_int8 ===
|
|
|
8033 VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderFloat16Int8ExtensionName = VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME;
|
|
|
8034 VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderFloat16Int8SpecVersion = VK_KHR_SHADER_FLOAT16_INT8_SPEC_VERSION;
|
|
|
8035
|
|
|
8036 //=== VK_KHR_16bit_storage ===
|
|
|
8037 VULKAN_HPP_CONSTEXPR_INLINE auto KHR16BitStorageExtensionName = VK_KHR_16BIT_STORAGE_EXTENSION_NAME;
|
|
|
8038 VULKAN_HPP_CONSTEXPR_INLINE auto KHR16BitStorageSpecVersion = VK_KHR_16BIT_STORAGE_SPEC_VERSION;
|
|
|
8039
|
|
|
8040 //=== VK_KHR_incremental_present ===
|
|
|
8041 VULKAN_HPP_CONSTEXPR_INLINE auto KHRIncrementalPresentExtensionName = VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME;
|
|
|
8042 VULKAN_HPP_CONSTEXPR_INLINE auto KHRIncrementalPresentSpecVersion = VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION;
|
|
|
8043
|
|
|
8044 //=== VK_KHR_descriptor_update_template ===
|
|
|
8045 VULKAN_HPP_CONSTEXPR_INLINE auto KHRDescriptorUpdateTemplateExtensionName = VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME;
|
|
|
8046 VULKAN_HPP_CONSTEXPR_INLINE auto KHRDescriptorUpdateTemplateSpecVersion = VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION;
|
|
|
8047
|
|
|
8048 //=== VK_NV_clip_space_w_scaling ===
|
|
|
8049 VULKAN_HPP_CONSTEXPR_INLINE auto NVClipSpaceWScalingExtensionName = VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME;
|
|
|
8050 VULKAN_HPP_CONSTEXPR_INLINE auto NVClipSpaceWScalingSpecVersion = VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION;
|
|
|
8051
|
|
|
8052 //=== VK_EXT_direct_mode_display ===
|
|
|
8053 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDirectModeDisplayExtensionName = VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME;
|
|
|
8054 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDirectModeDisplaySpecVersion = VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION;
|
|
|
8055
|
|
|
8056 #if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
|
|
|
8057 //=== VK_EXT_acquire_xlib_display ===
|
|
|
8058 VULKAN_HPP_CONSTEXPR_INLINE auto EXTAcquireXlibDisplayExtensionName = VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME;
|
|
|
8059 VULKAN_HPP_CONSTEXPR_INLINE auto EXTAcquireXlibDisplaySpecVersion = VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION;
|
|
|
8060 #endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
|
|
|
8061
|
|
|
8062 //=== VK_EXT_display_surface_counter ===
|
|
|
8063 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDisplaySurfaceCounterExtensionName = VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME;
|
|
|
8064 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDisplaySurfaceCounterSpecVersion = VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION;
|
|
|
8065
|
|
|
8066 //=== VK_EXT_display_control ===
|
|
|
8067 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDisplayControlExtensionName = VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME;
|
|
|
8068 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDisplayControlSpecVersion = VK_EXT_DISPLAY_CONTROL_SPEC_VERSION;
|
|
|
8069
|
|
|
8070 //=== VK_GOOGLE_display_timing ===
|
|
|
8071 VULKAN_HPP_CONSTEXPR_INLINE auto GOOGLEDisplayTimingExtensionName = VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME;
|
|
|
8072 VULKAN_HPP_CONSTEXPR_INLINE auto GOOGLEDisplayTimingSpecVersion = VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION;
|
|
|
8073
|
|
|
8074 //=== VK_NV_sample_mask_override_coverage ===
|
|
|
8075 VULKAN_HPP_CONSTEXPR_INLINE auto NVSampleMaskOverrideCoverageExtensionName = VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME;
|
|
|
8076 VULKAN_HPP_CONSTEXPR_INLINE auto NVSampleMaskOverrideCoverageSpecVersion = VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION;
|
|
|
8077
|
|
|
8078 //=== VK_NV_geometry_shader_passthrough ===
|
|
|
8079 VULKAN_HPP_CONSTEXPR_INLINE auto NVGeometryShaderPassthroughExtensionName = VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME;
|
|
|
8080 VULKAN_HPP_CONSTEXPR_INLINE auto NVGeometryShaderPassthroughSpecVersion = VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION;
|
|
|
8081
|
|
|
8082 //=== VK_NV_viewport_array2 ===
|
|
|
8083 VULKAN_HPP_CONSTEXPR_INLINE auto NVViewportArray2ExtensionName = VK_NV_VIEWPORT_ARRAY_2_EXTENSION_NAME;
|
|
|
8084 VULKAN_HPP_CONSTEXPR_INLINE auto NVViewportArray2SpecVersion = VK_NV_VIEWPORT_ARRAY_2_SPEC_VERSION;
|
|
|
8085
|
|
|
8086 //=== VK_NVX_multiview_per_view_attributes ===
|
|
|
8087 VULKAN_HPP_CONSTEXPR_INLINE auto NVXMultiviewPerViewAttributesExtensionName = VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME;
|
|
|
8088 VULKAN_HPP_CONSTEXPR_INLINE auto NVXMultiviewPerViewAttributesSpecVersion = VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION;
|
|
|
8089
|
|
|
8090 //=== VK_NV_viewport_swizzle ===
|
|
|
8091 VULKAN_HPP_CONSTEXPR_INLINE auto NVViewportSwizzleExtensionName = VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME;
|
|
|
8092 VULKAN_HPP_CONSTEXPR_INLINE auto NVViewportSwizzleSpecVersion = VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION;
|
|
|
8093
|
|
|
8094 //=== VK_EXT_discard_rectangles ===
|
|
|
8095 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDiscardRectanglesExtensionName = VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME;
|
|
|
8096 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDiscardRectanglesSpecVersion = VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION;
|
|
|
8097
|
|
|
8098 //=== VK_EXT_conservative_rasterization ===
|
|
|
8099 VULKAN_HPP_CONSTEXPR_INLINE auto EXTConservativeRasterizationExtensionName = VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME;
|
|
|
8100 VULKAN_HPP_CONSTEXPR_INLINE auto EXTConservativeRasterizationSpecVersion = VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION;
|
|
|
8101
|
|
|
8102 //=== VK_EXT_depth_clip_enable ===
|
|
|
8103 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthClipEnableExtensionName = VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME;
|
|
|
8104 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthClipEnableSpecVersion = VK_EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION;
|
|
|
8105
|
|
|
8106 //=== VK_EXT_swapchain_colorspace ===
|
|
|
8107 VULKAN_HPP_CONSTEXPR_INLINE auto EXTSwapchainColorSpaceExtensionName = VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME;
|
|
|
8108 VULKAN_HPP_CONSTEXPR_INLINE auto EXTSwapchainColorSpaceSpecVersion = VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION;
|
|
|
8109
|
|
|
8110 //=== VK_EXT_hdr_metadata ===
|
|
|
8111 VULKAN_HPP_CONSTEXPR_INLINE auto EXTHdrMetadataExtensionName = VK_EXT_HDR_METADATA_EXTENSION_NAME;
|
|
|
8112 VULKAN_HPP_CONSTEXPR_INLINE auto EXTHdrMetadataSpecVersion = VK_EXT_HDR_METADATA_SPEC_VERSION;
|
|
|
8113
|
|
|
8114 //=== VK_KHR_imageless_framebuffer ===
|
|
|
8115 VULKAN_HPP_CONSTEXPR_INLINE auto KHRImagelessFramebufferExtensionName = VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME;
|
|
|
8116 VULKAN_HPP_CONSTEXPR_INLINE auto KHRImagelessFramebufferSpecVersion = VK_KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION;
|
|
|
8117
|
|
|
8118 //=== VK_KHR_create_renderpass2 ===
|
|
|
8119 VULKAN_HPP_CONSTEXPR_INLINE auto KHRCreateRenderpass2ExtensionName = VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME;
|
|
|
8120 VULKAN_HPP_CONSTEXPR_INLINE auto KHRCreateRenderpass2SpecVersion = VK_KHR_CREATE_RENDERPASS_2_SPEC_VERSION;
|
|
|
8121
|
|
|
8122 //=== VK_IMG_relaxed_line_rasterization ===
|
|
|
8123 VULKAN_HPP_CONSTEXPR_INLINE auto IMGRelaxedLineRasterizationExtensionName = VK_IMG_RELAXED_LINE_RASTERIZATION_EXTENSION_NAME;
|
|
|
8124 VULKAN_HPP_CONSTEXPR_INLINE auto IMGRelaxedLineRasterizationSpecVersion = VK_IMG_RELAXED_LINE_RASTERIZATION_SPEC_VERSION;
|
|
|
8125
|
|
|
8126 //=== VK_KHR_shared_presentable_image ===
|
|
|
8127 VULKAN_HPP_CONSTEXPR_INLINE auto KHRSharedPresentableImageExtensionName = VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME;
|
|
|
8128 VULKAN_HPP_CONSTEXPR_INLINE auto KHRSharedPresentableImageSpecVersion = VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION;
|
|
|
8129
|
|
|
8130 //=== VK_KHR_external_fence_capabilities ===
|
|
|
8131 VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalFenceCapabilitiesExtensionName = VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME;
|
|
|
8132 VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalFenceCapabilitiesSpecVersion = VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION;
|
|
|
8133
|
|
|
8134 //=== VK_KHR_external_fence ===
|
|
|
8135 VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalFenceExtensionName = VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME;
|
|
|
8136 VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalFenceSpecVersion = VK_KHR_EXTERNAL_FENCE_SPEC_VERSION;
|
|
|
8137
|
|
|
8138 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
8139 //=== VK_KHR_external_fence_win32 ===
|
|
|
8140 VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalFenceWin32ExtensionName = VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME;
|
|
|
8141 VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalFenceWin32SpecVersion = VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION;
|
|
|
8142 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
8143
|
|
|
8144 //=== VK_KHR_external_fence_fd ===
|
|
|
8145 VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalFenceFdExtensionName = VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME;
|
|
|
8146 VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalFenceFdSpecVersion = VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION;
|
|
|
8147
|
|
|
8148 //=== VK_KHR_performance_query ===
|
|
|
8149 VULKAN_HPP_CONSTEXPR_INLINE auto KHRPerformanceQueryExtensionName = VK_KHR_PERFORMANCE_QUERY_EXTENSION_NAME;
|
|
|
8150 VULKAN_HPP_CONSTEXPR_INLINE auto KHRPerformanceQuerySpecVersion = VK_KHR_PERFORMANCE_QUERY_SPEC_VERSION;
|
|
|
8151
|
|
|
8152 //=== VK_KHR_maintenance2 ===
|
|
|
8153 VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance2ExtensionName = VK_KHR_MAINTENANCE_2_EXTENSION_NAME;
|
|
|
8154 VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance2SpecVersion = VK_KHR_MAINTENANCE_2_SPEC_VERSION;
|
|
|
8155
|
|
|
8156 //=== VK_KHR_get_surface_capabilities2 ===
|
|
|
8157 VULKAN_HPP_CONSTEXPR_INLINE auto KHRGetSurfaceCapabilities2ExtensionName = VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME;
|
|
|
8158 VULKAN_HPP_CONSTEXPR_INLINE auto KHRGetSurfaceCapabilities2SpecVersion = VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION;
|
|
|
8159
|
|
|
8160 //=== VK_KHR_variable_pointers ===
|
|
|
8161 VULKAN_HPP_CONSTEXPR_INLINE auto KHRVariablePointersExtensionName = VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME;
|
|
|
8162 VULKAN_HPP_CONSTEXPR_INLINE auto KHRVariablePointersSpecVersion = VK_KHR_VARIABLE_POINTERS_SPEC_VERSION;
|
|
|
8163
|
|
|
8164 //=== VK_KHR_get_display_properties2 ===
|
|
|
8165 VULKAN_HPP_CONSTEXPR_INLINE auto KHRGetDisplayProperties2ExtensionName = VK_KHR_GET_DISPLAY_PROPERTIES_2_EXTENSION_NAME;
|
|
|
8166 VULKAN_HPP_CONSTEXPR_INLINE auto KHRGetDisplayProperties2SpecVersion = VK_KHR_GET_DISPLAY_PROPERTIES_2_SPEC_VERSION;
|
|
|
8167
|
|
|
8168 #if defined( VK_USE_PLATFORM_IOS_MVK )
|
|
|
8169 //=== VK_MVK_ios_surface ===
|
|
|
8170 VULKAN_HPP_DEPRECATED( "The VK_MVK_ios_surface extension has been deprecated by VK_EXT_metal_surface." )
|
|
|
8171 VULKAN_HPP_CONSTEXPR_INLINE auto MVKIosSurfaceExtensionName = VK_MVK_IOS_SURFACE_EXTENSION_NAME;
|
|
|
8172 VULKAN_HPP_DEPRECATED( "The VK_MVK_ios_surface extension has been deprecated by VK_EXT_metal_surface." )
|
|
|
8173 VULKAN_HPP_CONSTEXPR_INLINE auto MVKIosSurfaceSpecVersion = VK_MVK_IOS_SURFACE_SPEC_VERSION;
|
|
|
8174 #endif /*VK_USE_PLATFORM_IOS_MVK*/
|
|
|
8175
|
|
|
8176 #if defined( VK_USE_PLATFORM_MACOS_MVK )
|
|
|
8177 //=== VK_MVK_macos_surface ===
|
|
|
8178 VULKAN_HPP_DEPRECATED( "The VK_MVK_macos_surface extension has been deprecated by VK_EXT_metal_surface." )
|
|
|
8179 VULKAN_HPP_CONSTEXPR_INLINE auto MVKMacosSurfaceExtensionName = VK_MVK_MACOS_SURFACE_EXTENSION_NAME;
|
|
|
8180 VULKAN_HPP_DEPRECATED( "The VK_MVK_macos_surface extension has been deprecated by VK_EXT_metal_surface." )
|
|
|
8181 VULKAN_HPP_CONSTEXPR_INLINE auto MVKMacosSurfaceSpecVersion = VK_MVK_MACOS_SURFACE_SPEC_VERSION;
|
|
|
8182 #endif /*VK_USE_PLATFORM_MACOS_MVK*/
|
|
|
8183
|
|
|
8184 //=== VK_EXT_external_memory_dma_buf ===
|
|
|
8185 VULKAN_HPP_CONSTEXPR_INLINE auto EXTExternalMemoryDmaBufExtensionName = VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME;
|
|
|
8186 VULKAN_HPP_CONSTEXPR_INLINE auto EXTExternalMemoryDmaBufSpecVersion = VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION;
|
|
|
8187
|
|
|
8188 //=== VK_EXT_queue_family_foreign ===
|
|
|
8189 VULKAN_HPP_CONSTEXPR_INLINE auto EXTQueueFamilyForeignExtensionName = VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME;
|
|
|
8190 VULKAN_HPP_CONSTEXPR_INLINE auto EXTQueueFamilyForeignSpecVersion = VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION;
|
|
|
8191
|
|
|
8192 //=== VK_KHR_dedicated_allocation ===
|
|
|
8193 VULKAN_HPP_CONSTEXPR_INLINE auto KHRDedicatedAllocationExtensionName = VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME;
|
|
|
8194 VULKAN_HPP_CONSTEXPR_INLINE auto KHRDedicatedAllocationSpecVersion = VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION;
|
|
|
8195
|
|
|
8196 //=== VK_EXT_debug_utils ===
|
|
|
8197 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDebugUtilsExtensionName = VK_EXT_DEBUG_UTILS_EXTENSION_NAME;
|
|
|
8198 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDebugUtilsSpecVersion = VK_EXT_DEBUG_UTILS_SPEC_VERSION;
|
|
|
8199
|
|
|
8200 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
|
|
8201 //=== VK_ANDROID_external_memory_android_hardware_buffer ===
|
|
|
8202 VULKAN_HPP_CONSTEXPR_INLINE auto ANDROIDExternalMemoryAndroidHardwareBufferExtensionName = VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME;
|
|
|
8203 VULKAN_HPP_CONSTEXPR_INLINE auto ANDROIDExternalMemoryAndroidHardwareBufferSpecVersion = VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_SPEC_VERSION;
|
|
|
8204 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
|
|
8205
|
|
|
8206 //=== VK_EXT_sampler_filter_minmax ===
|
|
|
8207 VULKAN_HPP_CONSTEXPR_INLINE auto EXTSamplerFilterMinmaxExtensionName = VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME;
|
|
|
8208 VULKAN_HPP_CONSTEXPR_INLINE auto EXTSamplerFilterMinmaxSpecVersion = VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION;
|
|
|
8209
|
|
|
8210 //=== VK_KHR_storage_buffer_storage_class ===
|
|
|
8211 VULKAN_HPP_CONSTEXPR_INLINE auto KHRStorageBufferStorageClassExtensionName = VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME;
|
|
|
8212 VULKAN_HPP_CONSTEXPR_INLINE auto KHRStorageBufferStorageClassSpecVersion = VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION;
|
|
|
8213
|
|
|
8214 //=== VK_AMD_gpu_shader_int16 ===
|
|
|
8215 VULKAN_HPP_DEPRECATED( "The VK_AMD_gpu_shader_int16 extension has been deprecated by VK_KHR_shader_float16_int8." )
|
|
|
8216 VULKAN_HPP_CONSTEXPR_INLINE auto AMDGpuShaderInt16ExtensionName = VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME;
|
|
|
8217 VULKAN_HPP_DEPRECATED( "The VK_AMD_gpu_shader_int16 extension has been deprecated by VK_KHR_shader_float16_int8." )
|
|
|
8218 VULKAN_HPP_CONSTEXPR_INLINE auto AMDGpuShaderInt16SpecVersion = VK_AMD_GPU_SHADER_INT16_SPEC_VERSION;
|
|
|
8219
|
|
|
8220 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
8221 //=== VK_AMDX_shader_enqueue ===
|
|
|
8222 VULKAN_HPP_CONSTEXPR_INLINE auto AMDXShaderEnqueueExtensionName = VK_AMDX_SHADER_ENQUEUE_EXTENSION_NAME;
|
|
|
8223 VULKAN_HPP_CONSTEXPR_INLINE auto AMDXShaderEnqueueSpecVersion = VK_AMDX_SHADER_ENQUEUE_SPEC_VERSION;
|
|
|
8224 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
8225
|
|
|
8226 //=== VK_AMD_mixed_attachment_samples ===
|
|
|
8227 VULKAN_HPP_CONSTEXPR_INLINE auto AMDMixedAttachmentSamplesExtensionName = VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME;
|
|
|
8228 VULKAN_HPP_CONSTEXPR_INLINE auto AMDMixedAttachmentSamplesSpecVersion = VK_AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION;
|
|
|
8229
|
|
|
8230 //=== VK_AMD_shader_fragment_mask ===
|
|
|
8231 VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderFragmentMaskExtensionName = VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME;
|
|
|
8232 VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderFragmentMaskSpecVersion = VK_AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION;
|
|
|
8233
|
|
|
8234 //=== VK_EXT_inline_uniform_block ===
|
|
|
8235 VULKAN_HPP_CONSTEXPR_INLINE auto EXTInlineUniformBlockExtensionName = VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME;
|
|
|
8236 VULKAN_HPP_CONSTEXPR_INLINE auto EXTInlineUniformBlockSpecVersion = VK_EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION;
|
|
|
8237
|
|
|
8238 //=== VK_EXT_shader_stencil_export ===
|
|
|
8239 VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderStencilExportExtensionName = VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME;
|
|
|
8240 VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderStencilExportSpecVersion = VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION;
|
|
|
8241
|
|
|
8242 //=== VK_KHR_shader_bfloat16 ===
|
|
|
8243 VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderBfloat16ExtensionName = VK_KHR_SHADER_BFLOAT16_EXTENSION_NAME;
|
|
|
8244 VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderBfloat16SpecVersion = VK_KHR_SHADER_BFLOAT16_SPEC_VERSION;
|
|
|
8245
|
|
|
8246 //=== VK_EXT_sample_locations ===
|
|
|
8247 VULKAN_HPP_CONSTEXPR_INLINE auto EXTSampleLocationsExtensionName = VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME;
|
|
|
8248 VULKAN_HPP_CONSTEXPR_INLINE auto EXTSampleLocationsSpecVersion = VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION;
|
|
|
8249
|
|
|
8250 //=== VK_KHR_relaxed_block_layout ===
|
|
|
8251 VULKAN_HPP_CONSTEXPR_INLINE auto KHRRelaxedBlockLayoutExtensionName = VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME;
|
|
|
8252 VULKAN_HPP_CONSTEXPR_INLINE auto KHRRelaxedBlockLayoutSpecVersion = VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION;
|
|
|
8253
|
|
|
8254 //=== VK_KHR_get_memory_requirements2 ===
|
|
|
8255 VULKAN_HPP_CONSTEXPR_INLINE auto KHRGetMemoryRequirements2ExtensionName = VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME;
|
|
|
8256 VULKAN_HPP_CONSTEXPR_INLINE auto KHRGetMemoryRequirements2SpecVersion = VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION;
|
|
|
8257
|
|
|
8258 //=== VK_KHR_image_format_list ===
|
|
|
8259 VULKAN_HPP_CONSTEXPR_INLINE auto KHRImageFormatListExtensionName = VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME;
|
|
|
8260 VULKAN_HPP_CONSTEXPR_INLINE auto KHRImageFormatListSpecVersion = VK_KHR_IMAGE_FORMAT_LIST_SPEC_VERSION;
|
|
|
8261
|
|
|
8262 //=== VK_EXT_blend_operation_advanced ===
|
|
|
8263 VULKAN_HPP_CONSTEXPR_INLINE auto EXTBlendOperationAdvancedExtensionName = VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME;
|
|
|
8264 VULKAN_HPP_CONSTEXPR_INLINE auto EXTBlendOperationAdvancedSpecVersion = VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION;
|
|
|
8265
|
|
|
8266 //=== VK_NV_fragment_coverage_to_color ===
|
|
|
8267 VULKAN_HPP_CONSTEXPR_INLINE auto NVFragmentCoverageToColorExtensionName = VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME;
|
|
|
8268 VULKAN_HPP_CONSTEXPR_INLINE auto NVFragmentCoverageToColorSpecVersion = VK_NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION;
|
|
|
8269
|
|
|
8270 //=== VK_KHR_acceleration_structure ===
|
|
|
8271 VULKAN_HPP_CONSTEXPR_INLINE auto KHRAccelerationStructureExtensionName = VK_KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME;
|
|
|
8272 VULKAN_HPP_CONSTEXPR_INLINE auto KHRAccelerationStructureSpecVersion = VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION;
|
|
|
8273
|
|
|
8274 //=== VK_KHR_ray_tracing_pipeline ===
|
|
|
8275 VULKAN_HPP_CONSTEXPR_INLINE auto KHRRayTracingPipelineExtensionName = VK_KHR_RAY_TRACING_PIPELINE_EXTENSION_NAME;
|
|
|
8276 VULKAN_HPP_CONSTEXPR_INLINE auto KHRRayTracingPipelineSpecVersion = VK_KHR_RAY_TRACING_PIPELINE_SPEC_VERSION;
|
|
|
8277
|
|
|
8278 //=== VK_KHR_ray_query ===
|
|
|
8279 VULKAN_HPP_CONSTEXPR_INLINE auto KHRRayQueryExtensionName = VK_KHR_RAY_QUERY_EXTENSION_NAME;
|
|
|
8280 VULKAN_HPP_CONSTEXPR_INLINE auto KHRRayQuerySpecVersion = VK_KHR_RAY_QUERY_SPEC_VERSION;
|
|
|
8281
|
|
|
8282 //=== VK_NV_framebuffer_mixed_samples ===
|
|
|
8283 VULKAN_HPP_CONSTEXPR_INLINE auto NVFramebufferMixedSamplesExtensionName = VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME;
|
|
|
8284 VULKAN_HPP_CONSTEXPR_INLINE auto NVFramebufferMixedSamplesSpecVersion = VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION;
|
|
|
8285
|
|
|
8286 //=== VK_NV_fill_rectangle ===
|
|
|
8287 VULKAN_HPP_CONSTEXPR_INLINE auto NVFillRectangleExtensionName = VK_NV_FILL_RECTANGLE_EXTENSION_NAME;
|
|
|
8288 VULKAN_HPP_CONSTEXPR_INLINE auto NVFillRectangleSpecVersion = VK_NV_FILL_RECTANGLE_SPEC_VERSION;
|
|
|
8289
|
|
|
8290 //=== VK_NV_shader_sm_builtins ===
|
|
|
8291 VULKAN_HPP_CONSTEXPR_INLINE auto NVShaderSmBuiltinsExtensionName = VK_NV_SHADER_SM_BUILTINS_EXTENSION_NAME;
|
|
|
8292 VULKAN_HPP_CONSTEXPR_INLINE auto NVShaderSmBuiltinsSpecVersion = VK_NV_SHADER_SM_BUILTINS_SPEC_VERSION;
|
|
|
8293
|
|
|
8294 //=== VK_EXT_post_depth_coverage ===
|
|
|
8295 VULKAN_HPP_CONSTEXPR_INLINE auto EXTPostDepthCoverageExtensionName = VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME;
|
|
|
8296 VULKAN_HPP_CONSTEXPR_INLINE auto EXTPostDepthCoverageSpecVersion = VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION;
|
|
|
8297
|
|
|
8298 //=== VK_KHR_sampler_ycbcr_conversion ===
|
|
|
8299 VULKAN_HPP_CONSTEXPR_INLINE auto KHRSamplerYcbcrConversionExtensionName = VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME;
|
|
|
8300 VULKAN_HPP_CONSTEXPR_INLINE auto KHRSamplerYcbcrConversionSpecVersion = VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION;
|
|
|
8301
|
|
|
8302 //=== VK_KHR_bind_memory2 ===
|
|
|
8303 VULKAN_HPP_CONSTEXPR_INLINE auto KHRBindMemory2ExtensionName = VK_KHR_BIND_MEMORY_2_EXTENSION_NAME;
|
|
|
8304 VULKAN_HPP_CONSTEXPR_INLINE auto KHRBindMemory2SpecVersion = VK_KHR_BIND_MEMORY_2_SPEC_VERSION;
|
|
|
8305
|
|
|
8306 //=== VK_EXT_image_drm_format_modifier ===
|
|
|
8307 VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageDrmFormatModifierExtensionName = VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME;
|
|
|
8308 VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageDrmFormatModifierSpecVersion = VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION;
|
|
|
8309
|
|
|
8310 //=== VK_EXT_validation_cache ===
|
|
|
8311 VULKAN_HPP_CONSTEXPR_INLINE auto EXTValidationCacheExtensionName = VK_EXT_VALIDATION_CACHE_EXTENSION_NAME;
|
|
|
8312 VULKAN_HPP_CONSTEXPR_INLINE auto EXTValidationCacheSpecVersion = VK_EXT_VALIDATION_CACHE_SPEC_VERSION;
|
|
|
8313
|
|
|
8314 //=== VK_EXT_descriptor_indexing ===
|
|
|
8315 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDescriptorIndexingExtensionName = VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME;
|
|
|
8316 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDescriptorIndexingSpecVersion = VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION;
|
|
|
8317
|
|
|
8318 //=== VK_EXT_shader_viewport_index_layer ===
|
|
|
8319 VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderViewportIndexLayerExtensionName = VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME;
|
|
|
8320 VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderViewportIndexLayerSpecVersion = VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION;
|
|
|
8321
|
|
|
8322 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
8323 //=== VK_KHR_portability_subset ===
|
|
|
8324 VULKAN_HPP_CONSTEXPR_INLINE auto KHRPortabilitySubsetExtensionName = VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME;
|
|
|
8325 VULKAN_HPP_CONSTEXPR_INLINE auto KHRPortabilitySubsetSpecVersion = VK_KHR_PORTABILITY_SUBSET_SPEC_VERSION;
|
|
|
8326 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
8327
|
|
|
8328 //=== VK_NV_shading_rate_image ===
|
|
|
8329 VULKAN_HPP_CONSTEXPR_INLINE auto NVShadingRateImageExtensionName = VK_NV_SHADING_RATE_IMAGE_EXTENSION_NAME;
|
|
|
8330 VULKAN_HPP_CONSTEXPR_INLINE auto NVShadingRateImageSpecVersion = VK_NV_SHADING_RATE_IMAGE_SPEC_VERSION;
|
|
|
8331
|
|
|
8332 //=== VK_NV_ray_tracing ===
|
|
|
8333 VULKAN_HPP_DEPRECATED( "The VK_NV_ray_tracing extension has been deprecated by VK_KHR_ray_tracing_pipeline." )
|
|
|
8334 VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingExtensionName = VK_NV_RAY_TRACING_EXTENSION_NAME;
|
|
|
8335 VULKAN_HPP_DEPRECATED( "The VK_NV_ray_tracing extension has been deprecated by VK_KHR_ray_tracing_pipeline." )
|
|
|
8336 VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingSpecVersion = VK_NV_RAY_TRACING_SPEC_VERSION;
|
|
|
8337
|
|
|
8338 //=== VK_NV_representative_fragment_test ===
|
|
|
8339 VULKAN_HPP_CONSTEXPR_INLINE auto NVRepresentativeFragmentTestExtensionName = VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME;
|
|
|
8340 VULKAN_HPP_CONSTEXPR_INLINE auto NVRepresentativeFragmentTestSpecVersion = VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION;
|
|
|
8341
|
|
|
8342 //=== VK_KHR_maintenance3 ===
|
|
|
8343 VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance3ExtensionName = VK_KHR_MAINTENANCE_3_EXTENSION_NAME;
|
|
|
8344 VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance3SpecVersion = VK_KHR_MAINTENANCE_3_SPEC_VERSION;
|
|
|
8345
|
|
|
8346 //=== VK_KHR_draw_indirect_count ===
|
|
|
8347 VULKAN_HPP_CONSTEXPR_INLINE auto KHRDrawIndirectCountExtensionName = VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME;
|
|
|
8348 VULKAN_HPP_CONSTEXPR_INLINE auto KHRDrawIndirectCountSpecVersion = VK_KHR_DRAW_INDIRECT_COUNT_SPEC_VERSION;
|
|
|
8349
|
|
|
8350 //=== VK_EXT_filter_cubic ===
|
|
|
8351 VULKAN_HPP_CONSTEXPR_INLINE auto EXTFilterCubicExtensionName = VK_EXT_FILTER_CUBIC_EXTENSION_NAME;
|
|
|
8352 VULKAN_HPP_CONSTEXPR_INLINE auto EXTFilterCubicSpecVersion = VK_EXT_FILTER_CUBIC_SPEC_VERSION;
|
|
|
8353
|
|
|
8354 //=== VK_QCOM_render_pass_shader_resolve ===
|
|
|
8355 VULKAN_HPP_CONSTEXPR_INLINE auto QCOMRenderPassShaderResolveExtensionName = VK_QCOM_RENDER_PASS_SHADER_RESOLVE_EXTENSION_NAME;
|
|
|
8356 VULKAN_HPP_CONSTEXPR_INLINE auto QCOMRenderPassShaderResolveSpecVersion = VK_QCOM_RENDER_PASS_SHADER_RESOLVE_SPEC_VERSION;
|
|
|
8357
|
|
|
8358 //=== VK_EXT_global_priority ===
|
|
|
8359 VULKAN_HPP_CONSTEXPR_INLINE auto EXTGlobalPriorityExtensionName = VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME;
|
|
|
8360 VULKAN_HPP_CONSTEXPR_INLINE auto EXTGlobalPrioritySpecVersion = VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION;
|
|
|
8361
|
|
|
8362 //=== VK_KHR_shader_subgroup_extended_types ===
|
|
|
8363 VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderSubgroupExtendedTypesExtensionName = VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_EXTENSION_NAME;
|
|
|
8364 VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderSubgroupExtendedTypesSpecVersion = VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_SPEC_VERSION;
|
|
|
8365
|
|
|
8366 //=== VK_KHR_8bit_storage ===
|
|
|
8367 VULKAN_HPP_CONSTEXPR_INLINE auto KHR8BitStorageExtensionName = VK_KHR_8BIT_STORAGE_EXTENSION_NAME;
|
|
|
8368 VULKAN_HPP_CONSTEXPR_INLINE auto KHR8BitStorageSpecVersion = VK_KHR_8BIT_STORAGE_SPEC_VERSION;
|
|
|
8369
|
|
|
8370 //=== VK_EXT_external_memory_host ===
|
|
|
8371 VULKAN_HPP_CONSTEXPR_INLINE auto EXTExternalMemoryHostExtensionName = VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME;
|
|
|
8372 VULKAN_HPP_CONSTEXPR_INLINE auto EXTExternalMemoryHostSpecVersion = VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION;
|
|
|
8373
|
|
|
8374 //=== VK_AMD_buffer_marker ===
|
|
|
8375 VULKAN_HPP_CONSTEXPR_INLINE auto AMDBufferMarkerExtensionName = VK_AMD_BUFFER_MARKER_EXTENSION_NAME;
|
|
|
8376 VULKAN_HPP_CONSTEXPR_INLINE auto AMDBufferMarkerSpecVersion = VK_AMD_BUFFER_MARKER_SPEC_VERSION;
|
|
|
8377
|
|
|
8378 //=== VK_KHR_shader_atomic_int64 ===
|
|
|
8379 VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderAtomicInt64ExtensionName = VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME;
|
|
|
8380 VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderAtomicInt64SpecVersion = VK_KHR_SHADER_ATOMIC_INT64_SPEC_VERSION;
|
|
|
8381
|
|
|
8382 //=== VK_KHR_shader_clock ===
|
|
|
8383 VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderClockExtensionName = VK_KHR_SHADER_CLOCK_EXTENSION_NAME;
|
|
|
8384 VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderClockSpecVersion = VK_KHR_SHADER_CLOCK_SPEC_VERSION;
|
|
|
8385
|
|
|
8386 //=== VK_AMD_pipeline_compiler_control ===
|
|
|
8387 VULKAN_HPP_CONSTEXPR_INLINE auto AMDPipelineCompilerControlExtensionName = VK_AMD_PIPELINE_COMPILER_CONTROL_EXTENSION_NAME;
|
|
|
8388 VULKAN_HPP_CONSTEXPR_INLINE auto AMDPipelineCompilerControlSpecVersion = VK_AMD_PIPELINE_COMPILER_CONTROL_SPEC_VERSION;
|
|
|
8389
|
|
|
8390 //=== VK_EXT_calibrated_timestamps ===
|
|
|
8391 VULKAN_HPP_CONSTEXPR_INLINE auto EXTCalibratedTimestampsExtensionName = VK_EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME;
|
|
|
8392 VULKAN_HPP_CONSTEXPR_INLINE auto EXTCalibratedTimestampsSpecVersion = VK_EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION;
|
|
|
8393
|
|
|
8394 //=== VK_AMD_shader_core_properties ===
|
|
|
8395 VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderCorePropertiesExtensionName = VK_AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME;
|
|
|
8396 VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderCorePropertiesSpecVersion = VK_AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION;
|
|
|
8397
|
|
|
8398 //=== VK_KHR_video_decode_h265 ===
|
|
|
8399 VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoDecodeH265ExtensionName = VK_KHR_VIDEO_DECODE_H265_EXTENSION_NAME;
|
|
|
8400 VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoDecodeH265SpecVersion = VK_KHR_VIDEO_DECODE_H265_SPEC_VERSION;
|
|
|
8401
|
|
|
8402 //=== VK_KHR_global_priority ===
|
|
|
8403 VULKAN_HPP_CONSTEXPR_INLINE auto KHRGlobalPriorityExtensionName = VK_KHR_GLOBAL_PRIORITY_EXTENSION_NAME;
|
|
|
8404 VULKAN_HPP_CONSTEXPR_INLINE auto KHRGlobalPrioritySpecVersion = VK_KHR_GLOBAL_PRIORITY_SPEC_VERSION;
|
|
|
8405
|
|
|
8406 //=== VK_AMD_memory_overallocation_behavior ===
|
|
|
8407 VULKAN_HPP_CONSTEXPR_INLINE auto AMDMemoryOverallocationBehaviorExtensionName = VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_EXTENSION_NAME;
|
|
|
8408 VULKAN_HPP_CONSTEXPR_INLINE auto AMDMemoryOverallocationBehaviorSpecVersion = VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_SPEC_VERSION;
|
|
|
8409
|
|
|
8410 //=== VK_EXT_vertex_attribute_divisor ===
|
|
|
8411 VULKAN_HPP_CONSTEXPR_INLINE auto EXTVertexAttributeDivisorExtensionName = VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME;
|
|
|
8412 VULKAN_HPP_CONSTEXPR_INLINE auto EXTVertexAttributeDivisorSpecVersion = VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION;
|
|
|
8413
|
|
|
8414 #if defined( VK_USE_PLATFORM_GGP )
|
|
|
8415 //=== VK_GGP_frame_token ===
|
|
|
8416 VULKAN_HPP_CONSTEXPR_INLINE auto GGPFrameTokenExtensionName = VK_GGP_FRAME_TOKEN_EXTENSION_NAME;
|
|
|
8417 VULKAN_HPP_CONSTEXPR_INLINE auto GGPFrameTokenSpecVersion = VK_GGP_FRAME_TOKEN_SPEC_VERSION;
|
|
|
8418 #endif /*VK_USE_PLATFORM_GGP*/
|
|
|
8419
|
|
|
8420 //=== VK_EXT_pipeline_creation_feedback ===
|
|
|
8421 VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelineCreationFeedbackExtensionName = VK_EXT_PIPELINE_CREATION_FEEDBACK_EXTENSION_NAME;
|
|
|
8422 VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelineCreationFeedbackSpecVersion = VK_EXT_PIPELINE_CREATION_FEEDBACK_SPEC_VERSION;
|
|
|
8423
|
|
|
8424 //=== VK_KHR_driver_properties ===
|
|
|
8425 VULKAN_HPP_CONSTEXPR_INLINE auto KHRDriverPropertiesExtensionName = VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME;
|
|
|
8426 VULKAN_HPP_CONSTEXPR_INLINE auto KHRDriverPropertiesSpecVersion = VK_KHR_DRIVER_PROPERTIES_SPEC_VERSION;
|
|
|
8427
|
|
|
8428 //=== VK_KHR_shader_float_controls ===
|
|
|
8429 VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderFloatControlsExtensionName = VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME;
|
|
|
8430 VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderFloatControlsSpecVersion = VK_KHR_SHADER_FLOAT_CONTROLS_SPEC_VERSION;
|
|
|
8431
|
|
|
8432 //=== VK_NV_shader_subgroup_partitioned ===
|
|
|
8433 VULKAN_HPP_CONSTEXPR_INLINE auto NVShaderSubgroupPartitionedExtensionName = VK_NV_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME;
|
|
|
8434 VULKAN_HPP_CONSTEXPR_INLINE auto NVShaderSubgroupPartitionedSpecVersion = VK_NV_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION;
|
|
|
8435
|
|
|
8436 //=== VK_KHR_depth_stencil_resolve ===
|
|
|
8437 VULKAN_HPP_CONSTEXPR_INLINE auto KHRDepthStencilResolveExtensionName = VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME;
|
|
|
8438 VULKAN_HPP_CONSTEXPR_INLINE auto KHRDepthStencilResolveSpecVersion = VK_KHR_DEPTH_STENCIL_RESOLVE_SPEC_VERSION;
|
|
|
8439
|
|
|
8440 //=== VK_KHR_swapchain_mutable_format ===
|
|
|
8441 VULKAN_HPP_CONSTEXPR_INLINE auto KHRSwapchainMutableFormatExtensionName = VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME;
|
|
|
8442 VULKAN_HPP_CONSTEXPR_INLINE auto KHRSwapchainMutableFormatSpecVersion = VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_SPEC_VERSION;
|
|
|
8443
|
|
|
8444 //=== VK_NV_compute_shader_derivatives ===
|
|
|
8445 VULKAN_HPP_CONSTEXPR_INLINE auto NVComputeShaderDerivativesExtensionName = VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME;
|
|
|
8446 VULKAN_HPP_CONSTEXPR_INLINE auto NVComputeShaderDerivativesSpecVersion = VK_NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION;
|
|
|
8447
|
|
|
8448 //=== VK_NV_mesh_shader ===
|
|
|
8449 VULKAN_HPP_CONSTEXPR_INLINE auto NVMeshShaderExtensionName = VK_NV_MESH_SHADER_EXTENSION_NAME;
|
|
|
8450 VULKAN_HPP_CONSTEXPR_INLINE auto NVMeshShaderSpecVersion = VK_NV_MESH_SHADER_SPEC_VERSION;
|
|
|
8451
|
|
|
8452 //=== VK_NV_fragment_shader_barycentric ===
|
|
|
8453 VULKAN_HPP_CONSTEXPR_INLINE auto NVFragmentShaderBarycentricExtensionName = VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME;
|
|
|
8454 VULKAN_HPP_CONSTEXPR_INLINE auto NVFragmentShaderBarycentricSpecVersion = VK_NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION;
|
|
|
8455
|
|
|
8456 //=== VK_NV_shader_image_footprint ===
|
|
|
8457 VULKAN_HPP_CONSTEXPR_INLINE auto NVShaderImageFootprintExtensionName = VK_NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME;
|
|
|
8458 VULKAN_HPP_CONSTEXPR_INLINE auto NVShaderImageFootprintSpecVersion = VK_NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION;
|
|
|
8459
|
|
|
8460 //=== VK_NV_scissor_exclusive ===
|
|
|
8461 VULKAN_HPP_CONSTEXPR_INLINE auto NVScissorExclusiveExtensionName = VK_NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME;
|
|
|
8462 VULKAN_HPP_CONSTEXPR_INLINE auto NVScissorExclusiveSpecVersion = VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION;
|
|
|
8463
|
|
|
8464 //=== VK_NV_device_diagnostic_checkpoints ===
|
|
|
8465 VULKAN_HPP_CONSTEXPR_INLINE auto NVDeviceDiagnosticCheckpointsExtensionName = VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_EXTENSION_NAME;
|
|
|
8466 VULKAN_HPP_CONSTEXPR_INLINE auto NVDeviceDiagnosticCheckpointsSpecVersion = VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_SPEC_VERSION;
|
|
|
8467
|
|
|
8468 //=== VK_KHR_timeline_semaphore ===
|
|
|
8469 VULKAN_HPP_CONSTEXPR_INLINE auto KHRTimelineSemaphoreExtensionName = VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME;
|
|
|
8470 VULKAN_HPP_CONSTEXPR_INLINE auto KHRTimelineSemaphoreSpecVersion = VK_KHR_TIMELINE_SEMAPHORE_SPEC_VERSION;
|
|
|
8471
|
|
|
8472 //=== VK_INTEL_shader_integer_functions2 ===
|
|
|
8473 VULKAN_HPP_CONSTEXPR_INLINE auto INTELShaderIntegerFunctions2ExtensionName = VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_EXTENSION_NAME;
|
|
|
8474 VULKAN_HPP_CONSTEXPR_INLINE auto INTELShaderIntegerFunctions2SpecVersion = VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_SPEC_VERSION;
|
|
|
8475
|
|
|
8476 //=== VK_INTEL_performance_query ===
|
|
|
8477 VULKAN_HPP_CONSTEXPR_INLINE auto INTELPerformanceQueryExtensionName = VK_INTEL_PERFORMANCE_QUERY_EXTENSION_NAME;
|
|
|
8478 VULKAN_HPP_CONSTEXPR_INLINE auto INTELPerformanceQuerySpecVersion = VK_INTEL_PERFORMANCE_QUERY_SPEC_VERSION;
|
|
|
8479
|
|
|
8480 //=== VK_KHR_vulkan_memory_model ===
|
|
|
8481 VULKAN_HPP_CONSTEXPR_INLINE auto KHRVulkanMemoryModelExtensionName = VK_KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME;
|
|
|
8482 VULKAN_HPP_CONSTEXPR_INLINE auto KHRVulkanMemoryModelSpecVersion = VK_KHR_VULKAN_MEMORY_MODEL_SPEC_VERSION;
|
|
|
8483
|
|
|
8484 //=== VK_EXT_pci_bus_info ===
|
|
|
8485 VULKAN_HPP_CONSTEXPR_INLINE auto EXTPciBusInfoExtensionName = VK_EXT_PCI_BUS_INFO_EXTENSION_NAME;
|
|
|
8486 VULKAN_HPP_CONSTEXPR_INLINE auto EXTPciBusInfoSpecVersion = VK_EXT_PCI_BUS_INFO_SPEC_VERSION;
|
|
|
8487
|
|
|
8488 //=== VK_AMD_display_native_hdr ===
|
|
|
8489 VULKAN_HPP_CONSTEXPR_INLINE auto AMDDisplayNativeHdrExtensionName = VK_AMD_DISPLAY_NATIVE_HDR_EXTENSION_NAME;
|
|
|
8490 VULKAN_HPP_CONSTEXPR_INLINE auto AMDDisplayNativeHdrSpecVersion = VK_AMD_DISPLAY_NATIVE_HDR_SPEC_VERSION;
|
|
|
8491
|
|
|
8492 #if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
|
8493 //=== VK_FUCHSIA_imagepipe_surface ===
|
|
|
8494 VULKAN_HPP_CONSTEXPR_INLINE auto FUCHSIAImagepipeSurfaceExtensionName = VK_FUCHSIA_IMAGEPIPE_SURFACE_EXTENSION_NAME;
|
|
|
8495 VULKAN_HPP_CONSTEXPR_INLINE auto FUCHSIAImagepipeSurfaceSpecVersion = VK_FUCHSIA_IMAGEPIPE_SURFACE_SPEC_VERSION;
|
|
|
8496 #endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
8497
|
|
|
8498 //=== VK_KHR_shader_terminate_invocation ===
|
|
|
8499 VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderTerminateInvocationExtensionName = VK_KHR_SHADER_TERMINATE_INVOCATION_EXTENSION_NAME;
|
|
|
8500 VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderTerminateInvocationSpecVersion = VK_KHR_SHADER_TERMINATE_INVOCATION_SPEC_VERSION;
|
|
|
8501
|
|
|
8502 #if defined( VK_USE_PLATFORM_METAL_EXT )
|
|
|
8503 //=== VK_EXT_metal_surface ===
|
|
|
8504 VULKAN_HPP_CONSTEXPR_INLINE auto EXTMetalSurfaceExtensionName = VK_EXT_METAL_SURFACE_EXTENSION_NAME;
|
|
|
8505 VULKAN_HPP_CONSTEXPR_INLINE auto EXTMetalSurfaceSpecVersion = VK_EXT_METAL_SURFACE_SPEC_VERSION;
|
|
|
8506 #endif /*VK_USE_PLATFORM_METAL_EXT*/
|
|
|
8507
|
|
|
8508 //=== VK_EXT_fragment_density_map ===
|
|
|
8509 VULKAN_HPP_CONSTEXPR_INLINE auto EXTFragmentDensityMapExtensionName = VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME;
|
|
|
8510 VULKAN_HPP_CONSTEXPR_INLINE auto EXTFragmentDensityMapSpecVersion = VK_EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION;
|
|
|
8511
|
|
|
8512 //=== VK_EXT_scalar_block_layout ===
|
|
|
8513 VULKAN_HPP_CONSTEXPR_INLINE auto EXTScalarBlockLayoutExtensionName = VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME;
|
|
|
8514 VULKAN_HPP_CONSTEXPR_INLINE auto EXTScalarBlockLayoutSpecVersion = VK_EXT_SCALAR_BLOCK_LAYOUT_SPEC_VERSION;
|
|
|
8515
|
|
|
8516 //=== VK_GOOGLE_hlsl_functionality1 ===
|
|
|
8517 VULKAN_HPP_CONSTEXPR_INLINE auto GOOGLEHlslFunctionality1ExtensionName = VK_GOOGLE_HLSL_FUNCTIONALITY_1_EXTENSION_NAME;
|
|
|
8518 VULKAN_HPP_CONSTEXPR_INLINE auto GOOGLEHlslFunctionality1SpecVersion = VK_GOOGLE_HLSL_FUNCTIONALITY_1_SPEC_VERSION;
|
|
|
8519
|
|
|
8520 //=== VK_GOOGLE_decorate_string ===
|
|
|
8521 VULKAN_HPP_CONSTEXPR_INLINE auto GOOGLEDecorateStringExtensionName = VK_GOOGLE_DECORATE_STRING_EXTENSION_NAME;
|
|
|
8522 VULKAN_HPP_CONSTEXPR_INLINE auto GOOGLEDecorateStringSpecVersion = VK_GOOGLE_DECORATE_STRING_SPEC_VERSION;
|
|
|
8523
|
|
|
8524 //=== VK_EXT_subgroup_size_control ===
|
|
|
8525 VULKAN_HPP_CONSTEXPR_INLINE auto EXTSubgroupSizeControlExtensionName = VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME;
|
|
|
8526 VULKAN_HPP_CONSTEXPR_INLINE auto EXTSubgroupSizeControlSpecVersion = VK_EXT_SUBGROUP_SIZE_CONTROL_SPEC_VERSION;
|
|
|
8527
|
|
|
8528 //=== VK_KHR_fragment_shading_rate ===
|
|
|
8529 VULKAN_HPP_CONSTEXPR_INLINE auto KHRFragmentShadingRateExtensionName = VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME;
|
|
|
8530 VULKAN_HPP_CONSTEXPR_INLINE auto KHRFragmentShadingRateSpecVersion = VK_KHR_FRAGMENT_SHADING_RATE_SPEC_VERSION;
|
|
|
8531
|
|
|
8532 //=== VK_AMD_shader_core_properties2 ===
|
|
|
8533 VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderCoreProperties2ExtensionName = VK_AMD_SHADER_CORE_PROPERTIES_2_EXTENSION_NAME;
|
|
|
8534 VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderCoreProperties2SpecVersion = VK_AMD_SHADER_CORE_PROPERTIES_2_SPEC_VERSION;
|
|
|
8535
|
|
|
8536 //=== VK_AMD_device_coherent_memory ===
|
|
|
8537 VULKAN_HPP_CONSTEXPR_INLINE auto AMDDeviceCoherentMemoryExtensionName = VK_AMD_DEVICE_COHERENT_MEMORY_EXTENSION_NAME;
|
|
|
8538 VULKAN_HPP_CONSTEXPR_INLINE auto AMDDeviceCoherentMemorySpecVersion = VK_AMD_DEVICE_COHERENT_MEMORY_SPEC_VERSION;
|
|
|
8539
|
|
|
8540 //=== VK_KHR_dynamic_rendering_local_read ===
|
|
|
8541 VULKAN_HPP_CONSTEXPR_INLINE auto KHRDynamicRenderingLocalReadExtensionName = VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_EXTENSION_NAME;
|
|
|
8542 VULKAN_HPP_CONSTEXPR_INLINE auto KHRDynamicRenderingLocalReadSpecVersion = VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_SPEC_VERSION;
|
|
|
8543
|
|
|
8544 //=== VK_EXT_shader_image_atomic_int64 ===
|
|
|
8545 VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderImageAtomicInt64ExtensionName = VK_EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME;
|
|
|
8546 VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderImageAtomicInt64SpecVersion = VK_EXT_SHADER_IMAGE_ATOMIC_INT64_SPEC_VERSION;
|
|
|
8547
|
|
|
8548 //=== VK_KHR_shader_quad_control ===
|
|
|
8549 VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderQuadControlExtensionName = VK_KHR_SHADER_QUAD_CONTROL_EXTENSION_NAME;
|
|
|
8550 VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderQuadControlSpecVersion = VK_KHR_SHADER_QUAD_CONTROL_SPEC_VERSION;
|
|
|
8551
|
|
|
8552 //=== VK_KHR_spirv_1_4 ===
|
|
|
8553 VULKAN_HPP_CONSTEXPR_INLINE auto KHRSpirv14ExtensionName = VK_KHR_SPIRV_1_4_EXTENSION_NAME;
|
|
|
8554 VULKAN_HPP_CONSTEXPR_INLINE auto KHRSpirv14SpecVersion = VK_KHR_SPIRV_1_4_SPEC_VERSION;
|
|
|
8555
|
|
|
8556 //=== VK_EXT_memory_budget ===
|
|
|
8557 VULKAN_HPP_CONSTEXPR_INLINE auto EXTMemoryBudgetExtensionName = VK_EXT_MEMORY_BUDGET_EXTENSION_NAME;
|
|
|
8558 VULKAN_HPP_CONSTEXPR_INLINE auto EXTMemoryBudgetSpecVersion = VK_EXT_MEMORY_BUDGET_SPEC_VERSION;
|
|
|
8559
|
|
|
8560 //=== VK_EXT_memory_priority ===
|
|
|
8561 VULKAN_HPP_CONSTEXPR_INLINE auto EXTMemoryPriorityExtensionName = VK_EXT_MEMORY_PRIORITY_EXTENSION_NAME;
|
|
|
8562 VULKAN_HPP_CONSTEXPR_INLINE auto EXTMemoryPrioritySpecVersion = VK_EXT_MEMORY_PRIORITY_SPEC_VERSION;
|
|
|
8563
|
|
|
8564 //=== VK_KHR_surface_protected_capabilities ===
|
|
|
8565 VULKAN_HPP_CONSTEXPR_INLINE auto KHRSurfaceProtectedCapabilitiesExtensionName = VK_KHR_SURFACE_PROTECTED_CAPABILITIES_EXTENSION_NAME;
|
|
|
8566 VULKAN_HPP_CONSTEXPR_INLINE auto KHRSurfaceProtectedCapabilitiesSpecVersion = VK_KHR_SURFACE_PROTECTED_CAPABILITIES_SPEC_VERSION;
|
|
|
8567
|
|
|
8568 //=== VK_NV_dedicated_allocation_image_aliasing ===
|
|
|
8569 VULKAN_HPP_CONSTEXPR_INLINE auto NVDedicatedAllocationImageAliasingExtensionName = VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_EXTENSION_NAME;
|
|
|
8570 VULKAN_HPP_CONSTEXPR_INLINE auto NVDedicatedAllocationImageAliasingSpecVersion = VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_SPEC_VERSION;
|
|
|
8571
|
|
|
8572 //=== VK_KHR_separate_depth_stencil_layouts ===
|
|
|
8573 VULKAN_HPP_CONSTEXPR_INLINE auto KHRSeparateDepthStencilLayoutsExtensionName = VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME;
|
|
|
8574 VULKAN_HPP_CONSTEXPR_INLINE auto KHRSeparateDepthStencilLayoutsSpecVersion = VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_SPEC_VERSION;
|
|
|
8575
|
|
|
8576 //=== VK_EXT_buffer_device_address ===
|
|
|
8577 VULKAN_HPP_DEPRECATED( "The VK_EXT_buffer_device_address extension has been deprecated by VK_KHR_buffer_device_address." )
|
|
|
8578 VULKAN_HPP_CONSTEXPR_INLINE auto EXTBufferDeviceAddressExtensionName = VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME;
|
|
|
8579 VULKAN_HPP_DEPRECATED( "The VK_EXT_buffer_device_address extension has been deprecated by VK_KHR_buffer_device_address." )
|
|
|
8580 VULKAN_HPP_CONSTEXPR_INLINE auto EXTBufferDeviceAddressSpecVersion = VK_EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION;
|
|
|
8581
|
|
|
8582 //=== VK_EXT_tooling_info ===
|
|
|
8583 VULKAN_HPP_CONSTEXPR_INLINE auto EXTToolingInfoExtensionName = VK_EXT_TOOLING_INFO_EXTENSION_NAME;
|
|
|
8584 VULKAN_HPP_CONSTEXPR_INLINE auto EXTToolingInfoSpecVersion = VK_EXT_TOOLING_INFO_SPEC_VERSION;
|
|
|
8585
|
|
|
8586 //=== VK_EXT_separate_stencil_usage ===
|
|
|
8587 VULKAN_HPP_CONSTEXPR_INLINE auto EXTSeparateStencilUsageExtensionName = VK_EXT_SEPARATE_STENCIL_USAGE_EXTENSION_NAME;
|
|
|
8588 VULKAN_HPP_CONSTEXPR_INLINE auto EXTSeparateStencilUsageSpecVersion = VK_EXT_SEPARATE_STENCIL_USAGE_SPEC_VERSION;
|
|
|
8589
|
|
|
8590 //=== VK_EXT_validation_features ===
|
|
|
8591 VULKAN_HPP_DEPRECATED( "The VK_EXT_validation_features extension has been deprecated by VK_EXT_layer_settings." )
|
|
|
8592 VULKAN_HPP_CONSTEXPR_INLINE auto EXTValidationFeaturesExtensionName = VK_EXT_VALIDATION_FEATURES_EXTENSION_NAME;
|
|
|
8593 VULKAN_HPP_DEPRECATED( "The VK_EXT_validation_features extension has been deprecated by VK_EXT_layer_settings." )
|
|
|
8594 VULKAN_HPP_CONSTEXPR_INLINE auto EXTValidationFeaturesSpecVersion = VK_EXT_VALIDATION_FEATURES_SPEC_VERSION;
|
|
|
8595
|
|
|
8596 //=== VK_KHR_present_wait ===
|
|
|
8597 VULKAN_HPP_CONSTEXPR_INLINE auto KHRPresentWaitExtensionName = VK_KHR_PRESENT_WAIT_EXTENSION_NAME;
|
|
|
8598 VULKAN_HPP_CONSTEXPR_INLINE auto KHRPresentWaitSpecVersion = VK_KHR_PRESENT_WAIT_SPEC_VERSION;
|
|
|
8599
|
|
|
8600 //=== VK_NV_cooperative_matrix ===
|
|
|
8601 VULKAN_HPP_CONSTEXPR_INLINE auto NVCooperativeMatrixExtensionName = VK_NV_COOPERATIVE_MATRIX_EXTENSION_NAME;
|
|
|
8602 VULKAN_HPP_CONSTEXPR_INLINE auto NVCooperativeMatrixSpecVersion = VK_NV_COOPERATIVE_MATRIX_SPEC_VERSION;
|
|
|
8603
|
|
|
8604 //=== VK_NV_coverage_reduction_mode ===
|
|
|
8605 VULKAN_HPP_CONSTEXPR_INLINE auto NVCoverageReductionModeExtensionName = VK_NV_COVERAGE_REDUCTION_MODE_EXTENSION_NAME;
|
|
|
8606 VULKAN_HPP_CONSTEXPR_INLINE auto NVCoverageReductionModeSpecVersion = VK_NV_COVERAGE_REDUCTION_MODE_SPEC_VERSION;
|
|
|
8607
|
|
|
8608 //=== VK_EXT_fragment_shader_interlock ===
|
|
|
8609 VULKAN_HPP_CONSTEXPR_INLINE auto EXTFragmentShaderInterlockExtensionName = VK_EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME;
|
|
|
8610 VULKAN_HPP_CONSTEXPR_INLINE auto EXTFragmentShaderInterlockSpecVersion = VK_EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION;
|
|
|
8611
|
|
|
8612 //=== VK_EXT_ycbcr_image_arrays ===
|
|
|
8613 VULKAN_HPP_CONSTEXPR_INLINE auto EXTYcbcrImageArraysExtensionName = VK_EXT_YCBCR_IMAGE_ARRAYS_EXTENSION_NAME;
|
|
|
8614 VULKAN_HPP_CONSTEXPR_INLINE auto EXTYcbcrImageArraysSpecVersion = VK_EXT_YCBCR_IMAGE_ARRAYS_SPEC_VERSION;
|
|
|
8615
|
|
|
8616 //=== VK_KHR_uniform_buffer_standard_layout ===
|
|
|
8617 VULKAN_HPP_CONSTEXPR_INLINE auto KHRUniformBufferStandardLayoutExtensionName = VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME;
|
|
|
8618 VULKAN_HPP_CONSTEXPR_INLINE auto KHRUniformBufferStandardLayoutSpecVersion = VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_SPEC_VERSION;
|
|
|
8619
|
|
|
8620 //=== VK_EXT_provoking_vertex ===
|
|
|
8621 VULKAN_HPP_CONSTEXPR_INLINE auto EXTProvokingVertexExtensionName = VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME;
|
|
|
8622 VULKAN_HPP_CONSTEXPR_INLINE auto EXTProvokingVertexSpecVersion = VK_EXT_PROVOKING_VERTEX_SPEC_VERSION;
|
|
|
8623
|
|
|
8624 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
8625 //=== VK_EXT_full_screen_exclusive ===
|
|
|
8626 VULKAN_HPP_CONSTEXPR_INLINE auto EXTFullScreenExclusiveExtensionName = VK_EXT_FULL_SCREEN_EXCLUSIVE_EXTENSION_NAME;
|
|
|
8627 VULKAN_HPP_CONSTEXPR_INLINE auto EXTFullScreenExclusiveSpecVersion = VK_EXT_FULL_SCREEN_EXCLUSIVE_SPEC_VERSION;
|
|
|
8628 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
8629
|
|
|
8630 //=== VK_EXT_headless_surface ===
|
|
|
8631 VULKAN_HPP_CONSTEXPR_INLINE auto EXTHeadlessSurfaceExtensionName = VK_EXT_HEADLESS_SURFACE_EXTENSION_NAME;
|
|
|
8632 VULKAN_HPP_CONSTEXPR_INLINE auto EXTHeadlessSurfaceSpecVersion = VK_EXT_HEADLESS_SURFACE_SPEC_VERSION;
|
|
|
8633
|
|
|
8634 //=== VK_KHR_buffer_device_address ===
|
|
|
8635 VULKAN_HPP_CONSTEXPR_INLINE auto KHRBufferDeviceAddressExtensionName = VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME;
|
|
|
8636 VULKAN_HPP_CONSTEXPR_INLINE auto KHRBufferDeviceAddressSpecVersion = VK_KHR_BUFFER_DEVICE_ADDRESS_SPEC_VERSION;
|
|
|
8637
|
|
|
8638 //=== VK_EXT_line_rasterization ===
|
|
|
8639 VULKAN_HPP_CONSTEXPR_INLINE auto EXTLineRasterizationExtensionName = VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME;
|
|
|
8640 VULKAN_HPP_CONSTEXPR_INLINE auto EXTLineRasterizationSpecVersion = VK_EXT_LINE_RASTERIZATION_SPEC_VERSION;
|
|
|
8641
|
|
|
8642 //=== VK_EXT_shader_atomic_float ===
|
|
|
8643 VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderAtomicFloatExtensionName = VK_EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME;
|
|
|
8644 VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderAtomicFloatSpecVersion = VK_EXT_SHADER_ATOMIC_FLOAT_SPEC_VERSION;
|
|
|
8645
|
|
|
8646 //=== VK_EXT_host_query_reset ===
|
|
|
8647 VULKAN_HPP_CONSTEXPR_INLINE auto EXTHostQueryResetExtensionName = VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME;
|
|
|
8648 VULKAN_HPP_CONSTEXPR_INLINE auto EXTHostQueryResetSpecVersion = VK_EXT_HOST_QUERY_RESET_SPEC_VERSION;
|
|
|
8649
|
|
|
8650 //=== VK_EXT_index_type_uint8 ===
|
|
|
8651 VULKAN_HPP_CONSTEXPR_INLINE auto EXTIndexTypeUint8ExtensionName = VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME;
|
|
|
8652 VULKAN_HPP_CONSTEXPR_INLINE auto EXTIndexTypeUint8SpecVersion = VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION;
|
|
|
8653
|
|
|
8654 //=== VK_EXT_extended_dynamic_state ===
|
|
|
8655 VULKAN_HPP_CONSTEXPR_INLINE auto EXTExtendedDynamicStateExtensionName = VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME;
|
|
|
8656 VULKAN_HPP_CONSTEXPR_INLINE auto EXTExtendedDynamicStateSpecVersion = VK_EXT_EXTENDED_DYNAMIC_STATE_SPEC_VERSION;
|
|
|
8657
|
|
|
8658 //=== VK_KHR_deferred_host_operations ===
|
|
|
8659 VULKAN_HPP_CONSTEXPR_INLINE auto KHRDeferredHostOperationsExtensionName = VK_KHR_DEFERRED_HOST_OPERATIONS_EXTENSION_NAME;
|
|
|
8660 VULKAN_HPP_CONSTEXPR_INLINE auto KHRDeferredHostOperationsSpecVersion = VK_KHR_DEFERRED_HOST_OPERATIONS_SPEC_VERSION;
|
|
|
8661
|
|
|
8662 //=== VK_KHR_pipeline_executable_properties ===
|
|
|
8663 VULKAN_HPP_CONSTEXPR_INLINE auto KHRPipelineExecutablePropertiesExtensionName = VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME;
|
|
|
8664 VULKAN_HPP_CONSTEXPR_INLINE auto KHRPipelineExecutablePropertiesSpecVersion = VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION;
|
|
|
8665
|
|
|
8666 //=== VK_EXT_host_image_copy ===
|
|
|
8667 VULKAN_HPP_CONSTEXPR_INLINE auto EXTHostImageCopyExtensionName = VK_EXT_HOST_IMAGE_COPY_EXTENSION_NAME;
|
|
|
8668 VULKAN_HPP_CONSTEXPR_INLINE auto EXTHostImageCopySpecVersion = VK_EXT_HOST_IMAGE_COPY_SPEC_VERSION;
|
|
|
8669
|
|
|
8670 //=== VK_KHR_map_memory2 ===
|
|
|
8671 VULKAN_HPP_CONSTEXPR_INLINE auto KHRMapMemory2ExtensionName = VK_KHR_MAP_MEMORY_2_EXTENSION_NAME;
|
|
|
8672 VULKAN_HPP_CONSTEXPR_INLINE auto KHRMapMemory2SpecVersion = VK_KHR_MAP_MEMORY_2_SPEC_VERSION;
|
|
|
8673
|
|
|
8674 //=== VK_EXT_map_memory_placed ===
|
|
|
8675 VULKAN_HPP_CONSTEXPR_INLINE auto EXTMapMemoryPlacedExtensionName = VK_EXT_MAP_MEMORY_PLACED_EXTENSION_NAME;
|
|
|
8676 VULKAN_HPP_CONSTEXPR_INLINE auto EXTMapMemoryPlacedSpecVersion = VK_EXT_MAP_MEMORY_PLACED_SPEC_VERSION;
|
|
|
8677
|
|
|
8678 //=== VK_EXT_shader_atomic_float2 ===
|
|
|
8679 VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderAtomicFloat2ExtensionName = VK_EXT_SHADER_ATOMIC_FLOAT_2_EXTENSION_NAME;
|
|
|
8680 VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderAtomicFloat2SpecVersion = VK_EXT_SHADER_ATOMIC_FLOAT_2_SPEC_VERSION;
|
|
|
8681
|
|
|
8682 //=== VK_EXT_surface_maintenance1 ===
|
|
|
8683 VULKAN_HPP_CONSTEXPR_INLINE auto EXTSurfaceMaintenance1ExtensionName = VK_EXT_SURFACE_MAINTENANCE_1_EXTENSION_NAME;
|
|
|
8684 VULKAN_HPP_CONSTEXPR_INLINE auto EXTSurfaceMaintenance1SpecVersion = VK_EXT_SURFACE_MAINTENANCE_1_SPEC_VERSION;
|
|
|
8685
|
|
|
8686 //=== VK_EXT_swapchain_maintenance1 ===
|
|
|
8687 VULKAN_HPP_CONSTEXPR_INLINE auto EXTSwapchainMaintenance1ExtensionName = VK_EXT_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME;
|
|
|
8688 VULKAN_HPP_CONSTEXPR_INLINE auto EXTSwapchainMaintenance1SpecVersion = VK_EXT_SWAPCHAIN_MAINTENANCE_1_SPEC_VERSION;
|
|
|
8689
|
|
|
8690 //=== VK_EXT_shader_demote_to_helper_invocation ===
|
|
|
8691 VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderDemoteToHelperInvocationExtensionName = VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME;
|
|
|
8692 VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderDemoteToHelperInvocationSpecVersion = VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_SPEC_VERSION;
|
|
|
8693
|
|
|
8694 //=== VK_NV_device_generated_commands ===
|
|
|
8695 VULKAN_HPP_CONSTEXPR_INLINE auto NVDeviceGeneratedCommandsExtensionName = VK_NV_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME;
|
|
|
8696 VULKAN_HPP_CONSTEXPR_INLINE auto NVDeviceGeneratedCommandsSpecVersion = VK_NV_DEVICE_GENERATED_COMMANDS_SPEC_VERSION;
|
|
|
8697
|
|
|
8698 //=== VK_NV_inherited_viewport_scissor ===
|
|
|
8699 VULKAN_HPP_CONSTEXPR_INLINE auto NVInheritedViewportScissorExtensionName = VK_NV_INHERITED_VIEWPORT_SCISSOR_EXTENSION_NAME;
|
|
|
8700 VULKAN_HPP_CONSTEXPR_INLINE auto NVInheritedViewportScissorSpecVersion = VK_NV_INHERITED_VIEWPORT_SCISSOR_SPEC_VERSION;
|
|
|
8701
|
|
|
8702 //=== VK_KHR_shader_integer_dot_product ===
|
|
|
8703 VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderIntegerDotProductExtensionName = VK_KHR_SHADER_INTEGER_DOT_PRODUCT_EXTENSION_NAME;
|
|
|
8704 VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderIntegerDotProductSpecVersion = VK_KHR_SHADER_INTEGER_DOT_PRODUCT_SPEC_VERSION;
|
|
|
8705
|
|
|
8706 //=== VK_EXT_texel_buffer_alignment ===
|
|
|
8707 VULKAN_HPP_CONSTEXPR_INLINE auto EXTTexelBufferAlignmentExtensionName = VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME;
|
|
|
8708 VULKAN_HPP_CONSTEXPR_INLINE auto EXTTexelBufferAlignmentSpecVersion = VK_EXT_TEXEL_BUFFER_ALIGNMENT_SPEC_VERSION;
|
|
|
8709
|
|
|
8710 //=== VK_QCOM_render_pass_transform ===
|
|
|
8711 VULKAN_HPP_CONSTEXPR_INLINE auto QCOMRenderPassTransformExtensionName = VK_QCOM_RENDER_PASS_TRANSFORM_EXTENSION_NAME;
|
|
|
8712 VULKAN_HPP_CONSTEXPR_INLINE auto QCOMRenderPassTransformSpecVersion = VK_QCOM_RENDER_PASS_TRANSFORM_SPEC_VERSION;
|
|
|
8713
|
|
|
8714 //=== VK_EXT_depth_bias_control ===
|
|
|
8715 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthBiasControlExtensionName = VK_EXT_DEPTH_BIAS_CONTROL_EXTENSION_NAME;
|
|
|
8716 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthBiasControlSpecVersion = VK_EXT_DEPTH_BIAS_CONTROL_SPEC_VERSION;
|
|
|
8717
|
|
|
8718 //=== VK_EXT_device_memory_report ===
|
|
|
8719 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDeviceMemoryReportExtensionName = VK_EXT_DEVICE_MEMORY_REPORT_EXTENSION_NAME;
|
|
|
8720 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDeviceMemoryReportSpecVersion = VK_EXT_DEVICE_MEMORY_REPORT_SPEC_VERSION;
|
|
|
8721
|
|
|
8722 //=== VK_EXT_acquire_drm_display ===
|
|
|
8723 VULKAN_HPP_CONSTEXPR_INLINE auto EXTAcquireDrmDisplayExtensionName = VK_EXT_ACQUIRE_DRM_DISPLAY_EXTENSION_NAME;
|
|
|
8724 VULKAN_HPP_CONSTEXPR_INLINE auto EXTAcquireDrmDisplaySpecVersion = VK_EXT_ACQUIRE_DRM_DISPLAY_SPEC_VERSION;
|
|
|
8725
|
|
|
8726 //=== VK_EXT_robustness2 ===
|
|
|
8727 VULKAN_HPP_CONSTEXPR_INLINE auto EXTRobustness2ExtensionName = VK_EXT_ROBUSTNESS_2_EXTENSION_NAME;
|
|
|
8728 VULKAN_HPP_CONSTEXPR_INLINE auto EXTRobustness2SpecVersion = VK_EXT_ROBUSTNESS_2_SPEC_VERSION;
|
|
|
8729
|
|
|
8730 //=== VK_EXT_custom_border_color ===
|
|
|
8731 VULKAN_HPP_CONSTEXPR_INLINE auto EXTCustomBorderColorExtensionName = VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME;
|
|
|
8732 VULKAN_HPP_CONSTEXPR_INLINE auto EXTCustomBorderColorSpecVersion = VK_EXT_CUSTOM_BORDER_COLOR_SPEC_VERSION;
|
|
|
8733
|
|
|
8734 //=== VK_GOOGLE_user_type ===
|
|
|
8735 VULKAN_HPP_CONSTEXPR_INLINE auto GOOGLEUserTypeExtensionName = VK_GOOGLE_USER_TYPE_EXTENSION_NAME;
|
|
|
8736 VULKAN_HPP_CONSTEXPR_INLINE auto GOOGLEUserTypeSpecVersion = VK_GOOGLE_USER_TYPE_SPEC_VERSION;
|
|
|
8737
|
|
|
8738 //=== VK_KHR_pipeline_library ===
|
|
|
8739 VULKAN_HPP_CONSTEXPR_INLINE auto KHRPipelineLibraryExtensionName = VK_KHR_PIPELINE_LIBRARY_EXTENSION_NAME;
|
|
|
8740 VULKAN_HPP_CONSTEXPR_INLINE auto KHRPipelineLibrarySpecVersion = VK_KHR_PIPELINE_LIBRARY_SPEC_VERSION;
|
|
|
8741
|
|
|
8742 //=== VK_NV_present_barrier ===
|
|
|
8743 VULKAN_HPP_CONSTEXPR_INLINE auto NVPresentBarrierExtensionName = VK_NV_PRESENT_BARRIER_EXTENSION_NAME;
|
|
|
8744 VULKAN_HPP_CONSTEXPR_INLINE auto NVPresentBarrierSpecVersion = VK_NV_PRESENT_BARRIER_SPEC_VERSION;
|
|
|
8745
|
|
|
8746 //=== VK_KHR_shader_non_semantic_info ===
|
|
|
8747 VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderNonSemanticInfoExtensionName = VK_KHR_SHADER_NON_SEMANTIC_INFO_EXTENSION_NAME;
|
|
|
8748 VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderNonSemanticInfoSpecVersion = VK_KHR_SHADER_NON_SEMANTIC_INFO_SPEC_VERSION;
|
|
|
8749
|
|
|
8750 //=== VK_KHR_present_id ===
|
|
|
8751 VULKAN_HPP_CONSTEXPR_INLINE auto KHRPresentIdExtensionName = VK_KHR_PRESENT_ID_EXTENSION_NAME;
|
|
|
8752 VULKAN_HPP_CONSTEXPR_INLINE auto KHRPresentIdSpecVersion = VK_KHR_PRESENT_ID_SPEC_VERSION;
|
|
|
8753
|
|
|
8754 //=== VK_EXT_private_data ===
|
|
|
8755 VULKAN_HPP_CONSTEXPR_INLINE auto EXTPrivateDataExtensionName = VK_EXT_PRIVATE_DATA_EXTENSION_NAME;
|
|
|
8756 VULKAN_HPP_CONSTEXPR_INLINE auto EXTPrivateDataSpecVersion = VK_EXT_PRIVATE_DATA_SPEC_VERSION;
|
|
|
8757
|
|
|
8758 //=== VK_EXT_pipeline_creation_cache_control ===
|
|
|
8759 VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelineCreationCacheControlExtensionName = VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_EXTENSION_NAME;
|
|
|
8760 VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelineCreationCacheControlSpecVersion = VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_SPEC_VERSION;
|
|
|
8761
|
|
|
8762 //=== VK_KHR_video_encode_queue ===
|
|
|
8763 VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoEncodeQueueExtensionName = VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME;
|
|
|
8764 VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoEncodeQueueSpecVersion = VK_KHR_VIDEO_ENCODE_QUEUE_SPEC_VERSION;
|
|
|
8765
|
|
|
8766 //=== VK_NV_device_diagnostics_config ===
|
|
|
8767 VULKAN_HPP_CONSTEXPR_INLINE auto NVDeviceDiagnosticsConfigExtensionName = VK_NV_DEVICE_DIAGNOSTICS_CONFIG_EXTENSION_NAME;
|
|
|
8768 VULKAN_HPP_CONSTEXPR_INLINE auto NVDeviceDiagnosticsConfigSpecVersion = VK_NV_DEVICE_DIAGNOSTICS_CONFIG_SPEC_VERSION;
|
|
|
8769
|
|
|
8770 //=== VK_QCOM_render_pass_store_ops ===
|
|
|
8771 VULKAN_HPP_CONSTEXPR_INLINE auto QCOMRenderPassStoreOpsExtensionName = VK_QCOM_RENDER_PASS_STORE_OPS_EXTENSION_NAME;
|
|
|
8772 VULKAN_HPP_CONSTEXPR_INLINE auto QCOMRenderPassStoreOpsSpecVersion = VK_QCOM_RENDER_PASS_STORE_OPS_SPEC_VERSION;
|
|
|
8773
|
|
|
8774 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
8775 //=== VK_NV_cuda_kernel_launch ===
|
|
|
8776 VULKAN_HPP_CONSTEXPR_INLINE auto NVCudaKernelLaunchExtensionName = VK_NV_CUDA_KERNEL_LAUNCH_EXTENSION_NAME;
|
|
|
8777 VULKAN_HPP_CONSTEXPR_INLINE auto NVCudaKernelLaunchSpecVersion = VK_NV_CUDA_KERNEL_LAUNCH_SPEC_VERSION;
|
|
|
8778 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
8779
|
|
|
8780 //=== VK_QCOM_tile_shading ===
|
|
|
8781 VULKAN_HPP_CONSTEXPR_INLINE auto QCOMTileShadingExtensionName = VK_QCOM_TILE_SHADING_EXTENSION_NAME;
|
|
|
8782 VULKAN_HPP_CONSTEXPR_INLINE auto QCOMTileShadingSpecVersion = VK_QCOM_TILE_SHADING_SPEC_VERSION;
|
|
|
8783
|
|
|
8784 //=== VK_NV_low_latency ===
|
|
|
8785 VULKAN_HPP_CONSTEXPR_INLINE auto NVLowLatencyExtensionName = VK_NV_LOW_LATENCY_EXTENSION_NAME;
|
|
|
8786 VULKAN_HPP_CONSTEXPR_INLINE auto NVLowLatencySpecVersion = VK_NV_LOW_LATENCY_SPEC_VERSION;
|
|
|
8787
|
|
|
8788 #if defined( VK_USE_PLATFORM_METAL_EXT )
|
|
|
8789 //=== VK_EXT_metal_objects ===
|
|
|
8790 VULKAN_HPP_CONSTEXPR_INLINE auto EXTMetalObjectsExtensionName = VK_EXT_METAL_OBJECTS_EXTENSION_NAME;
|
|
|
8791 VULKAN_HPP_CONSTEXPR_INLINE auto EXTMetalObjectsSpecVersion = VK_EXT_METAL_OBJECTS_SPEC_VERSION;
|
|
|
8792 #endif /*VK_USE_PLATFORM_METAL_EXT*/
|
|
|
8793
|
|
|
8794 //=== VK_KHR_synchronization2 ===
|
|
|
8795 VULKAN_HPP_CONSTEXPR_INLINE auto KHRSynchronization2ExtensionName = VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME;
|
|
|
8796 VULKAN_HPP_CONSTEXPR_INLINE auto KHRSynchronization2SpecVersion = VK_KHR_SYNCHRONIZATION_2_SPEC_VERSION;
|
|
|
8797
|
|
|
8798 //=== VK_EXT_descriptor_buffer ===
|
|
|
8799 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDescriptorBufferExtensionName = VK_EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME;
|
|
|
8800 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDescriptorBufferSpecVersion = VK_EXT_DESCRIPTOR_BUFFER_SPEC_VERSION;
|
|
|
8801
|
|
|
8802 //=== VK_EXT_graphics_pipeline_library ===
|
|
|
8803 VULKAN_HPP_CONSTEXPR_INLINE auto EXTGraphicsPipelineLibraryExtensionName = VK_EXT_GRAPHICS_PIPELINE_LIBRARY_EXTENSION_NAME;
|
|
|
8804 VULKAN_HPP_CONSTEXPR_INLINE auto EXTGraphicsPipelineLibrarySpecVersion = VK_EXT_GRAPHICS_PIPELINE_LIBRARY_SPEC_VERSION;
|
|
|
8805
|
|
|
8806 //=== VK_AMD_shader_early_and_late_fragment_tests ===
|
|
|
8807 VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderEarlyAndLateFragmentTestsExtensionName = VK_AMD_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_EXTENSION_NAME;
|
|
|
8808 VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderEarlyAndLateFragmentTestsSpecVersion = VK_AMD_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_SPEC_VERSION;
|
|
|
8809
|
|
|
8810 //=== VK_KHR_fragment_shader_barycentric ===
|
|
|
8811 VULKAN_HPP_CONSTEXPR_INLINE auto KHRFragmentShaderBarycentricExtensionName = VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME;
|
|
|
8812 VULKAN_HPP_CONSTEXPR_INLINE auto KHRFragmentShaderBarycentricSpecVersion = VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION;
|
|
|
8813
|
|
|
8814 //=== VK_KHR_shader_subgroup_uniform_control_flow ===
|
|
|
8815 VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderSubgroupUniformControlFlowExtensionName = VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_EXTENSION_NAME;
|
|
|
8816 VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderSubgroupUniformControlFlowSpecVersion = VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_SPEC_VERSION;
|
|
|
8817
|
|
|
8818 //=== VK_KHR_zero_initialize_workgroup_memory ===
|
|
|
8819 VULKAN_HPP_CONSTEXPR_INLINE auto KHRZeroInitializeWorkgroupMemoryExtensionName = VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_EXTENSION_NAME;
|
|
|
8820 VULKAN_HPP_CONSTEXPR_INLINE auto KHRZeroInitializeWorkgroupMemorySpecVersion = VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_SPEC_VERSION;
|
|
|
8821
|
|
|
8822 //=== VK_NV_fragment_shading_rate_enums ===
|
|
|
8823 VULKAN_HPP_CONSTEXPR_INLINE auto NVFragmentShadingRateEnumsExtensionName = VK_NV_FRAGMENT_SHADING_RATE_ENUMS_EXTENSION_NAME;
|
|
|
8824 VULKAN_HPP_CONSTEXPR_INLINE auto NVFragmentShadingRateEnumsSpecVersion = VK_NV_FRAGMENT_SHADING_RATE_ENUMS_SPEC_VERSION;
|
|
|
8825
|
|
|
8826 //=== VK_NV_ray_tracing_motion_blur ===
|
|
|
8827 VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingMotionBlurExtensionName = VK_NV_RAY_TRACING_MOTION_BLUR_EXTENSION_NAME;
|
|
|
8828 VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingMotionBlurSpecVersion = VK_NV_RAY_TRACING_MOTION_BLUR_SPEC_VERSION;
|
|
|
8829
|
|
|
8830 //=== VK_EXT_mesh_shader ===
|
|
|
8831 VULKAN_HPP_CONSTEXPR_INLINE auto EXTMeshShaderExtensionName = VK_EXT_MESH_SHADER_EXTENSION_NAME;
|
|
|
8832 VULKAN_HPP_CONSTEXPR_INLINE auto EXTMeshShaderSpecVersion = VK_EXT_MESH_SHADER_SPEC_VERSION;
|
|
|
8833
|
|
|
8834 //=== VK_EXT_ycbcr_2plane_444_formats ===
|
|
|
8835 VULKAN_HPP_CONSTEXPR_INLINE auto EXTYcbcr2Plane444FormatsExtensionName = VK_EXT_YCBCR_2PLANE_444_FORMATS_EXTENSION_NAME;
|
|
|
8836 VULKAN_HPP_CONSTEXPR_INLINE auto EXTYcbcr2Plane444FormatsSpecVersion = VK_EXT_YCBCR_2PLANE_444_FORMATS_SPEC_VERSION;
|
|
|
8837
|
|
|
8838 //=== VK_EXT_fragment_density_map2 ===
|
|
|
8839 VULKAN_HPP_CONSTEXPR_INLINE auto EXTFragmentDensityMap2ExtensionName = VK_EXT_FRAGMENT_DENSITY_MAP_2_EXTENSION_NAME;
|
|
|
8840 VULKAN_HPP_CONSTEXPR_INLINE auto EXTFragmentDensityMap2SpecVersion = VK_EXT_FRAGMENT_DENSITY_MAP_2_SPEC_VERSION;
|
|
|
8841
|
|
|
8842 //=== VK_QCOM_rotated_copy_commands ===
|
|
|
8843 VULKAN_HPP_CONSTEXPR_INLINE auto QCOMRotatedCopyCommandsExtensionName = VK_QCOM_ROTATED_COPY_COMMANDS_EXTENSION_NAME;
|
|
|
8844 VULKAN_HPP_CONSTEXPR_INLINE auto QCOMRotatedCopyCommandsSpecVersion = VK_QCOM_ROTATED_COPY_COMMANDS_SPEC_VERSION;
|
|
|
8845
|
|
|
8846 //=== VK_EXT_image_robustness ===
|
|
|
8847 VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageRobustnessExtensionName = VK_EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME;
|
|
|
8848 VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageRobustnessSpecVersion = VK_EXT_IMAGE_ROBUSTNESS_SPEC_VERSION;
|
|
|
8849
|
|
|
8850 //=== VK_KHR_workgroup_memory_explicit_layout ===
|
|
|
8851 VULKAN_HPP_CONSTEXPR_INLINE auto KHRWorkgroupMemoryExplicitLayoutExtensionName = VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_EXTENSION_NAME;
|
|
|
8852 VULKAN_HPP_CONSTEXPR_INLINE auto KHRWorkgroupMemoryExplicitLayoutSpecVersion = VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_SPEC_VERSION;
|
|
|
8853
|
|
|
8854 //=== VK_KHR_copy_commands2 ===
|
|
|
8855 VULKAN_HPP_CONSTEXPR_INLINE auto KHRCopyCommands2ExtensionName = VK_KHR_COPY_COMMANDS_2_EXTENSION_NAME;
|
|
|
8856 VULKAN_HPP_CONSTEXPR_INLINE auto KHRCopyCommands2SpecVersion = VK_KHR_COPY_COMMANDS_2_SPEC_VERSION;
|
|
|
8857
|
|
|
8858 //=== VK_EXT_image_compression_control ===
|
|
|
8859 VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageCompressionControlExtensionName = VK_EXT_IMAGE_COMPRESSION_CONTROL_EXTENSION_NAME;
|
|
|
8860 VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageCompressionControlSpecVersion = VK_EXT_IMAGE_COMPRESSION_CONTROL_SPEC_VERSION;
|
|
|
8861
|
|
|
8862 //=== VK_EXT_attachment_feedback_loop_layout ===
|
|
|
8863 VULKAN_HPP_CONSTEXPR_INLINE auto EXTAttachmentFeedbackLoopLayoutExtensionName = VK_EXT_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_EXTENSION_NAME;
|
|
|
8864 VULKAN_HPP_CONSTEXPR_INLINE auto EXTAttachmentFeedbackLoopLayoutSpecVersion = VK_EXT_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_SPEC_VERSION;
|
|
|
8865
|
|
|
8866 //=== VK_EXT_4444_formats ===
|
|
|
8867 VULKAN_HPP_CONSTEXPR_INLINE auto EXT4444FormatsExtensionName = VK_EXT_4444_FORMATS_EXTENSION_NAME;
|
|
|
8868 VULKAN_HPP_CONSTEXPR_INLINE auto EXT4444FormatsSpecVersion = VK_EXT_4444_FORMATS_SPEC_VERSION;
|
|
|
8869
|
|
|
8870 //=== VK_EXT_device_fault ===
|
|
|
8871 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDeviceFaultExtensionName = VK_EXT_DEVICE_FAULT_EXTENSION_NAME;
|
|
|
8872 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDeviceFaultSpecVersion = VK_EXT_DEVICE_FAULT_SPEC_VERSION;
|
|
|
8873
|
|
|
8874 //=== VK_ARM_rasterization_order_attachment_access ===
|
|
|
8875 VULKAN_HPP_CONSTEXPR_INLINE auto ARMRasterizationOrderAttachmentAccessExtensionName = VK_ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME;
|
|
|
8876 VULKAN_HPP_CONSTEXPR_INLINE auto ARMRasterizationOrderAttachmentAccessSpecVersion = VK_ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_SPEC_VERSION;
|
|
|
8877
|
|
|
8878 //=== VK_EXT_rgba10x6_formats ===
|
|
|
8879 VULKAN_HPP_CONSTEXPR_INLINE auto EXTRgba10X6FormatsExtensionName = VK_EXT_RGBA10X6_FORMATS_EXTENSION_NAME;
|
|
|
8880 VULKAN_HPP_CONSTEXPR_INLINE auto EXTRgba10X6FormatsSpecVersion = VK_EXT_RGBA10X6_FORMATS_SPEC_VERSION;
|
|
|
8881
|
|
|
8882 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
8883 //=== VK_NV_acquire_winrt_display ===
|
|
|
8884 VULKAN_HPP_CONSTEXPR_INLINE auto NVAcquireWinrtDisplayExtensionName = VK_NV_ACQUIRE_WINRT_DISPLAY_EXTENSION_NAME;
|
|
|
8885 VULKAN_HPP_CONSTEXPR_INLINE auto NVAcquireWinrtDisplaySpecVersion = VK_NV_ACQUIRE_WINRT_DISPLAY_SPEC_VERSION;
|
|
|
8886 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
8887
|
|
|
8888 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
|
|
|
8889 //=== VK_EXT_directfb_surface ===
|
|
|
8890 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDirectfbSurfaceExtensionName = VK_EXT_DIRECTFB_SURFACE_EXTENSION_NAME;
|
|
|
8891 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDirectfbSurfaceSpecVersion = VK_EXT_DIRECTFB_SURFACE_SPEC_VERSION;
|
|
|
8892 #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
|
|
|
8893
|
|
|
8894 //=== VK_VALVE_mutable_descriptor_type ===
|
|
|
8895 VULKAN_HPP_CONSTEXPR_INLINE auto VALVEMutableDescriptorTypeExtensionName = VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME;
|
|
|
8896 VULKAN_HPP_CONSTEXPR_INLINE auto VALVEMutableDescriptorTypeSpecVersion = VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION;
|
|
|
8897
|
|
|
8898 //=== VK_EXT_vertex_input_dynamic_state ===
|
|
|
8899 VULKAN_HPP_CONSTEXPR_INLINE auto EXTVertexInputDynamicStateExtensionName = VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME;
|
|
|
8900 VULKAN_HPP_CONSTEXPR_INLINE auto EXTVertexInputDynamicStateSpecVersion = VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_SPEC_VERSION;
|
|
|
8901
|
|
|
8902 //=== VK_EXT_physical_device_drm ===
|
|
|
8903 VULKAN_HPP_CONSTEXPR_INLINE auto EXTPhysicalDeviceDrmExtensionName = VK_EXT_PHYSICAL_DEVICE_DRM_EXTENSION_NAME;
|
|
|
8904 VULKAN_HPP_CONSTEXPR_INLINE auto EXTPhysicalDeviceDrmSpecVersion = VK_EXT_PHYSICAL_DEVICE_DRM_SPEC_VERSION;
|
|
|
8905
|
|
|
8906 //=== VK_EXT_device_address_binding_report ===
|
|
|
8907 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDeviceAddressBindingReportExtensionName = VK_EXT_DEVICE_ADDRESS_BINDING_REPORT_EXTENSION_NAME;
|
|
|
8908 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDeviceAddressBindingReportSpecVersion = VK_EXT_DEVICE_ADDRESS_BINDING_REPORT_SPEC_VERSION;
|
|
|
8909
|
|
|
8910 //=== VK_EXT_depth_clip_control ===
|
|
|
8911 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthClipControlExtensionName = VK_EXT_DEPTH_CLIP_CONTROL_EXTENSION_NAME;
|
|
|
8912 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthClipControlSpecVersion = VK_EXT_DEPTH_CLIP_CONTROL_SPEC_VERSION;
|
|
|
8913
|
|
|
8914 //=== VK_EXT_primitive_topology_list_restart ===
|
|
|
8915 VULKAN_HPP_CONSTEXPR_INLINE auto EXTPrimitiveTopologyListRestartExtensionName = VK_EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_EXTENSION_NAME;
|
|
|
8916 VULKAN_HPP_CONSTEXPR_INLINE auto EXTPrimitiveTopologyListRestartSpecVersion = VK_EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_SPEC_VERSION;
|
|
|
8917
|
|
|
8918 //=== VK_KHR_format_feature_flags2 ===
|
|
|
8919 VULKAN_HPP_CONSTEXPR_INLINE auto KHRFormatFeatureFlags2ExtensionName = VK_KHR_FORMAT_FEATURE_FLAGS_2_EXTENSION_NAME;
|
|
|
8920 VULKAN_HPP_CONSTEXPR_INLINE auto KHRFormatFeatureFlags2SpecVersion = VK_KHR_FORMAT_FEATURE_FLAGS_2_SPEC_VERSION;
|
|
|
8921
|
|
|
8922 //=== VK_EXT_present_mode_fifo_latest_ready ===
|
|
|
8923 VULKAN_HPP_CONSTEXPR_INLINE auto EXTPresentModeFifoLatestReadyExtensionName = VK_EXT_PRESENT_MODE_FIFO_LATEST_READY_EXTENSION_NAME;
|
|
|
8924 VULKAN_HPP_CONSTEXPR_INLINE auto EXTPresentModeFifoLatestReadySpecVersion = VK_EXT_PRESENT_MODE_FIFO_LATEST_READY_SPEC_VERSION;
|
|
|
8925
|
|
|
8926 #if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
|
8927 //=== VK_FUCHSIA_external_memory ===
|
|
|
8928 VULKAN_HPP_CONSTEXPR_INLINE auto FUCHSIAExternalMemoryExtensionName = VK_FUCHSIA_EXTERNAL_MEMORY_EXTENSION_NAME;
|
|
|
8929 VULKAN_HPP_CONSTEXPR_INLINE auto FUCHSIAExternalMemorySpecVersion = VK_FUCHSIA_EXTERNAL_MEMORY_SPEC_VERSION;
|
|
|
8930 #endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
8931
|
|
|
8932 #if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
|
8933 //=== VK_FUCHSIA_external_semaphore ===
|
|
|
8934 VULKAN_HPP_CONSTEXPR_INLINE auto FUCHSIAExternalSemaphoreExtensionName = VK_FUCHSIA_EXTERNAL_SEMAPHORE_EXTENSION_NAME;
|
|
|
8935 VULKAN_HPP_CONSTEXPR_INLINE auto FUCHSIAExternalSemaphoreSpecVersion = VK_FUCHSIA_EXTERNAL_SEMAPHORE_SPEC_VERSION;
|
|
|
8936 #endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
8937
|
|
|
8938 #if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
|
8939 //=== VK_FUCHSIA_buffer_collection ===
|
|
|
8940 VULKAN_HPP_CONSTEXPR_INLINE auto FUCHSIABufferCollectionExtensionName = VK_FUCHSIA_BUFFER_COLLECTION_EXTENSION_NAME;
|
|
|
8941 VULKAN_HPP_CONSTEXPR_INLINE auto FUCHSIABufferCollectionSpecVersion = VK_FUCHSIA_BUFFER_COLLECTION_SPEC_VERSION;
|
|
|
8942 #endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
8943
|
|
|
8944 //=== VK_HUAWEI_subpass_shading ===
|
|
|
8945 VULKAN_HPP_CONSTEXPR_INLINE auto HUAWEISubpassShadingExtensionName = VK_HUAWEI_SUBPASS_SHADING_EXTENSION_NAME;
|
|
|
8946 VULKAN_HPP_CONSTEXPR_INLINE auto HUAWEISubpassShadingSpecVersion = VK_HUAWEI_SUBPASS_SHADING_SPEC_VERSION;
|
|
|
8947
|
|
|
8948 //=== VK_HUAWEI_invocation_mask ===
|
|
|
8949 VULKAN_HPP_CONSTEXPR_INLINE auto HUAWEIInvocationMaskExtensionName = VK_HUAWEI_INVOCATION_MASK_EXTENSION_NAME;
|
|
|
8950 VULKAN_HPP_CONSTEXPR_INLINE auto HUAWEIInvocationMaskSpecVersion = VK_HUAWEI_INVOCATION_MASK_SPEC_VERSION;
|
|
|
8951
|
|
|
8952 //=== VK_NV_external_memory_rdma ===
|
|
|
8953 VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalMemoryRdmaExtensionName = VK_NV_EXTERNAL_MEMORY_RDMA_EXTENSION_NAME;
|
|
|
8954 VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalMemoryRdmaSpecVersion = VK_NV_EXTERNAL_MEMORY_RDMA_SPEC_VERSION;
|
|
|
8955
|
|
|
8956 //=== VK_EXT_pipeline_properties ===
|
|
|
8957 VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelinePropertiesExtensionName = VK_EXT_PIPELINE_PROPERTIES_EXTENSION_NAME;
|
|
|
8958 VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelinePropertiesSpecVersion = VK_EXT_PIPELINE_PROPERTIES_SPEC_VERSION;
|
|
|
8959
|
|
|
8960 //=== VK_EXT_frame_boundary ===
|
|
|
8961 VULKAN_HPP_CONSTEXPR_INLINE auto EXTFrameBoundaryExtensionName = VK_EXT_FRAME_BOUNDARY_EXTENSION_NAME;
|
|
|
8962 VULKAN_HPP_CONSTEXPR_INLINE auto EXTFrameBoundarySpecVersion = VK_EXT_FRAME_BOUNDARY_SPEC_VERSION;
|
|
|
8963
|
|
|
8964 //=== VK_EXT_multisampled_render_to_single_sampled ===
|
|
|
8965 VULKAN_HPP_CONSTEXPR_INLINE auto EXTMultisampledRenderToSingleSampledExtensionName = VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXTENSION_NAME;
|
|
|
8966 VULKAN_HPP_CONSTEXPR_INLINE auto EXTMultisampledRenderToSingleSampledSpecVersion = VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_SPEC_VERSION;
|
|
|
8967
|
|
|
8968 //=== VK_EXT_extended_dynamic_state2 ===
|
|
|
8969 VULKAN_HPP_CONSTEXPR_INLINE auto EXTExtendedDynamicState2ExtensionName = VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME;
|
|
|
8970 VULKAN_HPP_CONSTEXPR_INLINE auto EXTExtendedDynamicState2SpecVersion = VK_EXT_EXTENDED_DYNAMIC_STATE_2_SPEC_VERSION;
|
|
|
8971
|
|
|
8972 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
|
|
8973 //=== VK_QNX_screen_surface ===
|
|
|
8974 VULKAN_HPP_CONSTEXPR_INLINE auto QNXScreenSurfaceExtensionName = VK_QNX_SCREEN_SURFACE_EXTENSION_NAME;
|
|
|
8975 VULKAN_HPP_CONSTEXPR_INLINE auto QNXScreenSurfaceSpecVersion = VK_QNX_SCREEN_SURFACE_SPEC_VERSION;
|
|
|
8976 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
|
|
8977
|
|
|
8978 //=== VK_EXT_color_write_enable ===
|
|
|
8979 VULKAN_HPP_CONSTEXPR_INLINE auto EXTColorWriteEnableExtensionName = VK_EXT_COLOR_WRITE_ENABLE_EXTENSION_NAME;
|
|
|
8980 VULKAN_HPP_CONSTEXPR_INLINE auto EXTColorWriteEnableSpecVersion = VK_EXT_COLOR_WRITE_ENABLE_SPEC_VERSION;
|
|
|
8981
|
|
|
8982 //=== VK_EXT_primitives_generated_query ===
|
|
|
8983 VULKAN_HPP_CONSTEXPR_INLINE auto EXTPrimitivesGeneratedQueryExtensionName = VK_EXT_PRIMITIVES_GENERATED_QUERY_EXTENSION_NAME;
|
|
|
8984 VULKAN_HPP_CONSTEXPR_INLINE auto EXTPrimitivesGeneratedQuerySpecVersion = VK_EXT_PRIMITIVES_GENERATED_QUERY_SPEC_VERSION;
|
|
|
8985
|
|
|
8986 //=== VK_KHR_ray_tracing_maintenance1 ===
|
|
|
8987 VULKAN_HPP_CONSTEXPR_INLINE auto KHRRayTracingMaintenance1ExtensionName = VK_KHR_RAY_TRACING_MAINTENANCE_1_EXTENSION_NAME;
|
|
|
8988 VULKAN_HPP_CONSTEXPR_INLINE auto KHRRayTracingMaintenance1SpecVersion = VK_KHR_RAY_TRACING_MAINTENANCE_1_SPEC_VERSION;
|
|
|
8989
|
|
|
8990 //=== VK_KHR_shader_untyped_pointers ===
|
|
|
8991 VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderUntypedPointersExtensionName = VK_KHR_SHADER_UNTYPED_POINTERS_EXTENSION_NAME;
|
|
|
8992 VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderUntypedPointersSpecVersion = VK_KHR_SHADER_UNTYPED_POINTERS_SPEC_VERSION;
|
|
|
8993
|
|
|
8994 //=== VK_EXT_global_priority_query ===
|
|
|
8995 VULKAN_HPP_CONSTEXPR_INLINE auto EXTGlobalPriorityQueryExtensionName = VK_EXT_GLOBAL_PRIORITY_QUERY_EXTENSION_NAME;
|
|
|
8996 VULKAN_HPP_CONSTEXPR_INLINE auto EXTGlobalPriorityQuerySpecVersion = VK_EXT_GLOBAL_PRIORITY_QUERY_SPEC_VERSION;
|
|
|
8997
|
|
|
8998 //=== VK_VALVE_video_encode_rgb_conversion ===
|
|
|
8999 VULKAN_HPP_CONSTEXPR_INLINE auto VALVEVideoEncodeRgbConversionExtensionName = VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_EXTENSION_NAME;
|
|
|
9000 VULKAN_HPP_CONSTEXPR_INLINE auto VALVEVideoEncodeRgbConversionSpecVersion = VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_SPEC_VERSION;
|
|
|
9001
|
|
|
9002 //=== VK_EXT_image_view_min_lod ===
|
|
|
9003 VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageViewMinLodExtensionName = VK_EXT_IMAGE_VIEW_MIN_LOD_EXTENSION_NAME;
|
|
|
9004 VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageViewMinLodSpecVersion = VK_EXT_IMAGE_VIEW_MIN_LOD_SPEC_VERSION;
|
|
|
9005
|
|
|
9006 //=== VK_EXT_multi_draw ===
|
|
|
9007 VULKAN_HPP_CONSTEXPR_INLINE auto EXTMultiDrawExtensionName = VK_EXT_MULTI_DRAW_EXTENSION_NAME;
|
|
|
9008 VULKAN_HPP_CONSTEXPR_INLINE auto EXTMultiDrawSpecVersion = VK_EXT_MULTI_DRAW_SPEC_VERSION;
|
|
|
9009
|
|
|
9010 //=== VK_EXT_image_2d_view_of_3d ===
|
|
|
9011 VULKAN_HPP_CONSTEXPR_INLINE auto EXTImage2DViewOf3DExtensionName = VK_EXT_IMAGE_2D_VIEW_OF_3D_EXTENSION_NAME;
|
|
|
9012 VULKAN_HPP_CONSTEXPR_INLINE auto EXTImage2DViewOf3DSpecVersion = VK_EXT_IMAGE_2D_VIEW_OF_3D_SPEC_VERSION;
|
|
|
9013
|
|
|
9014 //=== VK_KHR_portability_enumeration ===
|
|
|
9015 VULKAN_HPP_CONSTEXPR_INLINE auto KHRPortabilityEnumerationExtensionName = VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME;
|
|
|
9016 VULKAN_HPP_CONSTEXPR_INLINE auto KHRPortabilityEnumerationSpecVersion = VK_KHR_PORTABILITY_ENUMERATION_SPEC_VERSION;
|
|
|
9017
|
|
|
9018 //=== VK_EXT_shader_tile_image ===
|
|
|
9019 VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderTileImageExtensionName = VK_EXT_SHADER_TILE_IMAGE_EXTENSION_NAME;
|
|
|
9020 VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderTileImageSpecVersion = VK_EXT_SHADER_TILE_IMAGE_SPEC_VERSION;
|
|
|
9021
|
|
|
9022 //=== VK_EXT_opacity_micromap ===
|
|
|
9023 VULKAN_HPP_CONSTEXPR_INLINE auto EXTOpacityMicromapExtensionName = VK_EXT_OPACITY_MICROMAP_EXTENSION_NAME;
|
|
|
9024 VULKAN_HPP_CONSTEXPR_INLINE auto EXTOpacityMicromapSpecVersion = VK_EXT_OPACITY_MICROMAP_SPEC_VERSION;
|
|
|
9025
|
|
|
9026 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
9027 //=== VK_NV_displacement_micromap ===
|
|
|
9028 VULKAN_HPP_DEPRECATED( "The VK_NV_displacement_micromap extension has been deprecated by VK_NV_cluster_acceleration_structure." )
|
|
|
9029 VULKAN_HPP_CONSTEXPR_INLINE auto NVDisplacementMicromapExtensionName = VK_NV_DISPLACEMENT_MICROMAP_EXTENSION_NAME;
|
|
|
9030 VULKAN_HPP_DEPRECATED( "The VK_NV_displacement_micromap extension has been deprecated by VK_NV_cluster_acceleration_structure." )
|
|
|
9031 VULKAN_HPP_CONSTEXPR_INLINE auto NVDisplacementMicromapSpecVersion = VK_NV_DISPLACEMENT_MICROMAP_SPEC_VERSION;
|
|
|
9032 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
9033
|
|
|
9034 //=== VK_EXT_load_store_op_none ===
|
|
|
9035 VULKAN_HPP_CONSTEXPR_INLINE auto EXTLoadStoreOpNoneExtensionName = VK_EXT_LOAD_STORE_OP_NONE_EXTENSION_NAME;
|
|
|
9036 VULKAN_HPP_CONSTEXPR_INLINE auto EXTLoadStoreOpNoneSpecVersion = VK_EXT_LOAD_STORE_OP_NONE_SPEC_VERSION;
|
|
|
9037
|
|
|
9038 //=== VK_HUAWEI_cluster_culling_shader ===
|
|
|
9039 VULKAN_HPP_CONSTEXPR_INLINE auto HUAWEIClusterCullingShaderExtensionName = VK_HUAWEI_CLUSTER_CULLING_SHADER_EXTENSION_NAME;
|
|
|
9040 VULKAN_HPP_CONSTEXPR_INLINE auto HUAWEIClusterCullingShaderSpecVersion = VK_HUAWEI_CLUSTER_CULLING_SHADER_SPEC_VERSION;
|
|
|
9041
|
|
|
9042 //=== VK_EXT_border_color_swizzle ===
|
|
|
9043 VULKAN_HPP_CONSTEXPR_INLINE auto EXTBorderColorSwizzleExtensionName = VK_EXT_BORDER_COLOR_SWIZZLE_EXTENSION_NAME;
|
|
|
9044 VULKAN_HPP_CONSTEXPR_INLINE auto EXTBorderColorSwizzleSpecVersion = VK_EXT_BORDER_COLOR_SWIZZLE_SPEC_VERSION;
|
|
|
9045
|
|
|
9046 //=== VK_EXT_pageable_device_local_memory ===
|
|
|
9047 VULKAN_HPP_CONSTEXPR_INLINE auto EXTPageableDeviceLocalMemoryExtensionName = VK_EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_EXTENSION_NAME;
|
|
|
9048 VULKAN_HPP_CONSTEXPR_INLINE auto EXTPageableDeviceLocalMemorySpecVersion = VK_EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_SPEC_VERSION;
|
|
|
9049
|
|
|
9050 //=== VK_KHR_maintenance4 ===
|
|
|
9051 VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance4ExtensionName = VK_KHR_MAINTENANCE_4_EXTENSION_NAME;
|
|
|
9052 VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance4SpecVersion = VK_KHR_MAINTENANCE_4_SPEC_VERSION;
|
|
|
9053
|
|
|
9054 //=== VK_ARM_shader_core_properties ===
|
|
|
9055 VULKAN_HPP_CONSTEXPR_INLINE auto ARMShaderCorePropertiesExtensionName = VK_ARM_SHADER_CORE_PROPERTIES_EXTENSION_NAME;
|
|
|
9056 VULKAN_HPP_CONSTEXPR_INLINE auto ARMShaderCorePropertiesSpecVersion = VK_ARM_SHADER_CORE_PROPERTIES_SPEC_VERSION;
|
|
|
9057
|
|
|
9058 //=== VK_KHR_shader_subgroup_rotate ===
|
|
|
9059 VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderSubgroupRotateExtensionName = VK_KHR_SHADER_SUBGROUP_ROTATE_EXTENSION_NAME;
|
|
|
9060 VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderSubgroupRotateSpecVersion = VK_KHR_SHADER_SUBGROUP_ROTATE_SPEC_VERSION;
|
|
|
9061
|
|
|
9062 //=== VK_ARM_scheduling_controls ===
|
|
|
9063 VULKAN_HPP_CONSTEXPR_INLINE auto ARMSchedulingControlsExtensionName = VK_ARM_SCHEDULING_CONTROLS_EXTENSION_NAME;
|
|
|
9064 VULKAN_HPP_CONSTEXPR_INLINE auto ARMSchedulingControlsSpecVersion = VK_ARM_SCHEDULING_CONTROLS_SPEC_VERSION;
|
|
|
9065
|
|
|
9066 //=== VK_EXT_image_sliced_view_of_3d ===
|
|
|
9067 VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageSlicedViewOf3DExtensionName = VK_EXT_IMAGE_SLICED_VIEW_OF_3D_EXTENSION_NAME;
|
|
|
9068 VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageSlicedViewOf3DSpecVersion = VK_EXT_IMAGE_SLICED_VIEW_OF_3D_SPEC_VERSION;
|
|
|
9069
|
|
|
9070 //=== VK_VALVE_descriptor_set_host_mapping ===
|
|
|
9071 VULKAN_HPP_CONSTEXPR_INLINE auto VALVEDescriptorSetHostMappingExtensionName = VK_VALVE_DESCRIPTOR_SET_HOST_MAPPING_EXTENSION_NAME;
|
|
|
9072 VULKAN_HPP_CONSTEXPR_INLINE auto VALVEDescriptorSetHostMappingSpecVersion = VK_VALVE_DESCRIPTOR_SET_HOST_MAPPING_SPEC_VERSION;
|
|
|
9073
|
|
|
9074 //=== VK_EXT_depth_clamp_zero_one ===
|
|
|
9075 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthClampZeroOneExtensionName = VK_EXT_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME;
|
|
|
9076 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthClampZeroOneSpecVersion = VK_EXT_DEPTH_CLAMP_ZERO_ONE_SPEC_VERSION;
|
|
|
9077
|
|
|
9078 //=== VK_EXT_non_seamless_cube_map ===
|
|
|
9079 VULKAN_HPP_CONSTEXPR_INLINE auto EXTNonSeamlessCubeMapExtensionName = VK_EXT_NON_SEAMLESS_CUBE_MAP_EXTENSION_NAME;
|
|
|
9080 VULKAN_HPP_CONSTEXPR_INLINE auto EXTNonSeamlessCubeMapSpecVersion = VK_EXT_NON_SEAMLESS_CUBE_MAP_SPEC_VERSION;
|
|
|
9081
|
|
|
9082 //=== VK_ARM_render_pass_striped ===
|
|
|
9083 VULKAN_HPP_CONSTEXPR_INLINE auto ARMRenderPassStripedExtensionName = VK_ARM_RENDER_PASS_STRIPED_EXTENSION_NAME;
|
|
|
9084 VULKAN_HPP_CONSTEXPR_INLINE auto ARMRenderPassStripedSpecVersion = VK_ARM_RENDER_PASS_STRIPED_SPEC_VERSION;
|
|
|
9085
|
|
|
9086 //=== VK_QCOM_fragment_density_map_offset ===
|
|
|
9087 VULKAN_HPP_CONSTEXPR_INLINE auto QCOMFragmentDensityMapOffsetExtensionName = VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME;
|
|
|
9088 VULKAN_HPP_CONSTEXPR_INLINE auto QCOMFragmentDensityMapOffsetSpecVersion = VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION;
|
|
|
9089
|
|
|
9090 //=== VK_NV_copy_memory_indirect ===
|
|
|
9091 VULKAN_HPP_CONSTEXPR_INLINE auto NVCopyMemoryIndirectExtensionName = VK_NV_COPY_MEMORY_INDIRECT_EXTENSION_NAME;
|
|
|
9092 VULKAN_HPP_CONSTEXPR_INLINE auto NVCopyMemoryIndirectSpecVersion = VK_NV_COPY_MEMORY_INDIRECT_SPEC_VERSION;
|
|
|
9093
|
|
|
9094 //=== VK_NV_memory_decompression ===
|
|
|
9095 VULKAN_HPP_CONSTEXPR_INLINE auto NVMemoryDecompressionExtensionName = VK_NV_MEMORY_DECOMPRESSION_EXTENSION_NAME;
|
|
|
9096 VULKAN_HPP_CONSTEXPR_INLINE auto NVMemoryDecompressionSpecVersion = VK_NV_MEMORY_DECOMPRESSION_SPEC_VERSION;
|
|
|
9097
|
|
|
9098 //=== VK_NV_device_generated_commands_compute ===
|
|
|
9099 VULKAN_HPP_CONSTEXPR_INLINE auto NVDeviceGeneratedCommandsComputeExtensionName = VK_NV_DEVICE_GENERATED_COMMANDS_COMPUTE_EXTENSION_NAME;
|
|
|
9100 VULKAN_HPP_CONSTEXPR_INLINE auto NVDeviceGeneratedCommandsComputeSpecVersion = VK_NV_DEVICE_GENERATED_COMMANDS_COMPUTE_SPEC_VERSION;
|
|
|
9101
|
|
|
9102 //=== VK_NV_ray_tracing_linear_swept_spheres ===
|
|
|
9103 VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingLinearSweptSpheresExtensionName = VK_NV_RAY_TRACING_LINEAR_SWEPT_SPHERES_EXTENSION_NAME;
|
|
|
9104 VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingLinearSweptSpheresSpecVersion = VK_NV_RAY_TRACING_LINEAR_SWEPT_SPHERES_SPEC_VERSION;
|
|
|
9105
|
|
|
9106 //=== VK_NV_linear_color_attachment ===
|
|
|
9107 VULKAN_HPP_CONSTEXPR_INLINE auto NVLinearColorAttachmentExtensionName = VK_NV_LINEAR_COLOR_ATTACHMENT_EXTENSION_NAME;
|
|
|
9108 VULKAN_HPP_CONSTEXPR_INLINE auto NVLinearColorAttachmentSpecVersion = VK_NV_LINEAR_COLOR_ATTACHMENT_SPEC_VERSION;
|
|
|
9109
|
|
|
9110 //=== VK_GOOGLE_surfaceless_query ===
|
|
|
9111 VULKAN_HPP_CONSTEXPR_INLINE auto GOOGLESurfacelessQueryExtensionName = VK_GOOGLE_SURFACELESS_QUERY_EXTENSION_NAME;
|
|
|
9112 VULKAN_HPP_CONSTEXPR_INLINE auto GOOGLESurfacelessQuerySpecVersion = VK_GOOGLE_SURFACELESS_QUERY_SPEC_VERSION;
|
|
|
9113
|
|
|
9114 //=== VK_KHR_shader_maximal_reconvergence ===
|
|
|
9115 VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderMaximalReconvergenceExtensionName = VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_EXTENSION_NAME;
|
|
|
9116 VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderMaximalReconvergenceSpecVersion = VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_SPEC_VERSION;
|
|
|
9117
|
|
|
9118 //=== VK_EXT_image_compression_control_swapchain ===
|
|
|
9119 VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageCompressionControlSwapchainExtensionName = VK_EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_EXTENSION_NAME;
|
|
|
9120 VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageCompressionControlSwapchainSpecVersion = VK_EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_SPEC_VERSION;
|
|
|
9121
|
|
|
9122 //=== VK_QCOM_image_processing ===
|
|
|
9123 VULKAN_HPP_CONSTEXPR_INLINE auto QCOMImageProcessingExtensionName = VK_QCOM_IMAGE_PROCESSING_EXTENSION_NAME;
|
|
|
9124 VULKAN_HPP_CONSTEXPR_INLINE auto QCOMImageProcessingSpecVersion = VK_QCOM_IMAGE_PROCESSING_SPEC_VERSION;
|
|
|
9125
|
|
|
9126 //=== VK_EXT_nested_command_buffer ===
|
|
|
9127 VULKAN_HPP_CONSTEXPR_INLINE auto EXTNestedCommandBufferExtensionName = VK_EXT_NESTED_COMMAND_BUFFER_EXTENSION_NAME;
|
|
|
9128 VULKAN_HPP_CONSTEXPR_INLINE auto EXTNestedCommandBufferSpecVersion = VK_EXT_NESTED_COMMAND_BUFFER_SPEC_VERSION;
|
|
|
9129
|
|
|
9130 #if defined( VK_USE_PLATFORM_OHOS )
|
|
|
9131 //=== VK_OHOS_external_memory ===
|
|
|
9132 VULKAN_HPP_CONSTEXPR_INLINE auto OHOSExternalMemoryExtensionName = VK_OHOS_EXTERNAL_MEMORY_EXTENSION_NAME;
|
|
|
9133 VULKAN_HPP_CONSTEXPR_INLINE auto OHOSExternalMemorySpecVersion = VK_OHOS_EXTERNAL_MEMORY_SPEC_VERSION;
|
|
|
9134 #endif /*VK_USE_PLATFORM_OHOS*/
|
|
|
9135
|
|
|
9136 //=== VK_EXT_external_memory_acquire_unmodified ===
|
|
|
9137 VULKAN_HPP_CONSTEXPR_INLINE auto EXTExternalMemoryAcquireUnmodifiedExtensionName = VK_EXT_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXTENSION_NAME;
|
|
|
9138 VULKAN_HPP_CONSTEXPR_INLINE auto EXTExternalMemoryAcquireUnmodifiedSpecVersion = VK_EXT_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_SPEC_VERSION;
|
|
|
9139
|
|
|
9140 //=== VK_EXT_extended_dynamic_state3 ===
|
|
|
9141 VULKAN_HPP_CONSTEXPR_INLINE auto EXTExtendedDynamicState3ExtensionName = VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME;
|
|
|
9142 VULKAN_HPP_CONSTEXPR_INLINE auto EXTExtendedDynamicState3SpecVersion = VK_EXT_EXTENDED_DYNAMIC_STATE_3_SPEC_VERSION;
|
|
|
9143
|
|
|
9144 //=== VK_EXT_subpass_merge_feedback ===
|
|
|
9145 VULKAN_HPP_CONSTEXPR_INLINE auto EXTSubpassMergeFeedbackExtensionName = VK_EXT_SUBPASS_MERGE_FEEDBACK_EXTENSION_NAME;
|
|
|
9146 VULKAN_HPP_CONSTEXPR_INLINE auto EXTSubpassMergeFeedbackSpecVersion = VK_EXT_SUBPASS_MERGE_FEEDBACK_SPEC_VERSION;
|
|
|
9147
|
|
|
9148 //=== VK_LUNARG_direct_driver_loading ===
|
|
|
9149 VULKAN_HPP_CONSTEXPR_INLINE auto LUNARGDirectDriverLoadingExtensionName = VK_LUNARG_DIRECT_DRIVER_LOADING_EXTENSION_NAME;
|
|
|
9150 VULKAN_HPP_CONSTEXPR_INLINE auto LUNARGDirectDriverLoadingSpecVersion = VK_LUNARG_DIRECT_DRIVER_LOADING_SPEC_VERSION;
|
|
|
9151
|
|
|
9152 //=== VK_ARM_tensors ===
|
|
|
9153 VULKAN_HPP_CONSTEXPR_INLINE auto ARMTensorsExtensionName = VK_ARM_TENSORS_EXTENSION_NAME;
|
|
|
9154 VULKAN_HPP_CONSTEXPR_INLINE auto ARMTensorsSpecVersion = VK_ARM_TENSORS_SPEC_VERSION;
|
|
|
9155
|
|
|
9156 //=== VK_EXT_shader_module_identifier ===
|
|
|
9157 VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderModuleIdentifierExtensionName = VK_EXT_SHADER_MODULE_IDENTIFIER_EXTENSION_NAME;
|
|
|
9158 VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderModuleIdentifierSpecVersion = VK_EXT_SHADER_MODULE_IDENTIFIER_SPEC_VERSION;
|
|
|
9159
|
|
|
9160 //=== VK_EXT_rasterization_order_attachment_access ===
|
|
|
9161 VULKAN_HPP_CONSTEXPR_INLINE auto EXTRasterizationOrderAttachmentAccessExtensionName = VK_EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME;
|
|
|
9162 VULKAN_HPP_CONSTEXPR_INLINE auto EXTRasterizationOrderAttachmentAccessSpecVersion = VK_EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_SPEC_VERSION;
|
|
|
9163
|
|
|
9164 //=== VK_NV_optical_flow ===
|
|
|
9165 VULKAN_HPP_CONSTEXPR_INLINE auto NVOpticalFlowExtensionName = VK_NV_OPTICAL_FLOW_EXTENSION_NAME;
|
|
|
9166 VULKAN_HPP_CONSTEXPR_INLINE auto NVOpticalFlowSpecVersion = VK_NV_OPTICAL_FLOW_SPEC_VERSION;
|
|
|
9167
|
|
|
9168 //=== VK_EXT_legacy_dithering ===
|
|
|
9169 VULKAN_HPP_CONSTEXPR_INLINE auto EXTLegacyDitheringExtensionName = VK_EXT_LEGACY_DITHERING_EXTENSION_NAME;
|
|
|
9170 VULKAN_HPP_CONSTEXPR_INLINE auto EXTLegacyDitheringSpecVersion = VK_EXT_LEGACY_DITHERING_SPEC_VERSION;
|
|
|
9171
|
|
|
9172 //=== VK_EXT_pipeline_protected_access ===
|
|
|
9173 VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelineProtectedAccessExtensionName = VK_EXT_PIPELINE_PROTECTED_ACCESS_EXTENSION_NAME;
|
|
|
9174 VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelineProtectedAccessSpecVersion = VK_EXT_PIPELINE_PROTECTED_ACCESS_SPEC_VERSION;
|
|
|
9175
|
|
|
9176 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
|
|
9177 //=== VK_ANDROID_external_format_resolve ===
|
|
|
9178 VULKAN_HPP_CONSTEXPR_INLINE auto ANDROIDExternalFormatResolveExtensionName = VK_ANDROID_EXTERNAL_FORMAT_RESOLVE_EXTENSION_NAME;
|
|
|
9179 VULKAN_HPP_CONSTEXPR_INLINE auto ANDROIDExternalFormatResolveSpecVersion = VK_ANDROID_EXTERNAL_FORMAT_RESOLVE_SPEC_VERSION;
|
|
|
9180 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
|
|
9181
|
|
|
9182 //=== VK_KHR_maintenance5 ===
|
|
|
9183 VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance5ExtensionName = VK_KHR_MAINTENANCE_5_EXTENSION_NAME;
|
|
|
9184 VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance5SpecVersion = VK_KHR_MAINTENANCE_5_SPEC_VERSION;
|
|
|
9185
|
|
|
9186 //=== VK_AMD_anti_lag ===
|
|
|
9187 VULKAN_HPP_CONSTEXPR_INLINE auto AMDAntiLagExtensionName = VK_AMD_ANTI_LAG_EXTENSION_NAME;
|
|
|
9188 VULKAN_HPP_CONSTEXPR_INLINE auto AMDAntiLagSpecVersion = VK_AMD_ANTI_LAG_SPEC_VERSION;
|
|
|
9189
|
|
|
9190 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
9191 //=== VK_AMDX_dense_geometry_format ===
|
|
|
9192 VULKAN_HPP_CONSTEXPR_INLINE auto AMDXDenseGeometryFormatExtensionName = VK_AMDX_DENSE_GEOMETRY_FORMAT_EXTENSION_NAME;
|
|
|
9193 VULKAN_HPP_CONSTEXPR_INLINE auto AMDXDenseGeometryFormatSpecVersion = VK_AMDX_DENSE_GEOMETRY_FORMAT_SPEC_VERSION;
|
|
|
9194 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
9195
|
|
|
9196 //=== VK_KHR_present_id2 ===
|
|
|
9197 VULKAN_HPP_CONSTEXPR_INLINE auto KHRPresentId2ExtensionName = VK_KHR_PRESENT_ID_2_EXTENSION_NAME;
|
|
|
9198 VULKAN_HPP_CONSTEXPR_INLINE auto KHRPresentId2SpecVersion = VK_KHR_PRESENT_ID_2_SPEC_VERSION;
|
|
|
9199
|
|
|
9200 //=== VK_KHR_present_wait2 ===
|
|
|
9201 VULKAN_HPP_CONSTEXPR_INLINE auto KHRPresentWait2ExtensionName = VK_KHR_PRESENT_WAIT_2_EXTENSION_NAME;
|
|
|
9202 VULKAN_HPP_CONSTEXPR_INLINE auto KHRPresentWait2SpecVersion = VK_KHR_PRESENT_WAIT_2_SPEC_VERSION;
|
|
|
9203
|
|
|
9204 //=== VK_KHR_ray_tracing_position_fetch ===
|
|
|
9205 VULKAN_HPP_CONSTEXPR_INLINE auto KHRRayTracingPositionFetchExtensionName = VK_KHR_RAY_TRACING_POSITION_FETCH_EXTENSION_NAME;
|
|
|
9206 VULKAN_HPP_CONSTEXPR_INLINE auto KHRRayTracingPositionFetchSpecVersion = VK_KHR_RAY_TRACING_POSITION_FETCH_SPEC_VERSION;
|
|
|
9207
|
|
|
9208 //=== VK_EXT_shader_object ===
|
|
|
9209 VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderObjectExtensionName = VK_EXT_SHADER_OBJECT_EXTENSION_NAME;
|
|
|
9210 VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderObjectSpecVersion = VK_EXT_SHADER_OBJECT_SPEC_VERSION;
|
|
|
9211
|
|
|
9212 //=== VK_KHR_pipeline_binary ===
|
|
|
9213 VULKAN_HPP_CONSTEXPR_INLINE auto KHRPipelineBinaryExtensionName = VK_KHR_PIPELINE_BINARY_EXTENSION_NAME;
|
|
|
9214 VULKAN_HPP_CONSTEXPR_INLINE auto KHRPipelineBinarySpecVersion = VK_KHR_PIPELINE_BINARY_SPEC_VERSION;
|
|
|
9215
|
|
|
9216 //=== VK_QCOM_tile_properties ===
|
|
|
9217 VULKAN_HPP_CONSTEXPR_INLINE auto QCOMTilePropertiesExtensionName = VK_QCOM_TILE_PROPERTIES_EXTENSION_NAME;
|
|
|
9218 VULKAN_HPP_CONSTEXPR_INLINE auto QCOMTilePropertiesSpecVersion = VK_QCOM_TILE_PROPERTIES_SPEC_VERSION;
|
|
|
9219
|
|
|
9220 //=== VK_SEC_amigo_profiling ===
|
|
|
9221 VULKAN_HPP_CONSTEXPR_INLINE auto SECAmigoProfilingExtensionName = VK_SEC_AMIGO_PROFILING_EXTENSION_NAME;
|
|
|
9222 VULKAN_HPP_CONSTEXPR_INLINE auto SECAmigoProfilingSpecVersion = VK_SEC_AMIGO_PROFILING_SPEC_VERSION;
|
|
|
9223
|
|
|
9224 //=== VK_KHR_surface_maintenance1 ===
|
|
|
9225 VULKAN_HPP_CONSTEXPR_INLINE auto KHRSurfaceMaintenance1ExtensionName = VK_KHR_SURFACE_MAINTENANCE_1_EXTENSION_NAME;
|
|
|
9226 VULKAN_HPP_CONSTEXPR_INLINE auto KHRSurfaceMaintenance1SpecVersion = VK_KHR_SURFACE_MAINTENANCE_1_SPEC_VERSION;
|
|
|
9227
|
|
|
9228 //=== VK_KHR_swapchain_maintenance1 ===
|
|
|
9229 VULKAN_HPP_CONSTEXPR_INLINE auto KHRSwapchainMaintenance1ExtensionName = VK_KHR_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME;
|
|
|
9230 VULKAN_HPP_CONSTEXPR_INLINE auto KHRSwapchainMaintenance1SpecVersion = VK_KHR_SWAPCHAIN_MAINTENANCE_1_SPEC_VERSION;
|
|
|
9231
|
|
|
9232 //=== VK_QCOM_multiview_per_view_viewports ===
|
|
|
9233 VULKAN_HPP_CONSTEXPR_INLINE auto QCOMMultiviewPerViewViewportsExtensionName = VK_QCOM_MULTIVIEW_PER_VIEW_VIEWPORTS_EXTENSION_NAME;
|
|
|
9234 VULKAN_HPP_CONSTEXPR_INLINE auto QCOMMultiviewPerViewViewportsSpecVersion = VK_QCOM_MULTIVIEW_PER_VIEW_VIEWPORTS_SPEC_VERSION;
|
|
|
9235
|
|
|
9236 //=== VK_NV_ray_tracing_invocation_reorder ===
|
|
|
9237 VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingInvocationReorderExtensionName = VK_NV_RAY_TRACING_INVOCATION_REORDER_EXTENSION_NAME;
|
|
|
9238 VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingInvocationReorderSpecVersion = VK_NV_RAY_TRACING_INVOCATION_REORDER_SPEC_VERSION;
|
|
|
9239
|
|
|
9240 //=== VK_NV_cooperative_vector ===
|
|
|
9241 VULKAN_HPP_CONSTEXPR_INLINE auto NVCooperativeVectorExtensionName = VK_NV_COOPERATIVE_VECTOR_EXTENSION_NAME;
|
|
|
9242 VULKAN_HPP_CONSTEXPR_INLINE auto NVCooperativeVectorSpecVersion = VK_NV_COOPERATIVE_VECTOR_SPEC_VERSION;
|
|
|
9243
|
|
|
9244 //=== VK_NV_extended_sparse_address_space ===
|
|
|
9245 VULKAN_HPP_CONSTEXPR_INLINE auto NVExtendedSparseAddressSpaceExtensionName = VK_NV_EXTENDED_SPARSE_ADDRESS_SPACE_EXTENSION_NAME;
|
|
|
9246 VULKAN_HPP_CONSTEXPR_INLINE auto NVExtendedSparseAddressSpaceSpecVersion = VK_NV_EXTENDED_SPARSE_ADDRESS_SPACE_SPEC_VERSION;
|
|
|
9247
|
|
|
9248 //=== VK_EXT_mutable_descriptor_type ===
|
|
|
9249 VULKAN_HPP_CONSTEXPR_INLINE auto EXTMutableDescriptorTypeExtensionName = VK_EXT_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME;
|
|
|
9250 VULKAN_HPP_CONSTEXPR_INLINE auto EXTMutableDescriptorTypeSpecVersion = VK_EXT_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION;
|
|
|
9251
|
|
|
9252 //=== VK_EXT_legacy_vertex_attributes ===
|
|
|
9253 VULKAN_HPP_CONSTEXPR_INLINE auto EXTLegacyVertexAttributesExtensionName = VK_EXT_LEGACY_VERTEX_ATTRIBUTES_EXTENSION_NAME;
|
|
|
9254 VULKAN_HPP_CONSTEXPR_INLINE auto EXTLegacyVertexAttributesSpecVersion = VK_EXT_LEGACY_VERTEX_ATTRIBUTES_SPEC_VERSION;
|
|
|
9255
|
|
|
9256 //=== VK_EXT_layer_settings ===
|
|
|
9257 VULKAN_HPP_CONSTEXPR_INLINE auto EXTLayerSettingsExtensionName = VK_EXT_LAYER_SETTINGS_EXTENSION_NAME;
|
|
|
9258 VULKAN_HPP_CONSTEXPR_INLINE auto EXTLayerSettingsSpecVersion = VK_EXT_LAYER_SETTINGS_SPEC_VERSION;
|
|
|
9259
|
|
|
9260 //=== VK_ARM_shader_core_builtins ===
|
|
|
9261 VULKAN_HPP_CONSTEXPR_INLINE auto ARMShaderCoreBuiltinsExtensionName = VK_ARM_SHADER_CORE_BUILTINS_EXTENSION_NAME;
|
|
|
9262 VULKAN_HPP_CONSTEXPR_INLINE auto ARMShaderCoreBuiltinsSpecVersion = VK_ARM_SHADER_CORE_BUILTINS_SPEC_VERSION;
|
|
|
9263
|
|
|
9264 //=== VK_EXT_pipeline_library_group_handles ===
|
|
|
9265 VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelineLibraryGroupHandlesExtensionName = VK_EXT_PIPELINE_LIBRARY_GROUP_HANDLES_EXTENSION_NAME;
|
|
|
9266 VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelineLibraryGroupHandlesSpecVersion = VK_EXT_PIPELINE_LIBRARY_GROUP_HANDLES_SPEC_VERSION;
|
|
|
9267
|
|
|
9268 //=== VK_EXT_dynamic_rendering_unused_attachments ===
|
|
|
9269 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDynamicRenderingUnusedAttachmentsExtensionName = VK_EXT_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_EXTENSION_NAME;
|
|
|
9270 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDynamicRenderingUnusedAttachmentsSpecVersion = VK_EXT_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_SPEC_VERSION;
|
|
|
9271
|
|
|
9272 //=== VK_NV_low_latency2 ===
|
|
|
9273 VULKAN_HPP_CONSTEXPR_INLINE auto NVLowLatency2ExtensionName = VK_NV_LOW_LATENCY_2_EXTENSION_NAME;
|
|
|
9274 VULKAN_HPP_CONSTEXPR_INLINE auto NVLowLatency2SpecVersion = VK_NV_LOW_LATENCY_2_SPEC_VERSION;
|
|
|
9275
|
|
|
9276 //=== VK_KHR_cooperative_matrix ===
|
|
|
9277 VULKAN_HPP_CONSTEXPR_INLINE auto KHRCooperativeMatrixExtensionName = VK_KHR_COOPERATIVE_MATRIX_EXTENSION_NAME;
|
|
|
9278 VULKAN_HPP_CONSTEXPR_INLINE auto KHRCooperativeMatrixSpecVersion = VK_KHR_COOPERATIVE_MATRIX_SPEC_VERSION;
|
|
|
9279
|
|
|
9280 //=== VK_ARM_data_graph ===
|
|
|
9281 VULKAN_HPP_CONSTEXPR_INLINE auto ARMDataGraphExtensionName = VK_ARM_DATA_GRAPH_EXTENSION_NAME;
|
|
|
9282 VULKAN_HPP_CONSTEXPR_INLINE auto ARMDataGraphSpecVersion = VK_ARM_DATA_GRAPH_SPEC_VERSION;
|
|
|
9283
|
|
|
9284 //=== VK_QCOM_multiview_per_view_render_areas ===
|
|
|
9285 VULKAN_HPP_CONSTEXPR_INLINE auto QCOMMultiviewPerViewRenderAreasExtensionName = VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_EXTENSION_NAME;
|
|
|
9286 VULKAN_HPP_CONSTEXPR_INLINE auto QCOMMultiviewPerViewRenderAreasSpecVersion = VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_SPEC_VERSION;
|
|
|
9287
|
|
|
9288 //=== VK_KHR_compute_shader_derivatives ===
|
|
|
9289 VULKAN_HPP_CONSTEXPR_INLINE auto KHRComputeShaderDerivativesExtensionName = VK_KHR_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME;
|
|
|
9290 VULKAN_HPP_CONSTEXPR_INLINE auto KHRComputeShaderDerivativesSpecVersion = VK_KHR_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION;
|
|
|
9291
|
|
|
9292 //=== VK_KHR_video_decode_av1 ===
|
|
|
9293 VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoDecodeAv1ExtensionName = VK_KHR_VIDEO_DECODE_AV1_EXTENSION_NAME;
|
|
|
9294 VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoDecodeAv1SpecVersion = VK_KHR_VIDEO_DECODE_AV1_SPEC_VERSION;
|
|
|
9295
|
|
|
9296 //=== VK_KHR_video_encode_av1 ===
|
|
|
9297 VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoEncodeAv1ExtensionName = VK_KHR_VIDEO_ENCODE_AV1_EXTENSION_NAME;
|
|
|
9298 VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoEncodeAv1SpecVersion = VK_KHR_VIDEO_ENCODE_AV1_SPEC_VERSION;
|
|
|
9299
|
|
|
9300 //=== VK_KHR_video_decode_vp9 ===
|
|
|
9301 VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoDecodeVp9ExtensionName = VK_KHR_VIDEO_DECODE_VP9_EXTENSION_NAME;
|
|
|
9302 VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoDecodeVp9SpecVersion = VK_KHR_VIDEO_DECODE_VP9_SPEC_VERSION;
|
|
|
9303
|
|
|
9304 //=== VK_KHR_video_maintenance1 ===
|
|
|
9305 VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoMaintenance1ExtensionName = VK_KHR_VIDEO_MAINTENANCE_1_EXTENSION_NAME;
|
|
|
9306 VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoMaintenance1SpecVersion = VK_KHR_VIDEO_MAINTENANCE_1_SPEC_VERSION;
|
|
|
9307
|
|
|
9308 //=== VK_NV_per_stage_descriptor_set ===
|
|
|
9309 VULKAN_HPP_CONSTEXPR_INLINE auto NVPerStageDescriptorSetExtensionName = VK_NV_PER_STAGE_DESCRIPTOR_SET_EXTENSION_NAME;
|
|
|
9310 VULKAN_HPP_CONSTEXPR_INLINE auto NVPerStageDescriptorSetSpecVersion = VK_NV_PER_STAGE_DESCRIPTOR_SET_SPEC_VERSION;
|
|
|
9311
|
|
|
9312 //=== VK_QCOM_image_processing2 ===
|
|
|
9313 VULKAN_HPP_CONSTEXPR_INLINE auto QCOMImageProcessing2ExtensionName = VK_QCOM_IMAGE_PROCESSING_2_EXTENSION_NAME;
|
|
|
9314 VULKAN_HPP_CONSTEXPR_INLINE auto QCOMImageProcessing2SpecVersion = VK_QCOM_IMAGE_PROCESSING_2_SPEC_VERSION;
|
|
|
9315
|
|
|
9316 //=== VK_QCOM_filter_cubic_weights ===
|
|
|
9317 VULKAN_HPP_CONSTEXPR_INLINE auto QCOMFilterCubicWeightsExtensionName = VK_QCOM_FILTER_CUBIC_WEIGHTS_EXTENSION_NAME;
|
|
|
9318 VULKAN_HPP_CONSTEXPR_INLINE auto QCOMFilterCubicWeightsSpecVersion = VK_QCOM_FILTER_CUBIC_WEIGHTS_SPEC_VERSION;
|
|
|
9319
|
|
|
9320 //=== VK_QCOM_ycbcr_degamma ===
|
|
|
9321 VULKAN_HPP_CONSTEXPR_INLINE auto QCOMYcbcrDegammaExtensionName = VK_QCOM_YCBCR_DEGAMMA_EXTENSION_NAME;
|
|
|
9322 VULKAN_HPP_CONSTEXPR_INLINE auto QCOMYcbcrDegammaSpecVersion = VK_QCOM_YCBCR_DEGAMMA_SPEC_VERSION;
|
|
|
9323
|
|
|
9324 //=== VK_QCOM_filter_cubic_clamp ===
|
|
|
9325 VULKAN_HPP_CONSTEXPR_INLINE auto QCOMFilterCubicClampExtensionName = VK_QCOM_FILTER_CUBIC_CLAMP_EXTENSION_NAME;
|
|
|
9326 VULKAN_HPP_CONSTEXPR_INLINE auto QCOMFilterCubicClampSpecVersion = VK_QCOM_FILTER_CUBIC_CLAMP_SPEC_VERSION;
|
|
|
9327
|
|
|
9328 //=== VK_EXT_attachment_feedback_loop_dynamic_state ===
|
|
|
9329 VULKAN_HPP_CONSTEXPR_INLINE auto EXTAttachmentFeedbackLoopDynamicStateExtensionName = VK_EXT_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_EXTENSION_NAME;
|
|
|
9330 VULKAN_HPP_CONSTEXPR_INLINE auto EXTAttachmentFeedbackLoopDynamicStateSpecVersion = VK_EXT_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_SPEC_VERSION;
|
|
|
9331
|
|
|
9332 //=== VK_KHR_vertex_attribute_divisor ===
|
|
|
9333 VULKAN_HPP_CONSTEXPR_INLINE auto KHRVertexAttributeDivisorExtensionName = VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME;
|
|
|
9334 VULKAN_HPP_CONSTEXPR_INLINE auto KHRVertexAttributeDivisorSpecVersion = VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION;
|
|
|
9335
|
|
|
9336 //=== VK_KHR_load_store_op_none ===
|
|
|
9337 VULKAN_HPP_CONSTEXPR_INLINE auto KHRLoadStoreOpNoneExtensionName = VK_KHR_LOAD_STORE_OP_NONE_EXTENSION_NAME;
|
|
|
9338 VULKAN_HPP_CONSTEXPR_INLINE auto KHRLoadStoreOpNoneSpecVersion = VK_KHR_LOAD_STORE_OP_NONE_SPEC_VERSION;
|
|
|
9339
|
|
|
9340 //=== VK_KHR_unified_image_layouts ===
|
|
|
9341 VULKAN_HPP_CONSTEXPR_INLINE auto KHRUnifiedImageLayoutsExtensionName = VK_KHR_UNIFIED_IMAGE_LAYOUTS_EXTENSION_NAME;
|
|
|
9342 VULKAN_HPP_CONSTEXPR_INLINE auto KHRUnifiedImageLayoutsSpecVersion = VK_KHR_UNIFIED_IMAGE_LAYOUTS_SPEC_VERSION;
|
|
|
9343
|
|
|
9344 //=== VK_KHR_shader_float_controls2 ===
|
|
|
9345 VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderFloatControls2ExtensionName = VK_KHR_SHADER_FLOAT_CONTROLS_2_EXTENSION_NAME;
|
|
|
9346 VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderFloatControls2SpecVersion = VK_KHR_SHADER_FLOAT_CONTROLS_2_SPEC_VERSION;
|
|
|
9347
|
|
|
9348 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
|
|
9349 //=== VK_QNX_external_memory_screen_buffer ===
|
|
|
9350 VULKAN_HPP_CONSTEXPR_INLINE auto QNXExternalMemoryScreenBufferExtensionName = VK_QNX_EXTERNAL_MEMORY_SCREEN_BUFFER_EXTENSION_NAME;
|
|
|
9351 VULKAN_HPP_CONSTEXPR_INLINE auto QNXExternalMemoryScreenBufferSpecVersion = VK_QNX_EXTERNAL_MEMORY_SCREEN_BUFFER_SPEC_VERSION;
|
|
|
9352 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
|
|
9353
|
|
|
9354 //=== VK_MSFT_layered_driver ===
|
|
|
9355 VULKAN_HPP_CONSTEXPR_INLINE auto MSFTLayeredDriverExtensionName = VK_MSFT_LAYERED_DRIVER_EXTENSION_NAME;
|
|
|
9356 VULKAN_HPP_CONSTEXPR_INLINE auto MSFTLayeredDriverSpecVersion = VK_MSFT_LAYERED_DRIVER_SPEC_VERSION;
|
|
|
9357
|
|
|
9358 //=== VK_KHR_index_type_uint8 ===
|
|
|
9359 VULKAN_HPP_CONSTEXPR_INLINE auto KHRIndexTypeUint8ExtensionName = VK_KHR_INDEX_TYPE_UINT8_EXTENSION_NAME;
|
|
|
9360 VULKAN_HPP_CONSTEXPR_INLINE auto KHRIndexTypeUint8SpecVersion = VK_KHR_INDEX_TYPE_UINT8_SPEC_VERSION;
|
|
|
9361
|
|
|
9362 //=== VK_KHR_line_rasterization ===
|
|
|
9363 VULKAN_HPP_CONSTEXPR_INLINE auto KHRLineRasterizationExtensionName = VK_KHR_LINE_RASTERIZATION_EXTENSION_NAME;
|
|
|
9364 VULKAN_HPP_CONSTEXPR_INLINE auto KHRLineRasterizationSpecVersion = VK_KHR_LINE_RASTERIZATION_SPEC_VERSION;
|
|
|
9365
|
|
|
9366 //=== VK_KHR_calibrated_timestamps ===
|
|
|
9367 VULKAN_HPP_CONSTEXPR_INLINE auto KHRCalibratedTimestampsExtensionName = VK_KHR_CALIBRATED_TIMESTAMPS_EXTENSION_NAME;
|
|
|
9368 VULKAN_HPP_CONSTEXPR_INLINE auto KHRCalibratedTimestampsSpecVersion = VK_KHR_CALIBRATED_TIMESTAMPS_SPEC_VERSION;
|
|
|
9369
|
|
|
9370 //=== VK_KHR_shader_expect_assume ===
|
|
|
9371 VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderExpectAssumeExtensionName = VK_KHR_SHADER_EXPECT_ASSUME_EXTENSION_NAME;
|
|
|
9372 VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderExpectAssumeSpecVersion = VK_KHR_SHADER_EXPECT_ASSUME_SPEC_VERSION;
|
|
|
9373
|
|
|
9374 //=== VK_KHR_maintenance6 ===
|
|
|
9375 VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance6ExtensionName = VK_KHR_MAINTENANCE_6_EXTENSION_NAME;
|
|
|
9376 VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance6SpecVersion = VK_KHR_MAINTENANCE_6_SPEC_VERSION;
|
|
|
9377
|
|
|
9378 //=== VK_NV_descriptor_pool_overallocation ===
|
|
|
9379 VULKAN_HPP_CONSTEXPR_INLINE auto NVDescriptorPoolOverallocationExtensionName = VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_EXTENSION_NAME;
|
|
|
9380 VULKAN_HPP_CONSTEXPR_INLINE auto NVDescriptorPoolOverallocationSpecVersion = VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_SPEC_VERSION;
|
|
|
9381
|
|
|
9382 //=== VK_QCOM_tile_memory_heap ===
|
|
|
9383 VULKAN_HPP_CONSTEXPR_INLINE auto QCOMTileMemoryHeapExtensionName = VK_QCOM_TILE_MEMORY_HEAP_EXTENSION_NAME;
|
|
|
9384 VULKAN_HPP_CONSTEXPR_INLINE auto QCOMTileMemoryHeapSpecVersion = VK_QCOM_TILE_MEMORY_HEAP_SPEC_VERSION;
|
|
|
9385
|
|
|
9386 //=== VK_KHR_copy_memory_indirect ===
|
|
|
9387 VULKAN_HPP_CONSTEXPR_INLINE auto KHRCopyMemoryIndirectExtensionName = VK_KHR_COPY_MEMORY_INDIRECT_EXTENSION_NAME;
|
|
|
9388 VULKAN_HPP_CONSTEXPR_INLINE auto KHRCopyMemoryIndirectSpecVersion = VK_KHR_COPY_MEMORY_INDIRECT_SPEC_VERSION;
|
|
|
9389
|
|
|
9390 //=== VK_EXT_memory_decompression ===
|
|
|
9391 VULKAN_HPP_CONSTEXPR_INLINE auto EXTMemoryDecompressionExtensionName = VK_EXT_MEMORY_DECOMPRESSION_EXTENSION_NAME;
|
|
|
9392 VULKAN_HPP_CONSTEXPR_INLINE auto EXTMemoryDecompressionSpecVersion = VK_EXT_MEMORY_DECOMPRESSION_SPEC_VERSION;
|
|
|
9393
|
|
|
9394 //=== VK_NV_display_stereo ===
|
|
|
9395 VULKAN_HPP_CONSTEXPR_INLINE auto NVDisplayStereoExtensionName = VK_NV_DISPLAY_STEREO_EXTENSION_NAME;
|
|
|
9396 VULKAN_HPP_CONSTEXPR_INLINE auto NVDisplayStereoSpecVersion = VK_NV_DISPLAY_STEREO_SPEC_VERSION;
|
|
|
9397
|
|
|
9398 //=== VK_KHR_video_encode_intra_refresh ===
|
|
|
9399 VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoEncodeIntraRefreshExtensionName = VK_KHR_VIDEO_ENCODE_INTRA_REFRESH_EXTENSION_NAME;
|
|
|
9400 VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoEncodeIntraRefreshSpecVersion = VK_KHR_VIDEO_ENCODE_INTRA_REFRESH_SPEC_VERSION;
|
|
|
9401
|
|
|
9402 //=== VK_KHR_video_encode_quantization_map ===
|
|
|
9403 VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoEncodeQuantizationMapExtensionName = VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME;
|
|
|
9404 VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoEncodeQuantizationMapSpecVersion = VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_SPEC_VERSION;
|
|
|
9405
|
|
|
9406 //=== VK_NV_raw_access_chains ===
|
|
|
9407 VULKAN_HPP_CONSTEXPR_INLINE auto NVRawAccessChainsExtensionName = VK_NV_RAW_ACCESS_CHAINS_EXTENSION_NAME;
|
|
|
9408 VULKAN_HPP_CONSTEXPR_INLINE auto NVRawAccessChainsSpecVersion = VK_NV_RAW_ACCESS_CHAINS_SPEC_VERSION;
|
|
|
9409
|
|
|
9410 //=== VK_NV_external_compute_queue ===
|
|
|
9411 VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalComputeQueueExtensionName = VK_NV_EXTERNAL_COMPUTE_QUEUE_EXTENSION_NAME;
|
|
|
9412 VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalComputeQueueSpecVersion = VK_NV_EXTERNAL_COMPUTE_QUEUE_SPEC_VERSION;
|
|
|
9413
|
|
|
9414 //=== VK_KHR_shader_relaxed_extended_instruction ===
|
|
|
9415 VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderRelaxedExtendedInstructionExtensionName = VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_EXTENSION_NAME;
|
|
|
9416 VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderRelaxedExtendedInstructionSpecVersion = VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_SPEC_VERSION;
|
|
|
9417
|
|
|
9418 //=== VK_NV_command_buffer_inheritance ===
|
|
|
9419 VULKAN_HPP_CONSTEXPR_INLINE auto NVCommandBufferInheritanceExtensionName = VK_NV_COMMAND_BUFFER_INHERITANCE_EXTENSION_NAME;
|
|
|
9420 VULKAN_HPP_CONSTEXPR_INLINE auto NVCommandBufferInheritanceSpecVersion = VK_NV_COMMAND_BUFFER_INHERITANCE_SPEC_VERSION;
|
|
|
9421
|
|
|
9422 //=== VK_KHR_maintenance7 ===
|
|
|
9423 VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance7ExtensionName = VK_KHR_MAINTENANCE_7_EXTENSION_NAME;
|
|
|
9424 VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance7SpecVersion = VK_KHR_MAINTENANCE_7_SPEC_VERSION;
|
|
|
9425
|
|
|
9426 //=== VK_NV_shader_atomic_float16_vector ===
|
|
|
9427 VULKAN_HPP_CONSTEXPR_INLINE auto NVShaderAtomicFloat16VectorExtensionName = VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_EXTENSION_NAME;
|
|
|
9428 VULKAN_HPP_CONSTEXPR_INLINE auto NVShaderAtomicFloat16VectorSpecVersion = VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_SPEC_VERSION;
|
|
|
9429
|
|
|
9430 //=== VK_EXT_shader_replicated_composites ===
|
|
|
9431 VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderReplicatedCompositesExtensionName = VK_EXT_SHADER_REPLICATED_COMPOSITES_EXTENSION_NAME;
|
|
|
9432 VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderReplicatedCompositesSpecVersion = VK_EXT_SHADER_REPLICATED_COMPOSITES_SPEC_VERSION;
|
|
|
9433
|
|
|
9434 //=== VK_EXT_shader_float8 ===
|
|
|
9435 VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderFloat8ExtensionName = VK_EXT_SHADER_FLOAT8_EXTENSION_NAME;
|
|
|
9436 VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderFloat8SpecVersion = VK_EXT_SHADER_FLOAT8_SPEC_VERSION;
|
|
|
9437
|
|
|
9438 //=== VK_NV_ray_tracing_validation ===
|
|
|
9439 VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingValidationExtensionName = VK_NV_RAY_TRACING_VALIDATION_EXTENSION_NAME;
|
|
|
9440 VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingValidationSpecVersion = VK_NV_RAY_TRACING_VALIDATION_SPEC_VERSION;
|
|
|
9441
|
|
|
9442 //=== VK_NV_cluster_acceleration_structure ===
|
|
|
9443 VULKAN_HPP_CONSTEXPR_INLINE auto NVClusterAccelerationStructureExtensionName = VK_NV_CLUSTER_ACCELERATION_STRUCTURE_EXTENSION_NAME;
|
|
|
9444 VULKAN_HPP_CONSTEXPR_INLINE auto NVClusterAccelerationStructureSpecVersion = VK_NV_CLUSTER_ACCELERATION_STRUCTURE_SPEC_VERSION;
|
|
|
9445
|
|
|
9446 //=== VK_NV_partitioned_acceleration_structure ===
|
|
|
9447 VULKAN_HPP_CONSTEXPR_INLINE auto NVPartitionedAccelerationStructureExtensionName = VK_NV_PARTITIONED_ACCELERATION_STRUCTURE_EXTENSION_NAME;
|
|
|
9448 VULKAN_HPP_CONSTEXPR_INLINE auto NVPartitionedAccelerationStructureSpecVersion = VK_NV_PARTITIONED_ACCELERATION_STRUCTURE_SPEC_VERSION;
|
|
|
9449
|
|
|
9450 //=== VK_EXT_device_generated_commands ===
|
|
|
9451 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDeviceGeneratedCommandsExtensionName = VK_EXT_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME;
|
|
|
9452 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDeviceGeneratedCommandsSpecVersion = VK_EXT_DEVICE_GENERATED_COMMANDS_SPEC_VERSION;
|
|
|
9453
|
|
|
9454 //=== VK_KHR_maintenance8 ===
|
|
|
9455 VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance8ExtensionName = VK_KHR_MAINTENANCE_8_EXTENSION_NAME;
|
|
|
9456 VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance8SpecVersion = VK_KHR_MAINTENANCE_8_SPEC_VERSION;
|
|
|
9457
|
|
|
9458 //=== VK_MESA_image_alignment_control ===
|
|
|
9459 VULKAN_HPP_CONSTEXPR_INLINE auto MESAImageAlignmentControlExtensionName = VK_MESA_IMAGE_ALIGNMENT_CONTROL_EXTENSION_NAME;
|
|
|
9460 VULKAN_HPP_CONSTEXPR_INLINE auto MESAImageAlignmentControlSpecVersion = VK_MESA_IMAGE_ALIGNMENT_CONTROL_SPEC_VERSION;
|
|
|
9461
|
|
|
9462 //=== VK_KHR_shader_fma ===
|
|
|
9463 VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderFmaExtensionName = VK_KHR_SHADER_FMA_EXTENSION_NAME;
|
|
|
9464 VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderFmaSpecVersion = VK_KHR_SHADER_FMA_SPEC_VERSION;
|
|
|
9465
|
|
|
9466 //=== VK_EXT_ray_tracing_invocation_reorder ===
|
|
|
9467 VULKAN_HPP_CONSTEXPR_INLINE auto EXTRayTracingInvocationReorderExtensionName = VK_EXT_RAY_TRACING_INVOCATION_REORDER_EXTENSION_NAME;
|
|
|
9468 VULKAN_HPP_CONSTEXPR_INLINE auto EXTRayTracingInvocationReorderSpecVersion = VK_EXT_RAY_TRACING_INVOCATION_REORDER_SPEC_VERSION;
|
|
|
9469
|
|
|
9470 //=== VK_EXT_depth_clamp_control ===
|
|
|
9471 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthClampControlExtensionName = VK_EXT_DEPTH_CLAMP_CONTROL_EXTENSION_NAME;
|
|
|
9472 VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthClampControlSpecVersion = VK_EXT_DEPTH_CLAMP_CONTROL_SPEC_VERSION;
|
|
|
9473
|
|
|
9474 //=== VK_KHR_maintenance9 ===
|
|
|
9475 VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance9ExtensionName = VK_KHR_MAINTENANCE_9_EXTENSION_NAME;
|
|
|
9476 VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance9SpecVersion = VK_KHR_MAINTENANCE_9_SPEC_VERSION;
|
|
|
9477
|
|
|
9478 //=== VK_KHR_video_maintenance2 ===
|
|
|
9479 VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoMaintenance2ExtensionName = VK_KHR_VIDEO_MAINTENANCE_2_EXTENSION_NAME;
|
|
|
9480 VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoMaintenance2SpecVersion = VK_KHR_VIDEO_MAINTENANCE_2_SPEC_VERSION;
|
|
|
9481
|
|
|
9482 #if defined( VK_USE_PLATFORM_OHOS )
|
|
|
9483 //=== VK_OHOS_surface ===
|
|
|
9484 VULKAN_HPP_CONSTEXPR_INLINE auto OHOSSurfaceExtensionName = VK_OHOS_SURFACE_EXTENSION_NAME;
|
|
|
9485 VULKAN_HPP_CONSTEXPR_INLINE auto OHOSSurfaceSpecVersion = VK_OHOS_SURFACE_SPEC_VERSION;
|
|
|
9486 #endif /*VK_USE_PLATFORM_OHOS*/
|
|
|
9487
|
|
|
9488 #if defined( VK_USE_PLATFORM_OHOS )
|
|
|
9489 //=== VK_OHOS_native_buffer ===
|
|
|
9490 VULKAN_HPP_CONSTEXPR_INLINE auto OHOSNativeBufferExtensionName = VK_OHOS_NATIVE_BUFFER_EXTENSION_NAME;
|
|
|
9491 VULKAN_HPP_CONSTEXPR_INLINE auto OHOSNativeBufferSpecVersion = VK_OHOS_NATIVE_BUFFER_SPEC_VERSION;
|
|
|
9492 #endif /*VK_USE_PLATFORM_OHOS*/
|
|
|
9493
|
|
|
9494 //=== VK_HUAWEI_hdr_vivid ===
|
|
|
9495 VULKAN_HPP_CONSTEXPR_INLINE auto HUAWEIHdrVividExtensionName = VK_HUAWEI_HDR_VIVID_EXTENSION_NAME;
|
|
|
9496 VULKAN_HPP_CONSTEXPR_INLINE auto HUAWEIHdrVividSpecVersion = VK_HUAWEI_HDR_VIVID_SPEC_VERSION;
|
|
|
9497
|
|
|
9498 //=== VK_NV_cooperative_matrix2 ===
|
|
|
9499 VULKAN_HPP_CONSTEXPR_INLINE auto NVCooperativeMatrix2ExtensionName = VK_NV_COOPERATIVE_MATRIX_2_EXTENSION_NAME;
|
|
|
9500 VULKAN_HPP_CONSTEXPR_INLINE auto NVCooperativeMatrix2SpecVersion = VK_NV_COOPERATIVE_MATRIX_2_SPEC_VERSION;
|
|
|
9501
|
|
|
9502 //=== VK_ARM_pipeline_opacity_micromap ===
|
|
|
9503 VULKAN_HPP_CONSTEXPR_INLINE auto ARMPipelineOpacityMicromapExtensionName = VK_ARM_PIPELINE_OPACITY_MICROMAP_EXTENSION_NAME;
|
|
|
9504 VULKAN_HPP_CONSTEXPR_INLINE auto ARMPipelineOpacityMicromapSpecVersion = VK_ARM_PIPELINE_OPACITY_MICROMAP_SPEC_VERSION;
|
|
|
9505
|
|
|
9506 #if defined( VK_USE_PLATFORM_METAL_EXT )
|
|
|
9507 //=== VK_EXT_external_memory_metal ===
|
|
|
9508 VULKAN_HPP_CONSTEXPR_INLINE auto EXTExternalMemoryMetalExtensionName = VK_EXT_EXTERNAL_MEMORY_METAL_EXTENSION_NAME;
|
|
|
9509 VULKAN_HPP_CONSTEXPR_INLINE auto EXTExternalMemoryMetalSpecVersion = VK_EXT_EXTERNAL_MEMORY_METAL_SPEC_VERSION;
|
|
|
9510 #endif /*VK_USE_PLATFORM_METAL_EXT*/
|
|
|
9511
|
|
|
9512 //=== VK_KHR_depth_clamp_zero_one ===
|
|
|
9513 VULKAN_HPP_CONSTEXPR_INLINE auto KHRDepthClampZeroOneExtensionName = VK_KHR_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME;
|
|
|
9514 VULKAN_HPP_CONSTEXPR_INLINE auto KHRDepthClampZeroOneSpecVersion = VK_KHR_DEPTH_CLAMP_ZERO_ONE_SPEC_VERSION;
|
|
|
9515
|
|
|
9516 //=== VK_ARM_performance_counters_by_region ===
|
|
|
9517 VULKAN_HPP_CONSTEXPR_INLINE auto ARMPerformanceCountersByRegionExtensionName = VK_ARM_PERFORMANCE_COUNTERS_BY_REGION_EXTENSION_NAME;
|
|
|
9518 VULKAN_HPP_CONSTEXPR_INLINE auto ARMPerformanceCountersByRegionSpecVersion = VK_ARM_PERFORMANCE_COUNTERS_BY_REGION_SPEC_VERSION;
|
|
|
9519
|
|
|
9520 //=== VK_EXT_vertex_attribute_robustness ===
|
|
|
9521 VULKAN_HPP_CONSTEXPR_INLINE auto EXTVertexAttributeRobustnessExtensionName = VK_EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_EXTENSION_NAME;
|
|
|
9522 VULKAN_HPP_CONSTEXPR_INLINE auto EXTVertexAttributeRobustnessSpecVersion = VK_EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_SPEC_VERSION;
|
|
|
9523
|
|
|
9524 //=== VK_ARM_format_pack ===
|
|
|
9525 VULKAN_HPP_CONSTEXPR_INLINE auto ARMFormatPackExtensionName = VK_ARM_FORMAT_PACK_EXTENSION_NAME;
|
|
|
9526 VULKAN_HPP_CONSTEXPR_INLINE auto ARMFormatPackSpecVersion = VK_ARM_FORMAT_PACK_SPEC_VERSION;
|
|
|
9527
|
|
|
9528 //=== VK_VALVE_fragment_density_map_layered ===
|
|
|
9529 VULKAN_HPP_CONSTEXPR_INLINE auto VALVEFragmentDensityMapLayeredExtensionName = VK_VALVE_FRAGMENT_DENSITY_MAP_LAYERED_EXTENSION_NAME;
|
|
|
9530 VULKAN_HPP_CONSTEXPR_INLINE auto VALVEFragmentDensityMapLayeredSpecVersion = VK_VALVE_FRAGMENT_DENSITY_MAP_LAYERED_SPEC_VERSION;
|
|
|
9531
|
|
|
9532 //=== VK_KHR_robustness2 ===
|
|
|
9533 VULKAN_HPP_CONSTEXPR_INLINE auto KHRRobustness2ExtensionName = VK_KHR_ROBUSTNESS_2_EXTENSION_NAME;
|
|
|
9534 VULKAN_HPP_CONSTEXPR_INLINE auto KHRRobustness2SpecVersion = VK_KHR_ROBUSTNESS_2_SPEC_VERSION;
|
|
|
9535
|
|
|
9536 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
9537 //=== VK_NV_present_metering ===
|
|
|
9538 VULKAN_HPP_CONSTEXPR_INLINE auto NVPresentMeteringExtensionName = VK_NV_PRESENT_METERING_EXTENSION_NAME;
|
|
|
9539 VULKAN_HPP_CONSTEXPR_INLINE auto NVPresentMeteringSpecVersion = VK_NV_PRESENT_METERING_SPEC_VERSION;
|
|
|
9540 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
9541
|
|
|
9542 //=== VK_EXT_fragment_density_map_offset ===
|
|
|
9543 VULKAN_HPP_CONSTEXPR_INLINE auto EXTFragmentDensityMapOffsetExtensionName = VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME;
|
|
|
9544 VULKAN_HPP_CONSTEXPR_INLINE auto EXTFragmentDensityMapOffsetSpecVersion = VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION;
|
|
|
9545
|
|
|
9546 //=== VK_EXT_zero_initialize_device_memory ===
|
|
|
9547 VULKAN_HPP_CONSTEXPR_INLINE auto EXTZeroInitializeDeviceMemoryExtensionName = VK_EXT_ZERO_INITIALIZE_DEVICE_MEMORY_EXTENSION_NAME;
|
|
|
9548 VULKAN_HPP_CONSTEXPR_INLINE auto EXTZeroInitializeDeviceMemorySpecVersion = VK_EXT_ZERO_INITIALIZE_DEVICE_MEMORY_SPEC_VERSION;
|
|
|
9549
|
|
|
9550 //=== VK_KHR_present_mode_fifo_latest_ready ===
|
|
|
9551 VULKAN_HPP_CONSTEXPR_INLINE auto KHRPresentModeFifoLatestReadyExtensionName = VK_KHR_PRESENT_MODE_FIFO_LATEST_READY_EXTENSION_NAME;
|
|
|
9552 VULKAN_HPP_CONSTEXPR_INLINE auto KHRPresentModeFifoLatestReadySpecVersion = VK_KHR_PRESENT_MODE_FIFO_LATEST_READY_SPEC_VERSION;
|
|
|
9553
|
|
|
9554 //=== VK_EXT_shader_64bit_indexing ===
|
|
|
9555 VULKAN_HPP_CONSTEXPR_INLINE auto EXTShader64BitIndexingExtensionName = VK_EXT_SHADER_64BIT_INDEXING_EXTENSION_NAME;
|
|
|
9556 VULKAN_HPP_CONSTEXPR_INLINE auto EXTShader64BitIndexingSpecVersion = VK_EXT_SHADER_64BIT_INDEXING_SPEC_VERSION;
|
|
|
9557
|
|
|
9558 //=== VK_EXT_custom_resolve ===
|
|
|
9559 VULKAN_HPP_CONSTEXPR_INLINE auto EXTCustomResolveExtensionName = VK_EXT_CUSTOM_RESOLVE_EXTENSION_NAME;
|
|
|
9560 VULKAN_HPP_CONSTEXPR_INLINE auto EXTCustomResolveSpecVersion = VK_EXT_CUSTOM_RESOLVE_SPEC_VERSION;
|
|
|
9561
|
|
|
9562 //=== VK_QCOM_data_graph_model ===
|
|
|
9563 VULKAN_HPP_CONSTEXPR_INLINE auto QCOMDataGraphModelExtensionName = VK_QCOM_DATA_GRAPH_MODEL_EXTENSION_NAME;
|
|
|
9564 VULKAN_HPP_CONSTEXPR_INLINE auto QCOMDataGraphModelSpecVersion = VK_QCOM_DATA_GRAPH_MODEL_SPEC_VERSION;
|
|
|
9565
|
|
|
9566 //=== VK_KHR_maintenance10 ===
|
|
|
9567 VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance10ExtensionName = VK_KHR_MAINTENANCE_10_EXTENSION_NAME;
|
|
|
9568 VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance10SpecVersion = VK_KHR_MAINTENANCE_10_SPEC_VERSION;
|
|
|
9569
|
|
|
9570 //=== VK_SEC_pipeline_cache_incremental_mode ===
|
|
|
9571 VULKAN_HPP_CONSTEXPR_INLINE auto SECPipelineCacheIncrementalModeExtensionName = VK_SEC_PIPELINE_CACHE_INCREMENTAL_MODE_EXTENSION_NAME;
|
|
|
9572 VULKAN_HPP_CONSTEXPR_INLINE auto SECPipelineCacheIncrementalModeSpecVersion = VK_SEC_PIPELINE_CACHE_INCREMENTAL_MODE_SPEC_VERSION;
|
|
|
9573
|
|
|
9574 //=== VK_EXT_shader_uniform_buffer_unsized_array ===
|
|
|
9575 VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderUniformBufferUnsizedArrayExtensionName = VK_EXT_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_EXTENSION_NAME;
|
|
|
9576 VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderUniformBufferUnsizedArraySpecVersion = VK_EXT_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_SPEC_VERSION;
|
|
|
9577
|
|
|
9578 } // namespace VULKAN_HPP_NAMESPACE
|
|
|
9579
|
|
|
9580 // clang-format off
|
|
|
9581 #include <vulkan/vulkan_handles.hpp>
|
|
|
9582 #include <vulkan/vulkan_structs.hpp>
|
|
|
9583 #include <vulkan/vulkan_funcs.hpp>
|
|
|
9584 // clang-format on
|
|
|
9585
|
|
|
9586 namespace VULKAN_HPP_NAMESPACE
|
|
|
9587 {
|
|
|
9588 #if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
|
|
|
9589
|
|
|
9590 //=======================
|
|
|
9591 //=== STRUCTS EXTENDS ===
|
|
|
9592 //=======================
|
|
|
9593
|
|
|
9594 //=== VK_VERSION_1_0 ===
|
|
|
9595 template <>
|
|
|
9596 struct StructExtends<ShaderModuleCreateInfo, PipelineShaderStageCreateInfo>
|
|
|
9597 {
|
|
|
9598 enum
|
|
|
9599 {
|
|
|
9600 value = true
|
|
|
9601 };
|
|
|
9602 };
|
|
|
9603
|
|
|
9604 template <>
|
|
|
9605 struct StructExtends<ShaderModuleCreateInfo, DataGraphPipelineCreateInfoARM>
|
|
|
9606 {
|
|
|
9607 enum
|
|
|
9608 {
|
|
|
9609 value = true
|
|
|
9610 };
|
|
|
9611 };
|
|
|
9612
|
|
|
9613 template <>
|
|
|
9614 struct StructExtends<PipelineLayoutCreateInfo, BindDescriptorSetsInfo>
|
|
|
9615 {
|
|
|
9616 enum
|
|
|
9617 {
|
|
|
9618 value = true
|
|
|
9619 };
|
|
|
9620 };
|
|
|
9621
|
|
|
9622 template <>
|
|
|
9623 struct StructExtends<PipelineLayoutCreateInfo, PushConstantsInfo>
|
|
|
9624 {
|
|
|
9625 enum
|
|
|
9626 {
|
|
|
9627 value = true
|
|
|
9628 };
|
|
|
9629 };
|
|
|
9630
|
|
|
9631 template <>
|
|
|
9632 struct StructExtends<PipelineLayoutCreateInfo, PushDescriptorSetInfo>
|
|
|
9633 {
|
|
|
9634 enum
|
|
|
9635 {
|
|
|
9636 value = true
|
|
|
9637 };
|
|
|
9638 };
|
|
|
9639
|
|
|
9640 template <>
|
|
|
9641 struct StructExtends<PipelineLayoutCreateInfo, PushDescriptorSetWithTemplateInfo>
|
|
|
9642 {
|
|
|
9643 enum
|
|
|
9644 {
|
|
|
9645 value = true
|
|
|
9646 };
|
|
|
9647 };
|
|
|
9648
|
|
|
9649 template <>
|
|
|
9650 struct StructExtends<PipelineLayoutCreateInfo, SetDescriptorBufferOffsetsInfoEXT>
|
|
|
9651 {
|
|
|
9652 enum
|
|
|
9653 {
|
|
|
9654 value = true
|
|
|
9655 };
|
|
|
9656 };
|
|
|
9657
|
|
|
9658 template <>
|
|
|
9659 struct StructExtends<PipelineLayoutCreateInfo, BindDescriptorBufferEmbeddedSamplersInfoEXT>
|
|
|
9660 {
|
|
|
9661 enum
|
|
|
9662 {
|
|
|
9663 value = true
|
|
|
9664 };
|
|
|
9665 };
|
|
|
9666
|
|
|
9667 template <>
|
|
|
9668 struct StructExtends<PipelineLayoutCreateInfo, IndirectCommandsLayoutCreateInfoEXT>
|
|
|
9669 {
|
|
|
9670 enum
|
|
|
9671 {
|
|
|
9672 value = true
|
|
|
9673 };
|
|
|
9674 };
|
|
|
9675
|
|
|
9676 //=== VK_VERSION_1_1 ===
|
|
|
9677 template <>
|
|
|
9678 struct StructExtends<MemoryDedicatedRequirements, MemoryRequirements2>
|
|
|
9679 {
|
|
|
9680 enum
|
|
|
9681 {
|
|
|
9682 value = true
|
|
|
9683 };
|
|
|
9684 };
|
|
|
9685
|
|
|
9686 template <>
|
|
|
9687 struct StructExtends<MemoryDedicatedAllocateInfo, MemoryAllocateInfo>
|
|
|
9688 {
|
|
|
9689 enum
|
|
|
9690 {
|
|
|
9691 value = true
|
|
|
9692 };
|
|
|
9693 };
|
|
|
9694
|
|
|
9695 template <>
|
|
|
9696 struct StructExtends<MemoryAllocateFlagsInfo, MemoryAllocateInfo>
|
|
|
9697 {
|
|
|
9698 enum
|
|
|
9699 {
|
|
|
9700 value = true
|
|
|
9701 };
|
|
|
9702 };
|
|
|
9703
|
|
|
9704 template <>
|
|
|
9705 struct StructExtends<DeviceGroupCommandBufferBeginInfo, CommandBufferBeginInfo>
|
|
|
9706 {
|
|
|
9707 enum
|
|
|
9708 {
|
|
|
9709 value = true
|
|
|
9710 };
|
|
|
9711 };
|
|
|
9712
|
|
|
9713 template <>
|
|
|
9714 struct StructExtends<DeviceGroupSubmitInfo, SubmitInfo>
|
|
|
9715 {
|
|
|
9716 enum
|
|
|
9717 {
|
|
|
9718 value = true
|
|
|
9719 };
|
|
|
9720 };
|
|
|
9721
|
|
|
9722 template <>
|
|
|
9723 struct StructExtends<DeviceGroupBindSparseInfo, BindSparseInfo>
|
|
|
9724 {
|
|
|
9725 enum
|
|
|
9726 {
|
|
|
9727 value = true
|
|
|
9728 };
|
|
|
9729 };
|
|
|
9730
|
|
|
9731 template <>
|
|
|
9732 struct StructExtends<BindBufferMemoryDeviceGroupInfo, BindBufferMemoryInfo>
|
|
|
9733 {
|
|
|
9734 enum
|
|
|
9735 {
|
|
|
9736 value = true
|
|
|
9737 };
|
|
|
9738 };
|
|
|
9739
|
|
|
9740 template <>
|
|
|
9741 struct StructExtends<BindImageMemoryDeviceGroupInfo, BindImageMemoryInfo>
|
|
|
9742 {
|
|
|
9743 enum
|
|
|
9744 {
|
|
|
9745 value = true
|
|
|
9746 };
|
|
|
9747 };
|
|
|
9748
|
|
|
9749 template <>
|
|
|
9750 struct StructExtends<DeviceGroupDeviceCreateInfo, DeviceCreateInfo>
|
|
|
9751 {
|
|
|
9752 enum
|
|
|
9753 {
|
|
|
9754 value = true
|
|
|
9755 };
|
|
|
9756 };
|
|
|
9757
|
|
|
9758 template <>
|
|
|
9759 struct StructExtends<PhysicalDeviceFeatures2, DeviceCreateInfo>
|
|
|
9760 {
|
|
|
9761 enum
|
|
|
9762 {
|
|
|
9763 value = true
|
|
|
9764 };
|
|
|
9765 };
|
|
|
9766
|
|
|
9767 template <>
|
|
|
9768 struct StructExtends<ImageViewUsageCreateInfo, ImageViewCreateInfo>
|
|
|
9769 {
|
|
|
9770 enum
|
|
|
9771 {
|
|
|
9772 value = true
|
|
|
9773 };
|
|
|
9774 };
|
|
|
9775
|
|
|
9776 template <>
|
|
|
9777 struct StructExtends<PhysicalDeviceProtectedMemoryFeatures, PhysicalDeviceFeatures2>
|
|
|
9778 {
|
|
|
9779 enum
|
|
|
9780 {
|
|
|
9781 value = true
|
|
|
9782 };
|
|
|
9783 };
|
|
|
9784
|
|
|
9785 template <>
|
|
|
9786 struct StructExtends<PhysicalDeviceProtectedMemoryFeatures, DeviceCreateInfo>
|
|
|
9787 {
|
|
|
9788 enum
|
|
|
9789 {
|
|
|
9790 value = true
|
|
|
9791 };
|
|
|
9792 };
|
|
|
9793
|
|
|
9794 template <>
|
|
|
9795 struct StructExtends<PhysicalDeviceProtectedMemoryProperties, PhysicalDeviceProperties2>
|
|
|
9796 {
|
|
|
9797 enum
|
|
|
9798 {
|
|
|
9799 value = true
|
|
|
9800 };
|
|
|
9801 };
|
|
|
9802
|
|
|
9803 template <>
|
|
|
9804 struct StructExtends<ProtectedSubmitInfo, SubmitInfo>
|
|
|
9805 {
|
|
|
9806 enum
|
|
|
9807 {
|
|
|
9808 value = true
|
|
|
9809 };
|
|
|
9810 };
|
|
|
9811
|
|
|
9812 template <>
|
|
|
9813 struct StructExtends<BindImagePlaneMemoryInfo, BindImageMemoryInfo>
|
|
|
9814 {
|
|
|
9815 enum
|
|
|
9816 {
|
|
|
9817 value = true
|
|
|
9818 };
|
|
|
9819 };
|
|
|
9820
|
|
|
9821 template <>
|
|
|
9822 struct StructExtends<ImagePlaneMemoryRequirementsInfo, ImageMemoryRequirementsInfo2>
|
|
|
9823 {
|
|
|
9824 enum
|
|
|
9825 {
|
|
|
9826 value = true
|
|
|
9827 };
|
|
|
9828 };
|
|
|
9829
|
|
|
9830 template <>
|
|
|
9831 struct StructExtends<PhysicalDeviceExternalImageFormatInfo, PhysicalDeviceImageFormatInfo2>
|
|
|
9832 {
|
|
|
9833 enum
|
|
|
9834 {
|
|
|
9835 value = true
|
|
|
9836 };
|
|
|
9837 };
|
|
|
9838
|
|
|
9839 template <>
|
|
|
9840 struct StructExtends<ExternalImageFormatProperties, ImageFormatProperties2>
|
|
|
9841 {
|
|
|
9842 enum
|
|
|
9843 {
|
|
|
9844 value = true
|
|
|
9845 };
|
|
|
9846 };
|
|
|
9847
|
|
|
9848 template <>
|
|
|
9849 struct StructExtends<PhysicalDeviceIDProperties, PhysicalDeviceProperties2>
|
|
|
9850 {
|
|
|
9851 enum
|
|
|
9852 {
|
|
|
9853 value = true
|
|
|
9854 };
|
|
|
9855 };
|
|
|
9856
|
|
|
9857 template <>
|
|
|
9858 struct StructExtends<ExternalMemoryImageCreateInfo, ImageCreateInfo>
|
|
|
9859 {
|
|
|
9860 enum
|
|
|
9861 {
|
|
|
9862 value = true
|
|
|
9863 };
|
|
|
9864 };
|
|
|
9865
|
|
|
9866 template <>
|
|
|
9867 struct StructExtends<ExternalMemoryBufferCreateInfo, BufferCreateInfo>
|
|
|
9868 {
|
|
|
9869 enum
|
|
|
9870 {
|
|
|
9871 value = true
|
|
|
9872 };
|
|
|
9873 };
|
|
|
9874
|
|
|
9875 template <>
|
|
|
9876 struct StructExtends<ExportMemoryAllocateInfo, MemoryAllocateInfo>
|
|
|
9877 {
|
|
|
9878 enum
|
|
|
9879 {
|
|
|
9880 value = true
|
|
|
9881 };
|
|
|
9882 };
|
|
|
9883
|
|
|
9884 template <>
|
|
|
9885 struct StructExtends<ExportFenceCreateInfo, FenceCreateInfo>
|
|
|
9886 {
|
|
|
9887 enum
|
|
|
9888 {
|
|
|
9889 value = true
|
|
|
9890 };
|
|
|
9891 };
|
|
|
9892
|
|
|
9893 template <>
|
|
|
9894 struct StructExtends<ExportSemaphoreCreateInfo, SemaphoreCreateInfo>
|
|
|
9895 {
|
|
|
9896 enum
|
|
|
9897 {
|
|
|
9898 value = true
|
|
|
9899 };
|
|
|
9900 };
|
|
|
9901
|
|
|
9902 template <>
|
|
|
9903 struct StructExtends<PhysicalDeviceSubgroupProperties, PhysicalDeviceProperties2>
|
|
|
9904 {
|
|
|
9905 enum
|
|
|
9906 {
|
|
|
9907 value = true
|
|
|
9908 };
|
|
|
9909 };
|
|
|
9910
|
|
|
9911 template <>
|
|
|
9912 struct StructExtends<PhysicalDevice16BitStorageFeatures, PhysicalDeviceFeatures2>
|
|
|
9913 {
|
|
|
9914 enum
|
|
|
9915 {
|
|
|
9916 value = true
|
|
|
9917 };
|
|
|
9918 };
|
|
|
9919
|
|
|
9920 template <>
|
|
|
9921 struct StructExtends<PhysicalDevice16BitStorageFeatures, DeviceCreateInfo>
|
|
|
9922 {
|
|
|
9923 enum
|
|
|
9924 {
|
|
|
9925 value = true
|
|
|
9926 };
|
|
|
9927 };
|
|
|
9928
|
|
|
9929 template <>
|
|
|
9930 struct StructExtends<PhysicalDeviceVariablePointersFeatures, PhysicalDeviceFeatures2>
|
|
|
9931 {
|
|
|
9932 enum
|
|
|
9933 {
|
|
|
9934 value = true
|
|
|
9935 };
|
|
|
9936 };
|
|
|
9937
|
|
|
9938 template <>
|
|
|
9939 struct StructExtends<PhysicalDeviceVariablePointersFeatures, DeviceCreateInfo>
|
|
|
9940 {
|
|
|
9941 enum
|
|
|
9942 {
|
|
|
9943 value = true
|
|
|
9944 };
|
|
|
9945 };
|
|
|
9946
|
|
|
9947 template <>
|
|
|
9948 struct StructExtends<PhysicalDeviceMaintenance3Properties, PhysicalDeviceProperties2>
|
|
|
9949 {
|
|
|
9950 enum
|
|
|
9951 {
|
|
|
9952 value = true
|
|
|
9953 };
|
|
|
9954 };
|
|
|
9955
|
|
|
9956 template <>
|
|
|
9957 struct StructExtends<SamplerYcbcrConversionInfo, SamplerCreateInfo>
|
|
|
9958 {
|
|
|
9959 enum
|
|
|
9960 {
|
|
|
9961 value = true
|
|
|
9962 };
|
|
|
9963 };
|
|
|
9964
|
|
|
9965 template <>
|
|
|
9966 struct StructExtends<SamplerYcbcrConversionInfo, ImageViewCreateInfo>
|
|
|
9967 {
|
|
|
9968 enum
|
|
|
9969 {
|
|
|
9970 value = true
|
|
|
9971 };
|
|
|
9972 };
|
|
|
9973
|
|
|
9974 template <>
|
|
|
9975 struct StructExtends<PhysicalDeviceSamplerYcbcrConversionFeatures, PhysicalDeviceFeatures2>
|
|
|
9976 {
|
|
|
9977 enum
|
|
|
9978 {
|
|
|
9979 value = true
|
|
|
9980 };
|
|
|
9981 };
|
|
|
9982
|
|
|
9983 template <>
|
|
|
9984 struct StructExtends<PhysicalDeviceSamplerYcbcrConversionFeatures, DeviceCreateInfo>
|
|
|
9985 {
|
|
|
9986 enum
|
|
|
9987 {
|
|
|
9988 value = true
|
|
|
9989 };
|
|
|
9990 };
|
|
|
9991
|
|
|
9992 template <>
|
|
|
9993 struct StructExtends<SamplerYcbcrConversionImageFormatProperties, ImageFormatProperties2>
|
|
|
9994 {
|
|
|
9995 enum
|
|
|
9996 {
|
|
|
9997 value = true
|
|
|
9998 };
|
|
|
9999 };
|
|
|
10000
|
|
|
10001 template <>
|
|
|
10002 struct StructExtends<DeviceGroupRenderPassBeginInfo, RenderPassBeginInfo>
|
|
|
10003 {
|
|
|
10004 enum
|
|
|
10005 {
|
|
|
10006 value = true
|
|
|
10007 };
|
|
|
10008 };
|
|
|
10009
|
|
|
10010 template <>
|
|
|
10011 struct StructExtends<DeviceGroupRenderPassBeginInfo, RenderingInfo>
|
|
|
10012 {
|
|
|
10013 enum
|
|
|
10014 {
|
|
|
10015 value = true
|
|
|
10016 };
|
|
|
10017 };
|
|
|
10018
|
|
|
10019 template <>
|
|
|
10020 struct StructExtends<PhysicalDevicePointClippingProperties, PhysicalDeviceProperties2>
|
|
|
10021 {
|
|
|
10022 enum
|
|
|
10023 {
|
|
|
10024 value = true
|
|
|
10025 };
|
|
|
10026 };
|
|
|
10027
|
|
|
10028 template <>
|
|
|
10029 struct StructExtends<RenderPassInputAttachmentAspectCreateInfo, RenderPassCreateInfo>
|
|
|
10030 {
|
|
|
10031 enum
|
|
|
10032 {
|
|
|
10033 value = true
|
|
|
10034 };
|
|
|
10035 };
|
|
|
10036
|
|
|
10037 template <>
|
|
|
10038 struct StructExtends<PipelineTessellationDomainOriginStateCreateInfo, PipelineTessellationStateCreateInfo>
|
|
|
10039 {
|
|
|
10040 enum
|
|
|
10041 {
|
|
|
10042 value = true
|
|
|
10043 };
|
|
|
10044 };
|
|
|
10045
|
|
|
10046 template <>
|
|
|
10047 struct StructExtends<RenderPassMultiviewCreateInfo, RenderPassCreateInfo>
|
|
|
10048 {
|
|
|
10049 enum
|
|
|
10050 {
|
|
|
10051 value = true
|
|
|
10052 };
|
|
|
10053 };
|
|
|
10054
|
|
|
10055 template <>
|
|
|
10056 struct StructExtends<PhysicalDeviceMultiviewFeatures, PhysicalDeviceFeatures2>
|
|
|
10057 {
|
|
|
10058 enum
|
|
|
10059 {
|
|
|
10060 value = true
|
|
|
10061 };
|
|
|
10062 };
|
|
|
10063
|
|
|
10064 template <>
|
|
|
10065 struct StructExtends<PhysicalDeviceMultiviewFeatures, DeviceCreateInfo>
|
|
|
10066 {
|
|
|
10067 enum
|
|
|
10068 {
|
|
|
10069 value = true
|
|
|
10070 };
|
|
|
10071 };
|
|
|
10072
|
|
|
10073 template <>
|
|
|
10074 struct StructExtends<PhysicalDeviceMultiviewProperties, PhysicalDeviceProperties2>
|
|
|
10075 {
|
|
|
10076 enum
|
|
|
10077 {
|
|
|
10078 value = true
|
|
|
10079 };
|
|
|
10080 };
|
|
|
10081
|
|
|
10082 template <>
|
|
|
10083 struct StructExtends<PhysicalDeviceShaderDrawParametersFeatures, PhysicalDeviceFeatures2>
|
|
|
10084 {
|
|
|
10085 enum
|
|
|
10086 {
|
|
|
10087 value = true
|
|
|
10088 };
|
|
|
10089 };
|
|
|
10090
|
|
|
10091 template <>
|
|
|
10092 struct StructExtends<PhysicalDeviceShaderDrawParametersFeatures, DeviceCreateInfo>
|
|
|
10093 {
|
|
|
10094 enum
|
|
|
10095 {
|
|
|
10096 value = true
|
|
|
10097 };
|
|
|
10098 };
|
|
|
10099
|
|
|
10100 //=== VK_VERSION_1_2 ===
|
|
|
10101 template <>
|
|
|
10102 struct StructExtends<PhysicalDeviceVulkan11Features, PhysicalDeviceFeatures2>
|
|
|
10103 {
|
|
|
10104 enum
|
|
|
10105 {
|
|
|
10106 value = true
|
|
|
10107 };
|
|
|
10108 };
|
|
|
10109
|
|
|
10110 template <>
|
|
|
10111 struct StructExtends<PhysicalDeviceVulkan11Features, DeviceCreateInfo>
|
|
|
10112 {
|
|
|
10113 enum
|
|
|
10114 {
|
|
|
10115 value = true
|
|
|
10116 };
|
|
|
10117 };
|
|
|
10118
|
|
|
10119 template <>
|
|
|
10120 struct StructExtends<PhysicalDeviceVulkan11Properties, PhysicalDeviceProperties2>
|
|
|
10121 {
|
|
|
10122 enum
|
|
|
10123 {
|
|
|
10124 value = true
|
|
|
10125 };
|
|
|
10126 };
|
|
|
10127
|
|
|
10128 template <>
|
|
|
10129 struct StructExtends<PhysicalDeviceVulkan12Features, PhysicalDeviceFeatures2>
|
|
|
10130 {
|
|
|
10131 enum
|
|
|
10132 {
|
|
|
10133 value = true
|
|
|
10134 };
|
|
|
10135 };
|
|
|
10136
|
|
|
10137 template <>
|
|
|
10138 struct StructExtends<PhysicalDeviceVulkan12Features, DeviceCreateInfo>
|
|
|
10139 {
|
|
|
10140 enum
|
|
|
10141 {
|
|
|
10142 value = true
|
|
|
10143 };
|
|
|
10144 };
|
|
|
10145
|
|
|
10146 template <>
|
|
|
10147 struct StructExtends<PhysicalDeviceVulkan12Properties, PhysicalDeviceProperties2>
|
|
|
10148 {
|
|
|
10149 enum
|
|
|
10150 {
|
|
|
10151 value = true
|
|
|
10152 };
|
|
|
10153 };
|
|
|
10154
|
|
|
10155 template <>
|
|
|
10156 struct StructExtends<ImageFormatListCreateInfo, ImageCreateInfo>
|
|
|
10157 {
|
|
|
10158 enum
|
|
|
10159 {
|
|
|
10160 value = true
|
|
|
10161 };
|
|
|
10162 };
|
|
|
10163
|
|
|
10164 template <>
|
|
|
10165 struct StructExtends<ImageFormatListCreateInfo, SwapchainCreateInfoKHR>
|
|
|
10166 {
|
|
|
10167 enum
|
|
|
10168 {
|
|
|
10169 value = true
|
|
|
10170 };
|
|
|
10171 };
|
|
|
10172
|
|
|
10173 template <>
|
|
|
10174 struct StructExtends<ImageFormatListCreateInfo, PhysicalDeviceImageFormatInfo2>
|
|
|
10175 {
|
|
|
10176 enum
|
|
|
10177 {
|
|
|
10178 value = true
|
|
|
10179 };
|
|
|
10180 };
|
|
|
10181
|
|
|
10182 template <>
|
|
|
10183 struct StructExtends<PhysicalDeviceDriverProperties, PhysicalDeviceProperties2>
|
|
|
10184 {
|
|
|
10185 enum
|
|
|
10186 {
|
|
|
10187 value = true
|
|
|
10188 };
|
|
|
10189 };
|
|
|
10190
|
|
|
10191 template <>
|
|
|
10192 struct StructExtends<PhysicalDeviceVulkanMemoryModelFeatures, PhysicalDeviceFeatures2>
|
|
|
10193 {
|
|
|
10194 enum
|
|
|
10195 {
|
|
|
10196 value = true
|
|
|
10197 };
|
|
|
10198 };
|
|
|
10199
|
|
|
10200 template <>
|
|
|
10201 struct StructExtends<PhysicalDeviceVulkanMemoryModelFeatures, DeviceCreateInfo>
|
|
|
10202 {
|
|
|
10203 enum
|
|
|
10204 {
|
|
|
10205 value = true
|
|
|
10206 };
|
|
|
10207 };
|
|
|
10208
|
|
|
10209 template <>
|
|
|
10210 struct StructExtends<PhysicalDeviceHostQueryResetFeatures, PhysicalDeviceFeatures2>
|
|
|
10211 {
|
|
|
10212 enum
|
|
|
10213 {
|
|
|
10214 value = true
|
|
|
10215 };
|
|
|
10216 };
|
|
|
10217
|
|
|
10218 template <>
|
|
|
10219 struct StructExtends<PhysicalDeviceHostQueryResetFeatures, DeviceCreateInfo>
|
|
|
10220 {
|
|
|
10221 enum
|
|
|
10222 {
|
|
|
10223 value = true
|
|
|
10224 };
|
|
|
10225 };
|
|
|
10226
|
|
|
10227 template <>
|
|
|
10228 struct StructExtends<PhysicalDeviceTimelineSemaphoreFeatures, PhysicalDeviceFeatures2>
|
|
|
10229 {
|
|
|
10230 enum
|
|
|
10231 {
|
|
|
10232 value = true
|
|
|
10233 };
|
|
|
10234 };
|
|
|
10235
|
|
|
10236 template <>
|
|
|
10237 struct StructExtends<PhysicalDeviceTimelineSemaphoreFeatures, DeviceCreateInfo>
|
|
|
10238 {
|
|
|
10239 enum
|
|
|
10240 {
|
|
|
10241 value = true
|
|
|
10242 };
|
|
|
10243 };
|
|
|
10244
|
|
|
10245 template <>
|
|
|
10246 struct StructExtends<PhysicalDeviceTimelineSemaphoreProperties, PhysicalDeviceProperties2>
|
|
|
10247 {
|
|
|
10248 enum
|
|
|
10249 {
|
|
|
10250 value = true
|
|
|
10251 };
|
|
|
10252 };
|
|
|
10253
|
|
|
10254 template <>
|
|
|
10255 struct StructExtends<SemaphoreTypeCreateInfo, SemaphoreCreateInfo>
|
|
|
10256 {
|
|
|
10257 enum
|
|
|
10258 {
|
|
|
10259 value = true
|
|
|
10260 };
|
|
|
10261 };
|
|
|
10262
|
|
|
10263 template <>
|
|
|
10264 struct StructExtends<SemaphoreTypeCreateInfo, PhysicalDeviceExternalSemaphoreInfo>
|
|
|
10265 {
|
|
|
10266 enum
|
|
|
10267 {
|
|
|
10268 value = true
|
|
|
10269 };
|
|
|
10270 };
|
|
|
10271
|
|
|
10272 template <>
|
|
|
10273 struct StructExtends<TimelineSemaphoreSubmitInfo, SubmitInfo>
|
|
|
10274 {
|
|
|
10275 enum
|
|
|
10276 {
|
|
|
10277 value = true
|
|
|
10278 };
|
|
|
10279 };
|
|
|
10280
|
|
|
10281 template <>
|
|
|
10282 struct StructExtends<TimelineSemaphoreSubmitInfo, BindSparseInfo>
|
|
|
10283 {
|
|
|
10284 enum
|
|
|
10285 {
|
|
|
10286 value = true
|
|
|
10287 };
|
|
|
10288 };
|
|
|
10289
|
|
|
10290 template <>
|
|
|
10291 struct StructExtends<PhysicalDeviceBufferDeviceAddressFeatures, PhysicalDeviceFeatures2>
|
|
|
10292 {
|
|
|
10293 enum
|
|
|
10294 {
|
|
|
10295 value = true
|
|
|
10296 };
|
|
|
10297 };
|
|
|
10298
|
|
|
10299 template <>
|
|
|
10300 struct StructExtends<PhysicalDeviceBufferDeviceAddressFeatures, DeviceCreateInfo>
|
|
|
10301 {
|
|
|
10302 enum
|
|
|
10303 {
|
|
|
10304 value = true
|
|
|
10305 };
|
|
|
10306 };
|
|
|
10307
|
|
|
10308 template <>
|
|
|
10309 struct StructExtends<BufferOpaqueCaptureAddressCreateInfo, BufferCreateInfo>
|
|
|
10310 {
|
|
|
10311 enum
|
|
|
10312 {
|
|
|
10313 value = true
|
|
|
10314 };
|
|
|
10315 };
|
|
|
10316
|
|
|
10317 template <>
|
|
|
10318 struct StructExtends<MemoryOpaqueCaptureAddressAllocateInfo, MemoryAllocateInfo>
|
|
|
10319 {
|
|
|
10320 enum
|
|
|
10321 {
|
|
|
10322 value = true
|
|
|
10323 };
|
|
|
10324 };
|
|
|
10325
|
|
|
10326 template <>
|
|
|
10327 struct StructExtends<PhysicalDevice8BitStorageFeatures, PhysicalDeviceFeatures2>
|
|
|
10328 {
|
|
|
10329 enum
|
|
|
10330 {
|
|
|
10331 value = true
|
|
|
10332 };
|
|
|
10333 };
|
|
|
10334
|
|
|
10335 template <>
|
|
|
10336 struct StructExtends<PhysicalDevice8BitStorageFeatures, DeviceCreateInfo>
|
|
|
10337 {
|
|
|
10338 enum
|
|
|
10339 {
|
|
|
10340 value = true
|
|
|
10341 };
|
|
|
10342 };
|
|
|
10343
|
|
|
10344 template <>
|
|
|
10345 struct StructExtends<PhysicalDeviceShaderAtomicInt64Features, PhysicalDeviceFeatures2>
|
|
|
10346 {
|
|
|
10347 enum
|
|
|
10348 {
|
|
|
10349 value = true
|
|
|
10350 };
|
|
|
10351 };
|
|
|
10352
|
|
|
10353 template <>
|
|
|
10354 struct StructExtends<PhysicalDeviceShaderAtomicInt64Features, DeviceCreateInfo>
|
|
|
10355 {
|
|
|
10356 enum
|
|
|
10357 {
|
|
|
10358 value = true
|
|
|
10359 };
|
|
|
10360 };
|
|
|
10361
|
|
|
10362 template <>
|
|
|
10363 struct StructExtends<PhysicalDeviceShaderFloat16Int8Features, PhysicalDeviceFeatures2>
|
|
|
10364 {
|
|
|
10365 enum
|
|
|
10366 {
|
|
|
10367 value = true
|
|
|
10368 };
|
|
|
10369 };
|
|
|
10370
|
|
|
10371 template <>
|
|
|
10372 struct StructExtends<PhysicalDeviceShaderFloat16Int8Features, DeviceCreateInfo>
|
|
|
10373 {
|
|
|
10374 enum
|
|
|
10375 {
|
|
|
10376 value = true
|
|
|
10377 };
|
|
|
10378 };
|
|
|
10379
|
|
|
10380 template <>
|
|
|
10381 struct StructExtends<PhysicalDeviceFloatControlsProperties, PhysicalDeviceProperties2>
|
|
|
10382 {
|
|
|
10383 enum
|
|
|
10384 {
|
|
|
10385 value = true
|
|
|
10386 };
|
|
|
10387 };
|
|
|
10388
|
|
|
10389 template <>
|
|
|
10390 struct StructExtends<DescriptorSetLayoutBindingFlagsCreateInfo, DescriptorSetLayoutCreateInfo>
|
|
|
10391 {
|
|
|
10392 enum
|
|
|
10393 {
|
|
|
10394 value = true
|
|
|
10395 };
|
|
|
10396 };
|
|
|
10397
|
|
|
10398 template <>
|
|
|
10399 struct StructExtends<PhysicalDeviceDescriptorIndexingFeatures, PhysicalDeviceFeatures2>
|
|
|
10400 {
|
|
|
10401 enum
|
|
|
10402 {
|
|
|
10403 value = true
|
|
|
10404 };
|
|
|
10405 };
|
|
|
10406
|
|
|
10407 template <>
|
|
|
10408 struct StructExtends<PhysicalDeviceDescriptorIndexingFeatures, DeviceCreateInfo>
|
|
|
10409 {
|
|
|
10410 enum
|
|
|
10411 {
|
|
|
10412 value = true
|
|
|
10413 };
|
|
|
10414 };
|
|
|
10415
|
|
|
10416 template <>
|
|
|
10417 struct StructExtends<PhysicalDeviceDescriptorIndexingProperties, PhysicalDeviceProperties2>
|
|
|
10418 {
|
|
|
10419 enum
|
|
|
10420 {
|
|
|
10421 value = true
|
|
|
10422 };
|
|
|
10423 };
|
|
|
10424
|
|
|
10425 template <>
|
|
|
10426 struct StructExtends<DescriptorSetVariableDescriptorCountAllocateInfo, DescriptorSetAllocateInfo>
|
|
|
10427 {
|
|
|
10428 enum
|
|
|
10429 {
|
|
|
10430 value = true
|
|
|
10431 };
|
|
|
10432 };
|
|
|
10433
|
|
|
10434 template <>
|
|
|
10435 struct StructExtends<DescriptorSetVariableDescriptorCountLayoutSupport, DescriptorSetLayoutSupport>
|
|
|
10436 {
|
|
|
10437 enum
|
|
|
10438 {
|
|
|
10439 value = true
|
|
|
10440 };
|
|
|
10441 };
|
|
|
10442
|
|
|
10443 template <>
|
|
|
10444 struct StructExtends<PhysicalDeviceScalarBlockLayoutFeatures, PhysicalDeviceFeatures2>
|
|
|
10445 {
|
|
|
10446 enum
|
|
|
10447 {
|
|
|
10448 value = true
|
|
|
10449 };
|
|
|
10450 };
|
|
|
10451
|
|
|
10452 template <>
|
|
|
10453 struct StructExtends<PhysicalDeviceScalarBlockLayoutFeatures, DeviceCreateInfo>
|
|
|
10454 {
|
|
|
10455 enum
|
|
|
10456 {
|
|
|
10457 value = true
|
|
|
10458 };
|
|
|
10459 };
|
|
|
10460
|
|
|
10461 template <>
|
|
|
10462 struct StructExtends<SamplerReductionModeCreateInfo, SamplerCreateInfo>
|
|
|
10463 {
|
|
|
10464 enum
|
|
|
10465 {
|
|
|
10466 value = true
|
|
|
10467 };
|
|
|
10468 };
|
|
|
10469
|
|
|
10470 template <>
|
|
|
10471 struct StructExtends<PhysicalDeviceSamplerFilterMinmaxProperties, PhysicalDeviceProperties2>
|
|
|
10472 {
|
|
|
10473 enum
|
|
|
10474 {
|
|
|
10475 value = true
|
|
|
10476 };
|
|
|
10477 };
|
|
|
10478
|
|
|
10479 template <>
|
|
|
10480 struct StructExtends<PhysicalDeviceUniformBufferStandardLayoutFeatures, PhysicalDeviceFeatures2>
|
|
|
10481 {
|
|
|
10482 enum
|
|
|
10483 {
|
|
|
10484 value = true
|
|
|
10485 };
|
|
|
10486 };
|
|
|
10487
|
|
|
10488 template <>
|
|
|
10489 struct StructExtends<PhysicalDeviceUniformBufferStandardLayoutFeatures, DeviceCreateInfo>
|
|
|
10490 {
|
|
|
10491 enum
|
|
|
10492 {
|
|
|
10493 value = true
|
|
|
10494 };
|
|
|
10495 };
|
|
|
10496
|
|
|
10497 template <>
|
|
|
10498 struct StructExtends<PhysicalDeviceShaderSubgroupExtendedTypesFeatures, PhysicalDeviceFeatures2>
|
|
|
10499 {
|
|
|
10500 enum
|
|
|
10501 {
|
|
|
10502 value = true
|
|
|
10503 };
|
|
|
10504 };
|
|
|
10505
|
|
|
10506 template <>
|
|
|
10507 struct StructExtends<PhysicalDeviceShaderSubgroupExtendedTypesFeatures, DeviceCreateInfo>
|
|
|
10508 {
|
|
|
10509 enum
|
|
|
10510 {
|
|
|
10511 value = true
|
|
|
10512 };
|
|
|
10513 };
|
|
|
10514
|
|
|
10515 template <>
|
|
|
10516 struct StructExtends<SubpassDescriptionDepthStencilResolve, SubpassDescription2>
|
|
|
10517 {
|
|
|
10518 enum
|
|
|
10519 {
|
|
|
10520 value = true
|
|
|
10521 };
|
|
|
10522 };
|
|
|
10523
|
|
|
10524 template <>
|
|
|
10525 struct StructExtends<PhysicalDeviceDepthStencilResolveProperties, PhysicalDeviceProperties2>
|
|
|
10526 {
|
|
|
10527 enum
|
|
|
10528 {
|
|
|
10529 value = true
|
|
|
10530 };
|
|
|
10531 };
|
|
|
10532
|
|
|
10533 template <>
|
|
|
10534 struct StructExtends<ImageStencilUsageCreateInfo, ImageCreateInfo>
|
|
|
10535 {
|
|
|
10536 enum
|
|
|
10537 {
|
|
|
10538 value = true
|
|
|
10539 };
|
|
|
10540 };
|
|
|
10541
|
|
|
10542 template <>
|
|
|
10543 struct StructExtends<ImageStencilUsageCreateInfo, PhysicalDeviceImageFormatInfo2>
|
|
|
10544 {
|
|
|
10545 enum
|
|
|
10546 {
|
|
|
10547 value = true
|
|
|
10548 };
|
|
|
10549 };
|
|
|
10550
|
|
|
10551 template <>
|
|
|
10552 struct StructExtends<PhysicalDeviceImagelessFramebufferFeatures, PhysicalDeviceFeatures2>
|
|
|
10553 {
|
|
|
10554 enum
|
|
|
10555 {
|
|
|
10556 value = true
|
|
|
10557 };
|
|
|
10558 };
|
|
|
10559
|
|
|
10560 template <>
|
|
|
10561 struct StructExtends<PhysicalDeviceImagelessFramebufferFeatures, DeviceCreateInfo>
|
|
|
10562 {
|
|
|
10563 enum
|
|
|
10564 {
|
|
|
10565 value = true
|
|
|
10566 };
|
|
|
10567 };
|
|
|
10568
|
|
|
10569 template <>
|
|
|
10570 struct StructExtends<FramebufferAttachmentsCreateInfo, FramebufferCreateInfo>
|
|
|
10571 {
|
|
|
10572 enum
|
|
|
10573 {
|
|
|
10574 value = true
|
|
|
10575 };
|
|
|
10576 };
|
|
|
10577
|
|
|
10578 template <>
|
|
|
10579 struct StructExtends<RenderPassAttachmentBeginInfo, RenderPassBeginInfo>
|
|
|
10580 {
|
|
|
10581 enum
|
|
|
10582 {
|
|
|
10583 value = true
|
|
|
10584 };
|
|
|
10585 };
|
|
|
10586
|
|
|
10587 template <>
|
|
|
10588 struct StructExtends<PhysicalDeviceSeparateDepthStencilLayoutsFeatures, PhysicalDeviceFeatures2>
|
|
|
10589 {
|
|
|
10590 enum
|
|
|
10591 {
|
|
|
10592 value = true
|
|
|
10593 };
|
|
|
10594 };
|
|
|
10595
|
|
|
10596 template <>
|
|
|
10597 struct StructExtends<PhysicalDeviceSeparateDepthStencilLayoutsFeatures, DeviceCreateInfo>
|
|
|
10598 {
|
|
|
10599 enum
|
|
|
10600 {
|
|
|
10601 value = true
|
|
|
10602 };
|
|
|
10603 };
|
|
|
10604
|
|
|
10605 template <>
|
|
|
10606 struct StructExtends<AttachmentReferenceStencilLayout, AttachmentReference2>
|
|
|
10607 {
|
|
|
10608 enum
|
|
|
10609 {
|
|
|
10610 value = true
|
|
|
10611 };
|
|
|
10612 };
|
|
|
10613
|
|
|
10614 template <>
|
|
|
10615 struct StructExtends<AttachmentDescriptionStencilLayout, AttachmentDescription2>
|
|
|
10616 {
|
|
|
10617 enum
|
|
|
10618 {
|
|
|
10619 value = true
|
|
|
10620 };
|
|
|
10621 };
|
|
|
10622
|
|
|
10623 //=== VK_VERSION_1_3 ===
|
|
|
10624 template <>
|
|
|
10625 struct StructExtends<PhysicalDeviceVulkan13Features, PhysicalDeviceFeatures2>
|
|
|
10626 {
|
|
|
10627 enum
|
|
|
10628 {
|
|
|
10629 value = true
|
|
|
10630 };
|
|
|
10631 };
|
|
|
10632
|
|
|
10633 template <>
|
|
|
10634 struct StructExtends<PhysicalDeviceVulkan13Features, DeviceCreateInfo>
|
|
|
10635 {
|
|
|
10636 enum
|
|
|
10637 {
|
|
|
10638 value = true
|
|
|
10639 };
|
|
|
10640 };
|
|
|
10641
|
|
|
10642 template <>
|
|
|
10643 struct StructExtends<PhysicalDeviceVulkan13Properties, PhysicalDeviceProperties2>
|
|
|
10644 {
|
|
|
10645 enum
|
|
|
10646 {
|
|
|
10647 value = true
|
|
|
10648 };
|
|
|
10649 };
|
|
|
10650
|
|
|
10651 template <>
|
|
|
10652 struct StructExtends<PhysicalDevicePrivateDataFeatures, PhysicalDeviceFeatures2>
|
|
|
10653 {
|
|
|
10654 enum
|
|
|
10655 {
|
|
|
10656 value = true
|
|
|
10657 };
|
|
|
10658 };
|
|
|
10659
|
|
|
10660 template <>
|
|
|
10661 struct StructExtends<PhysicalDevicePrivateDataFeatures, DeviceCreateInfo>
|
|
|
10662 {
|
|
|
10663 enum
|
|
|
10664 {
|
|
|
10665 value = true
|
|
|
10666 };
|
|
|
10667 };
|
|
|
10668
|
|
|
10669 template <>
|
|
|
10670 struct StructExtends<DevicePrivateDataCreateInfo, DeviceCreateInfo>
|
|
|
10671 {
|
|
|
10672 enum
|
|
|
10673 {
|
|
|
10674 value = true
|
|
|
10675 };
|
|
|
10676 };
|
|
|
10677
|
|
|
10678 template <>
|
|
|
10679 struct StructExtends<MemoryBarrier2, SubpassDependency2>
|
|
|
10680 {
|
|
|
10681 enum
|
|
|
10682 {
|
|
|
10683 value = true
|
|
|
10684 };
|
|
|
10685 };
|
|
|
10686
|
|
|
10687 template <>
|
|
|
10688 struct StructExtends<PhysicalDeviceSynchronization2Features, PhysicalDeviceFeatures2>
|
|
|
10689 {
|
|
|
10690 enum
|
|
|
10691 {
|
|
|
10692 value = true
|
|
|
10693 };
|
|
|
10694 };
|
|
|
10695
|
|
|
10696 template <>
|
|
|
10697 struct StructExtends<PhysicalDeviceSynchronization2Features, DeviceCreateInfo>
|
|
|
10698 {
|
|
|
10699 enum
|
|
|
10700 {
|
|
|
10701 value = true
|
|
|
10702 };
|
|
|
10703 };
|
|
|
10704
|
|
|
10705 template <>
|
|
|
10706 struct StructExtends<PhysicalDeviceTextureCompressionASTCHDRFeatures, PhysicalDeviceFeatures2>
|
|
|
10707 {
|
|
|
10708 enum
|
|
|
10709 {
|
|
|
10710 value = true
|
|
|
10711 };
|
|
|
10712 };
|
|
|
10713
|
|
|
10714 template <>
|
|
|
10715 struct StructExtends<PhysicalDeviceTextureCompressionASTCHDRFeatures, DeviceCreateInfo>
|
|
|
10716 {
|
|
|
10717 enum
|
|
|
10718 {
|
|
|
10719 value = true
|
|
|
10720 };
|
|
|
10721 };
|
|
|
10722
|
|
|
10723 template <>
|
|
|
10724 struct StructExtends<FormatProperties3, FormatProperties2>
|
|
|
10725 {
|
|
|
10726 enum
|
|
|
10727 {
|
|
|
10728 value = true
|
|
|
10729 };
|
|
|
10730 };
|
|
|
10731
|
|
|
10732 template <>
|
|
|
10733 struct StructExtends<PhysicalDeviceMaintenance4Features, PhysicalDeviceFeatures2>
|
|
|
10734 {
|
|
|
10735 enum
|
|
|
10736 {
|
|
|
10737 value = true
|
|
|
10738 };
|
|
|
10739 };
|
|
|
10740
|
|
|
10741 template <>
|
|
|
10742 struct StructExtends<PhysicalDeviceMaintenance4Features, DeviceCreateInfo>
|
|
|
10743 {
|
|
|
10744 enum
|
|
|
10745 {
|
|
|
10746 value = true
|
|
|
10747 };
|
|
|
10748 };
|
|
|
10749
|
|
|
10750 template <>
|
|
|
10751 struct StructExtends<PhysicalDeviceMaintenance4Properties, PhysicalDeviceProperties2>
|
|
|
10752 {
|
|
|
10753 enum
|
|
|
10754 {
|
|
|
10755 value = true
|
|
|
10756 };
|
|
|
10757 };
|
|
|
10758
|
|
|
10759 template <>
|
|
|
10760 struct StructExtends<PipelineCreationFeedbackCreateInfo, GraphicsPipelineCreateInfo>
|
|
|
10761 {
|
|
|
10762 enum
|
|
|
10763 {
|
|
|
10764 value = true
|
|
|
10765 };
|
|
|
10766 };
|
|
|
10767
|
|
|
10768 template <>
|
|
|
10769 struct StructExtends<PipelineCreationFeedbackCreateInfo, ComputePipelineCreateInfo>
|
|
|
10770 {
|
|
|
10771 enum
|
|
|
10772 {
|
|
|
10773 value = true
|
|
|
10774 };
|
|
|
10775 };
|
|
|
10776
|
|
|
10777 template <>
|
|
|
10778 struct StructExtends<PipelineCreationFeedbackCreateInfo, RayTracingPipelineCreateInfoNV>
|
|
|
10779 {
|
|
|
10780 enum
|
|
|
10781 {
|
|
|
10782 value = true
|
|
|
10783 };
|
|
|
10784 };
|
|
|
10785
|
|
|
10786 template <>
|
|
|
10787 struct StructExtends<PipelineCreationFeedbackCreateInfo, RayTracingPipelineCreateInfoKHR>
|
|
|
10788 {
|
|
|
10789 enum
|
|
|
10790 {
|
|
|
10791 value = true
|
|
|
10792 };
|
|
|
10793 };
|
|
|
10794 # if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
10795 template <>
|
|
|
10796 struct StructExtends<PipelineCreationFeedbackCreateInfo, ExecutionGraphPipelineCreateInfoAMDX>
|
|
|
10797 {
|
|
|
10798 enum
|
|
|
10799 {
|
|
|
10800 value = true
|
|
|
10801 };
|
|
|
10802 };
|
|
|
10803 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
10804 template <>
|
|
|
10805 struct StructExtends<PipelineCreationFeedbackCreateInfo, DataGraphPipelineCreateInfoARM>
|
|
|
10806 {
|
|
|
10807 enum
|
|
|
10808 {
|
|
|
10809 value = true
|
|
|
10810 };
|
|
|
10811 };
|
|
|
10812
|
|
|
10813 template <>
|
|
|
10814 struct StructExtends<PhysicalDeviceShaderTerminateInvocationFeatures, PhysicalDeviceFeatures2>
|
|
|
10815 {
|
|
|
10816 enum
|
|
|
10817 {
|
|
|
10818 value = true
|
|
|
10819 };
|
|
|
10820 };
|
|
|
10821
|
|
|
10822 template <>
|
|
|
10823 struct StructExtends<PhysicalDeviceShaderTerminateInvocationFeatures, DeviceCreateInfo>
|
|
|
10824 {
|
|
|
10825 enum
|
|
|
10826 {
|
|
|
10827 value = true
|
|
|
10828 };
|
|
|
10829 };
|
|
|
10830
|
|
|
10831 template <>
|
|
|
10832 struct StructExtends<PhysicalDeviceShaderDemoteToHelperInvocationFeatures, PhysicalDeviceFeatures2>
|
|
|
10833 {
|
|
|
10834 enum
|
|
|
10835 {
|
|
|
10836 value = true
|
|
|
10837 };
|
|
|
10838 };
|
|
|
10839
|
|
|
10840 template <>
|
|
|
10841 struct StructExtends<PhysicalDeviceShaderDemoteToHelperInvocationFeatures, DeviceCreateInfo>
|
|
|
10842 {
|
|
|
10843 enum
|
|
|
10844 {
|
|
|
10845 value = true
|
|
|
10846 };
|
|
|
10847 };
|
|
|
10848
|
|
|
10849 template <>
|
|
|
10850 struct StructExtends<PhysicalDevicePipelineCreationCacheControlFeatures, PhysicalDeviceFeatures2>
|
|
|
10851 {
|
|
|
10852 enum
|
|
|
10853 {
|
|
|
10854 value = true
|
|
|
10855 };
|
|
|
10856 };
|
|
|
10857
|
|
|
10858 template <>
|
|
|
10859 struct StructExtends<PhysicalDevicePipelineCreationCacheControlFeatures, DeviceCreateInfo>
|
|
|
10860 {
|
|
|
10861 enum
|
|
|
10862 {
|
|
|
10863 value = true
|
|
|
10864 };
|
|
|
10865 };
|
|
|
10866
|
|
|
10867 template <>
|
|
|
10868 struct StructExtends<PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures, PhysicalDeviceFeatures2>
|
|
|
10869 {
|
|
|
10870 enum
|
|
|
10871 {
|
|
|
10872 value = true
|
|
|
10873 };
|
|
|
10874 };
|
|
|
10875
|
|
|
10876 template <>
|
|
|
10877 struct StructExtends<PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures, DeviceCreateInfo>
|
|
|
10878 {
|
|
|
10879 enum
|
|
|
10880 {
|
|
|
10881 value = true
|
|
|
10882 };
|
|
|
10883 };
|
|
|
10884
|
|
|
10885 template <>
|
|
|
10886 struct StructExtends<PhysicalDeviceImageRobustnessFeatures, PhysicalDeviceFeatures2>
|
|
|
10887 {
|
|
|
10888 enum
|
|
|
10889 {
|
|
|
10890 value = true
|
|
|
10891 };
|
|
|
10892 };
|
|
|
10893
|
|
|
10894 template <>
|
|
|
10895 struct StructExtends<PhysicalDeviceImageRobustnessFeatures, DeviceCreateInfo>
|
|
|
10896 {
|
|
|
10897 enum
|
|
|
10898 {
|
|
|
10899 value = true
|
|
|
10900 };
|
|
|
10901 };
|
|
|
10902
|
|
|
10903 template <>
|
|
|
10904 struct StructExtends<PhysicalDeviceSubgroupSizeControlFeatures, PhysicalDeviceFeatures2>
|
|
|
10905 {
|
|
|
10906 enum
|
|
|
10907 {
|
|
|
10908 value = true
|
|
|
10909 };
|
|
|
10910 };
|
|
|
10911
|
|
|
10912 template <>
|
|
|
10913 struct StructExtends<PhysicalDeviceSubgroupSizeControlFeatures, DeviceCreateInfo>
|
|
|
10914 {
|
|
|
10915 enum
|
|
|
10916 {
|
|
|
10917 value = true
|
|
|
10918 };
|
|
|
10919 };
|
|
|
10920
|
|
|
10921 template <>
|
|
|
10922 struct StructExtends<PhysicalDeviceSubgroupSizeControlProperties, PhysicalDeviceProperties2>
|
|
|
10923 {
|
|
|
10924 enum
|
|
|
10925 {
|
|
|
10926 value = true
|
|
|
10927 };
|
|
|
10928 };
|
|
|
10929
|
|
|
10930 template <>
|
|
|
10931 struct StructExtends<PipelineShaderStageRequiredSubgroupSizeCreateInfo, PipelineShaderStageCreateInfo>
|
|
|
10932 {
|
|
|
10933 enum
|
|
|
10934 {
|
|
|
10935 value = true
|
|
|
10936 };
|
|
|
10937 };
|
|
|
10938
|
|
|
10939 template <>
|
|
|
10940 struct StructExtends<PipelineShaderStageRequiredSubgroupSizeCreateInfo, ShaderCreateInfoEXT>
|
|
|
10941 {
|
|
|
10942 enum
|
|
|
10943 {
|
|
|
10944 value = true
|
|
|
10945 };
|
|
|
10946 };
|
|
|
10947
|
|
|
10948 template <>
|
|
|
10949 struct StructExtends<PhysicalDeviceInlineUniformBlockFeatures, PhysicalDeviceFeatures2>
|
|
|
10950 {
|
|
|
10951 enum
|
|
|
10952 {
|
|
|
10953 value = true
|
|
|
10954 };
|
|
|
10955 };
|
|
|
10956
|
|
|
10957 template <>
|
|
|
10958 struct StructExtends<PhysicalDeviceInlineUniformBlockFeatures, DeviceCreateInfo>
|
|
|
10959 {
|
|
|
10960 enum
|
|
|
10961 {
|
|
|
10962 value = true
|
|
|
10963 };
|
|
|
10964 };
|
|
|
10965
|
|
|
10966 template <>
|
|
|
10967 struct StructExtends<PhysicalDeviceInlineUniformBlockProperties, PhysicalDeviceProperties2>
|
|
|
10968 {
|
|
|
10969 enum
|
|
|
10970 {
|
|
|
10971 value = true
|
|
|
10972 };
|
|
|
10973 };
|
|
|
10974
|
|
|
10975 template <>
|
|
|
10976 struct StructExtends<WriteDescriptorSetInlineUniformBlock, WriteDescriptorSet>
|
|
|
10977 {
|
|
|
10978 enum
|
|
|
10979 {
|
|
|
10980 value = true
|
|
|
10981 };
|
|
|
10982 };
|
|
|
10983
|
|
|
10984 template <>
|
|
|
10985 struct StructExtends<DescriptorPoolInlineUniformBlockCreateInfo, DescriptorPoolCreateInfo>
|
|
|
10986 {
|
|
|
10987 enum
|
|
|
10988 {
|
|
|
10989 value = true
|
|
|
10990 };
|
|
|
10991 };
|
|
|
10992
|
|
|
10993 template <>
|
|
|
10994 struct StructExtends<PhysicalDeviceShaderIntegerDotProductFeatures, PhysicalDeviceFeatures2>
|
|
|
10995 {
|
|
|
10996 enum
|
|
|
10997 {
|
|
|
10998 value = true
|
|
|
10999 };
|
|
|
11000 };
|
|
|
11001
|
|
|
11002 template <>
|
|
|
11003 struct StructExtends<PhysicalDeviceShaderIntegerDotProductFeatures, DeviceCreateInfo>
|
|
|
11004 {
|
|
|
11005 enum
|
|
|
11006 {
|
|
|
11007 value = true
|
|
|
11008 };
|
|
|
11009 };
|
|
|
11010
|
|
|
11011 template <>
|
|
|
11012 struct StructExtends<PhysicalDeviceShaderIntegerDotProductProperties, PhysicalDeviceProperties2>
|
|
|
11013 {
|
|
|
11014 enum
|
|
|
11015 {
|
|
|
11016 value = true
|
|
|
11017 };
|
|
|
11018 };
|
|
|
11019
|
|
|
11020 template <>
|
|
|
11021 struct StructExtends<PhysicalDeviceTexelBufferAlignmentProperties, PhysicalDeviceProperties2>
|
|
|
11022 {
|
|
|
11023 enum
|
|
|
11024 {
|
|
|
11025 value = true
|
|
|
11026 };
|
|
|
11027 };
|
|
|
11028
|
|
|
11029 template <>
|
|
|
11030 struct StructExtends<PipelineRenderingCreateInfo, GraphicsPipelineCreateInfo>
|
|
|
11031 {
|
|
|
11032 enum
|
|
|
11033 {
|
|
|
11034 value = true
|
|
|
11035 };
|
|
|
11036 };
|
|
|
11037
|
|
|
11038 template <>
|
|
|
11039 struct StructExtends<PhysicalDeviceDynamicRenderingFeatures, PhysicalDeviceFeatures2>
|
|
|
11040 {
|
|
|
11041 enum
|
|
|
11042 {
|
|
|
11043 value = true
|
|
|
11044 };
|
|
|
11045 };
|
|
|
11046
|
|
|
11047 template <>
|
|
|
11048 struct StructExtends<PhysicalDeviceDynamicRenderingFeatures, DeviceCreateInfo>
|
|
|
11049 {
|
|
|
11050 enum
|
|
|
11051 {
|
|
|
11052 value = true
|
|
|
11053 };
|
|
|
11054 };
|
|
|
11055
|
|
|
11056 template <>
|
|
|
11057 struct StructExtends<CommandBufferInheritanceRenderingInfo, CommandBufferInheritanceInfo>
|
|
|
11058 {
|
|
|
11059 enum
|
|
|
11060 {
|
|
|
11061 value = true
|
|
|
11062 };
|
|
|
11063 };
|
|
|
11064
|
|
|
11065 //=== VK_VERSION_1_4 ===
|
|
|
11066 template <>
|
|
|
11067 struct StructExtends<PhysicalDeviceVulkan14Features, PhysicalDeviceFeatures2>
|
|
|
11068 {
|
|
|
11069 enum
|
|
|
11070 {
|
|
|
11071 value = true
|
|
|
11072 };
|
|
|
11073 };
|
|
|
11074
|
|
|
11075 template <>
|
|
|
11076 struct StructExtends<PhysicalDeviceVulkan14Features, DeviceCreateInfo>
|
|
|
11077 {
|
|
|
11078 enum
|
|
|
11079 {
|
|
|
11080 value = true
|
|
|
11081 };
|
|
|
11082 };
|
|
|
11083
|
|
|
11084 template <>
|
|
|
11085 struct StructExtends<PhysicalDeviceVulkan14Properties, PhysicalDeviceProperties2>
|
|
|
11086 {
|
|
|
11087 enum
|
|
|
11088 {
|
|
|
11089 value = true
|
|
|
11090 };
|
|
|
11091 };
|
|
|
11092
|
|
|
11093 template <>
|
|
|
11094 struct StructExtends<DeviceQueueGlobalPriorityCreateInfo, DeviceQueueCreateInfo>
|
|
|
11095 {
|
|
|
11096 enum
|
|
|
11097 {
|
|
|
11098 value = true
|
|
|
11099 };
|
|
|
11100 };
|
|
|
11101
|
|
|
11102 template <>
|
|
|
11103 struct StructExtends<PhysicalDeviceGlobalPriorityQueryFeatures, PhysicalDeviceFeatures2>
|
|
|
11104 {
|
|
|
11105 enum
|
|
|
11106 {
|
|
|
11107 value = true
|
|
|
11108 };
|
|
|
11109 };
|
|
|
11110
|
|
|
11111 template <>
|
|
|
11112 struct StructExtends<PhysicalDeviceGlobalPriorityQueryFeatures, DeviceCreateInfo>
|
|
|
11113 {
|
|
|
11114 enum
|
|
|
11115 {
|
|
|
11116 value = true
|
|
|
11117 };
|
|
|
11118 };
|
|
|
11119
|
|
|
11120 template <>
|
|
|
11121 struct StructExtends<QueueFamilyGlobalPriorityProperties, QueueFamilyProperties2>
|
|
|
11122 {
|
|
|
11123 enum
|
|
|
11124 {
|
|
|
11125 value = true
|
|
|
11126 };
|
|
|
11127 };
|
|
|
11128
|
|
|
11129 template <>
|
|
|
11130 struct StructExtends<PhysicalDeviceIndexTypeUint8Features, PhysicalDeviceFeatures2>
|
|
|
11131 {
|
|
|
11132 enum
|
|
|
11133 {
|
|
|
11134 value = true
|
|
|
11135 };
|
|
|
11136 };
|
|
|
11137
|
|
|
11138 template <>
|
|
|
11139 struct StructExtends<PhysicalDeviceIndexTypeUint8Features, DeviceCreateInfo>
|
|
|
11140 {
|
|
|
11141 enum
|
|
|
11142 {
|
|
|
11143 value = true
|
|
|
11144 };
|
|
|
11145 };
|
|
|
11146
|
|
|
11147 template <>
|
|
|
11148 struct StructExtends<PhysicalDeviceMaintenance5Features, PhysicalDeviceFeatures2>
|
|
|
11149 {
|
|
|
11150 enum
|
|
|
11151 {
|
|
|
11152 value = true
|
|
|
11153 };
|
|
|
11154 };
|
|
|
11155
|
|
|
11156 template <>
|
|
|
11157 struct StructExtends<PhysicalDeviceMaintenance5Features, DeviceCreateInfo>
|
|
|
11158 {
|
|
|
11159 enum
|
|
|
11160 {
|
|
|
11161 value = true
|
|
|
11162 };
|
|
|
11163 };
|
|
|
11164
|
|
|
11165 template <>
|
|
|
11166 struct StructExtends<PhysicalDeviceMaintenance5Properties, PhysicalDeviceProperties2>
|
|
|
11167 {
|
|
|
11168 enum
|
|
|
11169 {
|
|
|
11170 value = true
|
|
|
11171 };
|
|
|
11172 };
|
|
|
11173
|
|
|
11174 template <>
|
|
|
11175 struct StructExtends<BufferUsageFlags2CreateInfo, BufferViewCreateInfo>
|
|
|
11176 {
|
|
|
11177 enum
|
|
|
11178 {
|
|
|
11179 value = true
|
|
|
11180 };
|
|
|
11181 };
|
|
|
11182
|
|
|
11183 template <>
|
|
|
11184 struct StructExtends<BufferUsageFlags2CreateInfo, BufferCreateInfo>
|
|
|
11185 {
|
|
|
11186 enum
|
|
|
11187 {
|
|
|
11188 value = true
|
|
|
11189 };
|
|
|
11190 };
|
|
|
11191
|
|
|
11192 template <>
|
|
|
11193 struct StructExtends<BufferUsageFlags2CreateInfo, PhysicalDeviceExternalBufferInfo>
|
|
|
11194 {
|
|
|
11195 enum
|
|
|
11196 {
|
|
|
11197 value = true
|
|
|
11198 };
|
|
|
11199 };
|
|
|
11200
|
|
|
11201 template <>
|
|
|
11202 struct StructExtends<BufferUsageFlags2CreateInfo, DescriptorBufferBindingInfoEXT>
|
|
|
11203 {
|
|
|
11204 enum
|
|
|
11205 {
|
|
|
11206 value = true
|
|
|
11207 };
|
|
|
11208 };
|
|
|
11209
|
|
|
11210 template <>
|
|
|
11211 struct StructExtends<PhysicalDeviceMaintenance6Features, PhysicalDeviceFeatures2>
|
|
|
11212 {
|
|
|
11213 enum
|
|
|
11214 {
|
|
|
11215 value = true
|
|
|
11216 };
|
|
|
11217 };
|
|
|
11218
|
|
|
11219 template <>
|
|
|
11220 struct StructExtends<PhysicalDeviceMaintenance6Features, DeviceCreateInfo>
|
|
|
11221 {
|
|
|
11222 enum
|
|
|
11223 {
|
|
|
11224 value = true
|
|
|
11225 };
|
|
|
11226 };
|
|
|
11227
|
|
|
11228 template <>
|
|
|
11229 struct StructExtends<PhysicalDeviceMaintenance6Properties, PhysicalDeviceProperties2>
|
|
|
11230 {
|
|
|
11231 enum
|
|
|
11232 {
|
|
|
11233 value = true
|
|
|
11234 };
|
|
|
11235 };
|
|
|
11236
|
|
|
11237 template <>
|
|
|
11238 struct StructExtends<BindMemoryStatus, BindBufferMemoryInfo>
|
|
|
11239 {
|
|
|
11240 enum
|
|
|
11241 {
|
|
|
11242 value = true
|
|
|
11243 };
|
|
|
11244 };
|
|
|
11245
|
|
|
11246 template <>
|
|
|
11247 struct StructExtends<BindMemoryStatus, BindImageMemoryInfo>
|
|
|
11248 {
|
|
|
11249 enum
|
|
|
11250 {
|
|
|
11251 value = true
|
|
|
11252 };
|
|
|
11253 };
|
|
|
11254
|
|
|
11255 template <>
|
|
|
11256 struct StructExtends<PhysicalDeviceHostImageCopyFeatures, PhysicalDeviceFeatures2>
|
|
|
11257 {
|
|
|
11258 enum
|
|
|
11259 {
|
|
|
11260 value = true
|
|
|
11261 };
|
|
|
11262 };
|
|
|
11263
|
|
|
11264 template <>
|
|
|
11265 struct StructExtends<PhysicalDeviceHostImageCopyFeatures, DeviceCreateInfo>
|
|
|
11266 {
|
|
|
11267 enum
|
|
|
11268 {
|
|
|
11269 value = true
|
|
|
11270 };
|
|
|
11271 };
|
|
|
11272
|
|
|
11273 template <>
|
|
|
11274 struct StructExtends<PhysicalDeviceHostImageCopyProperties, PhysicalDeviceProperties2>
|
|
|
11275 {
|
|
|
11276 enum
|
|
|
11277 {
|
|
|
11278 value = true
|
|
|
11279 };
|
|
|
11280 };
|
|
|
11281
|
|
|
11282 template <>
|
|
|
11283 struct StructExtends<SubresourceHostMemcpySize, SubresourceLayout2>
|
|
|
11284 {
|
|
|
11285 enum
|
|
|
11286 {
|
|
|
11287 value = true
|
|
|
11288 };
|
|
|
11289 };
|
|
|
11290
|
|
|
11291 template <>
|
|
|
11292 struct StructExtends<HostImageCopyDevicePerformanceQuery, ImageFormatProperties2>
|
|
|
11293 {
|
|
|
11294 enum
|
|
|
11295 {
|
|
|
11296 value = true
|
|
|
11297 };
|
|
|
11298 };
|
|
|
11299
|
|
|
11300 template <>
|
|
|
11301 struct StructExtends<PhysicalDeviceShaderSubgroupRotateFeatures, PhysicalDeviceFeatures2>
|
|
|
11302 {
|
|
|
11303 enum
|
|
|
11304 {
|
|
|
11305 value = true
|
|
|
11306 };
|
|
|
11307 };
|
|
|
11308
|
|
|
11309 template <>
|
|
|
11310 struct StructExtends<PhysicalDeviceShaderSubgroupRotateFeatures, DeviceCreateInfo>
|
|
|
11311 {
|
|
|
11312 enum
|
|
|
11313 {
|
|
|
11314 value = true
|
|
|
11315 };
|
|
|
11316 };
|
|
|
11317
|
|
|
11318 template <>
|
|
|
11319 struct StructExtends<PhysicalDeviceShaderFloatControls2Features, PhysicalDeviceFeatures2>
|
|
|
11320 {
|
|
|
11321 enum
|
|
|
11322 {
|
|
|
11323 value = true
|
|
|
11324 };
|
|
|
11325 };
|
|
|
11326
|
|
|
11327 template <>
|
|
|
11328 struct StructExtends<PhysicalDeviceShaderFloatControls2Features, DeviceCreateInfo>
|
|
|
11329 {
|
|
|
11330 enum
|
|
|
11331 {
|
|
|
11332 value = true
|
|
|
11333 };
|
|
|
11334 };
|
|
|
11335
|
|
|
11336 template <>
|
|
|
11337 struct StructExtends<PhysicalDeviceShaderExpectAssumeFeatures, PhysicalDeviceFeatures2>
|
|
|
11338 {
|
|
|
11339 enum
|
|
|
11340 {
|
|
|
11341 value = true
|
|
|
11342 };
|
|
|
11343 };
|
|
|
11344
|
|
|
11345 template <>
|
|
|
11346 struct StructExtends<PhysicalDeviceShaderExpectAssumeFeatures, DeviceCreateInfo>
|
|
|
11347 {
|
|
|
11348 enum
|
|
|
11349 {
|
|
|
11350 value = true
|
|
|
11351 };
|
|
|
11352 };
|
|
|
11353
|
|
|
11354 template <>
|
|
|
11355 struct StructExtends<PipelineCreateFlags2CreateInfo, ComputePipelineCreateInfo>
|
|
|
11356 {
|
|
|
11357 enum
|
|
|
11358 {
|
|
|
11359 value = true
|
|
|
11360 };
|
|
|
11361 };
|
|
|
11362
|
|
|
11363 template <>
|
|
|
11364 struct StructExtends<PipelineCreateFlags2CreateInfo, GraphicsPipelineCreateInfo>
|
|
|
11365 {
|
|
|
11366 enum
|
|
|
11367 {
|
|
|
11368 value = true
|
|
|
11369 };
|
|
|
11370 };
|
|
|
11371
|
|
|
11372 template <>
|
|
|
11373 struct StructExtends<PipelineCreateFlags2CreateInfo, RayTracingPipelineCreateInfoNV>
|
|
|
11374 {
|
|
|
11375 enum
|
|
|
11376 {
|
|
|
11377 value = true
|
|
|
11378 };
|
|
|
11379 };
|
|
|
11380
|
|
|
11381 template <>
|
|
|
11382 struct StructExtends<PipelineCreateFlags2CreateInfo, RayTracingPipelineCreateInfoKHR>
|
|
|
11383 {
|
|
|
11384 enum
|
|
|
11385 {
|
|
|
11386 value = true
|
|
|
11387 };
|
|
|
11388 };
|
|
|
11389
|
|
|
11390 template <>
|
|
|
11391 struct StructExtends<PhysicalDevicePushDescriptorProperties, PhysicalDeviceProperties2>
|
|
|
11392 {
|
|
|
11393 enum
|
|
|
11394 {
|
|
|
11395 value = true
|
|
|
11396 };
|
|
|
11397 };
|
|
|
11398
|
|
|
11399 template <>
|
|
|
11400 struct StructExtends<PhysicalDevicePipelineProtectedAccessFeatures, PhysicalDeviceFeatures2>
|
|
|
11401 {
|
|
|
11402 enum
|
|
|
11403 {
|
|
|
11404 value = true
|
|
|
11405 };
|
|
|
11406 };
|
|
|
11407
|
|
|
11408 template <>
|
|
|
11409 struct StructExtends<PhysicalDevicePipelineProtectedAccessFeatures, DeviceCreateInfo>
|
|
|
11410 {
|
|
|
11411 enum
|
|
|
11412 {
|
|
|
11413 value = true
|
|
|
11414 };
|
|
|
11415 };
|
|
|
11416
|
|
|
11417 template <>
|
|
|
11418 struct StructExtends<PhysicalDevicePipelineRobustnessFeatures, PhysicalDeviceFeatures2>
|
|
|
11419 {
|
|
|
11420 enum
|
|
|
11421 {
|
|
|
11422 value = true
|
|
|
11423 };
|
|
|
11424 };
|
|
|
11425
|
|
|
11426 template <>
|
|
|
11427 struct StructExtends<PhysicalDevicePipelineRobustnessFeatures, DeviceCreateInfo>
|
|
|
11428 {
|
|
|
11429 enum
|
|
|
11430 {
|
|
|
11431 value = true
|
|
|
11432 };
|
|
|
11433 };
|
|
|
11434
|
|
|
11435 template <>
|
|
|
11436 struct StructExtends<PhysicalDevicePipelineRobustnessProperties, PhysicalDeviceProperties2>
|
|
|
11437 {
|
|
|
11438 enum
|
|
|
11439 {
|
|
|
11440 value = true
|
|
|
11441 };
|
|
|
11442 };
|
|
|
11443
|
|
|
11444 template <>
|
|
|
11445 struct StructExtends<PipelineRobustnessCreateInfo, GraphicsPipelineCreateInfo>
|
|
|
11446 {
|
|
|
11447 enum
|
|
|
11448 {
|
|
|
11449 value = true
|
|
|
11450 };
|
|
|
11451 };
|
|
|
11452
|
|
|
11453 template <>
|
|
|
11454 struct StructExtends<PipelineRobustnessCreateInfo, ComputePipelineCreateInfo>
|
|
|
11455 {
|
|
|
11456 enum
|
|
|
11457 {
|
|
|
11458 value = true
|
|
|
11459 };
|
|
|
11460 };
|
|
|
11461
|
|
|
11462 template <>
|
|
|
11463 struct StructExtends<PipelineRobustnessCreateInfo, PipelineShaderStageCreateInfo>
|
|
|
11464 {
|
|
|
11465 enum
|
|
|
11466 {
|
|
|
11467 value = true
|
|
|
11468 };
|
|
|
11469 };
|
|
|
11470
|
|
|
11471 template <>
|
|
|
11472 struct StructExtends<PipelineRobustnessCreateInfo, RayTracingPipelineCreateInfoKHR>
|
|
|
11473 {
|
|
|
11474 enum
|
|
|
11475 {
|
|
|
11476 value = true
|
|
|
11477 };
|
|
|
11478 };
|
|
|
11479
|
|
|
11480 template <>
|
|
|
11481 struct StructExtends<PhysicalDeviceLineRasterizationFeatures, PhysicalDeviceFeatures2>
|
|
|
11482 {
|
|
|
11483 enum
|
|
|
11484 {
|
|
|
11485 value = true
|
|
|
11486 };
|
|
|
11487 };
|
|
|
11488
|
|
|
11489 template <>
|
|
|
11490 struct StructExtends<PhysicalDeviceLineRasterizationFeatures, DeviceCreateInfo>
|
|
|
11491 {
|
|
|
11492 enum
|
|
|
11493 {
|
|
|
11494 value = true
|
|
|
11495 };
|
|
|
11496 };
|
|
|
11497
|
|
|
11498 template <>
|
|
|
11499 struct StructExtends<PhysicalDeviceLineRasterizationProperties, PhysicalDeviceProperties2>
|
|
|
11500 {
|
|
|
11501 enum
|
|
|
11502 {
|
|
|
11503 value = true
|
|
|
11504 };
|
|
|
11505 };
|
|
|
11506
|
|
|
11507 template <>
|
|
|
11508 struct StructExtends<PipelineRasterizationLineStateCreateInfo, PipelineRasterizationStateCreateInfo>
|
|
|
11509 {
|
|
|
11510 enum
|
|
|
11511 {
|
|
|
11512 value = true
|
|
|
11513 };
|
|
|
11514 };
|
|
|
11515
|
|
|
11516 template <>
|
|
|
11517 struct StructExtends<PhysicalDeviceVertexAttributeDivisorProperties, PhysicalDeviceProperties2>
|
|
|
11518 {
|
|
|
11519 enum
|
|
|
11520 {
|
|
|
11521 value = true
|
|
|
11522 };
|
|
|
11523 };
|
|
|
11524
|
|
|
11525 template <>
|
|
|
11526 struct StructExtends<PipelineVertexInputDivisorStateCreateInfo, PipelineVertexInputStateCreateInfo>
|
|
|
11527 {
|
|
|
11528 enum
|
|
|
11529 {
|
|
|
11530 value = true
|
|
|
11531 };
|
|
|
11532 };
|
|
|
11533
|
|
|
11534 template <>
|
|
|
11535 struct StructExtends<PhysicalDeviceVertexAttributeDivisorFeatures, PhysicalDeviceFeatures2>
|
|
|
11536 {
|
|
|
11537 enum
|
|
|
11538 {
|
|
|
11539 value = true
|
|
|
11540 };
|
|
|
11541 };
|
|
|
11542
|
|
|
11543 template <>
|
|
|
11544 struct StructExtends<PhysicalDeviceVertexAttributeDivisorFeatures, DeviceCreateInfo>
|
|
|
11545 {
|
|
|
11546 enum
|
|
|
11547 {
|
|
|
11548 value = true
|
|
|
11549 };
|
|
|
11550 };
|
|
|
11551
|
|
|
11552 template <>
|
|
|
11553 struct StructExtends<PhysicalDeviceDynamicRenderingLocalReadFeatures, PhysicalDeviceFeatures2>
|
|
|
11554 {
|
|
|
11555 enum
|
|
|
11556 {
|
|
|
11557 value = true
|
|
|
11558 };
|
|
|
11559 };
|
|
|
11560
|
|
|
11561 template <>
|
|
|
11562 struct StructExtends<PhysicalDeviceDynamicRenderingLocalReadFeatures, DeviceCreateInfo>
|
|
|
11563 {
|
|
|
11564 enum
|
|
|
11565 {
|
|
|
11566 value = true
|
|
|
11567 };
|
|
|
11568 };
|
|
|
11569
|
|
|
11570 template <>
|
|
|
11571 struct StructExtends<RenderingAttachmentLocationInfo, GraphicsPipelineCreateInfo>
|
|
|
11572 {
|
|
|
11573 enum
|
|
|
11574 {
|
|
|
11575 value = true
|
|
|
11576 };
|
|
|
11577 };
|
|
|
11578
|
|
|
11579 template <>
|
|
|
11580 struct StructExtends<RenderingAttachmentLocationInfo, CommandBufferInheritanceInfo>
|
|
|
11581 {
|
|
|
11582 enum
|
|
|
11583 {
|
|
|
11584 value = true
|
|
|
11585 };
|
|
|
11586 };
|
|
|
11587
|
|
|
11588 template <>
|
|
|
11589 struct StructExtends<RenderingInputAttachmentIndexInfo, GraphicsPipelineCreateInfo>
|
|
|
11590 {
|
|
|
11591 enum
|
|
|
11592 {
|
|
|
11593 value = true
|
|
|
11594 };
|
|
|
11595 };
|
|
|
11596
|
|
|
11597 template <>
|
|
|
11598 struct StructExtends<RenderingInputAttachmentIndexInfo, CommandBufferInheritanceInfo>
|
|
|
11599 {
|
|
|
11600 enum
|
|
|
11601 {
|
|
|
11602 value = true
|
|
|
11603 };
|
|
|
11604 };
|
|
|
11605
|
|
|
11606 //=== VK_KHR_swapchain ===
|
|
|
11607 template <>
|
|
|
11608 struct StructExtends<ImageSwapchainCreateInfoKHR, ImageCreateInfo>
|
|
|
11609 {
|
|
|
11610 enum
|
|
|
11611 {
|
|
|
11612 value = true
|
|
|
11613 };
|
|
|
11614 };
|
|
|
11615
|
|
|
11616 template <>
|
|
|
11617 struct StructExtends<BindImageMemorySwapchainInfoKHR, BindImageMemoryInfo>
|
|
|
11618 {
|
|
|
11619 enum
|
|
|
11620 {
|
|
|
11621 value = true
|
|
|
11622 };
|
|
|
11623 };
|
|
|
11624
|
|
|
11625 template <>
|
|
|
11626 struct StructExtends<DeviceGroupPresentInfoKHR, PresentInfoKHR>
|
|
|
11627 {
|
|
|
11628 enum
|
|
|
11629 {
|
|
|
11630 value = true
|
|
|
11631 };
|
|
|
11632 };
|
|
|
11633
|
|
|
11634 template <>
|
|
|
11635 struct StructExtends<DeviceGroupSwapchainCreateInfoKHR, SwapchainCreateInfoKHR>
|
|
|
11636 {
|
|
|
11637 enum
|
|
|
11638 {
|
|
|
11639 value = true
|
|
|
11640 };
|
|
|
11641 };
|
|
|
11642
|
|
|
11643 //=== VK_KHR_display_swapchain ===
|
|
|
11644 template <>
|
|
|
11645 struct StructExtends<DisplayPresentInfoKHR, PresentInfoKHR>
|
|
|
11646 {
|
|
|
11647 enum
|
|
|
11648 {
|
|
|
11649 value = true
|
|
|
11650 };
|
|
|
11651 };
|
|
|
11652
|
|
|
11653 //=== VK_EXT_debug_report ===
|
|
|
11654 template <>
|
|
|
11655 struct StructExtends<DebugReportCallbackCreateInfoEXT, InstanceCreateInfo>
|
|
|
11656 {
|
|
|
11657 enum
|
|
|
11658 {
|
|
|
11659 value = true
|
|
|
11660 };
|
|
|
11661 };
|
|
|
11662
|
|
|
11663 //=== VK_AMD_rasterization_order ===
|
|
|
11664 template <>
|
|
|
11665 struct StructExtends<PipelineRasterizationStateRasterizationOrderAMD, PipelineRasterizationStateCreateInfo>
|
|
|
11666 {
|
|
|
11667 enum
|
|
|
11668 {
|
|
|
11669 value = true
|
|
|
11670 };
|
|
|
11671 };
|
|
|
11672
|
|
|
11673 //=== VK_KHR_video_queue ===
|
|
|
11674 template <>
|
|
|
11675 struct StructExtends<QueueFamilyQueryResultStatusPropertiesKHR, QueueFamilyProperties2>
|
|
|
11676 {
|
|
|
11677 enum
|
|
|
11678 {
|
|
|
11679 value = true
|
|
|
11680 };
|
|
|
11681 };
|
|
|
11682
|
|
|
11683 template <>
|
|
|
11684 struct StructExtends<QueueFamilyVideoPropertiesKHR, QueueFamilyProperties2>
|
|
|
11685 {
|
|
|
11686 enum
|
|
|
11687 {
|
|
|
11688 value = true
|
|
|
11689 };
|
|
|
11690 };
|
|
|
11691
|
|
|
11692 template <>
|
|
|
11693 struct StructExtends<VideoProfileInfoKHR, QueryPoolCreateInfo>
|
|
|
11694 {
|
|
|
11695 enum
|
|
|
11696 {
|
|
|
11697 value = true
|
|
|
11698 };
|
|
|
11699 };
|
|
|
11700
|
|
|
11701 template <>
|
|
|
11702 struct StructExtends<VideoProfileListInfoKHR, PhysicalDeviceImageFormatInfo2>
|
|
|
11703 {
|
|
|
11704 enum
|
|
|
11705 {
|
|
|
11706 value = true
|
|
|
11707 };
|
|
|
11708 };
|
|
|
11709
|
|
|
11710 template <>
|
|
|
11711 struct StructExtends<VideoProfileListInfoKHR, PhysicalDeviceVideoFormatInfoKHR>
|
|
|
11712 {
|
|
|
11713 enum
|
|
|
11714 {
|
|
|
11715 value = true
|
|
|
11716 };
|
|
|
11717 };
|
|
|
11718
|
|
|
11719 template <>
|
|
|
11720 struct StructExtends<VideoProfileListInfoKHR, ImageCreateInfo>
|
|
|
11721 {
|
|
|
11722 enum
|
|
|
11723 {
|
|
|
11724 value = true
|
|
|
11725 };
|
|
|
11726 };
|
|
|
11727
|
|
|
11728 template <>
|
|
|
11729 struct StructExtends<VideoProfileListInfoKHR, BufferCreateInfo>
|
|
|
11730 {
|
|
|
11731 enum
|
|
|
11732 {
|
|
|
11733 value = true
|
|
|
11734 };
|
|
|
11735 };
|
|
|
11736
|
|
|
11737 //=== VK_KHR_video_decode_queue ===
|
|
|
11738 template <>
|
|
|
11739 struct StructExtends<VideoDecodeCapabilitiesKHR, VideoCapabilitiesKHR>
|
|
|
11740 {
|
|
|
11741 enum
|
|
|
11742 {
|
|
|
11743 value = true
|
|
|
11744 };
|
|
|
11745 };
|
|
|
11746
|
|
|
11747 template <>
|
|
|
11748 struct StructExtends<VideoDecodeUsageInfoKHR, VideoProfileInfoKHR>
|
|
|
11749 {
|
|
|
11750 enum
|
|
|
11751 {
|
|
|
11752 value = true
|
|
|
11753 };
|
|
|
11754 };
|
|
|
11755
|
|
|
11756 template <>
|
|
|
11757 struct StructExtends<VideoDecodeUsageInfoKHR, QueryPoolCreateInfo>
|
|
|
11758 {
|
|
|
11759 enum
|
|
|
11760 {
|
|
|
11761 value = true
|
|
|
11762 };
|
|
|
11763 };
|
|
|
11764
|
|
|
11765 //=== VK_NV_dedicated_allocation ===
|
|
|
11766 template <>
|
|
|
11767 struct StructExtends<DedicatedAllocationImageCreateInfoNV, ImageCreateInfo>
|
|
|
11768 {
|
|
|
11769 enum
|
|
|
11770 {
|
|
|
11771 value = true
|
|
|
11772 };
|
|
|
11773 };
|
|
|
11774
|
|
|
11775 template <>
|
|
|
11776 struct StructExtends<DedicatedAllocationBufferCreateInfoNV, BufferCreateInfo>
|
|
|
11777 {
|
|
|
11778 enum
|
|
|
11779 {
|
|
|
11780 value = true
|
|
|
11781 };
|
|
|
11782 };
|
|
|
11783
|
|
|
11784 template <>
|
|
|
11785 struct StructExtends<DedicatedAllocationMemoryAllocateInfoNV, MemoryAllocateInfo>
|
|
|
11786 {
|
|
|
11787 enum
|
|
|
11788 {
|
|
|
11789 value = true
|
|
|
11790 };
|
|
|
11791 };
|
|
|
11792
|
|
|
11793 //=== VK_EXT_transform_feedback ===
|
|
|
11794 template <>
|
|
|
11795 struct StructExtends<PhysicalDeviceTransformFeedbackFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
11796 {
|
|
|
11797 enum
|
|
|
11798 {
|
|
|
11799 value = true
|
|
|
11800 };
|
|
|
11801 };
|
|
|
11802
|
|
|
11803 template <>
|
|
|
11804 struct StructExtends<PhysicalDeviceTransformFeedbackFeaturesEXT, DeviceCreateInfo>
|
|
|
11805 {
|
|
|
11806 enum
|
|
|
11807 {
|
|
|
11808 value = true
|
|
|
11809 };
|
|
|
11810 };
|
|
|
11811
|
|
|
11812 template <>
|
|
|
11813 struct StructExtends<PhysicalDeviceTransformFeedbackPropertiesEXT, PhysicalDeviceProperties2>
|
|
|
11814 {
|
|
|
11815 enum
|
|
|
11816 {
|
|
|
11817 value = true
|
|
|
11818 };
|
|
|
11819 };
|
|
|
11820
|
|
|
11821 template <>
|
|
|
11822 struct StructExtends<PipelineRasterizationStateStreamCreateInfoEXT, PipelineRasterizationStateCreateInfo>
|
|
|
11823 {
|
|
|
11824 enum
|
|
|
11825 {
|
|
|
11826 value = true
|
|
|
11827 };
|
|
|
11828 };
|
|
|
11829
|
|
|
11830 //=== VK_NVX_binary_import ===
|
|
|
11831 template <>
|
|
|
11832 struct StructExtends<CuModuleTexturingModeCreateInfoNVX, CuModuleCreateInfoNVX>
|
|
|
11833 {
|
|
|
11834 enum
|
|
|
11835 {
|
|
|
11836 value = true
|
|
|
11837 };
|
|
|
11838 };
|
|
|
11839
|
|
|
11840 //=== VK_KHR_video_encode_h264 ===
|
|
|
11841 template <>
|
|
|
11842 struct StructExtends<VideoEncodeH264CapabilitiesKHR, VideoCapabilitiesKHR>
|
|
|
11843 {
|
|
|
11844 enum
|
|
|
11845 {
|
|
|
11846 value = true
|
|
|
11847 };
|
|
|
11848 };
|
|
|
11849
|
|
|
11850 template <>
|
|
|
11851 struct StructExtends<VideoEncodeH264QualityLevelPropertiesKHR, VideoEncodeQualityLevelPropertiesKHR>
|
|
|
11852 {
|
|
|
11853 enum
|
|
|
11854 {
|
|
|
11855 value = true
|
|
|
11856 };
|
|
|
11857 };
|
|
|
11858
|
|
|
11859 template <>
|
|
|
11860 struct StructExtends<VideoEncodeH264SessionCreateInfoKHR, VideoSessionCreateInfoKHR>
|
|
|
11861 {
|
|
|
11862 enum
|
|
|
11863 {
|
|
|
11864 value = true
|
|
|
11865 };
|
|
|
11866 };
|
|
|
11867
|
|
|
11868 template <>
|
|
|
11869 struct StructExtends<VideoEncodeH264SessionParametersCreateInfoKHR, VideoSessionParametersCreateInfoKHR>
|
|
|
11870 {
|
|
|
11871 enum
|
|
|
11872 {
|
|
|
11873 value = true
|
|
|
11874 };
|
|
|
11875 };
|
|
|
11876
|
|
|
11877 template <>
|
|
|
11878 struct StructExtends<VideoEncodeH264SessionParametersAddInfoKHR, VideoSessionParametersUpdateInfoKHR>
|
|
|
11879 {
|
|
|
11880 enum
|
|
|
11881 {
|
|
|
11882 value = true
|
|
|
11883 };
|
|
|
11884 };
|
|
|
11885
|
|
|
11886 template <>
|
|
|
11887 struct StructExtends<VideoEncodeH264SessionParametersGetInfoKHR, VideoEncodeSessionParametersGetInfoKHR>
|
|
|
11888 {
|
|
|
11889 enum
|
|
|
11890 {
|
|
|
11891 value = true
|
|
|
11892 };
|
|
|
11893 };
|
|
|
11894
|
|
|
11895 template <>
|
|
|
11896 struct StructExtends<VideoEncodeH264SessionParametersFeedbackInfoKHR, VideoEncodeSessionParametersFeedbackInfoKHR>
|
|
|
11897 {
|
|
|
11898 enum
|
|
|
11899 {
|
|
|
11900 value = true
|
|
|
11901 };
|
|
|
11902 };
|
|
|
11903
|
|
|
11904 template <>
|
|
|
11905 struct StructExtends<VideoEncodeH264PictureInfoKHR, VideoEncodeInfoKHR>
|
|
|
11906 {
|
|
|
11907 enum
|
|
|
11908 {
|
|
|
11909 value = true
|
|
|
11910 };
|
|
|
11911 };
|
|
|
11912
|
|
|
11913 template <>
|
|
|
11914 struct StructExtends<VideoEncodeH264DpbSlotInfoKHR, VideoReferenceSlotInfoKHR>
|
|
|
11915 {
|
|
|
11916 enum
|
|
|
11917 {
|
|
|
11918 value = true
|
|
|
11919 };
|
|
|
11920 };
|
|
|
11921
|
|
|
11922 template <>
|
|
|
11923 struct StructExtends<VideoEncodeH264ProfileInfoKHR, VideoProfileInfoKHR>
|
|
|
11924 {
|
|
|
11925 enum
|
|
|
11926 {
|
|
|
11927 value = true
|
|
|
11928 };
|
|
|
11929 };
|
|
|
11930
|
|
|
11931 template <>
|
|
|
11932 struct StructExtends<VideoEncodeH264ProfileInfoKHR, QueryPoolCreateInfo>
|
|
|
11933 {
|
|
|
11934 enum
|
|
|
11935 {
|
|
|
11936 value = true
|
|
|
11937 };
|
|
|
11938 };
|
|
|
11939
|
|
|
11940 template <>
|
|
|
11941 struct StructExtends<VideoEncodeH264RateControlInfoKHR, VideoCodingControlInfoKHR>
|
|
|
11942 {
|
|
|
11943 enum
|
|
|
11944 {
|
|
|
11945 value = true
|
|
|
11946 };
|
|
|
11947 };
|
|
|
11948
|
|
|
11949 template <>
|
|
|
11950 struct StructExtends<VideoEncodeH264RateControlInfoKHR, VideoBeginCodingInfoKHR>
|
|
|
11951 {
|
|
|
11952 enum
|
|
|
11953 {
|
|
|
11954 value = true
|
|
|
11955 };
|
|
|
11956 };
|
|
|
11957
|
|
|
11958 template <>
|
|
|
11959 struct StructExtends<VideoEncodeH264RateControlLayerInfoKHR, VideoEncodeRateControlLayerInfoKHR>
|
|
|
11960 {
|
|
|
11961 enum
|
|
|
11962 {
|
|
|
11963 value = true
|
|
|
11964 };
|
|
|
11965 };
|
|
|
11966
|
|
|
11967 template <>
|
|
|
11968 struct StructExtends<VideoEncodeH264GopRemainingFrameInfoKHR, VideoBeginCodingInfoKHR>
|
|
|
11969 {
|
|
|
11970 enum
|
|
|
11971 {
|
|
|
11972 value = true
|
|
|
11973 };
|
|
|
11974 };
|
|
|
11975
|
|
|
11976 //=== VK_KHR_video_encode_h265 ===
|
|
|
11977 template <>
|
|
|
11978 struct StructExtends<VideoEncodeH265CapabilitiesKHR, VideoCapabilitiesKHR>
|
|
|
11979 {
|
|
|
11980 enum
|
|
|
11981 {
|
|
|
11982 value = true
|
|
|
11983 };
|
|
|
11984 };
|
|
|
11985
|
|
|
11986 template <>
|
|
|
11987 struct StructExtends<VideoEncodeH265SessionCreateInfoKHR, VideoSessionCreateInfoKHR>
|
|
|
11988 {
|
|
|
11989 enum
|
|
|
11990 {
|
|
|
11991 value = true
|
|
|
11992 };
|
|
|
11993 };
|
|
|
11994
|
|
|
11995 template <>
|
|
|
11996 struct StructExtends<VideoEncodeH265QualityLevelPropertiesKHR, VideoEncodeQualityLevelPropertiesKHR>
|
|
|
11997 {
|
|
|
11998 enum
|
|
|
11999 {
|
|
|
12000 value = true
|
|
|
12001 };
|
|
|
12002 };
|
|
|
12003
|
|
|
12004 template <>
|
|
|
12005 struct StructExtends<VideoEncodeH265SessionParametersCreateInfoKHR, VideoSessionParametersCreateInfoKHR>
|
|
|
12006 {
|
|
|
12007 enum
|
|
|
12008 {
|
|
|
12009 value = true
|
|
|
12010 };
|
|
|
12011 };
|
|
|
12012
|
|
|
12013 template <>
|
|
|
12014 struct StructExtends<VideoEncodeH265SessionParametersAddInfoKHR, VideoSessionParametersUpdateInfoKHR>
|
|
|
12015 {
|
|
|
12016 enum
|
|
|
12017 {
|
|
|
12018 value = true
|
|
|
12019 };
|
|
|
12020 };
|
|
|
12021
|
|
|
12022 template <>
|
|
|
12023 struct StructExtends<VideoEncodeH265SessionParametersGetInfoKHR, VideoEncodeSessionParametersGetInfoKHR>
|
|
|
12024 {
|
|
|
12025 enum
|
|
|
12026 {
|
|
|
12027 value = true
|
|
|
12028 };
|
|
|
12029 };
|
|
|
12030
|
|
|
12031 template <>
|
|
|
12032 struct StructExtends<VideoEncodeH265SessionParametersFeedbackInfoKHR, VideoEncodeSessionParametersFeedbackInfoKHR>
|
|
|
12033 {
|
|
|
12034 enum
|
|
|
12035 {
|
|
|
12036 value = true
|
|
|
12037 };
|
|
|
12038 };
|
|
|
12039
|
|
|
12040 template <>
|
|
|
12041 struct StructExtends<VideoEncodeH265PictureInfoKHR, VideoEncodeInfoKHR>
|
|
|
12042 {
|
|
|
12043 enum
|
|
|
12044 {
|
|
|
12045 value = true
|
|
|
12046 };
|
|
|
12047 };
|
|
|
12048
|
|
|
12049 template <>
|
|
|
12050 struct StructExtends<VideoEncodeH265DpbSlotInfoKHR, VideoReferenceSlotInfoKHR>
|
|
|
12051 {
|
|
|
12052 enum
|
|
|
12053 {
|
|
|
12054 value = true
|
|
|
12055 };
|
|
|
12056 };
|
|
|
12057
|
|
|
12058 template <>
|
|
|
12059 struct StructExtends<VideoEncodeH265ProfileInfoKHR, VideoProfileInfoKHR>
|
|
|
12060 {
|
|
|
12061 enum
|
|
|
12062 {
|
|
|
12063 value = true
|
|
|
12064 };
|
|
|
12065 };
|
|
|
12066
|
|
|
12067 template <>
|
|
|
12068 struct StructExtends<VideoEncodeH265ProfileInfoKHR, QueryPoolCreateInfo>
|
|
|
12069 {
|
|
|
12070 enum
|
|
|
12071 {
|
|
|
12072 value = true
|
|
|
12073 };
|
|
|
12074 };
|
|
|
12075
|
|
|
12076 template <>
|
|
|
12077 struct StructExtends<VideoEncodeH265RateControlInfoKHR, VideoCodingControlInfoKHR>
|
|
|
12078 {
|
|
|
12079 enum
|
|
|
12080 {
|
|
|
12081 value = true
|
|
|
12082 };
|
|
|
12083 };
|
|
|
12084
|
|
|
12085 template <>
|
|
|
12086 struct StructExtends<VideoEncodeH265RateControlInfoKHR, VideoBeginCodingInfoKHR>
|
|
|
12087 {
|
|
|
12088 enum
|
|
|
12089 {
|
|
|
12090 value = true
|
|
|
12091 };
|
|
|
12092 };
|
|
|
12093
|
|
|
12094 template <>
|
|
|
12095 struct StructExtends<VideoEncodeH265RateControlLayerInfoKHR, VideoEncodeRateControlLayerInfoKHR>
|
|
|
12096 {
|
|
|
12097 enum
|
|
|
12098 {
|
|
|
12099 value = true
|
|
|
12100 };
|
|
|
12101 };
|
|
|
12102
|
|
|
12103 template <>
|
|
|
12104 struct StructExtends<VideoEncodeH265GopRemainingFrameInfoKHR, VideoBeginCodingInfoKHR>
|
|
|
12105 {
|
|
|
12106 enum
|
|
|
12107 {
|
|
|
12108 value = true
|
|
|
12109 };
|
|
|
12110 };
|
|
|
12111
|
|
|
12112 //=== VK_KHR_video_decode_h264 ===
|
|
|
12113 template <>
|
|
|
12114 struct StructExtends<VideoDecodeH264ProfileInfoKHR, VideoProfileInfoKHR>
|
|
|
12115 {
|
|
|
12116 enum
|
|
|
12117 {
|
|
|
12118 value = true
|
|
|
12119 };
|
|
|
12120 };
|
|
|
12121
|
|
|
12122 template <>
|
|
|
12123 struct StructExtends<VideoDecodeH264ProfileInfoKHR, QueryPoolCreateInfo>
|
|
|
12124 {
|
|
|
12125 enum
|
|
|
12126 {
|
|
|
12127 value = true
|
|
|
12128 };
|
|
|
12129 };
|
|
|
12130
|
|
|
12131 template <>
|
|
|
12132 struct StructExtends<VideoDecodeH264CapabilitiesKHR, VideoCapabilitiesKHR>
|
|
|
12133 {
|
|
|
12134 enum
|
|
|
12135 {
|
|
|
12136 value = true
|
|
|
12137 };
|
|
|
12138 };
|
|
|
12139
|
|
|
12140 template <>
|
|
|
12141 struct StructExtends<VideoDecodeH264SessionParametersCreateInfoKHR, VideoSessionParametersCreateInfoKHR>
|
|
|
12142 {
|
|
|
12143 enum
|
|
|
12144 {
|
|
|
12145 value = true
|
|
|
12146 };
|
|
|
12147 };
|
|
|
12148
|
|
|
12149 template <>
|
|
|
12150 struct StructExtends<VideoDecodeH264SessionParametersAddInfoKHR, VideoSessionParametersUpdateInfoKHR>
|
|
|
12151 {
|
|
|
12152 enum
|
|
|
12153 {
|
|
|
12154 value = true
|
|
|
12155 };
|
|
|
12156 };
|
|
|
12157
|
|
|
12158 template <>
|
|
|
12159 struct StructExtends<VideoDecodeH264PictureInfoKHR, VideoDecodeInfoKHR>
|
|
|
12160 {
|
|
|
12161 enum
|
|
|
12162 {
|
|
|
12163 value = true
|
|
|
12164 };
|
|
|
12165 };
|
|
|
12166
|
|
|
12167 template <>
|
|
|
12168 struct StructExtends<VideoDecodeH264DpbSlotInfoKHR, VideoReferenceSlotInfoKHR>
|
|
|
12169 {
|
|
|
12170 enum
|
|
|
12171 {
|
|
|
12172 value = true
|
|
|
12173 };
|
|
|
12174 };
|
|
|
12175
|
|
|
12176 //=== VK_AMD_texture_gather_bias_lod ===
|
|
|
12177 template <>
|
|
|
12178 struct StructExtends<TextureLODGatherFormatPropertiesAMD, ImageFormatProperties2>
|
|
|
12179 {
|
|
|
12180 enum
|
|
|
12181 {
|
|
|
12182 value = true
|
|
|
12183 };
|
|
|
12184 };
|
|
|
12185
|
|
|
12186 //=== VK_NV_corner_sampled_image ===
|
|
|
12187 template <>
|
|
|
12188 struct StructExtends<PhysicalDeviceCornerSampledImageFeaturesNV, PhysicalDeviceFeatures2>
|
|
|
12189 {
|
|
|
12190 enum
|
|
|
12191 {
|
|
|
12192 value = true
|
|
|
12193 };
|
|
|
12194 };
|
|
|
12195
|
|
|
12196 template <>
|
|
|
12197 struct StructExtends<PhysicalDeviceCornerSampledImageFeaturesNV, DeviceCreateInfo>
|
|
|
12198 {
|
|
|
12199 enum
|
|
|
12200 {
|
|
|
12201 value = true
|
|
|
12202 };
|
|
|
12203 };
|
|
|
12204
|
|
|
12205 //=== VK_NV_external_memory ===
|
|
|
12206 template <>
|
|
|
12207 struct StructExtends<ExternalMemoryImageCreateInfoNV, ImageCreateInfo>
|
|
|
12208 {
|
|
|
12209 enum
|
|
|
12210 {
|
|
|
12211 value = true
|
|
|
12212 };
|
|
|
12213 };
|
|
|
12214
|
|
|
12215 template <>
|
|
|
12216 struct StructExtends<ExportMemoryAllocateInfoNV, MemoryAllocateInfo>
|
|
|
12217 {
|
|
|
12218 enum
|
|
|
12219 {
|
|
|
12220 value = true
|
|
|
12221 };
|
|
|
12222 };
|
|
|
12223
|
|
|
12224 # if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
12225 //=== VK_NV_external_memory_win32 ===
|
|
|
12226 template <>
|
|
|
12227 struct StructExtends<ImportMemoryWin32HandleInfoNV, MemoryAllocateInfo>
|
|
|
12228 {
|
|
|
12229 enum
|
|
|
12230 {
|
|
|
12231 value = true
|
|
|
12232 };
|
|
|
12233 };
|
|
|
12234
|
|
|
12235 template <>
|
|
|
12236 struct StructExtends<ExportMemoryWin32HandleInfoNV, MemoryAllocateInfo>
|
|
|
12237 {
|
|
|
12238 enum
|
|
|
12239 {
|
|
|
12240 value = true
|
|
|
12241 };
|
|
|
12242 };
|
|
|
12243 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
12244
|
|
|
12245 # if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
12246 //=== VK_NV_win32_keyed_mutex ===
|
|
|
12247 template <>
|
|
|
12248 struct StructExtends<Win32KeyedMutexAcquireReleaseInfoNV, SubmitInfo>
|
|
|
12249 {
|
|
|
12250 enum
|
|
|
12251 {
|
|
|
12252 value = true
|
|
|
12253 };
|
|
|
12254 };
|
|
|
12255
|
|
|
12256 template <>
|
|
|
12257 struct StructExtends<Win32KeyedMutexAcquireReleaseInfoNV, SubmitInfo2>
|
|
|
12258 {
|
|
|
12259 enum
|
|
|
12260 {
|
|
|
12261 value = true
|
|
|
12262 };
|
|
|
12263 };
|
|
|
12264 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
12265
|
|
|
12266 //=== VK_EXT_validation_flags ===
|
|
|
12267 template <>
|
|
|
12268 struct StructExtends<ValidationFlagsEXT, InstanceCreateInfo>
|
|
|
12269 {
|
|
|
12270 enum
|
|
|
12271 {
|
|
|
12272 value = true
|
|
|
12273 };
|
|
|
12274 };
|
|
|
12275
|
|
|
12276 //=== VK_EXT_astc_decode_mode ===
|
|
|
12277 template <>
|
|
|
12278 struct StructExtends<ImageViewASTCDecodeModeEXT, ImageViewCreateInfo>
|
|
|
12279 {
|
|
|
12280 enum
|
|
|
12281 {
|
|
|
12282 value = true
|
|
|
12283 };
|
|
|
12284 };
|
|
|
12285
|
|
|
12286 template <>
|
|
|
12287 struct StructExtends<PhysicalDeviceASTCDecodeFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
12288 {
|
|
|
12289 enum
|
|
|
12290 {
|
|
|
12291 value = true
|
|
|
12292 };
|
|
|
12293 };
|
|
|
12294
|
|
|
12295 template <>
|
|
|
12296 struct StructExtends<PhysicalDeviceASTCDecodeFeaturesEXT, DeviceCreateInfo>
|
|
|
12297 {
|
|
|
12298 enum
|
|
|
12299 {
|
|
|
12300 value = true
|
|
|
12301 };
|
|
|
12302 };
|
|
|
12303
|
|
|
12304 # if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
12305 //=== VK_KHR_external_memory_win32 ===
|
|
|
12306 template <>
|
|
|
12307 struct StructExtends<ImportMemoryWin32HandleInfoKHR, MemoryAllocateInfo>
|
|
|
12308 {
|
|
|
12309 enum
|
|
|
12310 {
|
|
|
12311 value = true
|
|
|
12312 };
|
|
|
12313 };
|
|
|
12314
|
|
|
12315 template <>
|
|
|
12316 struct StructExtends<ExportMemoryWin32HandleInfoKHR, MemoryAllocateInfo>
|
|
|
12317 {
|
|
|
12318 enum
|
|
|
12319 {
|
|
|
12320 value = true
|
|
|
12321 };
|
|
|
12322 };
|
|
|
12323 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
12324
|
|
|
12325 //=== VK_KHR_external_memory_fd ===
|
|
|
12326 template <>
|
|
|
12327 struct StructExtends<ImportMemoryFdInfoKHR, MemoryAllocateInfo>
|
|
|
12328 {
|
|
|
12329 enum
|
|
|
12330 {
|
|
|
12331 value = true
|
|
|
12332 };
|
|
|
12333 };
|
|
|
12334
|
|
|
12335 # if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
12336 //=== VK_KHR_win32_keyed_mutex ===
|
|
|
12337 template <>
|
|
|
12338 struct StructExtends<Win32KeyedMutexAcquireReleaseInfoKHR, SubmitInfo>
|
|
|
12339 {
|
|
|
12340 enum
|
|
|
12341 {
|
|
|
12342 value = true
|
|
|
12343 };
|
|
|
12344 };
|
|
|
12345
|
|
|
12346 template <>
|
|
|
12347 struct StructExtends<Win32KeyedMutexAcquireReleaseInfoKHR, SubmitInfo2>
|
|
|
12348 {
|
|
|
12349 enum
|
|
|
12350 {
|
|
|
12351 value = true
|
|
|
12352 };
|
|
|
12353 };
|
|
|
12354 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
12355
|
|
|
12356 # if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
12357 //=== VK_KHR_external_semaphore_win32 ===
|
|
|
12358 template <>
|
|
|
12359 struct StructExtends<ExportSemaphoreWin32HandleInfoKHR, SemaphoreCreateInfo>
|
|
|
12360 {
|
|
|
12361 enum
|
|
|
12362 {
|
|
|
12363 value = true
|
|
|
12364 };
|
|
|
12365 };
|
|
|
12366
|
|
|
12367 template <>
|
|
|
12368 struct StructExtends<D3D12FenceSubmitInfoKHR, SubmitInfo>
|
|
|
12369 {
|
|
|
12370 enum
|
|
|
12371 {
|
|
|
12372 value = true
|
|
|
12373 };
|
|
|
12374 };
|
|
|
12375 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
12376
|
|
|
12377 //=== VK_EXT_conditional_rendering ===
|
|
|
12378 template <>
|
|
|
12379 struct StructExtends<PhysicalDeviceConditionalRenderingFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
12380 {
|
|
|
12381 enum
|
|
|
12382 {
|
|
|
12383 value = true
|
|
|
12384 };
|
|
|
12385 };
|
|
|
12386
|
|
|
12387 template <>
|
|
|
12388 struct StructExtends<PhysicalDeviceConditionalRenderingFeaturesEXT, DeviceCreateInfo>
|
|
|
12389 {
|
|
|
12390 enum
|
|
|
12391 {
|
|
|
12392 value = true
|
|
|
12393 };
|
|
|
12394 };
|
|
|
12395
|
|
|
12396 template <>
|
|
|
12397 struct StructExtends<CommandBufferInheritanceConditionalRenderingInfoEXT, CommandBufferInheritanceInfo>
|
|
|
12398 {
|
|
|
12399 enum
|
|
|
12400 {
|
|
|
12401 value = true
|
|
|
12402 };
|
|
|
12403 };
|
|
|
12404
|
|
|
12405 //=== VK_KHR_incremental_present ===
|
|
|
12406 template <>
|
|
|
12407 struct StructExtends<PresentRegionsKHR, PresentInfoKHR>
|
|
|
12408 {
|
|
|
12409 enum
|
|
|
12410 {
|
|
|
12411 value = true
|
|
|
12412 };
|
|
|
12413 };
|
|
|
12414
|
|
|
12415 //=== VK_NV_clip_space_w_scaling ===
|
|
|
12416 template <>
|
|
|
12417 struct StructExtends<PipelineViewportWScalingStateCreateInfoNV, PipelineViewportStateCreateInfo>
|
|
|
12418 {
|
|
|
12419 enum
|
|
|
12420 {
|
|
|
12421 value = true
|
|
|
12422 };
|
|
|
12423 };
|
|
|
12424
|
|
|
12425 //=== VK_EXT_display_control ===
|
|
|
12426 template <>
|
|
|
12427 struct StructExtends<SwapchainCounterCreateInfoEXT, SwapchainCreateInfoKHR>
|
|
|
12428 {
|
|
|
12429 enum
|
|
|
12430 {
|
|
|
12431 value = true
|
|
|
12432 };
|
|
|
12433 };
|
|
|
12434
|
|
|
12435 //=== VK_GOOGLE_display_timing ===
|
|
|
12436 template <>
|
|
|
12437 struct StructExtends<PresentTimesInfoGOOGLE, PresentInfoKHR>
|
|
|
12438 {
|
|
|
12439 enum
|
|
|
12440 {
|
|
|
12441 value = true
|
|
|
12442 };
|
|
|
12443 };
|
|
|
12444
|
|
|
12445 //=== VK_NVX_multiview_per_view_attributes ===
|
|
|
12446 template <>
|
|
|
12447 struct StructExtends<PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, PhysicalDeviceProperties2>
|
|
|
12448 {
|
|
|
12449 enum
|
|
|
12450 {
|
|
|
12451 value = true
|
|
|
12452 };
|
|
|
12453 };
|
|
|
12454
|
|
|
12455 template <>
|
|
|
12456 struct StructExtends<MultiviewPerViewAttributesInfoNVX, CommandBufferInheritanceInfo>
|
|
|
12457 {
|
|
|
12458 enum
|
|
|
12459 {
|
|
|
12460 value = true
|
|
|
12461 };
|
|
|
12462 };
|
|
|
12463
|
|
|
12464 template <>
|
|
|
12465 struct StructExtends<MultiviewPerViewAttributesInfoNVX, GraphicsPipelineCreateInfo>
|
|
|
12466 {
|
|
|
12467 enum
|
|
|
12468 {
|
|
|
12469 value = true
|
|
|
12470 };
|
|
|
12471 };
|
|
|
12472
|
|
|
12473 template <>
|
|
|
12474 struct StructExtends<MultiviewPerViewAttributesInfoNVX, RenderingInfo>
|
|
|
12475 {
|
|
|
12476 enum
|
|
|
12477 {
|
|
|
12478 value = true
|
|
|
12479 };
|
|
|
12480 };
|
|
|
12481
|
|
|
12482 //=== VK_NV_viewport_swizzle ===
|
|
|
12483 template <>
|
|
|
12484 struct StructExtends<PipelineViewportSwizzleStateCreateInfoNV, PipelineViewportStateCreateInfo>
|
|
|
12485 {
|
|
|
12486 enum
|
|
|
12487 {
|
|
|
12488 value = true
|
|
|
12489 };
|
|
|
12490 };
|
|
|
12491
|
|
|
12492 //=== VK_EXT_discard_rectangles ===
|
|
|
12493 template <>
|
|
|
12494 struct StructExtends<PhysicalDeviceDiscardRectanglePropertiesEXT, PhysicalDeviceProperties2>
|
|
|
12495 {
|
|
|
12496 enum
|
|
|
12497 {
|
|
|
12498 value = true
|
|
|
12499 };
|
|
|
12500 };
|
|
|
12501
|
|
|
12502 template <>
|
|
|
12503 struct StructExtends<PipelineDiscardRectangleStateCreateInfoEXT, GraphicsPipelineCreateInfo>
|
|
|
12504 {
|
|
|
12505 enum
|
|
|
12506 {
|
|
|
12507 value = true
|
|
|
12508 };
|
|
|
12509 };
|
|
|
12510
|
|
|
12511 //=== VK_EXT_conservative_rasterization ===
|
|
|
12512 template <>
|
|
|
12513 struct StructExtends<PhysicalDeviceConservativeRasterizationPropertiesEXT, PhysicalDeviceProperties2>
|
|
|
12514 {
|
|
|
12515 enum
|
|
|
12516 {
|
|
|
12517 value = true
|
|
|
12518 };
|
|
|
12519 };
|
|
|
12520
|
|
|
12521 template <>
|
|
|
12522 struct StructExtends<PipelineRasterizationConservativeStateCreateInfoEXT, PipelineRasterizationStateCreateInfo>
|
|
|
12523 {
|
|
|
12524 enum
|
|
|
12525 {
|
|
|
12526 value = true
|
|
|
12527 };
|
|
|
12528 };
|
|
|
12529
|
|
|
12530 //=== VK_EXT_depth_clip_enable ===
|
|
|
12531 template <>
|
|
|
12532 struct StructExtends<PhysicalDeviceDepthClipEnableFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
12533 {
|
|
|
12534 enum
|
|
|
12535 {
|
|
|
12536 value = true
|
|
|
12537 };
|
|
|
12538 };
|
|
|
12539
|
|
|
12540 template <>
|
|
|
12541 struct StructExtends<PhysicalDeviceDepthClipEnableFeaturesEXT, DeviceCreateInfo>
|
|
|
12542 {
|
|
|
12543 enum
|
|
|
12544 {
|
|
|
12545 value = true
|
|
|
12546 };
|
|
|
12547 };
|
|
|
12548
|
|
|
12549 template <>
|
|
|
12550 struct StructExtends<PipelineRasterizationDepthClipStateCreateInfoEXT, PipelineRasterizationStateCreateInfo>
|
|
|
12551 {
|
|
|
12552 enum
|
|
|
12553 {
|
|
|
12554 value = true
|
|
|
12555 };
|
|
|
12556 };
|
|
|
12557
|
|
|
12558 //=== VK_IMG_relaxed_line_rasterization ===
|
|
|
12559 template <>
|
|
|
12560 struct StructExtends<PhysicalDeviceRelaxedLineRasterizationFeaturesIMG, PhysicalDeviceFeatures2>
|
|
|
12561 {
|
|
|
12562 enum
|
|
|
12563 {
|
|
|
12564 value = true
|
|
|
12565 };
|
|
|
12566 };
|
|
|
12567
|
|
|
12568 template <>
|
|
|
12569 struct StructExtends<PhysicalDeviceRelaxedLineRasterizationFeaturesIMG, DeviceCreateInfo>
|
|
|
12570 {
|
|
|
12571 enum
|
|
|
12572 {
|
|
|
12573 value = true
|
|
|
12574 };
|
|
|
12575 };
|
|
|
12576
|
|
|
12577 //=== VK_KHR_shared_presentable_image ===
|
|
|
12578 template <>
|
|
|
12579 struct StructExtends<SharedPresentSurfaceCapabilitiesKHR, SurfaceCapabilities2KHR>
|
|
|
12580 {
|
|
|
12581 enum
|
|
|
12582 {
|
|
|
12583 value = true
|
|
|
12584 };
|
|
|
12585 };
|
|
|
12586
|
|
|
12587 # if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
12588 //=== VK_KHR_external_fence_win32 ===
|
|
|
12589 template <>
|
|
|
12590 struct StructExtends<ExportFenceWin32HandleInfoKHR, FenceCreateInfo>
|
|
|
12591 {
|
|
|
12592 enum
|
|
|
12593 {
|
|
|
12594 value = true
|
|
|
12595 };
|
|
|
12596 };
|
|
|
12597 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
12598
|
|
|
12599 //=== VK_KHR_performance_query ===
|
|
|
12600 template <>
|
|
|
12601 struct StructExtends<PhysicalDevicePerformanceQueryFeaturesKHR, PhysicalDeviceFeatures2>
|
|
|
12602 {
|
|
|
12603 enum
|
|
|
12604 {
|
|
|
12605 value = true
|
|
|
12606 };
|
|
|
12607 };
|
|
|
12608
|
|
|
12609 template <>
|
|
|
12610 struct StructExtends<PhysicalDevicePerformanceQueryFeaturesKHR, DeviceCreateInfo>
|
|
|
12611 {
|
|
|
12612 enum
|
|
|
12613 {
|
|
|
12614 value = true
|
|
|
12615 };
|
|
|
12616 };
|
|
|
12617
|
|
|
12618 template <>
|
|
|
12619 struct StructExtends<PhysicalDevicePerformanceQueryPropertiesKHR, PhysicalDeviceProperties2>
|
|
|
12620 {
|
|
|
12621 enum
|
|
|
12622 {
|
|
|
12623 value = true
|
|
|
12624 };
|
|
|
12625 };
|
|
|
12626
|
|
|
12627 template <>
|
|
|
12628 struct StructExtends<QueryPoolPerformanceCreateInfoKHR, QueryPoolCreateInfo>
|
|
|
12629 {
|
|
|
12630 enum
|
|
|
12631 {
|
|
|
12632 value = true
|
|
|
12633 };
|
|
|
12634 };
|
|
|
12635
|
|
|
12636 template <>
|
|
|
12637 struct StructExtends<PerformanceQuerySubmitInfoKHR, SubmitInfo>
|
|
|
12638 {
|
|
|
12639 enum
|
|
|
12640 {
|
|
|
12641 value = true
|
|
|
12642 };
|
|
|
12643 };
|
|
|
12644
|
|
|
12645 template <>
|
|
|
12646 struct StructExtends<PerformanceQuerySubmitInfoKHR, SubmitInfo2>
|
|
|
12647 {
|
|
|
12648 enum
|
|
|
12649 {
|
|
|
12650 value = true
|
|
|
12651 };
|
|
|
12652 };
|
|
|
12653
|
|
|
12654 //=== VK_EXT_debug_utils ===
|
|
|
12655 template <>
|
|
|
12656 struct StructExtends<DebugUtilsMessengerCreateInfoEXT, InstanceCreateInfo>
|
|
|
12657 {
|
|
|
12658 enum
|
|
|
12659 {
|
|
|
12660 value = true
|
|
|
12661 };
|
|
|
12662 };
|
|
|
12663
|
|
|
12664 template <>
|
|
|
12665 struct StructExtends<DebugUtilsObjectNameInfoEXT, PipelineShaderStageCreateInfo>
|
|
|
12666 {
|
|
|
12667 enum
|
|
|
12668 {
|
|
|
12669 value = true
|
|
|
12670 };
|
|
|
12671 };
|
|
|
12672
|
|
|
12673 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
|
|
12674 //=== VK_ANDROID_external_memory_android_hardware_buffer ===
|
|
|
12675 template <>
|
|
|
12676 struct StructExtends<AndroidHardwareBufferUsageANDROID, ImageFormatProperties2>
|
|
|
12677 {
|
|
|
12678 enum
|
|
|
12679 {
|
|
|
12680 value = true
|
|
|
12681 };
|
|
|
12682 };
|
|
|
12683
|
|
|
12684 template <>
|
|
|
12685 struct StructExtends<AndroidHardwareBufferFormatPropertiesANDROID, AndroidHardwareBufferPropertiesANDROID>
|
|
|
12686 {
|
|
|
12687 enum
|
|
|
12688 {
|
|
|
12689 value = true
|
|
|
12690 };
|
|
|
12691 };
|
|
|
12692
|
|
|
12693 template <>
|
|
|
12694 struct StructExtends<ImportAndroidHardwareBufferInfoANDROID, MemoryAllocateInfo>
|
|
|
12695 {
|
|
|
12696 enum
|
|
|
12697 {
|
|
|
12698 value = true
|
|
|
12699 };
|
|
|
12700 };
|
|
|
12701
|
|
|
12702 template <>
|
|
|
12703 struct StructExtends<ExternalFormatANDROID, ImageCreateInfo>
|
|
|
12704 {
|
|
|
12705 enum
|
|
|
12706 {
|
|
|
12707 value = true
|
|
|
12708 };
|
|
|
12709 };
|
|
|
12710
|
|
|
12711 template <>
|
|
|
12712 struct StructExtends<ExternalFormatANDROID, SamplerYcbcrConversionCreateInfo>
|
|
|
12713 {
|
|
|
12714 enum
|
|
|
12715 {
|
|
|
12716 value = true
|
|
|
12717 };
|
|
|
12718 };
|
|
|
12719
|
|
|
12720 template <>
|
|
|
12721 struct StructExtends<ExternalFormatANDROID, AttachmentDescription2>
|
|
|
12722 {
|
|
|
12723 enum
|
|
|
12724 {
|
|
|
12725 value = true
|
|
|
12726 };
|
|
|
12727 };
|
|
|
12728
|
|
|
12729 template <>
|
|
|
12730 struct StructExtends<ExternalFormatANDROID, GraphicsPipelineCreateInfo>
|
|
|
12731 {
|
|
|
12732 enum
|
|
|
12733 {
|
|
|
12734 value = true
|
|
|
12735 };
|
|
|
12736 };
|
|
|
12737
|
|
|
12738 template <>
|
|
|
12739 struct StructExtends<ExternalFormatANDROID, CommandBufferInheritanceInfo>
|
|
|
12740 {
|
|
|
12741 enum
|
|
|
12742 {
|
|
|
12743 value = true
|
|
|
12744 };
|
|
|
12745 };
|
|
|
12746
|
|
|
12747 template <>
|
|
|
12748 struct StructExtends<AndroidHardwareBufferFormatProperties2ANDROID, AndroidHardwareBufferPropertiesANDROID>
|
|
|
12749 {
|
|
|
12750 enum
|
|
|
12751 {
|
|
|
12752 value = true
|
|
|
12753 };
|
|
|
12754 };
|
|
|
12755 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
|
|
12756
|
|
|
12757 # if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
12758 //=== VK_AMDX_shader_enqueue ===
|
|
|
12759 template <>
|
|
|
12760 struct StructExtends<PhysicalDeviceShaderEnqueueFeaturesAMDX, PhysicalDeviceFeatures2>
|
|
|
12761 {
|
|
|
12762 enum
|
|
|
12763 {
|
|
|
12764 value = true
|
|
|
12765 };
|
|
|
12766 };
|
|
|
12767
|
|
|
12768 template <>
|
|
|
12769 struct StructExtends<PhysicalDeviceShaderEnqueueFeaturesAMDX, DeviceCreateInfo>
|
|
|
12770 {
|
|
|
12771 enum
|
|
|
12772 {
|
|
|
12773 value = true
|
|
|
12774 };
|
|
|
12775 };
|
|
|
12776
|
|
|
12777 template <>
|
|
|
12778 struct StructExtends<PhysicalDeviceShaderEnqueuePropertiesAMDX, PhysicalDeviceProperties2>
|
|
|
12779 {
|
|
|
12780 enum
|
|
|
12781 {
|
|
|
12782 value = true
|
|
|
12783 };
|
|
|
12784 };
|
|
|
12785
|
|
|
12786 template <>
|
|
|
12787 struct StructExtends<PipelineShaderStageNodeCreateInfoAMDX, PipelineShaderStageCreateInfo>
|
|
|
12788 {
|
|
|
12789 enum
|
|
|
12790 {
|
|
|
12791 value = true
|
|
|
12792 };
|
|
|
12793 };
|
|
|
12794 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
12795
|
|
|
12796 //=== VK_AMD_mixed_attachment_samples ===
|
|
|
12797 template <>
|
|
|
12798 struct StructExtends<AttachmentSampleCountInfoAMD, CommandBufferInheritanceInfo>
|
|
|
12799 {
|
|
|
12800 enum
|
|
|
12801 {
|
|
|
12802 value = true
|
|
|
12803 };
|
|
|
12804 };
|
|
|
12805
|
|
|
12806 template <>
|
|
|
12807 struct StructExtends<AttachmentSampleCountInfoAMD, GraphicsPipelineCreateInfo>
|
|
|
12808 {
|
|
|
12809 enum
|
|
|
12810 {
|
|
|
12811 value = true
|
|
|
12812 };
|
|
|
12813 };
|
|
|
12814
|
|
|
12815 //=== VK_KHR_shader_bfloat16 ===
|
|
|
12816 template <>
|
|
|
12817 struct StructExtends<PhysicalDeviceShaderBfloat16FeaturesKHR, PhysicalDeviceFeatures2>
|
|
|
12818 {
|
|
|
12819 enum
|
|
|
12820 {
|
|
|
12821 value = true
|
|
|
12822 };
|
|
|
12823 };
|
|
|
12824
|
|
|
12825 template <>
|
|
|
12826 struct StructExtends<PhysicalDeviceShaderBfloat16FeaturesKHR, DeviceCreateInfo>
|
|
|
12827 {
|
|
|
12828 enum
|
|
|
12829 {
|
|
|
12830 value = true
|
|
|
12831 };
|
|
|
12832 };
|
|
|
12833
|
|
|
12834 //=== VK_EXT_sample_locations ===
|
|
|
12835 template <>
|
|
|
12836 struct StructExtends<SampleLocationsInfoEXT, ImageMemoryBarrier>
|
|
|
12837 {
|
|
|
12838 enum
|
|
|
12839 {
|
|
|
12840 value = true
|
|
|
12841 };
|
|
|
12842 };
|
|
|
12843
|
|
|
12844 template <>
|
|
|
12845 struct StructExtends<SampleLocationsInfoEXT, ImageMemoryBarrier2>
|
|
|
12846 {
|
|
|
12847 enum
|
|
|
12848 {
|
|
|
12849 value = true
|
|
|
12850 };
|
|
|
12851 };
|
|
|
12852
|
|
|
12853 template <>
|
|
|
12854 struct StructExtends<RenderPassSampleLocationsBeginInfoEXT, RenderPassBeginInfo>
|
|
|
12855 {
|
|
|
12856 enum
|
|
|
12857 {
|
|
|
12858 value = true
|
|
|
12859 };
|
|
|
12860 };
|
|
|
12861
|
|
|
12862 template <>
|
|
|
12863 struct StructExtends<PipelineSampleLocationsStateCreateInfoEXT, PipelineMultisampleStateCreateInfo>
|
|
|
12864 {
|
|
|
12865 enum
|
|
|
12866 {
|
|
|
12867 value = true
|
|
|
12868 };
|
|
|
12869 };
|
|
|
12870
|
|
|
12871 template <>
|
|
|
12872 struct StructExtends<PhysicalDeviceSampleLocationsPropertiesEXT, PhysicalDeviceProperties2>
|
|
|
12873 {
|
|
|
12874 enum
|
|
|
12875 {
|
|
|
12876 value = true
|
|
|
12877 };
|
|
|
12878 };
|
|
|
12879
|
|
|
12880 //=== VK_EXT_blend_operation_advanced ===
|
|
|
12881 template <>
|
|
|
12882 struct StructExtends<PhysicalDeviceBlendOperationAdvancedFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
12883 {
|
|
|
12884 enum
|
|
|
12885 {
|
|
|
12886 value = true
|
|
|
12887 };
|
|
|
12888 };
|
|
|
12889
|
|
|
12890 template <>
|
|
|
12891 struct StructExtends<PhysicalDeviceBlendOperationAdvancedFeaturesEXT, DeviceCreateInfo>
|
|
|
12892 {
|
|
|
12893 enum
|
|
|
12894 {
|
|
|
12895 value = true
|
|
|
12896 };
|
|
|
12897 };
|
|
|
12898
|
|
|
12899 template <>
|
|
|
12900 struct StructExtends<PhysicalDeviceBlendOperationAdvancedPropertiesEXT, PhysicalDeviceProperties2>
|
|
|
12901 {
|
|
|
12902 enum
|
|
|
12903 {
|
|
|
12904 value = true
|
|
|
12905 };
|
|
|
12906 };
|
|
|
12907
|
|
|
12908 template <>
|
|
|
12909 struct StructExtends<PipelineColorBlendAdvancedStateCreateInfoEXT, PipelineColorBlendStateCreateInfo>
|
|
|
12910 {
|
|
|
12911 enum
|
|
|
12912 {
|
|
|
12913 value = true
|
|
|
12914 };
|
|
|
12915 };
|
|
|
12916
|
|
|
12917 //=== VK_NV_fragment_coverage_to_color ===
|
|
|
12918 template <>
|
|
|
12919 struct StructExtends<PipelineCoverageToColorStateCreateInfoNV, PipelineMultisampleStateCreateInfo>
|
|
|
12920 {
|
|
|
12921 enum
|
|
|
12922 {
|
|
|
12923 value = true
|
|
|
12924 };
|
|
|
12925 };
|
|
|
12926
|
|
|
12927 //=== VK_KHR_acceleration_structure ===
|
|
|
12928 template <>
|
|
|
12929 struct StructExtends<WriteDescriptorSetAccelerationStructureKHR, WriteDescriptorSet>
|
|
|
12930 {
|
|
|
12931 enum
|
|
|
12932 {
|
|
|
12933 value = true
|
|
|
12934 };
|
|
|
12935 };
|
|
|
12936
|
|
|
12937 template <>
|
|
|
12938 struct StructExtends<PhysicalDeviceAccelerationStructureFeaturesKHR, PhysicalDeviceFeatures2>
|
|
|
12939 {
|
|
|
12940 enum
|
|
|
12941 {
|
|
|
12942 value = true
|
|
|
12943 };
|
|
|
12944 };
|
|
|
12945
|
|
|
12946 template <>
|
|
|
12947 struct StructExtends<PhysicalDeviceAccelerationStructureFeaturesKHR, DeviceCreateInfo>
|
|
|
12948 {
|
|
|
12949 enum
|
|
|
12950 {
|
|
|
12951 value = true
|
|
|
12952 };
|
|
|
12953 };
|
|
|
12954
|
|
|
12955 template <>
|
|
|
12956 struct StructExtends<PhysicalDeviceAccelerationStructurePropertiesKHR, PhysicalDeviceProperties2>
|
|
|
12957 {
|
|
|
12958 enum
|
|
|
12959 {
|
|
|
12960 value = true
|
|
|
12961 };
|
|
|
12962 };
|
|
|
12963
|
|
|
12964 //=== VK_KHR_ray_tracing_pipeline ===
|
|
|
12965 template <>
|
|
|
12966 struct StructExtends<PhysicalDeviceRayTracingPipelineFeaturesKHR, PhysicalDeviceFeatures2>
|
|
|
12967 {
|
|
|
12968 enum
|
|
|
12969 {
|
|
|
12970 value = true
|
|
|
12971 };
|
|
|
12972 };
|
|
|
12973
|
|
|
12974 template <>
|
|
|
12975 struct StructExtends<PhysicalDeviceRayTracingPipelineFeaturesKHR, DeviceCreateInfo>
|
|
|
12976 {
|
|
|
12977 enum
|
|
|
12978 {
|
|
|
12979 value = true
|
|
|
12980 };
|
|
|
12981 };
|
|
|
12982
|
|
|
12983 template <>
|
|
|
12984 struct StructExtends<PhysicalDeviceRayTracingPipelinePropertiesKHR, PhysicalDeviceProperties2>
|
|
|
12985 {
|
|
|
12986 enum
|
|
|
12987 {
|
|
|
12988 value = true
|
|
|
12989 };
|
|
|
12990 };
|
|
|
12991
|
|
|
12992 //=== VK_KHR_ray_query ===
|
|
|
12993 template <>
|
|
|
12994 struct StructExtends<PhysicalDeviceRayQueryFeaturesKHR, PhysicalDeviceFeatures2>
|
|
|
12995 {
|
|
|
12996 enum
|
|
|
12997 {
|
|
|
12998 value = true
|
|
|
12999 };
|
|
|
13000 };
|
|
|
13001
|
|
|
13002 template <>
|
|
|
13003 struct StructExtends<PhysicalDeviceRayQueryFeaturesKHR, DeviceCreateInfo>
|
|
|
13004 {
|
|
|
13005 enum
|
|
|
13006 {
|
|
|
13007 value = true
|
|
|
13008 };
|
|
|
13009 };
|
|
|
13010
|
|
|
13011 //=== VK_NV_framebuffer_mixed_samples ===
|
|
|
13012 template <>
|
|
|
13013 struct StructExtends<PipelineCoverageModulationStateCreateInfoNV, PipelineMultisampleStateCreateInfo>
|
|
|
13014 {
|
|
|
13015 enum
|
|
|
13016 {
|
|
|
13017 value = true
|
|
|
13018 };
|
|
|
13019 };
|
|
|
13020
|
|
|
13021 //=== VK_NV_shader_sm_builtins ===
|
|
|
13022 template <>
|
|
|
13023 struct StructExtends<PhysicalDeviceShaderSMBuiltinsPropertiesNV, PhysicalDeviceProperties2>
|
|
|
13024 {
|
|
|
13025 enum
|
|
|
13026 {
|
|
|
13027 value = true
|
|
|
13028 };
|
|
|
13029 };
|
|
|
13030
|
|
|
13031 template <>
|
|
|
13032 struct StructExtends<PhysicalDeviceShaderSMBuiltinsFeaturesNV, PhysicalDeviceFeatures2>
|
|
|
13033 {
|
|
|
13034 enum
|
|
|
13035 {
|
|
|
13036 value = true
|
|
|
13037 };
|
|
|
13038 };
|
|
|
13039
|
|
|
13040 template <>
|
|
|
13041 struct StructExtends<PhysicalDeviceShaderSMBuiltinsFeaturesNV, DeviceCreateInfo>
|
|
|
13042 {
|
|
|
13043 enum
|
|
|
13044 {
|
|
|
13045 value = true
|
|
|
13046 };
|
|
|
13047 };
|
|
|
13048
|
|
|
13049 //=== VK_EXT_image_drm_format_modifier ===
|
|
|
13050 template <>
|
|
|
13051 struct StructExtends<DrmFormatModifierPropertiesListEXT, FormatProperties2>
|
|
|
13052 {
|
|
|
13053 enum
|
|
|
13054 {
|
|
|
13055 value = true
|
|
|
13056 };
|
|
|
13057 };
|
|
|
13058
|
|
|
13059 template <>
|
|
|
13060 struct StructExtends<PhysicalDeviceImageDrmFormatModifierInfoEXT, PhysicalDeviceImageFormatInfo2>
|
|
|
13061 {
|
|
|
13062 enum
|
|
|
13063 {
|
|
|
13064 value = true
|
|
|
13065 };
|
|
|
13066 };
|
|
|
13067
|
|
|
13068 template <>
|
|
|
13069 struct StructExtends<ImageDrmFormatModifierListCreateInfoEXT, ImageCreateInfo>
|
|
|
13070 {
|
|
|
13071 enum
|
|
|
13072 {
|
|
|
13073 value = true
|
|
|
13074 };
|
|
|
13075 };
|
|
|
13076
|
|
|
13077 template <>
|
|
|
13078 struct StructExtends<ImageDrmFormatModifierExplicitCreateInfoEXT, ImageCreateInfo>
|
|
|
13079 {
|
|
|
13080 enum
|
|
|
13081 {
|
|
|
13082 value = true
|
|
|
13083 };
|
|
|
13084 };
|
|
|
13085
|
|
|
13086 template <>
|
|
|
13087 struct StructExtends<DrmFormatModifierPropertiesList2EXT, FormatProperties2>
|
|
|
13088 {
|
|
|
13089 enum
|
|
|
13090 {
|
|
|
13091 value = true
|
|
|
13092 };
|
|
|
13093 };
|
|
|
13094
|
|
|
13095 //=== VK_EXT_validation_cache ===
|
|
|
13096 template <>
|
|
|
13097 struct StructExtends<ShaderModuleValidationCacheCreateInfoEXT, ShaderModuleCreateInfo>
|
|
|
13098 {
|
|
|
13099 enum
|
|
|
13100 {
|
|
|
13101 value = true
|
|
|
13102 };
|
|
|
13103 };
|
|
|
13104
|
|
|
13105 template <>
|
|
|
13106 struct StructExtends<ShaderModuleValidationCacheCreateInfoEXT, PipelineShaderStageCreateInfo>
|
|
|
13107 {
|
|
|
13108 enum
|
|
|
13109 {
|
|
|
13110 value = true
|
|
|
13111 };
|
|
|
13112 };
|
|
|
13113
|
|
|
13114 # if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
13115 //=== VK_KHR_portability_subset ===
|
|
|
13116 template <>
|
|
|
13117 struct StructExtends<PhysicalDevicePortabilitySubsetFeaturesKHR, PhysicalDeviceFeatures2>
|
|
|
13118 {
|
|
|
13119 enum
|
|
|
13120 {
|
|
|
13121 value = true
|
|
|
13122 };
|
|
|
13123 };
|
|
|
13124
|
|
|
13125 template <>
|
|
|
13126 struct StructExtends<PhysicalDevicePortabilitySubsetFeaturesKHR, DeviceCreateInfo>
|
|
|
13127 {
|
|
|
13128 enum
|
|
|
13129 {
|
|
|
13130 value = true
|
|
|
13131 };
|
|
|
13132 };
|
|
|
13133
|
|
|
13134 template <>
|
|
|
13135 struct StructExtends<PhysicalDevicePortabilitySubsetPropertiesKHR, PhysicalDeviceProperties2>
|
|
|
13136 {
|
|
|
13137 enum
|
|
|
13138 {
|
|
|
13139 value = true
|
|
|
13140 };
|
|
|
13141 };
|
|
|
13142 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
13143
|
|
|
13144 //=== VK_NV_shading_rate_image ===
|
|
|
13145 template <>
|
|
|
13146 struct StructExtends<PipelineViewportShadingRateImageStateCreateInfoNV, PipelineViewportStateCreateInfo>
|
|
|
13147 {
|
|
|
13148 enum
|
|
|
13149 {
|
|
|
13150 value = true
|
|
|
13151 };
|
|
|
13152 };
|
|
|
13153
|
|
|
13154 template <>
|
|
|
13155 struct StructExtends<PhysicalDeviceShadingRateImageFeaturesNV, PhysicalDeviceFeatures2>
|
|
|
13156 {
|
|
|
13157 enum
|
|
|
13158 {
|
|
|
13159 value = true
|
|
|
13160 };
|
|
|
13161 };
|
|
|
13162
|
|
|
13163 template <>
|
|
|
13164 struct StructExtends<PhysicalDeviceShadingRateImageFeaturesNV, DeviceCreateInfo>
|
|
|
13165 {
|
|
|
13166 enum
|
|
|
13167 {
|
|
|
13168 value = true
|
|
|
13169 };
|
|
|
13170 };
|
|
|
13171
|
|
|
13172 template <>
|
|
|
13173 struct StructExtends<PhysicalDeviceShadingRateImagePropertiesNV, PhysicalDeviceProperties2>
|
|
|
13174 {
|
|
|
13175 enum
|
|
|
13176 {
|
|
|
13177 value = true
|
|
|
13178 };
|
|
|
13179 };
|
|
|
13180
|
|
|
13181 template <>
|
|
|
13182 struct StructExtends<PipelineViewportCoarseSampleOrderStateCreateInfoNV, PipelineViewportStateCreateInfo>
|
|
|
13183 {
|
|
|
13184 enum
|
|
|
13185 {
|
|
|
13186 value = true
|
|
|
13187 };
|
|
|
13188 };
|
|
|
13189
|
|
|
13190 //=== VK_NV_ray_tracing ===
|
|
|
13191 template <>
|
|
|
13192 struct StructExtends<WriteDescriptorSetAccelerationStructureNV, WriteDescriptorSet>
|
|
|
13193 {
|
|
|
13194 enum
|
|
|
13195 {
|
|
|
13196 value = true
|
|
|
13197 };
|
|
|
13198 };
|
|
|
13199
|
|
|
13200 template <>
|
|
|
13201 struct StructExtends<PhysicalDeviceRayTracingPropertiesNV, PhysicalDeviceProperties2>
|
|
|
13202 {
|
|
|
13203 enum
|
|
|
13204 {
|
|
|
13205 value = true
|
|
|
13206 };
|
|
|
13207 };
|
|
|
13208
|
|
|
13209 //=== VK_NV_representative_fragment_test ===
|
|
|
13210 template <>
|
|
|
13211 struct StructExtends<PhysicalDeviceRepresentativeFragmentTestFeaturesNV, PhysicalDeviceFeatures2>
|
|
|
13212 {
|
|
|
13213 enum
|
|
|
13214 {
|
|
|
13215 value = true
|
|
|
13216 };
|
|
|
13217 };
|
|
|
13218
|
|
|
13219 template <>
|
|
|
13220 struct StructExtends<PhysicalDeviceRepresentativeFragmentTestFeaturesNV, DeviceCreateInfo>
|
|
|
13221 {
|
|
|
13222 enum
|
|
|
13223 {
|
|
|
13224 value = true
|
|
|
13225 };
|
|
|
13226 };
|
|
|
13227
|
|
|
13228 template <>
|
|
|
13229 struct StructExtends<PipelineRepresentativeFragmentTestStateCreateInfoNV, GraphicsPipelineCreateInfo>
|
|
|
13230 {
|
|
|
13231 enum
|
|
|
13232 {
|
|
|
13233 value = true
|
|
|
13234 };
|
|
|
13235 };
|
|
|
13236
|
|
|
13237 //=== VK_EXT_filter_cubic ===
|
|
|
13238 template <>
|
|
|
13239 struct StructExtends<PhysicalDeviceImageViewImageFormatInfoEXT, PhysicalDeviceImageFormatInfo2>
|
|
|
13240 {
|
|
|
13241 enum
|
|
|
13242 {
|
|
|
13243 value = true
|
|
|
13244 };
|
|
|
13245 };
|
|
|
13246
|
|
|
13247 template <>
|
|
|
13248 struct StructExtends<FilterCubicImageViewImageFormatPropertiesEXT, ImageFormatProperties2>
|
|
|
13249 {
|
|
|
13250 enum
|
|
|
13251 {
|
|
|
13252 value = true
|
|
|
13253 };
|
|
|
13254 };
|
|
|
13255
|
|
|
13256 //=== VK_EXT_external_memory_host ===
|
|
|
13257 template <>
|
|
|
13258 struct StructExtends<ImportMemoryHostPointerInfoEXT, MemoryAllocateInfo>
|
|
|
13259 {
|
|
|
13260 enum
|
|
|
13261 {
|
|
|
13262 value = true
|
|
|
13263 };
|
|
|
13264 };
|
|
|
13265
|
|
|
13266 template <>
|
|
|
13267 struct StructExtends<PhysicalDeviceExternalMemoryHostPropertiesEXT, PhysicalDeviceProperties2>
|
|
|
13268 {
|
|
|
13269 enum
|
|
|
13270 {
|
|
|
13271 value = true
|
|
|
13272 };
|
|
|
13273 };
|
|
|
13274
|
|
|
13275 //=== VK_KHR_shader_clock ===
|
|
|
13276 template <>
|
|
|
13277 struct StructExtends<PhysicalDeviceShaderClockFeaturesKHR, PhysicalDeviceFeatures2>
|
|
|
13278 {
|
|
|
13279 enum
|
|
|
13280 {
|
|
|
13281 value = true
|
|
|
13282 };
|
|
|
13283 };
|
|
|
13284
|
|
|
13285 template <>
|
|
|
13286 struct StructExtends<PhysicalDeviceShaderClockFeaturesKHR, DeviceCreateInfo>
|
|
|
13287 {
|
|
|
13288 enum
|
|
|
13289 {
|
|
|
13290 value = true
|
|
|
13291 };
|
|
|
13292 };
|
|
|
13293
|
|
|
13294 //=== VK_AMD_pipeline_compiler_control ===
|
|
|
13295 template <>
|
|
|
13296 struct StructExtends<PipelineCompilerControlCreateInfoAMD, GraphicsPipelineCreateInfo>
|
|
|
13297 {
|
|
|
13298 enum
|
|
|
13299 {
|
|
|
13300 value = true
|
|
|
13301 };
|
|
|
13302 };
|
|
|
13303
|
|
|
13304 template <>
|
|
|
13305 struct StructExtends<PipelineCompilerControlCreateInfoAMD, ComputePipelineCreateInfo>
|
|
|
13306 {
|
|
|
13307 enum
|
|
|
13308 {
|
|
|
13309 value = true
|
|
|
13310 };
|
|
|
13311 };
|
|
|
13312 # if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
13313 template <>
|
|
|
13314 struct StructExtends<PipelineCompilerControlCreateInfoAMD, ExecutionGraphPipelineCreateInfoAMDX>
|
|
|
13315 {
|
|
|
13316 enum
|
|
|
13317 {
|
|
|
13318 value = true
|
|
|
13319 };
|
|
|
13320 };
|
|
|
13321 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
13322
|
|
|
13323 //=== VK_AMD_shader_core_properties ===
|
|
|
13324 template <>
|
|
|
13325 struct StructExtends<PhysicalDeviceShaderCorePropertiesAMD, PhysicalDeviceProperties2>
|
|
|
13326 {
|
|
|
13327 enum
|
|
|
13328 {
|
|
|
13329 value = true
|
|
|
13330 };
|
|
|
13331 };
|
|
|
13332
|
|
|
13333 //=== VK_KHR_video_decode_h265 ===
|
|
|
13334 template <>
|
|
|
13335 struct StructExtends<VideoDecodeH265ProfileInfoKHR, VideoProfileInfoKHR>
|
|
|
13336 {
|
|
|
13337 enum
|
|
|
13338 {
|
|
|
13339 value = true
|
|
|
13340 };
|
|
|
13341 };
|
|
|
13342
|
|
|
13343 template <>
|
|
|
13344 struct StructExtends<VideoDecodeH265ProfileInfoKHR, QueryPoolCreateInfo>
|
|
|
13345 {
|
|
|
13346 enum
|
|
|
13347 {
|
|
|
13348 value = true
|
|
|
13349 };
|
|
|
13350 };
|
|
|
13351
|
|
|
13352 template <>
|
|
|
13353 struct StructExtends<VideoDecodeH265CapabilitiesKHR, VideoCapabilitiesKHR>
|
|
|
13354 {
|
|
|
13355 enum
|
|
|
13356 {
|
|
|
13357 value = true
|
|
|
13358 };
|
|
|
13359 };
|
|
|
13360
|
|
|
13361 template <>
|
|
|
13362 struct StructExtends<VideoDecodeH265SessionParametersCreateInfoKHR, VideoSessionParametersCreateInfoKHR>
|
|
|
13363 {
|
|
|
13364 enum
|
|
|
13365 {
|
|
|
13366 value = true
|
|
|
13367 };
|
|
|
13368 };
|
|
|
13369
|
|
|
13370 template <>
|
|
|
13371 struct StructExtends<VideoDecodeH265SessionParametersAddInfoKHR, VideoSessionParametersUpdateInfoKHR>
|
|
|
13372 {
|
|
|
13373 enum
|
|
|
13374 {
|
|
|
13375 value = true
|
|
|
13376 };
|
|
|
13377 };
|
|
|
13378
|
|
|
13379 template <>
|
|
|
13380 struct StructExtends<VideoDecodeH265PictureInfoKHR, VideoDecodeInfoKHR>
|
|
|
13381 {
|
|
|
13382 enum
|
|
|
13383 {
|
|
|
13384 value = true
|
|
|
13385 };
|
|
|
13386 };
|
|
|
13387
|
|
|
13388 template <>
|
|
|
13389 struct StructExtends<VideoDecodeH265DpbSlotInfoKHR, VideoReferenceSlotInfoKHR>
|
|
|
13390 {
|
|
|
13391 enum
|
|
|
13392 {
|
|
|
13393 value = true
|
|
|
13394 };
|
|
|
13395 };
|
|
|
13396
|
|
|
13397 //=== VK_AMD_memory_overallocation_behavior ===
|
|
|
13398 template <>
|
|
|
13399 struct StructExtends<DeviceMemoryOverallocationCreateInfoAMD, DeviceCreateInfo>
|
|
|
13400 {
|
|
|
13401 enum
|
|
|
13402 {
|
|
|
13403 value = true
|
|
|
13404 };
|
|
|
13405 };
|
|
|
13406
|
|
|
13407 //=== VK_EXT_vertex_attribute_divisor ===
|
|
|
13408 template <>
|
|
|
13409 struct StructExtends<PhysicalDeviceVertexAttributeDivisorPropertiesEXT, PhysicalDeviceProperties2>
|
|
|
13410 {
|
|
|
13411 enum
|
|
|
13412 {
|
|
|
13413 value = true
|
|
|
13414 };
|
|
|
13415 };
|
|
|
13416
|
|
|
13417 # if defined( VK_USE_PLATFORM_GGP )
|
|
|
13418 //=== VK_GGP_frame_token ===
|
|
|
13419 template <>
|
|
|
13420 struct StructExtends<PresentFrameTokenGGP, PresentInfoKHR>
|
|
|
13421 {
|
|
|
13422 enum
|
|
|
13423 {
|
|
|
13424 value = true
|
|
|
13425 };
|
|
|
13426 };
|
|
|
13427 # endif /*VK_USE_PLATFORM_GGP*/
|
|
|
13428
|
|
|
13429 //=== VK_NV_mesh_shader ===
|
|
|
13430 template <>
|
|
|
13431 struct StructExtends<PhysicalDeviceMeshShaderFeaturesNV, PhysicalDeviceFeatures2>
|
|
|
13432 {
|
|
|
13433 enum
|
|
|
13434 {
|
|
|
13435 value = true
|
|
|
13436 };
|
|
|
13437 };
|
|
|
13438
|
|
|
13439 template <>
|
|
|
13440 struct StructExtends<PhysicalDeviceMeshShaderFeaturesNV, DeviceCreateInfo>
|
|
|
13441 {
|
|
|
13442 enum
|
|
|
13443 {
|
|
|
13444 value = true
|
|
|
13445 };
|
|
|
13446 };
|
|
|
13447
|
|
|
13448 template <>
|
|
|
13449 struct StructExtends<PhysicalDeviceMeshShaderPropertiesNV, PhysicalDeviceProperties2>
|
|
|
13450 {
|
|
|
13451 enum
|
|
|
13452 {
|
|
|
13453 value = true
|
|
|
13454 };
|
|
|
13455 };
|
|
|
13456
|
|
|
13457 //=== VK_NV_shader_image_footprint ===
|
|
|
13458 template <>
|
|
|
13459 struct StructExtends<PhysicalDeviceShaderImageFootprintFeaturesNV, PhysicalDeviceFeatures2>
|
|
|
13460 {
|
|
|
13461 enum
|
|
|
13462 {
|
|
|
13463 value = true
|
|
|
13464 };
|
|
|
13465 };
|
|
|
13466
|
|
|
13467 template <>
|
|
|
13468 struct StructExtends<PhysicalDeviceShaderImageFootprintFeaturesNV, DeviceCreateInfo>
|
|
|
13469 {
|
|
|
13470 enum
|
|
|
13471 {
|
|
|
13472 value = true
|
|
|
13473 };
|
|
|
13474 };
|
|
|
13475
|
|
|
13476 //=== VK_NV_scissor_exclusive ===
|
|
|
13477 template <>
|
|
|
13478 struct StructExtends<PipelineViewportExclusiveScissorStateCreateInfoNV, PipelineViewportStateCreateInfo>
|
|
|
13479 {
|
|
|
13480 enum
|
|
|
13481 {
|
|
|
13482 value = true
|
|
|
13483 };
|
|
|
13484 };
|
|
|
13485
|
|
|
13486 template <>
|
|
|
13487 struct StructExtends<PhysicalDeviceExclusiveScissorFeaturesNV, PhysicalDeviceFeatures2>
|
|
|
13488 {
|
|
|
13489 enum
|
|
|
13490 {
|
|
|
13491 value = true
|
|
|
13492 };
|
|
|
13493 };
|
|
|
13494
|
|
|
13495 template <>
|
|
|
13496 struct StructExtends<PhysicalDeviceExclusiveScissorFeaturesNV, DeviceCreateInfo>
|
|
|
13497 {
|
|
|
13498 enum
|
|
|
13499 {
|
|
|
13500 value = true
|
|
|
13501 };
|
|
|
13502 };
|
|
|
13503
|
|
|
13504 //=== VK_NV_device_diagnostic_checkpoints ===
|
|
|
13505 template <>
|
|
|
13506 struct StructExtends<QueueFamilyCheckpointPropertiesNV, QueueFamilyProperties2>
|
|
|
13507 {
|
|
|
13508 enum
|
|
|
13509 {
|
|
|
13510 value = true
|
|
|
13511 };
|
|
|
13512 };
|
|
|
13513
|
|
|
13514 template <>
|
|
|
13515 struct StructExtends<QueueFamilyCheckpointProperties2NV, QueueFamilyProperties2>
|
|
|
13516 {
|
|
|
13517 enum
|
|
|
13518 {
|
|
|
13519 value = true
|
|
|
13520 };
|
|
|
13521 };
|
|
|
13522
|
|
|
13523 //=== VK_INTEL_shader_integer_functions2 ===
|
|
|
13524 template <>
|
|
|
13525 struct StructExtends<PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL, PhysicalDeviceFeatures2>
|
|
|
13526 {
|
|
|
13527 enum
|
|
|
13528 {
|
|
|
13529 value = true
|
|
|
13530 };
|
|
|
13531 };
|
|
|
13532
|
|
|
13533 template <>
|
|
|
13534 struct StructExtends<PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL, DeviceCreateInfo>
|
|
|
13535 {
|
|
|
13536 enum
|
|
|
13537 {
|
|
|
13538 value = true
|
|
|
13539 };
|
|
|
13540 };
|
|
|
13541
|
|
|
13542 //=== VK_INTEL_performance_query ===
|
|
|
13543 template <>
|
|
|
13544 struct StructExtends<QueryPoolPerformanceQueryCreateInfoINTEL, QueryPoolCreateInfo>
|
|
|
13545 {
|
|
|
13546 enum
|
|
|
13547 {
|
|
|
13548 value = true
|
|
|
13549 };
|
|
|
13550 };
|
|
|
13551
|
|
|
13552 //=== VK_EXT_pci_bus_info ===
|
|
|
13553 template <>
|
|
|
13554 struct StructExtends<PhysicalDevicePCIBusInfoPropertiesEXT, PhysicalDeviceProperties2>
|
|
|
13555 {
|
|
|
13556 enum
|
|
|
13557 {
|
|
|
13558 value = true
|
|
|
13559 };
|
|
|
13560 };
|
|
|
13561
|
|
|
13562 //=== VK_AMD_display_native_hdr ===
|
|
|
13563 template <>
|
|
|
13564 struct StructExtends<DisplayNativeHdrSurfaceCapabilitiesAMD, SurfaceCapabilities2KHR>
|
|
|
13565 {
|
|
|
13566 enum
|
|
|
13567 {
|
|
|
13568 value = true
|
|
|
13569 };
|
|
|
13570 };
|
|
|
13571
|
|
|
13572 template <>
|
|
|
13573 struct StructExtends<SwapchainDisplayNativeHdrCreateInfoAMD, SwapchainCreateInfoKHR>
|
|
|
13574 {
|
|
|
13575 enum
|
|
|
13576 {
|
|
|
13577 value = true
|
|
|
13578 };
|
|
|
13579 };
|
|
|
13580
|
|
|
13581 //=== VK_EXT_fragment_density_map ===
|
|
|
13582 template <>
|
|
|
13583 struct StructExtends<PhysicalDeviceFragmentDensityMapFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
13584 {
|
|
|
13585 enum
|
|
|
13586 {
|
|
|
13587 value = true
|
|
|
13588 };
|
|
|
13589 };
|
|
|
13590
|
|
|
13591 template <>
|
|
|
13592 struct StructExtends<PhysicalDeviceFragmentDensityMapFeaturesEXT, DeviceCreateInfo>
|
|
|
13593 {
|
|
|
13594 enum
|
|
|
13595 {
|
|
|
13596 value = true
|
|
|
13597 };
|
|
|
13598 };
|
|
|
13599
|
|
|
13600 template <>
|
|
|
13601 struct StructExtends<PhysicalDeviceFragmentDensityMapPropertiesEXT, PhysicalDeviceProperties2>
|
|
|
13602 {
|
|
|
13603 enum
|
|
|
13604 {
|
|
|
13605 value = true
|
|
|
13606 };
|
|
|
13607 };
|
|
|
13608
|
|
|
13609 template <>
|
|
|
13610 struct StructExtends<RenderPassFragmentDensityMapCreateInfoEXT, RenderPassCreateInfo>
|
|
|
13611 {
|
|
|
13612 enum
|
|
|
13613 {
|
|
|
13614 value = true
|
|
|
13615 };
|
|
|
13616 };
|
|
|
13617
|
|
|
13618 template <>
|
|
|
13619 struct StructExtends<RenderPassFragmentDensityMapCreateInfoEXT, RenderPassCreateInfo2>
|
|
|
13620 {
|
|
|
13621 enum
|
|
|
13622 {
|
|
|
13623 value = true
|
|
|
13624 };
|
|
|
13625 };
|
|
|
13626
|
|
|
13627 template <>
|
|
|
13628 struct StructExtends<RenderingFragmentDensityMapAttachmentInfoEXT, RenderingInfo>
|
|
|
13629 {
|
|
|
13630 enum
|
|
|
13631 {
|
|
|
13632 value = true
|
|
|
13633 };
|
|
|
13634 };
|
|
|
13635
|
|
|
13636 //=== VK_KHR_fragment_shading_rate ===
|
|
|
13637 template <>
|
|
|
13638 struct StructExtends<FragmentShadingRateAttachmentInfoKHR, SubpassDescription2>
|
|
|
13639 {
|
|
|
13640 enum
|
|
|
13641 {
|
|
|
13642 value = true
|
|
|
13643 };
|
|
|
13644 };
|
|
|
13645
|
|
|
13646 template <>
|
|
|
13647 struct StructExtends<PipelineFragmentShadingRateStateCreateInfoKHR, GraphicsPipelineCreateInfo>
|
|
|
13648 {
|
|
|
13649 enum
|
|
|
13650 {
|
|
|
13651 value = true
|
|
|
13652 };
|
|
|
13653 };
|
|
|
13654
|
|
|
13655 template <>
|
|
|
13656 struct StructExtends<PhysicalDeviceFragmentShadingRateFeaturesKHR, PhysicalDeviceFeatures2>
|
|
|
13657 {
|
|
|
13658 enum
|
|
|
13659 {
|
|
|
13660 value = true
|
|
|
13661 };
|
|
|
13662 };
|
|
|
13663
|
|
|
13664 template <>
|
|
|
13665 struct StructExtends<PhysicalDeviceFragmentShadingRateFeaturesKHR, DeviceCreateInfo>
|
|
|
13666 {
|
|
|
13667 enum
|
|
|
13668 {
|
|
|
13669 value = true
|
|
|
13670 };
|
|
|
13671 };
|
|
|
13672
|
|
|
13673 template <>
|
|
|
13674 struct StructExtends<PhysicalDeviceFragmentShadingRatePropertiesKHR, PhysicalDeviceProperties2>
|
|
|
13675 {
|
|
|
13676 enum
|
|
|
13677 {
|
|
|
13678 value = true
|
|
|
13679 };
|
|
|
13680 };
|
|
|
13681
|
|
|
13682 template <>
|
|
|
13683 struct StructExtends<RenderingFragmentShadingRateAttachmentInfoKHR, RenderingInfo>
|
|
|
13684 {
|
|
|
13685 enum
|
|
|
13686 {
|
|
|
13687 value = true
|
|
|
13688 };
|
|
|
13689 };
|
|
|
13690
|
|
|
13691 //=== VK_AMD_shader_core_properties2 ===
|
|
|
13692 template <>
|
|
|
13693 struct StructExtends<PhysicalDeviceShaderCoreProperties2AMD, PhysicalDeviceProperties2>
|
|
|
13694 {
|
|
|
13695 enum
|
|
|
13696 {
|
|
|
13697 value = true
|
|
|
13698 };
|
|
|
13699 };
|
|
|
13700
|
|
|
13701 //=== VK_AMD_device_coherent_memory ===
|
|
|
13702 template <>
|
|
|
13703 struct StructExtends<PhysicalDeviceCoherentMemoryFeaturesAMD, PhysicalDeviceFeatures2>
|
|
|
13704 {
|
|
|
13705 enum
|
|
|
13706 {
|
|
|
13707 value = true
|
|
|
13708 };
|
|
|
13709 };
|
|
|
13710
|
|
|
13711 template <>
|
|
|
13712 struct StructExtends<PhysicalDeviceCoherentMemoryFeaturesAMD, DeviceCreateInfo>
|
|
|
13713 {
|
|
|
13714 enum
|
|
|
13715 {
|
|
|
13716 value = true
|
|
|
13717 };
|
|
|
13718 };
|
|
|
13719
|
|
|
13720 //=== VK_EXT_shader_image_atomic_int64 ===
|
|
|
13721 template <>
|
|
|
13722 struct StructExtends<PhysicalDeviceShaderImageAtomicInt64FeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
13723 {
|
|
|
13724 enum
|
|
|
13725 {
|
|
|
13726 value = true
|
|
|
13727 };
|
|
|
13728 };
|
|
|
13729
|
|
|
13730 template <>
|
|
|
13731 struct StructExtends<PhysicalDeviceShaderImageAtomicInt64FeaturesEXT, DeviceCreateInfo>
|
|
|
13732 {
|
|
|
13733 enum
|
|
|
13734 {
|
|
|
13735 value = true
|
|
|
13736 };
|
|
|
13737 };
|
|
|
13738
|
|
|
13739 //=== VK_KHR_shader_quad_control ===
|
|
|
13740 template <>
|
|
|
13741 struct StructExtends<PhysicalDeviceShaderQuadControlFeaturesKHR, PhysicalDeviceFeatures2>
|
|
|
13742 {
|
|
|
13743 enum
|
|
|
13744 {
|
|
|
13745 value = true
|
|
|
13746 };
|
|
|
13747 };
|
|
|
13748
|
|
|
13749 template <>
|
|
|
13750 struct StructExtends<PhysicalDeviceShaderQuadControlFeaturesKHR, DeviceCreateInfo>
|
|
|
13751 {
|
|
|
13752 enum
|
|
|
13753 {
|
|
|
13754 value = true
|
|
|
13755 };
|
|
|
13756 };
|
|
|
13757
|
|
|
13758 //=== VK_EXT_memory_budget ===
|
|
|
13759 template <>
|
|
|
13760 struct StructExtends<PhysicalDeviceMemoryBudgetPropertiesEXT, PhysicalDeviceMemoryProperties2>
|
|
|
13761 {
|
|
|
13762 enum
|
|
|
13763 {
|
|
|
13764 value = true
|
|
|
13765 };
|
|
|
13766 };
|
|
|
13767
|
|
|
13768 //=== VK_EXT_memory_priority ===
|
|
|
13769 template <>
|
|
|
13770 struct StructExtends<PhysicalDeviceMemoryPriorityFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
13771 {
|
|
|
13772 enum
|
|
|
13773 {
|
|
|
13774 value = true
|
|
|
13775 };
|
|
|
13776 };
|
|
|
13777
|
|
|
13778 template <>
|
|
|
13779 struct StructExtends<PhysicalDeviceMemoryPriorityFeaturesEXT, DeviceCreateInfo>
|
|
|
13780 {
|
|
|
13781 enum
|
|
|
13782 {
|
|
|
13783 value = true
|
|
|
13784 };
|
|
|
13785 };
|
|
|
13786
|
|
|
13787 template <>
|
|
|
13788 struct StructExtends<MemoryPriorityAllocateInfoEXT, MemoryAllocateInfo>
|
|
|
13789 {
|
|
|
13790 enum
|
|
|
13791 {
|
|
|
13792 value = true
|
|
|
13793 };
|
|
|
13794 };
|
|
|
13795
|
|
|
13796 //=== VK_KHR_surface_protected_capabilities ===
|
|
|
13797 template <>
|
|
|
13798 struct StructExtends<SurfaceProtectedCapabilitiesKHR, SurfaceCapabilities2KHR>
|
|
|
13799 {
|
|
|
13800 enum
|
|
|
13801 {
|
|
|
13802 value = true
|
|
|
13803 };
|
|
|
13804 };
|
|
|
13805
|
|
|
13806 //=== VK_NV_dedicated_allocation_image_aliasing ===
|
|
|
13807 template <>
|
|
|
13808 struct StructExtends<PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, PhysicalDeviceFeatures2>
|
|
|
13809 {
|
|
|
13810 enum
|
|
|
13811 {
|
|
|
13812 value = true
|
|
|
13813 };
|
|
|
13814 };
|
|
|
13815
|
|
|
13816 template <>
|
|
|
13817 struct StructExtends<PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, DeviceCreateInfo>
|
|
|
13818 {
|
|
|
13819 enum
|
|
|
13820 {
|
|
|
13821 value = true
|
|
|
13822 };
|
|
|
13823 };
|
|
|
13824
|
|
|
13825 //=== VK_EXT_buffer_device_address ===
|
|
|
13826 template <>
|
|
|
13827 struct StructExtends<PhysicalDeviceBufferDeviceAddressFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
13828 {
|
|
|
13829 enum
|
|
|
13830 {
|
|
|
13831 value = true
|
|
|
13832 };
|
|
|
13833 };
|
|
|
13834
|
|
|
13835 template <>
|
|
|
13836 struct StructExtends<PhysicalDeviceBufferDeviceAddressFeaturesEXT, DeviceCreateInfo>
|
|
|
13837 {
|
|
|
13838 enum
|
|
|
13839 {
|
|
|
13840 value = true
|
|
|
13841 };
|
|
|
13842 };
|
|
|
13843
|
|
|
13844 template <>
|
|
|
13845 struct StructExtends<BufferDeviceAddressCreateInfoEXT, BufferCreateInfo>
|
|
|
13846 {
|
|
|
13847 enum
|
|
|
13848 {
|
|
|
13849 value = true
|
|
|
13850 };
|
|
|
13851 };
|
|
|
13852
|
|
|
13853 //=== VK_EXT_validation_features ===
|
|
|
13854 template <>
|
|
|
13855 struct StructExtends<ValidationFeaturesEXT, InstanceCreateInfo>
|
|
|
13856 {
|
|
|
13857 enum
|
|
|
13858 {
|
|
|
13859 value = true
|
|
|
13860 };
|
|
|
13861 };
|
|
|
13862
|
|
|
13863 template <>
|
|
|
13864 struct StructExtends<ValidationFeaturesEXT, ShaderModuleCreateInfo>
|
|
|
13865 {
|
|
|
13866 enum
|
|
|
13867 {
|
|
|
13868 value = true
|
|
|
13869 };
|
|
|
13870 };
|
|
|
13871
|
|
|
13872 template <>
|
|
|
13873 struct StructExtends<ValidationFeaturesEXT, ShaderCreateInfoEXT>
|
|
|
13874 {
|
|
|
13875 enum
|
|
|
13876 {
|
|
|
13877 value = true
|
|
|
13878 };
|
|
|
13879 };
|
|
|
13880
|
|
|
13881 //=== VK_KHR_present_wait ===
|
|
|
13882 template <>
|
|
|
13883 struct StructExtends<PhysicalDevicePresentWaitFeaturesKHR, PhysicalDeviceFeatures2>
|
|
|
13884 {
|
|
|
13885 enum
|
|
|
13886 {
|
|
|
13887 value = true
|
|
|
13888 };
|
|
|
13889 };
|
|
|
13890
|
|
|
13891 template <>
|
|
|
13892 struct StructExtends<PhysicalDevicePresentWaitFeaturesKHR, DeviceCreateInfo>
|
|
|
13893 {
|
|
|
13894 enum
|
|
|
13895 {
|
|
|
13896 value = true
|
|
|
13897 };
|
|
|
13898 };
|
|
|
13899
|
|
|
13900 //=== VK_NV_cooperative_matrix ===
|
|
|
13901 template <>
|
|
|
13902 struct StructExtends<PhysicalDeviceCooperativeMatrixFeaturesNV, PhysicalDeviceFeatures2>
|
|
|
13903 {
|
|
|
13904 enum
|
|
|
13905 {
|
|
|
13906 value = true
|
|
|
13907 };
|
|
|
13908 };
|
|
|
13909
|
|
|
13910 template <>
|
|
|
13911 struct StructExtends<PhysicalDeviceCooperativeMatrixFeaturesNV, DeviceCreateInfo>
|
|
|
13912 {
|
|
|
13913 enum
|
|
|
13914 {
|
|
|
13915 value = true
|
|
|
13916 };
|
|
|
13917 };
|
|
|
13918
|
|
|
13919 template <>
|
|
|
13920 struct StructExtends<PhysicalDeviceCooperativeMatrixPropertiesNV, PhysicalDeviceProperties2>
|
|
|
13921 {
|
|
|
13922 enum
|
|
|
13923 {
|
|
|
13924 value = true
|
|
|
13925 };
|
|
|
13926 };
|
|
|
13927
|
|
|
13928 //=== VK_NV_coverage_reduction_mode ===
|
|
|
13929 template <>
|
|
|
13930 struct StructExtends<PhysicalDeviceCoverageReductionModeFeaturesNV, PhysicalDeviceFeatures2>
|
|
|
13931 {
|
|
|
13932 enum
|
|
|
13933 {
|
|
|
13934 value = true
|
|
|
13935 };
|
|
|
13936 };
|
|
|
13937
|
|
|
13938 template <>
|
|
|
13939 struct StructExtends<PhysicalDeviceCoverageReductionModeFeaturesNV, DeviceCreateInfo>
|
|
|
13940 {
|
|
|
13941 enum
|
|
|
13942 {
|
|
|
13943 value = true
|
|
|
13944 };
|
|
|
13945 };
|
|
|
13946
|
|
|
13947 template <>
|
|
|
13948 struct StructExtends<PipelineCoverageReductionStateCreateInfoNV, PipelineMultisampleStateCreateInfo>
|
|
|
13949 {
|
|
|
13950 enum
|
|
|
13951 {
|
|
|
13952 value = true
|
|
|
13953 };
|
|
|
13954 };
|
|
|
13955
|
|
|
13956 //=== VK_EXT_fragment_shader_interlock ===
|
|
|
13957 template <>
|
|
|
13958 struct StructExtends<PhysicalDeviceFragmentShaderInterlockFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
13959 {
|
|
|
13960 enum
|
|
|
13961 {
|
|
|
13962 value = true
|
|
|
13963 };
|
|
|
13964 };
|
|
|
13965
|
|
|
13966 template <>
|
|
|
13967 struct StructExtends<PhysicalDeviceFragmentShaderInterlockFeaturesEXT, DeviceCreateInfo>
|
|
|
13968 {
|
|
|
13969 enum
|
|
|
13970 {
|
|
|
13971 value = true
|
|
|
13972 };
|
|
|
13973 };
|
|
|
13974
|
|
|
13975 //=== VK_EXT_ycbcr_image_arrays ===
|
|
|
13976 template <>
|
|
|
13977 struct StructExtends<PhysicalDeviceYcbcrImageArraysFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
13978 {
|
|
|
13979 enum
|
|
|
13980 {
|
|
|
13981 value = true
|
|
|
13982 };
|
|
|
13983 };
|
|
|
13984
|
|
|
13985 template <>
|
|
|
13986 struct StructExtends<PhysicalDeviceYcbcrImageArraysFeaturesEXT, DeviceCreateInfo>
|
|
|
13987 {
|
|
|
13988 enum
|
|
|
13989 {
|
|
|
13990 value = true
|
|
|
13991 };
|
|
|
13992 };
|
|
|
13993
|
|
|
13994 //=== VK_EXT_provoking_vertex ===
|
|
|
13995 template <>
|
|
|
13996 struct StructExtends<PhysicalDeviceProvokingVertexFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
13997 {
|
|
|
13998 enum
|
|
|
13999 {
|
|
|
14000 value = true
|
|
|
14001 };
|
|
|
14002 };
|
|
|
14003
|
|
|
14004 template <>
|
|
|
14005 struct StructExtends<PhysicalDeviceProvokingVertexFeaturesEXT, DeviceCreateInfo>
|
|
|
14006 {
|
|
|
14007 enum
|
|
|
14008 {
|
|
|
14009 value = true
|
|
|
14010 };
|
|
|
14011 };
|
|
|
14012
|
|
|
14013 template <>
|
|
|
14014 struct StructExtends<PhysicalDeviceProvokingVertexPropertiesEXT, PhysicalDeviceProperties2>
|
|
|
14015 {
|
|
|
14016 enum
|
|
|
14017 {
|
|
|
14018 value = true
|
|
|
14019 };
|
|
|
14020 };
|
|
|
14021
|
|
|
14022 template <>
|
|
|
14023 struct StructExtends<PipelineRasterizationProvokingVertexStateCreateInfoEXT, PipelineRasterizationStateCreateInfo>
|
|
|
14024 {
|
|
|
14025 enum
|
|
|
14026 {
|
|
|
14027 value = true
|
|
|
14028 };
|
|
|
14029 };
|
|
|
14030
|
|
|
14031 # if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
14032 //=== VK_EXT_full_screen_exclusive ===
|
|
|
14033 template <>
|
|
|
14034 struct StructExtends<SurfaceFullScreenExclusiveInfoEXT, PhysicalDeviceSurfaceInfo2KHR>
|
|
|
14035 {
|
|
|
14036 enum
|
|
|
14037 {
|
|
|
14038 value = true
|
|
|
14039 };
|
|
|
14040 };
|
|
|
14041
|
|
|
14042 template <>
|
|
|
14043 struct StructExtends<SurfaceFullScreenExclusiveInfoEXT, SwapchainCreateInfoKHR>
|
|
|
14044 {
|
|
|
14045 enum
|
|
|
14046 {
|
|
|
14047 value = true
|
|
|
14048 };
|
|
|
14049 };
|
|
|
14050
|
|
|
14051 template <>
|
|
|
14052 struct StructExtends<SurfaceCapabilitiesFullScreenExclusiveEXT, SurfaceCapabilities2KHR>
|
|
|
14053 {
|
|
|
14054 enum
|
|
|
14055 {
|
|
|
14056 value = true
|
|
|
14057 };
|
|
|
14058 };
|
|
|
14059
|
|
|
14060 template <>
|
|
|
14061 struct StructExtends<SurfaceFullScreenExclusiveWin32InfoEXT, PhysicalDeviceSurfaceInfo2KHR>
|
|
|
14062 {
|
|
|
14063 enum
|
|
|
14064 {
|
|
|
14065 value = true
|
|
|
14066 };
|
|
|
14067 };
|
|
|
14068
|
|
|
14069 template <>
|
|
|
14070 struct StructExtends<SurfaceFullScreenExclusiveWin32InfoEXT, SwapchainCreateInfoKHR>
|
|
|
14071 {
|
|
|
14072 enum
|
|
|
14073 {
|
|
|
14074 value = true
|
|
|
14075 };
|
|
|
14076 };
|
|
|
14077 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
14078
|
|
|
14079 //=== VK_EXT_shader_atomic_float ===
|
|
|
14080 template <>
|
|
|
14081 struct StructExtends<PhysicalDeviceShaderAtomicFloatFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
14082 {
|
|
|
14083 enum
|
|
|
14084 {
|
|
|
14085 value = true
|
|
|
14086 };
|
|
|
14087 };
|
|
|
14088
|
|
|
14089 template <>
|
|
|
14090 struct StructExtends<PhysicalDeviceShaderAtomicFloatFeaturesEXT, DeviceCreateInfo>
|
|
|
14091 {
|
|
|
14092 enum
|
|
|
14093 {
|
|
|
14094 value = true
|
|
|
14095 };
|
|
|
14096 };
|
|
|
14097
|
|
|
14098 //=== VK_EXT_extended_dynamic_state ===
|
|
|
14099 template <>
|
|
|
14100 struct StructExtends<PhysicalDeviceExtendedDynamicStateFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
14101 {
|
|
|
14102 enum
|
|
|
14103 {
|
|
|
14104 value = true
|
|
|
14105 };
|
|
|
14106 };
|
|
|
14107
|
|
|
14108 template <>
|
|
|
14109 struct StructExtends<PhysicalDeviceExtendedDynamicStateFeaturesEXT, DeviceCreateInfo>
|
|
|
14110 {
|
|
|
14111 enum
|
|
|
14112 {
|
|
|
14113 value = true
|
|
|
14114 };
|
|
|
14115 };
|
|
|
14116
|
|
|
14117 //=== VK_KHR_pipeline_executable_properties ===
|
|
|
14118 template <>
|
|
|
14119 struct StructExtends<PhysicalDevicePipelineExecutablePropertiesFeaturesKHR, PhysicalDeviceFeatures2>
|
|
|
14120 {
|
|
|
14121 enum
|
|
|
14122 {
|
|
|
14123 value = true
|
|
|
14124 };
|
|
|
14125 };
|
|
|
14126
|
|
|
14127 template <>
|
|
|
14128 struct StructExtends<PhysicalDevicePipelineExecutablePropertiesFeaturesKHR, DeviceCreateInfo>
|
|
|
14129 {
|
|
|
14130 enum
|
|
|
14131 {
|
|
|
14132 value = true
|
|
|
14133 };
|
|
|
14134 };
|
|
|
14135
|
|
|
14136 //=== VK_EXT_map_memory_placed ===
|
|
|
14137 template <>
|
|
|
14138 struct StructExtends<PhysicalDeviceMapMemoryPlacedFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
14139 {
|
|
|
14140 enum
|
|
|
14141 {
|
|
|
14142 value = true
|
|
|
14143 };
|
|
|
14144 };
|
|
|
14145
|
|
|
14146 template <>
|
|
|
14147 struct StructExtends<PhysicalDeviceMapMemoryPlacedFeaturesEXT, DeviceCreateInfo>
|
|
|
14148 {
|
|
|
14149 enum
|
|
|
14150 {
|
|
|
14151 value = true
|
|
|
14152 };
|
|
|
14153 };
|
|
|
14154
|
|
|
14155 template <>
|
|
|
14156 struct StructExtends<PhysicalDeviceMapMemoryPlacedPropertiesEXT, PhysicalDeviceProperties2>
|
|
|
14157 {
|
|
|
14158 enum
|
|
|
14159 {
|
|
|
14160 value = true
|
|
|
14161 };
|
|
|
14162 };
|
|
|
14163
|
|
|
14164 template <>
|
|
|
14165 struct StructExtends<MemoryMapPlacedInfoEXT, MemoryMapInfo>
|
|
|
14166 {
|
|
|
14167 enum
|
|
|
14168 {
|
|
|
14169 value = true
|
|
|
14170 };
|
|
|
14171 };
|
|
|
14172
|
|
|
14173 //=== VK_EXT_shader_atomic_float2 ===
|
|
|
14174 template <>
|
|
|
14175 struct StructExtends<PhysicalDeviceShaderAtomicFloat2FeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
14176 {
|
|
|
14177 enum
|
|
|
14178 {
|
|
|
14179 value = true
|
|
|
14180 };
|
|
|
14181 };
|
|
|
14182
|
|
|
14183 template <>
|
|
|
14184 struct StructExtends<PhysicalDeviceShaderAtomicFloat2FeaturesEXT, DeviceCreateInfo>
|
|
|
14185 {
|
|
|
14186 enum
|
|
|
14187 {
|
|
|
14188 value = true
|
|
|
14189 };
|
|
|
14190 };
|
|
|
14191
|
|
|
14192 //=== VK_NV_device_generated_commands ===
|
|
|
14193 template <>
|
|
|
14194 struct StructExtends<PhysicalDeviceDeviceGeneratedCommandsPropertiesNV, PhysicalDeviceProperties2>
|
|
|
14195 {
|
|
|
14196 enum
|
|
|
14197 {
|
|
|
14198 value = true
|
|
|
14199 };
|
|
|
14200 };
|
|
|
14201
|
|
|
14202 template <>
|
|
|
14203 struct StructExtends<PhysicalDeviceDeviceGeneratedCommandsFeaturesNV, PhysicalDeviceFeatures2>
|
|
|
14204 {
|
|
|
14205 enum
|
|
|
14206 {
|
|
|
14207 value = true
|
|
|
14208 };
|
|
|
14209 };
|
|
|
14210
|
|
|
14211 template <>
|
|
|
14212 struct StructExtends<PhysicalDeviceDeviceGeneratedCommandsFeaturesNV, DeviceCreateInfo>
|
|
|
14213 {
|
|
|
14214 enum
|
|
|
14215 {
|
|
|
14216 value = true
|
|
|
14217 };
|
|
|
14218 };
|
|
|
14219
|
|
|
14220 template <>
|
|
|
14221 struct StructExtends<GraphicsPipelineShaderGroupsCreateInfoNV, GraphicsPipelineCreateInfo>
|
|
|
14222 {
|
|
|
14223 enum
|
|
|
14224 {
|
|
|
14225 value = true
|
|
|
14226 };
|
|
|
14227 };
|
|
|
14228
|
|
|
14229 //=== VK_NV_inherited_viewport_scissor ===
|
|
|
14230 template <>
|
|
|
14231 struct StructExtends<PhysicalDeviceInheritedViewportScissorFeaturesNV, PhysicalDeviceFeatures2>
|
|
|
14232 {
|
|
|
14233 enum
|
|
|
14234 {
|
|
|
14235 value = true
|
|
|
14236 };
|
|
|
14237 };
|
|
|
14238
|
|
|
14239 template <>
|
|
|
14240 struct StructExtends<PhysicalDeviceInheritedViewportScissorFeaturesNV, DeviceCreateInfo>
|
|
|
14241 {
|
|
|
14242 enum
|
|
|
14243 {
|
|
|
14244 value = true
|
|
|
14245 };
|
|
|
14246 };
|
|
|
14247
|
|
|
14248 template <>
|
|
|
14249 struct StructExtends<CommandBufferInheritanceViewportScissorInfoNV, CommandBufferInheritanceInfo>
|
|
|
14250 {
|
|
|
14251 enum
|
|
|
14252 {
|
|
|
14253 value = true
|
|
|
14254 };
|
|
|
14255 };
|
|
|
14256
|
|
|
14257 //=== VK_EXT_texel_buffer_alignment ===
|
|
|
14258 template <>
|
|
|
14259 struct StructExtends<PhysicalDeviceTexelBufferAlignmentFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
14260 {
|
|
|
14261 enum
|
|
|
14262 {
|
|
|
14263 value = true
|
|
|
14264 };
|
|
|
14265 };
|
|
|
14266
|
|
|
14267 template <>
|
|
|
14268 struct StructExtends<PhysicalDeviceTexelBufferAlignmentFeaturesEXT, DeviceCreateInfo>
|
|
|
14269 {
|
|
|
14270 enum
|
|
|
14271 {
|
|
|
14272 value = true
|
|
|
14273 };
|
|
|
14274 };
|
|
|
14275
|
|
|
14276 //=== VK_QCOM_render_pass_transform ===
|
|
|
14277 template <>
|
|
|
14278 struct StructExtends<RenderPassTransformBeginInfoQCOM, RenderPassBeginInfo>
|
|
|
14279 {
|
|
|
14280 enum
|
|
|
14281 {
|
|
|
14282 value = true
|
|
|
14283 };
|
|
|
14284 };
|
|
|
14285
|
|
|
14286 template <>
|
|
|
14287 struct StructExtends<CommandBufferInheritanceRenderPassTransformInfoQCOM, CommandBufferInheritanceInfo>
|
|
|
14288 {
|
|
|
14289 enum
|
|
|
14290 {
|
|
|
14291 value = true
|
|
|
14292 };
|
|
|
14293 };
|
|
|
14294
|
|
|
14295 //=== VK_EXT_depth_bias_control ===
|
|
|
14296 template <>
|
|
|
14297 struct StructExtends<PhysicalDeviceDepthBiasControlFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
14298 {
|
|
|
14299 enum
|
|
|
14300 {
|
|
|
14301 value = true
|
|
|
14302 };
|
|
|
14303 };
|
|
|
14304
|
|
|
14305 template <>
|
|
|
14306 struct StructExtends<PhysicalDeviceDepthBiasControlFeaturesEXT, DeviceCreateInfo>
|
|
|
14307 {
|
|
|
14308 enum
|
|
|
14309 {
|
|
|
14310 value = true
|
|
|
14311 };
|
|
|
14312 };
|
|
|
14313
|
|
|
14314 template <>
|
|
|
14315 struct StructExtends<DepthBiasRepresentationInfoEXT, DepthBiasInfoEXT>
|
|
|
14316 {
|
|
|
14317 enum
|
|
|
14318 {
|
|
|
14319 value = true
|
|
|
14320 };
|
|
|
14321 };
|
|
|
14322
|
|
|
14323 template <>
|
|
|
14324 struct StructExtends<DepthBiasRepresentationInfoEXT, PipelineRasterizationStateCreateInfo>
|
|
|
14325 {
|
|
|
14326 enum
|
|
|
14327 {
|
|
|
14328 value = true
|
|
|
14329 };
|
|
|
14330 };
|
|
|
14331
|
|
|
14332 //=== VK_EXT_device_memory_report ===
|
|
|
14333 template <>
|
|
|
14334 struct StructExtends<PhysicalDeviceDeviceMemoryReportFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
14335 {
|
|
|
14336 enum
|
|
|
14337 {
|
|
|
14338 value = true
|
|
|
14339 };
|
|
|
14340 };
|
|
|
14341
|
|
|
14342 template <>
|
|
|
14343 struct StructExtends<PhysicalDeviceDeviceMemoryReportFeaturesEXT, DeviceCreateInfo>
|
|
|
14344 {
|
|
|
14345 enum
|
|
|
14346 {
|
|
|
14347 value = true
|
|
|
14348 };
|
|
|
14349 };
|
|
|
14350
|
|
|
14351 template <>
|
|
|
14352 struct StructExtends<DeviceDeviceMemoryReportCreateInfoEXT, DeviceCreateInfo>
|
|
|
14353 {
|
|
|
14354 enum
|
|
|
14355 {
|
|
|
14356 value = true
|
|
|
14357 };
|
|
|
14358 };
|
|
|
14359
|
|
|
14360 //=== VK_EXT_custom_border_color ===
|
|
|
14361 template <>
|
|
|
14362 struct StructExtends<SamplerCustomBorderColorCreateInfoEXT, SamplerCreateInfo>
|
|
|
14363 {
|
|
|
14364 enum
|
|
|
14365 {
|
|
|
14366 value = true
|
|
|
14367 };
|
|
|
14368 };
|
|
|
14369
|
|
|
14370 template <>
|
|
|
14371 struct StructExtends<PhysicalDeviceCustomBorderColorPropertiesEXT, PhysicalDeviceProperties2>
|
|
|
14372 {
|
|
|
14373 enum
|
|
|
14374 {
|
|
|
14375 value = true
|
|
|
14376 };
|
|
|
14377 };
|
|
|
14378
|
|
|
14379 template <>
|
|
|
14380 struct StructExtends<PhysicalDeviceCustomBorderColorFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
14381 {
|
|
|
14382 enum
|
|
|
14383 {
|
|
|
14384 value = true
|
|
|
14385 };
|
|
|
14386 };
|
|
|
14387
|
|
|
14388 template <>
|
|
|
14389 struct StructExtends<PhysicalDeviceCustomBorderColorFeaturesEXT, DeviceCreateInfo>
|
|
|
14390 {
|
|
|
14391 enum
|
|
|
14392 {
|
|
|
14393 value = true
|
|
|
14394 };
|
|
|
14395 };
|
|
|
14396
|
|
|
14397 //=== VK_KHR_pipeline_library ===
|
|
|
14398 template <>
|
|
|
14399 struct StructExtends<PipelineLibraryCreateInfoKHR, GraphicsPipelineCreateInfo>
|
|
|
14400 {
|
|
|
14401 enum
|
|
|
14402 {
|
|
|
14403 value = true
|
|
|
14404 };
|
|
|
14405 };
|
|
|
14406
|
|
|
14407 //=== VK_NV_present_barrier ===
|
|
|
14408 template <>
|
|
|
14409 struct StructExtends<PhysicalDevicePresentBarrierFeaturesNV, PhysicalDeviceFeatures2>
|
|
|
14410 {
|
|
|
14411 enum
|
|
|
14412 {
|
|
|
14413 value = true
|
|
|
14414 };
|
|
|
14415 };
|
|
|
14416
|
|
|
14417 template <>
|
|
|
14418 struct StructExtends<PhysicalDevicePresentBarrierFeaturesNV, DeviceCreateInfo>
|
|
|
14419 {
|
|
|
14420 enum
|
|
|
14421 {
|
|
|
14422 value = true
|
|
|
14423 };
|
|
|
14424 };
|
|
|
14425
|
|
|
14426 template <>
|
|
|
14427 struct StructExtends<SurfaceCapabilitiesPresentBarrierNV, SurfaceCapabilities2KHR>
|
|
|
14428 {
|
|
|
14429 enum
|
|
|
14430 {
|
|
|
14431 value = true
|
|
|
14432 };
|
|
|
14433 };
|
|
|
14434
|
|
|
14435 template <>
|
|
|
14436 struct StructExtends<SwapchainPresentBarrierCreateInfoNV, SwapchainCreateInfoKHR>
|
|
|
14437 {
|
|
|
14438 enum
|
|
|
14439 {
|
|
|
14440 value = true
|
|
|
14441 };
|
|
|
14442 };
|
|
|
14443
|
|
|
14444 //=== VK_KHR_present_id ===
|
|
|
14445 template <>
|
|
|
14446 struct StructExtends<PresentIdKHR, PresentInfoKHR>
|
|
|
14447 {
|
|
|
14448 enum
|
|
|
14449 {
|
|
|
14450 value = true
|
|
|
14451 };
|
|
|
14452 };
|
|
|
14453
|
|
|
14454 template <>
|
|
|
14455 struct StructExtends<PhysicalDevicePresentIdFeaturesKHR, PhysicalDeviceFeatures2>
|
|
|
14456 {
|
|
|
14457 enum
|
|
|
14458 {
|
|
|
14459 value = true
|
|
|
14460 };
|
|
|
14461 };
|
|
|
14462
|
|
|
14463 template <>
|
|
|
14464 struct StructExtends<PhysicalDevicePresentIdFeaturesKHR, DeviceCreateInfo>
|
|
|
14465 {
|
|
|
14466 enum
|
|
|
14467 {
|
|
|
14468 value = true
|
|
|
14469 };
|
|
|
14470 };
|
|
|
14471
|
|
|
14472 //=== VK_KHR_video_encode_queue ===
|
|
|
14473 template <>
|
|
|
14474 struct StructExtends<VideoEncodeCapabilitiesKHR, VideoCapabilitiesKHR>
|
|
|
14475 {
|
|
|
14476 enum
|
|
|
14477 {
|
|
|
14478 value = true
|
|
|
14479 };
|
|
|
14480 };
|
|
|
14481
|
|
|
14482 template <>
|
|
|
14483 struct StructExtends<QueryPoolVideoEncodeFeedbackCreateInfoKHR, QueryPoolCreateInfo>
|
|
|
14484 {
|
|
|
14485 enum
|
|
|
14486 {
|
|
|
14487 value = true
|
|
|
14488 };
|
|
|
14489 };
|
|
|
14490
|
|
|
14491 template <>
|
|
|
14492 struct StructExtends<VideoEncodeUsageInfoKHR, VideoProfileInfoKHR>
|
|
|
14493 {
|
|
|
14494 enum
|
|
|
14495 {
|
|
|
14496 value = true
|
|
|
14497 };
|
|
|
14498 };
|
|
|
14499
|
|
|
14500 template <>
|
|
|
14501 struct StructExtends<VideoEncodeUsageInfoKHR, QueryPoolCreateInfo>
|
|
|
14502 {
|
|
|
14503 enum
|
|
|
14504 {
|
|
|
14505 value = true
|
|
|
14506 };
|
|
|
14507 };
|
|
|
14508
|
|
|
14509 template <>
|
|
|
14510 struct StructExtends<VideoEncodeRateControlInfoKHR, VideoCodingControlInfoKHR>
|
|
|
14511 {
|
|
|
14512 enum
|
|
|
14513 {
|
|
|
14514 value = true
|
|
|
14515 };
|
|
|
14516 };
|
|
|
14517
|
|
|
14518 template <>
|
|
|
14519 struct StructExtends<VideoEncodeRateControlInfoKHR, VideoBeginCodingInfoKHR>
|
|
|
14520 {
|
|
|
14521 enum
|
|
|
14522 {
|
|
|
14523 value = true
|
|
|
14524 };
|
|
|
14525 };
|
|
|
14526
|
|
|
14527 template <>
|
|
|
14528 struct StructExtends<VideoEncodeQualityLevelInfoKHR, VideoCodingControlInfoKHR>
|
|
|
14529 {
|
|
|
14530 enum
|
|
|
14531 {
|
|
|
14532 value = true
|
|
|
14533 };
|
|
|
14534 };
|
|
|
14535
|
|
|
14536 template <>
|
|
|
14537 struct StructExtends<VideoEncodeQualityLevelInfoKHR, VideoSessionParametersCreateInfoKHR>
|
|
|
14538 {
|
|
|
14539 enum
|
|
|
14540 {
|
|
|
14541 value = true
|
|
|
14542 };
|
|
|
14543 };
|
|
|
14544
|
|
|
14545 //=== VK_NV_device_diagnostics_config ===
|
|
|
14546 template <>
|
|
|
14547 struct StructExtends<PhysicalDeviceDiagnosticsConfigFeaturesNV, PhysicalDeviceFeatures2>
|
|
|
14548 {
|
|
|
14549 enum
|
|
|
14550 {
|
|
|
14551 value = true
|
|
|
14552 };
|
|
|
14553 };
|
|
|
14554
|
|
|
14555 template <>
|
|
|
14556 struct StructExtends<PhysicalDeviceDiagnosticsConfigFeaturesNV, DeviceCreateInfo>
|
|
|
14557 {
|
|
|
14558 enum
|
|
|
14559 {
|
|
|
14560 value = true
|
|
|
14561 };
|
|
|
14562 };
|
|
|
14563
|
|
|
14564 template <>
|
|
|
14565 struct StructExtends<DeviceDiagnosticsConfigCreateInfoNV, DeviceCreateInfo>
|
|
|
14566 {
|
|
|
14567 enum
|
|
|
14568 {
|
|
|
14569 value = true
|
|
|
14570 };
|
|
|
14571 };
|
|
|
14572
|
|
|
14573 # if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
14574 //=== VK_NV_cuda_kernel_launch ===
|
|
|
14575 template <>
|
|
|
14576 struct StructExtends<PhysicalDeviceCudaKernelLaunchFeaturesNV, PhysicalDeviceFeatures2>
|
|
|
14577 {
|
|
|
14578 enum
|
|
|
14579 {
|
|
|
14580 value = true
|
|
|
14581 };
|
|
|
14582 };
|
|
|
14583
|
|
|
14584 template <>
|
|
|
14585 struct StructExtends<PhysicalDeviceCudaKernelLaunchFeaturesNV, DeviceCreateInfo>
|
|
|
14586 {
|
|
|
14587 enum
|
|
|
14588 {
|
|
|
14589 value = true
|
|
|
14590 };
|
|
|
14591 };
|
|
|
14592
|
|
|
14593 template <>
|
|
|
14594 struct StructExtends<PhysicalDeviceCudaKernelLaunchPropertiesNV, PhysicalDeviceProperties2>
|
|
|
14595 {
|
|
|
14596 enum
|
|
|
14597 {
|
|
|
14598 value = true
|
|
|
14599 };
|
|
|
14600 };
|
|
|
14601 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
14602
|
|
|
14603 //=== VK_QCOM_tile_shading ===
|
|
|
14604 template <>
|
|
|
14605 struct StructExtends<PhysicalDeviceTileShadingFeaturesQCOM, PhysicalDeviceFeatures2>
|
|
|
14606 {
|
|
|
14607 enum
|
|
|
14608 {
|
|
|
14609 value = true
|
|
|
14610 };
|
|
|
14611 };
|
|
|
14612
|
|
|
14613 template <>
|
|
|
14614 struct StructExtends<PhysicalDeviceTileShadingFeaturesQCOM, DeviceCreateInfo>
|
|
|
14615 {
|
|
|
14616 enum
|
|
|
14617 {
|
|
|
14618 value = true
|
|
|
14619 };
|
|
|
14620 };
|
|
|
14621
|
|
|
14622 template <>
|
|
|
14623 struct StructExtends<PhysicalDeviceTileShadingPropertiesQCOM, PhysicalDeviceProperties2>
|
|
|
14624 {
|
|
|
14625 enum
|
|
|
14626 {
|
|
|
14627 value = true
|
|
|
14628 };
|
|
|
14629 };
|
|
|
14630
|
|
|
14631 template <>
|
|
|
14632 struct StructExtends<RenderPassTileShadingCreateInfoQCOM, RenderPassCreateInfo>
|
|
|
14633 {
|
|
|
14634 enum
|
|
|
14635 {
|
|
|
14636 value = true
|
|
|
14637 };
|
|
|
14638 };
|
|
|
14639
|
|
|
14640 template <>
|
|
|
14641 struct StructExtends<RenderPassTileShadingCreateInfoQCOM, RenderPassCreateInfo2>
|
|
|
14642 {
|
|
|
14643 enum
|
|
|
14644 {
|
|
|
14645 value = true
|
|
|
14646 };
|
|
|
14647 };
|
|
|
14648
|
|
|
14649 template <>
|
|
|
14650 struct StructExtends<RenderPassTileShadingCreateInfoQCOM, RenderingInfo>
|
|
|
14651 {
|
|
|
14652 enum
|
|
|
14653 {
|
|
|
14654 value = true
|
|
|
14655 };
|
|
|
14656 };
|
|
|
14657
|
|
|
14658 template <>
|
|
|
14659 struct StructExtends<RenderPassTileShadingCreateInfoQCOM, CommandBufferInheritanceInfo>
|
|
|
14660 {
|
|
|
14661 enum
|
|
|
14662 {
|
|
|
14663 value = true
|
|
|
14664 };
|
|
|
14665 };
|
|
|
14666
|
|
|
14667 //=== VK_NV_low_latency ===
|
|
|
14668 template <>
|
|
|
14669 struct StructExtends<QueryLowLatencySupportNV, SemaphoreCreateInfo>
|
|
|
14670 {
|
|
|
14671 enum
|
|
|
14672 {
|
|
|
14673 value = true
|
|
|
14674 };
|
|
|
14675 };
|
|
|
14676
|
|
|
14677 # if defined( VK_USE_PLATFORM_METAL_EXT )
|
|
|
14678 //=== VK_EXT_metal_objects ===
|
|
|
14679 template <>
|
|
|
14680 struct StructExtends<ExportMetalObjectCreateInfoEXT, InstanceCreateInfo>
|
|
|
14681 {
|
|
|
14682 enum
|
|
|
14683 {
|
|
|
14684 value = true
|
|
|
14685 };
|
|
|
14686 };
|
|
|
14687
|
|
|
14688 template <>
|
|
|
14689 struct StructExtends<ExportMetalObjectCreateInfoEXT, MemoryAllocateInfo>
|
|
|
14690 {
|
|
|
14691 enum
|
|
|
14692 {
|
|
|
14693 value = true
|
|
|
14694 };
|
|
|
14695 };
|
|
|
14696
|
|
|
14697 template <>
|
|
|
14698 struct StructExtends<ExportMetalObjectCreateInfoEXT, ImageCreateInfo>
|
|
|
14699 {
|
|
|
14700 enum
|
|
|
14701 {
|
|
|
14702 value = true
|
|
|
14703 };
|
|
|
14704 };
|
|
|
14705
|
|
|
14706 template <>
|
|
|
14707 struct StructExtends<ExportMetalObjectCreateInfoEXT, ImageViewCreateInfo>
|
|
|
14708 {
|
|
|
14709 enum
|
|
|
14710 {
|
|
|
14711 value = true
|
|
|
14712 };
|
|
|
14713 };
|
|
|
14714
|
|
|
14715 template <>
|
|
|
14716 struct StructExtends<ExportMetalObjectCreateInfoEXT, BufferViewCreateInfo>
|
|
|
14717 {
|
|
|
14718 enum
|
|
|
14719 {
|
|
|
14720 value = true
|
|
|
14721 };
|
|
|
14722 };
|
|
|
14723
|
|
|
14724 template <>
|
|
|
14725 struct StructExtends<ExportMetalObjectCreateInfoEXT, SemaphoreCreateInfo>
|
|
|
14726 {
|
|
|
14727 enum
|
|
|
14728 {
|
|
|
14729 value = true
|
|
|
14730 };
|
|
|
14731 };
|
|
|
14732
|
|
|
14733 template <>
|
|
|
14734 struct StructExtends<ExportMetalObjectCreateInfoEXT, EventCreateInfo>
|
|
|
14735 {
|
|
|
14736 enum
|
|
|
14737 {
|
|
|
14738 value = true
|
|
|
14739 };
|
|
|
14740 };
|
|
|
14741
|
|
|
14742 template <>
|
|
|
14743 struct StructExtends<ExportMetalDeviceInfoEXT, ExportMetalObjectsInfoEXT>
|
|
|
14744 {
|
|
|
14745 enum
|
|
|
14746 {
|
|
|
14747 value = true
|
|
|
14748 };
|
|
|
14749 };
|
|
|
14750
|
|
|
14751 template <>
|
|
|
14752 struct StructExtends<ExportMetalCommandQueueInfoEXT, ExportMetalObjectsInfoEXT>
|
|
|
14753 {
|
|
|
14754 enum
|
|
|
14755 {
|
|
|
14756 value = true
|
|
|
14757 };
|
|
|
14758 };
|
|
|
14759
|
|
|
14760 template <>
|
|
|
14761 struct StructExtends<ExportMetalBufferInfoEXT, ExportMetalObjectsInfoEXT>
|
|
|
14762 {
|
|
|
14763 enum
|
|
|
14764 {
|
|
|
14765 value = true
|
|
|
14766 };
|
|
|
14767 };
|
|
|
14768
|
|
|
14769 template <>
|
|
|
14770 struct StructExtends<ImportMetalBufferInfoEXT, MemoryAllocateInfo>
|
|
|
14771 {
|
|
|
14772 enum
|
|
|
14773 {
|
|
|
14774 value = true
|
|
|
14775 };
|
|
|
14776 };
|
|
|
14777
|
|
|
14778 template <>
|
|
|
14779 struct StructExtends<ExportMetalTextureInfoEXT, ExportMetalObjectsInfoEXT>
|
|
|
14780 {
|
|
|
14781 enum
|
|
|
14782 {
|
|
|
14783 value = true
|
|
|
14784 };
|
|
|
14785 };
|
|
|
14786
|
|
|
14787 template <>
|
|
|
14788 struct StructExtends<ImportMetalTextureInfoEXT, ImageCreateInfo>
|
|
|
14789 {
|
|
|
14790 enum
|
|
|
14791 {
|
|
|
14792 value = true
|
|
|
14793 };
|
|
|
14794 };
|
|
|
14795
|
|
|
14796 template <>
|
|
|
14797 struct StructExtends<ExportMetalIOSurfaceInfoEXT, ExportMetalObjectsInfoEXT>
|
|
|
14798 {
|
|
|
14799 enum
|
|
|
14800 {
|
|
|
14801 value = true
|
|
|
14802 };
|
|
|
14803 };
|
|
|
14804
|
|
|
14805 template <>
|
|
|
14806 struct StructExtends<ImportMetalIOSurfaceInfoEXT, ImageCreateInfo>
|
|
|
14807 {
|
|
|
14808 enum
|
|
|
14809 {
|
|
|
14810 value = true
|
|
|
14811 };
|
|
|
14812 };
|
|
|
14813
|
|
|
14814 template <>
|
|
|
14815 struct StructExtends<ExportMetalSharedEventInfoEXT, ExportMetalObjectsInfoEXT>
|
|
|
14816 {
|
|
|
14817 enum
|
|
|
14818 {
|
|
|
14819 value = true
|
|
|
14820 };
|
|
|
14821 };
|
|
|
14822
|
|
|
14823 template <>
|
|
|
14824 struct StructExtends<ImportMetalSharedEventInfoEXT, SemaphoreCreateInfo>
|
|
|
14825 {
|
|
|
14826 enum
|
|
|
14827 {
|
|
|
14828 value = true
|
|
|
14829 };
|
|
|
14830 };
|
|
|
14831
|
|
|
14832 template <>
|
|
|
14833 struct StructExtends<ImportMetalSharedEventInfoEXT, EventCreateInfo>
|
|
|
14834 {
|
|
|
14835 enum
|
|
|
14836 {
|
|
|
14837 value = true
|
|
|
14838 };
|
|
|
14839 };
|
|
|
14840 # endif /*VK_USE_PLATFORM_METAL_EXT*/
|
|
|
14841
|
|
|
14842 //=== VK_EXT_descriptor_buffer ===
|
|
|
14843 template <>
|
|
|
14844 struct StructExtends<PhysicalDeviceDescriptorBufferPropertiesEXT, PhysicalDeviceProperties2>
|
|
|
14845 {
|
|
|
14846 enum
|
|
|
14847 {
|
|
|
14848 value = true
|
|
|
14849 };
|
|
|
14850 };
|
|
|
14851
|
|
|
14852 template <>
|
|
|
14853 struct StructExtends<PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT, PhysicalDeviceProperties2>
|
|
|
14854 {
|
|
|
14855 enum
|
|
|
14856 {
|
|
|
14857 value = true
|
|
|
14858 };
|
|
|
14859 };
|
|
|
14860
|
|
|
14861 template <>
|
|
|
14862 struct StructExtends<PhysicalDeviceDescriptorBufferFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
14863 {
|
|
|
14864 enum
|
|
|
14865 {
|
|
|
14866 value = true
|
|
|
14867 };
|
|
|
14868 };
|
|
|
14869
|
|
|
14870 template <>
|
|
|
14871 struct StructExtends<PhysicalDeviceDescriptorBufferFeaturesEXT, DeviceCreateInfo>
|
|
|
14872 {
|
|
|
14873 enum
|
|
|
14874 {
|
|
|
14875 value = true
|
|
|
14876 };
|
|
|
14877 };
|
|
|
14878
|
|
|
14879 template <>
|
|
|
14880 struct StructExtends<DescriptorBufferBindingPushDescriptorBufferHandleEXT, DescriptorBufferBindingInfoEXT>
|
|
|
14881 {
|
|
|
14882 enum
|
|
|
14883 {
|
|
|
14884 value = true
|
|
|
14885 };
|
|
|
14886 };
|
|
|
14887
|
|
|
14888 template <>
|
|
|
14889 struct StructExtends<OpaqueCaptureDescriptorDataCreateInfoEXT, BufferCreateInfo>
|
|
|
14890 {
|
|
|
14891 enum
|
|
|
14892 {
|
|
|
14893 value = true
|
|
|
14894 };
|
|
|
14895 };
|
|
|
14896
|
|
|
14897 template <>
|
|
|
14898 struct StructExtends<OpaqueCaptureDescriptorDataCreateInfoEXT, ImageCreateInfo>
|
|
|
14899 {
|
|
|
14900 enum
|
|
|
14901 {
|
|
|
14902 value = true
|
|
|
14903 };
|
|
|
14904 };
|
|
|
14905
|
|
|
14906 template <>
|
|
|
14907 struct StructExtends<OpaqueCaptureDescriptorDataCreateInfoEXT, ImageViewCreateInfo>
|
|
|
14908 {
|
|
|
14909 enum
|
|
|
14910 {
|
|
|
14911 value = true
|
|
|
14912 };
|
|
|
14913 };
|
|
|
14914
|
|
|
14915 template <>
|
|
|
14916 struct StructExtends<OpaqueCaptureDescriptorDataCreateInfoEXT, SamplerCreateInfo>
|
|
|
14917 {
|
|
|
14918 enum
|
|
|
14919 {
|
|
|
14920 value = true
|
|
|
14921 };
|
|
|
14922 };
|
|
|
14923
|
|
|
14924 template <>
|
|
|
14925 struct StructExtends<OpaqueCaptureDescriptorDataCreateInfoEXT, AccelerationStructureCreateInfoKHR>
|
|
|
14926 {
|
|
|
14927 enum
|
|
|
14928 {
|
|
|
14929 value = true
|
|
|
14930 };
|
|
|
14931 };
|
|
|
14932
|
|
|
14933 template <>
|
|
|
14934 struct StructExtends<OpaqueCaptureDescriptorDataCreateInfoEXT, AccelerationStructureCreateInfoNV>
|
|
|
14935 {
|
|
|
14936 enum
|
|
|
14937 {
|
|
|
14938 value = true
|
|
|
14939 };
|
|
|
14940 };
|
|
|
14941
|
|
|
14942 template <>
|
|
|
14943 struct StructExtends<OpaqueCaptureDescriptorDataCreateInfoEXT, TensorCreateInfoARM>
|
|
|
14944 {
|
|
|
14945 enum
|
|
|
14946 {
|
|
|
14947 value = true
|
|
|
14948 };
|
|
|
14949 };
|
|
|
14950
|
|
|
14951 template <>
|
|
|
14952 struct StructExtends<OpaqueCaptureDescriptorDataCreateInfoEXT, TensorViewCreateInfoARM>
|
|
|
14953 {
|
|
|
14954 enum
|
|
|
14955 {
|
|
|
14956 value = true
|
|
|
14957 };
|
|
|
14958 };
|
|
|
14959
|
|
|
14960 //=== VK_EXT_graphics_pipeline_library ===
|
|
|
14961 template <>
|
|
|
14962 struct StructExtends<PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
14963 {
|
|
|
14964 enum
|
|
|
14965 {
|
|
|
14966 value = true
|
|
|
14967 };
|
|
|
14968 };
|
|
|
14969
|
|
|
14970 template <>
|
|
|
14971 struct StructExtends<PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT, DeviceCreateInfo>
|
|
|
14972 {
|
|
|
14973 enum
|
|
|
14974 {
|
|
|
14975 value = true
|
|
|
14976 };
|
|
|
14977 };
|
|
|
14978
|
|
|
14979 template <>
|
|
|
14980 struct StructExtends<PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT, PhysicalDeviceProperties2>
|
|
|
14981 {
|
|
|
14982 enum
|
|
|
14983 {
|
|
|
14984 value = true
|
|
|
14985 };
|
|
|
14986 };
|
|
|
14987
|
|
|
14988 template <>
|
|
|
14989 struct StructExtends<GraphicsPipelineLibraryCreateInfoEXT, GraphicsPipelineCreateInfo>
|
|
|
14990 {
|
|
|
14991 enum
|
|
|
14992 {
|
|
|
14993 value = true
|
|
|
14994 };
|
|
|
14995 };
|
|
|
14996
|
|
|
14997 //=== VK_AMD_shader_early_and_late_fragment_tests ===
|
|
|
14998 template <>
|
|
|
14999 struct StructExtends<PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD, PhysicalDeviceFeatures2>
|
|
|
15000 {
|
|
|
15001 enum
|
|
|
15002 {
|
|
|
15003 value = true
|
|
|
15004 };
|
|
|
15005 };
|
|
|
15006
|
|
|
15007 template <>
|
|
|
15008 struct StructExtends<PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD, DeviceCreateInfo>
|
|
|
15009 {
|
|
|
15010 enum
|
|
|
15011 {
|
|
|
15012 value = true
|
|
|
15013 };
|
|
|
15014 };
|
|
|
15015
|
|
|
15016 //=== VK_KHR_fragment_shader_barycentric ===
|
|
|
15017 template <>
|
|
|
15018 struct StructExtends<PhysicalDeviceFragmentShaderBarycentricFeaturesKHR, PhysicalDeviceFeatures2>
|
|
|
15019 {
|
|
|
15020 enum
|
|
|
15021 {
|
|
|
15022 value = true
|
|
|
15023 };
|
|
|
15024 };
|
|
|
15025
|
|
|
15026 template <>
|
|
|
15027 struct StructExtends<PhysicalDeviceFragmentShaderBarycentricFeaturesKHR, DeviceCreateInfo>
|
|
|
15028 {
|
|
|
15029 enum
|
|
|
15030 {
|
|
|
15031 value = true
|
|
|
15032 };
|
|
|
15033 };
|
|
|
15034
|
|
|
15035 template <>
|
|
|
15036 struct StructExtends<PhysicalDeviceFragmentShaderBarycentricPropertiesKHR, PhysicalDeviceProperties2>
|
|
|
15037 {
|
|
|
15038 enum
|
|
|
15039 {
|
|
|
15040 value = true
|
|
|
15041 };
|
|
|
15042 };
|
|
|
15043
|
|
|
15044 //=== VK_KHR_shader_subgroup_uniform_control_flow ===
|
|
|
15045 template <>
|
|
|
15046 struct StructExtends<PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR, PhysicalDeviceFeatures2>
|
|
|
15047 {
|
|
|
15048 enum
|
|
|
15049 {
|
|
|
15050 value = true
|
|
|
15051 };
|
|
|
15052 };
|
|
|
15053
|
|
|
15054 template <>
|
|
|
15055 struct StructExtends<PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR, DeviceCreateInfo>
|
|
|
15056 {
|
|
|
15057 enum
|
|
|
15058 {
|
|
|
15059 value = true
|
|
|
15060 };
|
|
|
15061 };
|
|
|
15062
|
|
|
15063 //=== VK_NV_fragment_shading_rate_enums ===
|
|
|
15064 template <>
|
|
|
15065 struct StructExtends<PhysicalDeviceFragmentShadingRateEnumsFeaturesNV, PhysicalDeviceFeatures2>
|
|
|
15066 {
|
|
|
15067 enum
|
|
|
15068 {
|
|
|
15069 value = true
|
|
|
15070 };
|
|
|
15071 };
|
|
|
15072
|
|
|
15073 template <>
|
|
|
15074 struct StructExtends<PhysicalDeviceFragmentShadingRateEnumsFeaturesNV, DeviceCreateInfo>
|
|
|
15075 {
|
|
|
15076 enum
|
|
|
15077 {
|
|
|
15078 value = true
|
|
|
15079 };
|
|
|
15080 };
|
|
|
15081
|
|
|
15082 template <>
|
|
|
15083 struct StructExtends<PhysicalDeviceFragmentShadingRateEnumsPropertiesNV, PhysicalDeviceProperties2>
|
|
|
15084 {
|
|
|
15085 enum
|
|
|
15086 {
|
|
|
15087 value = true
|
|
|
15088 };
|
|
|
15089 };
|
|
|
15090
|
|
|
15091 template <>
|
|
|
15092 struct StructExtends<PipelineFragmentShadingRateEnumStateCreateInfoNV, GraphicsPipelineCreateInfo>
|
|
|
15093 {
|
|
|
15094 enum
|
|
|
15095 {
|
|
|
15096 value = true
|
|
|
15097 };
|
|
|
15098 };
|
|
|
15099
|
|
|
15100 //=== VK_NV_ray_tracing_motion_blur ===
|
|
|
15101 template <>
|
|
|
15102 struct StructExtends<AccelerationStructureGeometryMotionTrianglesDataNV, AccelerationStructureGeometryTrianglesDataKHR>
|
|
|
15103 {
|
|
|
15104 enum
|
|
|
15105 {
|
|
|
15106 value = true
|
|
|
15107 };
|
|
|
15108 };
|
|
|
15109
|
|
|
15110 template <>
|
|
|
15111 struct StructExtends<AccelerationStructureMotionInfoNV, AccelerationStructureCreateInfoKHR>
|
|
|
15112 {
|
|
|
15113 enum
|
|
|
15114 {
|
|
|
15115 value = true
|
|
|
15116 };
|
|
|
15117 };
|
|
|
15118
|
|
|
15119 template <>
|
|
|
15120 struct StructExtends<PhysicalDeviceRayTracingMotionBlurFeaturesNV, PhysicalDeviceFeatures2>
|
|
|
15121 {
|
|
|
15122 enum
|
|
|
15123 {
|
|
|
15124 value = true
|
|
|
15125 };
|
|
|
15126 };
|
|
|
15127
|
|
|
15128 template <>
|
|
|
15129 struct StructExtends<PhysicalDeviceRayTracingMotionBlurFeaturesNV, DeviceCreateInfo>
|
|
|
15130 {
|
|
|
15131 enum
|
|
|
15132 {
|
|
|
15133 value = true
|
|
|
15134 };
|
|
|
15135 };
|
|
|
15136
|
|
|
15137 //=== VK_EXT_mesh_shader ===
|
|
|
15138 template <>
|
|
|
15139 struct StructExtends<PhysicalDeviceMeshShaderFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
15140 {
|
|
|
15141 enum
|
|
|
15142 {
|
|
|
15143 value = true
|
|
|
15144 };
|
|
|
15145 };
|
|
|
15146
|
|
|
15147 template <>
|
|
|
15148 struct StructExtends<PhysicalDeviceMeshShaderFeaturesEXT, DeviceCreateInfo>
|
|
|
15149 {
|
|
|
15150 enum
|
|
|
15151 {
|
|
|
15152 value = true
|
|
|
15153 };
|
|
|
15154 };
|
|
|
15155
|
|
|
15156 template <>
|
|
|
15157 struct StructExtends<PhysicalDeviceMeshShaderPropertiesEXT, PhysicalDeviceProperties2>
|
|
|
15158 {
|
|
|
15159 enum
|
|
|
15160 {
|
|
|
15161 value = true
|
|
|
15162 };
|
|
|
15163 };
|
|
|
15164
|
|
|
15165 //=== VK_EXT_ycbcr_2plane_444_formats ===
|
|
|
15166 template <>
|
|
|
15167 struct StructExtends<PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
15168 {
|
|
|
15169 enum
|
|
|
15170 {
|
|
|
15171 value = true
|
|
|
15172 };
|
|
|
15173 };
|
|
|
15174
|
|
|
15175 template <>
|
|
|
15176 struct StructExtends<PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT, DeviceCreateInfo>
|
|
|
15177 {
|
|
|
15178 enum
|
|
|
15179 {
|
|
|
15180 value = true
|
|
|
15181 };
|
|
|
15182 };
|
|
|
15183
|
|
|
15184 //=== VK_EXT_fragment_density_map2 ===
|
|
|
15185 template <>
|
|
|
15186 struct StructExtends<PhysicalDeviceFragmentDensityMap2FeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
15187 {
|
|
|
15188 enum
|
|
|
15189 {
|
|
|
15190 value = true
|
|
|
15191 };
|
|
|
15192 };
|
|
|
15193
|
|
|
15194 template <>
|
|
|
15195 struct StructExtends<PhysicalDeviceFragmentDensityMap2FeaturesEXT, DeviceCreateInfo>
|
|
|
15196 {
|
|
|
15197 enum
|
|
|
15198 {
|
|
|
15199 value = true
|
|
|
15200 };
|
|
|
15201 };
|
|
|
15202
|
|
|
15203 template <>
|
|
|
15204 struct StructExtends<PhysicalDeviceFragmentDensityMap2PropertiesEXT, PhysicalDeviceProperties2>
|
|
|
15205 {
|
|
|
15206 enum
|
|
|
15207 {
|
|
|
15208 value = true
|
|
|
15209 };
|
|
|
15210 };
|
|
|
15211
|
|
|
15212 //=== VK_QCOM_rotated_copy_commands ===
|
|
|
15213 template <>
|
|
|
15214 struct StructExtends<CopyCommandTransformInfoQCOM, BufferImageCopy2>
|
|
|
15215 {
|
|
|
15216 enum
|
|
|
15217 {
|
|
|
15218 value = true
|
|
|
15219 };
|
|
|
15220 };
|
|
|
15221
|
|
|
15222 template <>
|
|
|
15223 struct StructExtends<CopyCommandTransformInfoQCOM, ImageBlit2>
|
|
|
15224 {
|
|
|
15225 enum
|
|
|
15226 {
|
|
|
15227 value = true
|
|
|
15228 };
|
|
|
15229 };
|
|
|
15230
|
|
|
15231 //=== VK_KHR_workgroup_memory_explicit_layout ===
|
|
|
15232 template <>
|
|
|
15233 struct StructExtends<PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR, PhysicalDeviceFeatures2>
|
|
|
15234 {
|
|
|
15235 enum
|
|
|
15236 {
|
|
|
15237 value = true
|
|
|
15238 };
|
|
|
15239 };
|
|
|
15240
|
|
|
15241 template <>
|
|
|
15242 struct StructExtends<PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR, DeviceCreateInfo>
|
|
|
15243 {
|
|
|
15244 enum
|
|
|
15245 {
|
|
|
15246 value = true
|
|
|
15247 };
|
|
|
15248 };
|
|
|
15249
|
|
|
15250 //=== VK_EXT_image_compression_control ===
|
|
|
15251 template <>
|
|
|
15252 struct StructExtends<PhysicalDeviceImageCompressionControlFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
15253 {
|
|
|
15254 enum
|
|
|
15255 {
|
|
|
15256 value = true
|
|
|
15257 };
|
|
|
15258 };
|
|
|
15259
|
|
|
15260 template <>
|
|
|
15261 struct StructExtends<PhysicalDeviceImageCompressionControlFeaturesEXT, DeviceCreateInfo>
|
|
|
15262 {
|
|
|
15263 enum
|
|
|
15264 {
|
|
|
15265 value = true
|
|
|
15266 };
|
|
|
15267 };
|
|
|
15268
|
|
|
15269 template <>
|
|
|
15270 struct StructExtends<ImageCompressionControlEXT, ImageCreateInfo>
|
|
|
15271 {
|
|
|
15272 enum
|
|
|
15273 {
|
|
|
15274 value = true
|
|
|
15275 };
|
|
|
15276 };
|
|
|
15277
|
|
|
15278 template <>
|
|
|
15279 struct StructExtends<ImageCompressionControlEXT, SwapchainCreateInfoKHR>
|
|
|
15280 {
|
|
|
15281 enum
|
|
|
15282 {
|
|
|
15283 value = true
|
|
|
15284 };
|
|
|
15285 };
|
|
|
15286
|
|
|
15287 template <>
|
|
|
15288 struct StructExtends<ImageCompressionControlEXT, PhysicalDeviceImageFormatInfo2>
|
|
|
15289 {
|
|
|
15290 enum
|
|
|
15291 {
|
|
|
15292 value = true
|
|
|
15293 };
|
|
|
15294 };
|
|
|
15295
|
|
|
15296 template <>
|
|
|
15297 struct StructExtends<ImageCompressionPropertiesEXT, ImageFormatProperties2>
|
|
|
15298 {
|
|
|
15299 enum
|
|
|
15300 {
|
|
|
15301 value = true
|
|
|
15302 };
|
|
|
15303 };
|
|
|
15304
|
|
|
15305 template <>
|
|
|
15306 struct StructExtends<ImageCompressionPropertiesEXT, SurfaceFormat2KHR>
|
|
|
15307 {
|
|
|
15308 enum
|
|
|
15309 {
|
|
|
15310 value = true
|
|
|
15311 };
|
|
|
15312 };
|
|
|
15313
|
|
|
15314 template <>
|
|
|
15315 struct StructExtends<ImageCompressionPropertiesEXT, SubresourceLayout2>
|
|
|
15316 {
|
|
|
15317 enum
|
|
|
15318 {
|
|
|
15319 value = true
|
|
|
15320 };
|
|
|
15321 };
|
|
|
15322
|
|
|
15323 //=== VK_EXT_attachment_feedback_loop_layout ===
|
|
|
15324 template <>
|
|
|
15325 struct StructExtends<PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
15326 {
|
|
|
15327 enum
|
|
|
15328 {
|
|
|
15329 value = true
|
|
|
15330 };
|
|
|
15331 };
|
|
|
15332
|
|
|
15333 template <>
|
|
|
15334 struct StructExtends<PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT, DeviceCreateInfo>
|
|
|
15335 {
|
|
|
15336 enum
|
|
|
15337 {
|
|
|
15338 value = true
|
|
|
15339 };
|
|
|
15340 };
|
|
|
15341
|
|
|
15342 //=== VK_EXT_4444_formats ===
|
|
|
15343 template <>
|
|
|
15344 struct StructExtends<PhysicalDevice4444FormatsFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
15345 {
|
|
|
15346 enum
|
|
|
15347 {
|
|
|
15348 value = true
|
|
|
15349 };
|
|
|
15350 };
|
|
|
15351
|
|
|
15352 template <>
|
|
|
15353 struct StructExtends<PhysicalDevice4444FormatsFeaturesEXT, DeviceCreateInfo>
|
|
|
15354 {
|
|
|
15355 enum
|
|
|
15356 {
|
|
|
15357 value = true
|
|
|
15358 };
|
|
|
15359 };
|
|
|
15360
|
|
|
15361 //=== VK_EXT_device_fault ===
|
|
|
15362 template <>
|
|
|
15363 struct StructExtends<PhysicalDeviceFaultFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
15364 {
|
|
|
15365 enum
|
|
|
15366 {
|
|
|
15367 value = true
|
|
|
15368 };
|
|
|
15369 };
|
|
|
15370
|
|
|
15371 template <>
|
|
|
15372 struct StructExtends<PhysicalDeviceFaultFeaturesEXT, DeviceCreateInfo>
|
|
|
15373 {
|
|
|
15374 enum
|
|
|
15375 {
|
|
|
15376 value = true
|
|
|
15377 };
|
|
|
15378 };
|
|
|
15379
|
|
|
15380 //=== VK_EXT_rgba10x6_formats ===
|
|
|
15381 template <>
|
|
|
15382 struct StructExtends<PhysicalDeviceRGBA10X6FormatsFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
15383 {
|
|
|
15384 enum
|
|
|
15385 {
|
|
|
15386 value = true
|
|
|
15387 };
|
|
|
15388 };
|
|
|
15389
|
|
|
15390 template <>
|
|
|
15391 struct StructExtends<PhysicalDeviceRGBA10X6FormatsFeaturesEXT, DeviceCreateInfo>
|
|
|
15392 {
|
|
|
15393 enum
|
|
|
15394 {
|
|
|
15395 value = true
|
|
|
15396 };
|
|
|
15397 };
|
|
|
15398
|
|
|
15399 //=== VK_EXT_vertex_input_dynamic_state ===
|
|
|
15400 template <>
|
|
|
15401 struct StructExtends<PhysicalDeviceVertexInputDynamicStateFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
15402 {
|
|
|
15403 enum
|
|
|
15404 {
|
|
|
15405 value = true
|
|
|
15406 };
|
|
|
15407 };
|
|
|
15408
|
|
|
15409 template <>
|
|
|
15410 struct StructExtends<PhysicalDeviceVertexInputDynamicStateFeaturesEXT, DeviceCreateInfo>
|
|
|
15411 {
|
|
|
15412 enum
|
|
|
15413 {
|
|
|
15414 value = true
|
|
|
15415 };
|
|
|
15416 };
|
|
|
15417
|
|
|
15418 //=== VK_EXT_physical_device_drm ===
|
|
|
15419 template <>
|
|
|
15420 struct StructExtends<PhysicalDeviceDrmPropertiesEXT, PhysicalDeviceProperties2>
|
|
|
15421 {
|
|
|
15422 enum
|
|
|
15423 {
|
|
|
15424 value = true
|
|
|
15425 };
|
|
|
15426 };
|
|
|
15427
|
|
|
15428 //=== VK_EXT_device_address_binding_report ===
|
|
|
15429 template <>
|
|
|
15430 struct StructExtends<PhysicalDeviceAddressBindingReportFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
15431 {
|
|
|
15432 enum
|
|
|
15433 {
|
|
|
15434 value = true
|
|
|
15435 };
|
|
|
15436 };
|
|
|
15437
|
|
|
15438 template <>
|
|
|
15439 struct StructExtends<PhysicalDeviceAddressBindingReportFeaturesEXT, DeviceCreateInfo>
|
|
|
15440 {
|
|
|
15441 enum
|
|
|
15442 {
|
|
|
15443 value = true
|
|
|
15444 };
|
|
|
15445 };
|
|
|
15446
|
|
|
15447 template <>
|
|
|
15448 struct StructExtends<DeviceAddressBindingCallbackDataEXT, DebugUtilsMessengerCallbackDataEXT>
|
|
|
15449 {
|
|
|
15450 enum
|
|
|
15451 {
|
|
|
15452 value = true
|
|
|
15453 };
|
|
|
15454 };
|
|
|
15455
|
|
|
15456 //=== VK_EXT_depth_clip_control ===
|
|
|
15457 template <>
|
|
|
15458 struct StructExtends<PhysicalDeviceDepthClipControlFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
15459 {
|
|
|
15460 enum
|
|
|
15461 {
|
|
|
15462 value = true
|
|
|
15463 };
|
|
|
15464 };
|
|
|
15465
|
|
|
15466 template <>
|
|
|
15467 struct StructExtends<PhysicalDeviceDepthClipControlFeaturesEXT, DeviceCreateInfo>
|
|
|
15468 {
|
|
|
15469 enum
|
|
|
15470 {
|
|
|
15471 value = true
|
|
|
15472 };
|
|
|
15473 };
|
|
|
15474
|
|
|
15475 template <>
|
|
|
15476 struct StructExtends<PipelineViewportDepthClipControlCreateInfoEXT, PipelineViewportStateCreateInfo>
|
|
|
15477 {
|
|
|
15478 enum
|
|
|
15479 {
|
|
|
15480 value = true
|
|
|
15481 };
|
|
|
15482 };
|
|
|
15483
|
|
|
15484 //=== VK_EXT_primitive_topology_list_restart ===
|
|
|
15485 template <>
|
|
|
15486 struct StructExtends<PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
15487 {
|
|
|
15488 enum
|
|
|
15489 {
|
|
|
15490 value = true
|
|
|
15491 };
|
|
|
15492 };
|
|
|
15493
|
|
|
15494 template <>
|
|
|
15495 struct StructExtends<PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT, DeviceCreateInfo>
|
|
|
15496 {
|
|
|
15497 enum
|
|
|
15498 {
|
|
|
15499 value = true
|
|
|
15500 };
|
|
|
15501 };
|
|
|
15502
|
|
|
15503 # if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
|
15504 //=== VK_FUCHSIA_external_memory ===
|
|
|
15505 template <>
|
|
|
15506 struct StructExtends<ImportMemoryZirconHandleInfoFUCHSIA, MemoryAllocateInfo>
|
|
|
15507 {
|
|
|
15508 enum
|
|
|
15509 {
|
|
|
15510 value = true
|
|
|
15511 };
|
|
|
15512 };
|
|
|
15513 # endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
15514
|
|
|
15515 # if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
|
15516 //=== VK_FUCHSIA_buffer_collection ===
|
|
|
15517 template <>
|
|
|
15518 struct StructExtends<ImportMemoryBufferCollectionFUCHSIA, MemoryAllocateInfo>
|
|
|
15519 {
|
|
|
15520 enum
|
|
|
15521 {
|
|
|
15522 value = true
|
|
|
15523 };
|
|
|
15524 };
|
|
|
15525
|
|
|
15526 template <>
|
|
|
15527 struct StructExtends<BufferCollectionImageCreateInfoFUCHSIA, ImageCreateInfo>
|
|
|
15528 {
|
|
|
15529 enum
|
|
|
15530 {
|
|
|
15531 value = true
|
|
|
15532 };
|
|
|
15533 };
|
|
|
15534
|
|
|
15535 template <>
|
|
|
15536 struct StructExtends<BufferCollectionBufferCreateInfoFUCHSIA, BufferCreateInfo>
|
|
|
15537 {
|
|
|
15538 enum
|
|
|
15539 {
|
|
|
15540 value = true
|
|
|
15541 };
|
|
|
15542 };
|
|
|
15543 # endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
15544
|
|
|
15545 //=== VK_HUAWEI_subpass_shading ===
|
|
|
15546 template <>
|
|
|
15547 struct StructExtends<SubpassShadingPipelineCreateInfoHUAWEI, ComputePipelineCreateInfo>
|
|
|
15548 {
|
|
|
15549 enum
|
|
|
15550 {
|
|
|
15551 value = true
|
|
|
15552 };
|
|
|
15553 };
|
|
|
15554
|
|
|
15555 template <>
|
|
|
15556 struct StructExtends<PhysicalDeviceSubpassShadingFeaturesHUAWEI, PhysicalDeviceFeatures2>
|
|
|
15557 {
|
|
|
15558 enum
|
|
|
15559 {
|
|
|
15560 value = true
|
|
|
15561 };
|
|
|
15562 };
|
|
|
15563
|
|
|
15564 template <>
|
|
|
15565 struct StructExtends<PhysicalDeviceSubpassShadingFeaturesHUAWEI, DeviceCreateInfo>
|
|
|
15566 {
|
|
|
15567 enum
|
|
|
15568 {
|
|
|
15569 value = true
|
|
|
15570 };
|
|
|
15571 };
|
|
|
15572
|
|
|
15573 template <>
|
|
|
15574 struct StructExtends<PhysicalDeviceSubpassShadingPropertiesHUAWEI, PhysicalDeviceProperties2>
|
|
|
15575 {
|
|
|
15576 enum
|
|
|
15577 {
|
|
|
15578 value = true
|
|
|
15579 };
|
|
|
15580 };
|
|
|
15581
|
|
|
15582 //=== VK_HUAWEI_invocation_mask ===
|
|
|
15583 template <>
|
|
|
15584 struct StructExtends<PhysicalDeviceInvocationMaskFeaturesHUAWEI, PhysicalDeviceFeatures2>
|
|
|
15585 {
|
|
|
15586 enum
|
|
|
15587 {
|
|
|
15588 value = true
|
|
|
15589 };
|
|
|
15590 };
|
|
|
15591
|
|
|
15592 template <>
|
|
|
15593 struct StructExtends<PhysicalDeviceInvocationMaskFeaturesHUAWEI, DeviceCreateInfo>
|
|
|
15594 {
|
|
|
15595 enum
|
|
|
15596 {
|
|
|
15597 value = true
|
|
|
15598 };
|
|
|
15599 };
|
|
|
15600
|
|
|
15601 //=== VK_NV_external_memory_rdma ===
|
|
|
15602 template <>
|
|
|
15603 struct StructExtends<PhysicalDeviceExternalMemoryRDMAFeaturesNV, PhysicalDeviceFeatures2>
|
|
|
15604 {
|
|
|
15605 enum
|
|
|
15606 {
|
|
|
15607 value = true
|
|
|
15608 };
|
|
|
15609 };
|
|
|
15610
|
|
|
15611 template <>
|
|
|
15612 struct StructExtends<PhysicalDeviceExternalMemoryRDMAFeaturesNV, DeviceCreateInfo>
|
|
|
15613 {
|
|
|
15614 enum
|
|
|
15615 {
|
|
|
15616 value = true
|
|
|
15617 };
|
|
|
15618 };
|
|
|
15619
|
|
|
15620 //=== VK_EXT_pipeline_properties ===
|
|
|
15621 template <>
|
|
|
15622 struct StructExtends<PhysicalDevicePipelinePropertiesFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
15623 {
|
|
|
15624 enum
|
|
|
15625 {
|
|
|
15626 value = true
|
|
|
15627 };
|
|
|
15628 };
|
|
|
15629
|
|
|
15630 template <>
|
|
|
15631 struct StructExtends<PhysicalDevicePipelinePropertiesFeaturesEXT, DeviceCreateInfo>
|
|
|
15632 {
|
|
|
15633 enum
|
|
|
15634 {
|
|
|
15635 value = true
|
|
|
15636 };
|
|
|
15637 };
|
|
|
15638
|
|
|
15639 //=== VK_EXT_frame_boundary ===
|
|
|
15640 template <>
|
|
|
15641 struct StructExtends<PhysicalDeviceFrameBoundaryFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
15642 {
|
|
|
15643 enum
|
|
|
15644 {
|
|
|
15645 value = true
|
|
|
15646 };
|
|
|
15647 };
|
|
|
15648
|
|
|
15649 template <>
|
|
|
15650 struct StructExtends<PhysicalDeviceFrameBoundaryFeaturesEXT, DeviceCreateInfo>
|
|
|
15651 {
|
|
|
15652 enum
|
|
|
15653 {
|
|
|
15654 value = true
|
|
|
15655 };
|
|
|
15656 };
|
|
|
15657
|
|
|
15658 template <>
|
|
|
15659 struct StructExtends<FrameBoundaryEXT, SubmitInfo>
|
|
|
15660 {
|
|
|
15661 enum
|
|
|
15662 {
|
|
|
15663 value = true
|
|
|
15664 };
|
|
|
15665 };
|
|
|
15666
|
|
|
15667 template <>
|
|
|
15668 struct StructExtends<FrameBoundaryEXT, SubmitInfo2>
|
|
|
15669 {
|
|
|
15670 enum
|
|
|
15671 {
|
|
|
15672 value = true
|
|
|
15673 };
|
|
|
15674 };
|
|
|
15675
|
|
|
15676 template <>
|
|
|
15677 struct StructExtends<FrameBoundaryEXT, PresentInfoKHR>
|
|
|
15678 {
|
|
|
15679 enum
|
|
|
15680 {
|
|
|
15681 value = true
|
|
|
15682 };
|
|
|
15683 };
|
|
|
15684
|
|
|
15685 template <>
|
|
|
15686 struct StructExtends<FrameBoundaryEXT, BindSparseInfo>
|
|
|
15687 {
|
|
|
15688 enum
|
|
|
15689 {
|
|
|
15690 value = true
|
|
|
15691 };
|
|
|
15692 };
|
|
|
15693
|
|
|
15694 //=== VK_EXT_multisampled_render_to_single_sampled ===
|
|
|
15695 template <>
|
|
|
15696 struct StructExtends<PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
15697 {
|
|
|
15698 enum
|
|
|
15699 {
|
|
|
15700 value = true
|
|
|
15701 };
|
|
|
15702 };
|
|
|
15703
|
|
|
15704 template <>
|
|
|
15705 struct StructExtends<PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT, DeviceCreateInfo>
|
|
|
15706 {
|
|
|
15707 enum
|
|
|
15708 {
|
|
|
15709 value = true
|
|
|
15710 };
|
|
|
15711 };
|
|
|
15712
|
|
|
15713 template <>
|
|
|
15714 struct StructExtends<SubpassResolvePerformanceQueryEXT, FormatProperties2>
|
|
|
15715 {
|
|
|
15716 enum
|
|
|
15717 {
|
|
|
15718 value = true
|
|
|
15719 };
|
|
|
15720 };
|
|
|
15721
|
|
|
15722 template <>
|
|
|
15723 struct StructExtends<MultisampledRenderToSingleSampledInfoEXT, SubpassDescription2>
|
|
|
15724 {
|
|
|
15725 enum
|
|
|
15726 {
|
|
|
15727 value = true
|
|
|
15728 };
|
|
|
15729 };
|
|
|
15730
|
|
|
15731 template <>
|
|
|
15732 struct StructExtends<MultisampledRenderToSingleSampledInfoEXT, RenderingInfo>
|
|
|
15733 {
|
|
|
15734 enum
|
|
|
15735 {
|
|
|
15736 value = true
|
|
|
15737 };
|
|
|
15738 };
|
|
|
15739
|
|
|
15740 //=== VK_EXT_extended_dynamic_state2 ===
|
|
|
15741 template <>
|
|
|
15742 struct StructExtends<PhysicalDeviceExtendedDynamicState2FeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
15743 {
|
|
|
15744 enum
|
|
|
15745 {
|
|
|
15746 value = true
|
|
|
15747 };
|
|
|
15748 };
|
|
|
15749
|
|
|
15750 template <>
|
|
|
15751 struct StructExtends<PhysicalDeviceExtendedDynamicState2FeaturesEXT, DeviceCreateInfo>
|
|
|
15752 {
|
|
|
15753 enum
|
|
|
15754 {
|
|
|
15755 value = true
|
|
|
15756 };
|
|
|
15757 };
|
|
|
15758
|
|
|
15759 //=== VK_EXT_color_write_enable ===
|
|
|
15760 template <>
|
|
|
15761 struct StructExtends<PhysicalDeviceColorWriteEnableFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
15762 {
|
|
|
15763 enum
|
|
|
15764 {
|
|
|
15765 value = true
|
|
|
15766 };
|
|
|
15767 };
|
|
|
15768
|
|
|
15769 template <>
|
|
|
15770 struct StructExtends<PhysicalDeviceColorWriteEnableFeaturesEXT, DeviceCreateInfo>
|
|
|
15771 {
|
|
|
15772 enum
|
|
|
15773 {
|
|
|
15774 value = true
|
|
|
15775 };
|
|
|
15776 };
|
|
|
15777
|
|
|
15778 template <>
|
|
|
15779 struct StructExtends<PipelineColorWriteCreateInfoEXT, PipelineColorBlendStateCreateInfo>
|
|
|
15780 {
|
|
|
15781 enum
|
|
|
15782 {
|
|
|
15783 value = true
|
|
|
15784 };
|
|
|
15785 };
|
|
|
15786
|
|
|
15787 //=== VK_EXT_primitives_generated_query ===
|
|
|
15788 template <>
|
|
|
15789 struct StructExtends<PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
15790 {
|
|
|
15791 enum
|
|
|
15792 {
|
|
|
15793 value = true
|
|
|
15794 };
|
|
|
15795 };
|
|
|
15796
|
|
|
15797 template <>
|
|
|
15798 struct StructExtends<PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT, DeviceCreateInfo>
|
|
|
15799 {
|
|
|
15800 enum
|
|
|
15801 {
|
|
|
15802 value = true
|
|
|
15803 };
|
|
|
15804 };
|
|
|
15805
|
|
|
15806 //=== VK_KHR_ray_tracing_maintenance1 ===
|
|
|
15807 template <>
|
|
|
15808 struct StructExtends<PhysicalDeviceRayTracingMaintenance1FeaturesKHR, PhysicalDeviceFeatures2>
|
|
|
15809 {
|
|
|
15810 enum
|
|
|
15811 {
|
|
|
15812 value = true
|
|
|
15813 };
|
|
|
15814 };
|
|
|
15815
|
|
|
15816 template <>
|
|
|
15817 struct StructExtends<PhysicalDeviceRayTracingMaintenance1FeaturesKHR, DeviceCreateInfo>
|
|
|
15818 {
|
|
|
15819 enum
|
|
|
15820 {
|
|
|
15821 value = true
|
|
|
15822 };
|
|
|
15823 };
|
|
|
15824
|
|
|
15825 //=== VK_KHR_shader_untyped_pointers ===
|
|
|
15826 template <>
|
|
|
15827 struct StructExtends<PhysicalDeviceShaderUntypedPointersFeaturesKHR, PhysicalDeviceFeatures2>
|
|
|
15828 {
|
|
|
15829 enum
|
|
|
15830 {
|
|
|
15831 value = true
|
|
|
15832 };
|
|
|
15833 };
|
|
|
15834
|
|
|
15835 template <>
|
|
|
15836 struct StructExtends<PhysicalDeviceShaderUntypedPointersFeaturesKHR, DeviceCreateInfo>
|
|
|
15837 {
|
|
|
15838 enum
|
|
|
15839 {
|
|
|
15840 value = true
|
|
|
15841 };
|
|
|
15842 };
|
|
|
15843
|
|
|
15844 //=== VK_VALVE_video_encode_rgb_conversion ===
|
|
|
15845 template <>
|
|
|
15846 struct StructExtends<PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE, PhysicalDeviceFeatures2>
|
|
|
15847 {
|
|
|
15848 enum
|
|
|
15849 {
|
|
|
15850 value = true
|
|
|
15851 };
|
|
|
15852 };
|
|
|
15853
|
|
|
15854 template <>
|
|
|
15855 struct StructExtends<PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE, DeviceCreateInfo>
|
|
|
15856 {
|
|
|
15857 enum
|
|
|
15858 {
|
|
|
15859 value = true
|
|
|
15860 };
|
|
|
15861 };
|
|
|
15862
|
|
|
15863 template <>
|
|
|
15864 struct StructExtends<VideoEncodeRgbConversionCapabilitiesVALVE, VideoCapabilitiesKHR>
|
|
|
15865 {
|
|
|
15866 enum
|
|
|
15867 {
|
|
|
15868 value = true
|
|
|
15869 };
|
|
|
15870 };
|
|
|
15871
|
|
|
15872 template <>
|
|
|
15873 struct StructExtends<VideoEncodeProfileRgbConversionInfoVALVE, VideoProfileInfoKHR>
|
|
|
15874 {
|
|
|
15875 enum
|
|
|
15876 {
|
|
|
15877 value = true
|
|
|
15878 };
|
|
|
15879 };
|
|
|
15880
|
|
|
15881 template <>
|
|
|
15882 struct StructExtends<VideoEncodeSessionRgbConversionCreateInfoVALVE, VideoSessionCreateInfoKHR>
|
|
|
15883 {
|
|
|
15884 enum
|
|
|
15885 {
|
|
|
15886 value = true
|
|
|
15887 };
|
|
|
15888 };
|
|
|
15889
|
|
|
15890 //=== VK_EXT_image_view_min_lod ===
|
|
|
15891 template <>
|
|
|
15892 struct StructExtends<PhysicalDeviceImageViewMinLodFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
15893 {
|
|
|
15894 enum
|
|
|
15895 {
|
|
|
15896 value = true
|
|
|
15897 };
|
|
|
15898 };
|
|
|
15899
|
|
|
15900 template <>
|
|
|
15901 struct StructExtends<PhysicalDeviceImageViewMinLodFeaturesEXT, DeviceCreateInfo>
|
|
|
15902 {
|
|
|
15903 enum
|
|
|
15904 {
|
|
|
15905 value = true
|
|
|
15906 };
|
|
|
15907 };
|
|
|
15908
|
|
|
15909 template <>
|
|
|
15910 struct StructExtends<ImageViewMinLodCreateInfoEXT, ImageViewCreateInfo>
|
|
|
15911 {
|
|
|
15912 enum
|
|
|
15913 {
|
|
|
15914 value = true
|
|
|
15915 };
|
|
|
15916 };
|
|
|
15917
|
|
|
15918 //=== VK_EXT_multi_draw ===
|
|
|
15919 template <>
|
|
|
15920 struct StructExtends<PhysicalDeviceMultiDrawFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
15921 {
|
|
|
15922 enum
|
|
|
15923 {
|
|
|
15924 value = true
|
|
|
15925 };
|
|
|
15926 };
|
|
|
15927
|
|
|
15928 template <>
|
|
|
15929 struct StructExtends<PhysicalDeviceMultiDrawFeaturesEXT, DeviceCreateInfo>
|
|
|
15930 {
|
|
|
15931 enum
|
|
|
15932 {
|
|
|
15933 value = true
|
|
|
15934 };
|
|
|
15935 };
|
|
|
15936
|
|
|
15937 template <>
|
|
|
15938 struct StructExtends<PhysicalDeviceMultiDrawPropertiesEXT, PhysicalDeviceProperties2>
|
|
|
15939 {
|
|
|
15940 enum
|
|
|
15941 {
|
|
|
15942 value = true
|
|
|
15943 };
|
|
|
15944 };
|
|
|
15945
|
|
|
15946 //=== VK_EXT_image_2d_view_of_3d ===
|
|
|
15947 template <>
|
|
|
15948 struct StructExtends<PhysicalDeviceImage2DViewOf3DFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
15949 {
|
|
|
15950 enum
|
|
|
15951 {
|
|
|
15952 value = true
|
|
|
15953 };
|
|
|
15954 };
|
|
|
15955
|
|
|
15956 template <>
|
|
|
15957 struct StructExtends<PhysicalDeviceImage2DViewOf3DFeaturesEXT, DeviceCreateInfo>
|
|
|
15958 {
|
|
|
15959 enum
|
|
|
15960 {
|
|
|
15961 value = true
|
|
|
15962 };
|
|
|
15963 };
|
|
|
15964
|
|
|
15965 //=== VK_EXT_shader_tile_image ===
|
|
|
15966 template <>
|
|
|
15967 struct StructExtends<PhysicalDeviceShaderTileImageFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
15968 {
|
|
|
15969 enum
|
|
|
15970 {
|
|
|
15971 value = true
|
|
|
15972 };
|
|
|
15973 };
|
|
|
15974
|
|
|
15975 template <>
|
|
|
15976 struct StructExtends<PhysicalDeviceShaderTileImageFeaturesEXT, DeviceCreateInfo>
|
|
|
15977 {
|
|
|
15978 enum
|
|
|
15979 {
|
|
|
15980 value = true
|
|
|
15981 };
|
|
|
15982 };
|
|
|
15983
|
|
|
15984 template <>
|
|
|
15985 struct StructExtends<PhysicalDeviceShaderTileImagePropertiesEXT, PhysicalDeviceProperties2>
|
|
|
15986 {
|
|
|
15987 enum
|
|
|
15988 {
|
|
|
15989 value = true
|
|
|
15990 };
|
|
|
15991 };
|
|
|
15992
|
|
|
15993 //=== VK_EXT_opacity_micromap ===
|
|
|
15994 template <>
|
|
|
15995 struct StructExtends<PhysicalDeviceOpacityMicromapFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
15996 {
|
|
|
15997 enum
|
|
|
15998 {
|
|
|
15999 value = true
|
|
|
16000 };
|
|
|
16001 };
|
|
|
16002
|
|
|
16003 template <>
|
|
|
16004 struct StructExtends<PhysicalDeviceOpacityMicromapFeaturesEXT, DeviceCreateInfo>
|
|
|
16005 {
|
|
|
16006 enum
|
|
|
16007 {
|
|
|
16008 value = true
|
|
|
16009 };
|
|
|
16010 };
|
|
|
16011
|
|
|
16012 template <>
|
|
|
16013 struct StructExtends<PhysicalDeviceOpacityMicromapPropertiesEXT, PhysicalDeviceProperties2>
|
|
|
16014 {
|
|
|
16015 enum
|
|
|
16016 {
|
|
|
16017 value = true
|
|
|
16018 };
|
|
|
16019 };
|
|
|
16020
|
|
|
16021 template <>
|
|
|
16022 struct StructExtends<AccelerationStructureTrianglesOpacityMicromapEXT, AccelerationStructureGeometryTrianglesDataKHR>
|
|
|
16023 {
|
|
|
16024 enum
|
|
|
16025 {
|
|
|
16026 value = true
|
|
|
16027 };
|
|
|
16028 };
|
|
|
16029 # if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
16030 template <>
|
|
|
16031 struct StructExtends<AccelerationStructureTrianglesOpacityMicromapEXT, AccelerationStructureDenseGeometryFormatTrianglesDataAMDX>
|
|
|
16032 {
|
|
|
16033 enum
|
|
|
16034 {
|
|
|
16035 value = true
|
|
|
16036 };
|
|
|
16037 };
|
|
|
16038 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
16039
|
|
|
16040 # if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
16041 //=== VK_NV_displacement_micromap ===
|
|
|
16042 template <>
|
|
|
16043 struct StructExtends<PhysicalDeviceDisplacementMicromapFeaturesNV, PhysicalDeviceFeatures2>
|
|
|
16044 {
|
|
|
16045 enum
|
|
|
16046 {
|
|
|
16047 value = true
|
|
|
16048 };
|
|
|
16049 };
|
|
|
16050
|
|
|
16051 template <>
|
|
|
16052 struct StructExtends<PhysicalDeviceDisplacementMicromapFeaturesNV, DeviceCreateInfo>
|
|
|
16053 {
|
|
|
16054 enum
|
|
|
16055 {
|
|
|
16056 value = true
|
|
|
16057 };
|
|
|
16058 };
|
|
|
16059
|
|
|
16060 template <>
|
|
|
16061 struct StructExtends<PhysicalDeviceDisplacementMicromapPropertiesNV, PhysicalDeviceProperties2>
|
|
|
16062 {
|
|
|
16063 enum
|
|
|
16064 {
|
|
|
16065 value = true
|
|
|
16066 };
|
|
|
16067 };
|
|
|
16068
|
|
|
16069 template <>
|
|
|
16070 struct StructExtends<AccelerationStructureTrianglesDisplacementMicromapNV, AccelerationStructureGeometryTrianglesDataKHR>
|
|
|
16071 {
|
|
|
16072 enum
|
|
|
16073 {
|
|
|
16074 value = true
|
|
|
16075 };
|
|
|
16076 };
|
|
|
16077 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
16078
|
|
|
16079 //=== VK_HUAWEI_cluster_culling_shader ===
|
|
|
16080 template <>
|
|
|
16081 struct StructExtends<PhysicalDeviceClusterCullingShaderFeaturesHUAWEI, PhysicalDeviceFeatures2>
|
|
|
16082 {
|
|
|
16083 enum
|
|
|
16084 {
|
|
|
16085 value = true
|
|
|
16086 };
|
|
|
16087 };
|
|
|
16088
|
|
|
16089 template <>
|
|
|
16090 struct StructExtends<PhysicalDeviceClusterCullingShaderFeaturesHUAWEI, DeviceCreateInfo>
|
|
|
16091 {
|
|
|
16092 enum
|
|
|
16093 {
|
|
|
16094 value = true
|
|
|
16095 };
|
|
|
16096 };
|
|
|
16097
|
|
|
16098 template <>
|
|
|
16099 struct StructExtends<PhysicalDeviceClusterCullingShaderPropertiesHUAWEI, PhysicalDeviceProperties2>
|
|
|
16100 {
|
|
|
16101 enum
|
|
|
16102 {
|
|
|
16103 value = true
|
|
|
16104 };
|
|
|
16105 };
|
|
|
16106
|
|
|
16107 template <>
|
|
|
16108 struct StructExtends<PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI, PhysicalDeviceClusterCullingShaderFeaturesHUAWEI>
|
|
|
16109 {
|
|
|
16110 enum
|
|
|
16111 {
|
|
|
16112 value = true
|
|
|
16113 };
|
|
|
16114 };
|
|
|
16115
|
|
|
16116 //=== VK_EXT_border_color_swizzle ===
|
|
|
16117 template <>
|
|
|
16118 struct StructExtends<PhysicalDeviceBorderColorSwizzleFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
16119 {
|
|
|
16120 enum
|
|
|
16121 {
|
|
|
16122 value = true
|
|
|
16123 };
|
|
|
16124 };
|
|
|
16125
|
|
|
16126 template <>
|
|
|
16127 struct StructExtends<PhysicalDeviceBorderColorSwizzleFeaturesEXT, DeviceCreateInfo>
|
|
|
16128 {
|
|
|
16129 enum
|
|
|
16130 {
|
|
|
16131 value = true
|
|
|
16132 };
|
|
|
16133 };
|
|
|
16134
|
|
|
16135 template <>
|
|
|
16136 struct StructExtends<SamplerBorderColorComponentMappingCreateInfoEXT, SamplerCreateInfo>
|
|
|
16137 {
|
|
|
16138 enum
|
|
|
16139 {
|
|
|
16140 value = true
|
|
|
16141 };
|
|
|
16142 };
|
|
|
16143
|
|
|
16144 //=== VK_EXT_pageable_device_local_memory ===
|
|
|
16145 template <>
|
|
|
16146 struct StructExtends<PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
16147 {
|
|
|
16148 enum
|
|
|
16149 {
|
|
|
16150 value = true
|
|
|
16151 };
|
|
|
16152 };
|
|
|
16153
|
|
|
16154 template <>
|
|
|
16155 struct StructExtends<PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT, DeviceCreateInfo>
|
|
|
16156 {
|
|
|
16157 enum
|
|
|
16158 {
|
|
|
16159 value = true
|
|
|
16160 };
|
|
|
16161 };
|
|
|
16162
|
|
|
16163 //=== VK_ARM_shader_core_properties ===
|
|
|
16164 template <>
|
|
|
16165 struct StructExtends<PhysicalDeviceShaderCorePropertiesARM, PhysicalDeviceProperties2>
|
|
|
16166 {
|
|
|
16167 enum
|
|
|
16168 {
|
|
|
16169 value = true
|
|
|
16170 };
|
|
|
16171 };
|
|
|
16172
|
|
|
16173 //=== VK_ARM_scheduling_controls ===
|
|
|
16174 template <>
|
|
|
16175 struct StructExtends<DeviceQueueShaderCoreControlCreateInfoARM, DeviceQueueCreateInfo>
|
|
|
16176 {
|
|
|
16177 enum
|
|
|
16178 {
|
|
|
16179 value = true
|
|
|
16180 };
|
|
|
16181 };
|
|
|
16182
|
|
|
16183 template <>
|
|
|
16184 struct StructExtends<DeviceQueueShaderCoreControlCreateInfoARM, DeviceCreateInfo>
|
|
|
16185 {
|
|
|
16186 enum
|
|
|
16187 {
|
|
|
16188 value = true
|
|
|
16189 };
|
|
|
16190 };
|
|
|
16191
|
|
|
16192 template <>
|
|
|
16193 struct StructExtends<PhysicalDeviceSchedulingControlsFeaturesARM, PhysicalDeviceFeatures2>
|
|
|
16194 {
|
|
|
16195 enum
|
|
|
16196 {
|
|
|
16197 value = true
|
|
|
16198 };
|
|
|
16199 };
|
|
|
16200
|
|
|
16201 template <>
|
|
|
16202 struct StructExtends<PhysicalDeviceSchedulingControlsFeaturesARM, DeviceCreateInfo>
|
|
|
16203 {
|
|
|
16204 enum
|
|
|
16205 {
|
|
|
16206 value = true
|
|
|
16207 };
|
|
|
16208 };
|
|
|
16209
|
|
|
16210 template <>
|
|
|
16211 struct StructExtends<PhysicalDeviceSchedulingControlsPropertiesARM, PhysicalDeviceProperties2>
|
|
|
16212 {
|
|
|
16213 enum
|
|
|
16214 {
|
|
|
16215 value = true
|
|
|
16216 };
|
|
|
16217 };
|
|
|
16218
|
|
|
16219 //=== VK_EXT_image_sliced_view_of_3d ===
|
|
|
16220 template <>
|
|
|
16221 struct StructExtends<PhysicalDeviceImageSlicedViewOf3DFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
16222 {
|
|
|
16223 enum
|
|
|
16224 {
|
|
|
16225 value = true
|
|
|
16226 };
|
|
|
16227 };
|
|
|
16228
|
|
|
16229 template <>
|
|
|
16230 struct StructExtends<PhysicalDeviceImageSlicedViewOf3DFeaturesEXT, DeviceCreateInfo>
|
|
|
16231 {
|
|
|
16232 enum
|
|
|
16233 {
|
|
|
16234 value = true
|
|
|
16235 };
|
|
|
16236 };
|
|
|
16237
|
|
|
16238 template <>
|
|
|
16239 struct StructExtends<ImageViewSlicedCreateInfoEXT, ImageViewCreateInfo>
|
|
|
16240 {
|
|
|
16241 enum
|
|
|
16242 {
|
|
|
16243 value = true
|
|
|
16244 };
|
|
|
16245 };
|
|
|
16246
|
|
|
16247 //=== VK_VALVE_descriptor_set_host_mapping ===
|
|
|
16248 template <>
|
|
|
16249 struct StructExtends<PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE, PhysicalDeviceFeatures2>
|
|
|
16250 {
|
|
|
16251 enum
|
|
|
16252 {
|
|
|
16253 value = true
|
|
|
16254 };
|
|
|
16255 };
|
|
|
16256
|
|
|
16257 template <>
|
|
|
16258 struct StructExtends<PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE, DeviceCreateInfo>
|
|
|
16259 {
|
|
|
16260 enum
|
|
|
16261 {
|
|
|
16262 value = true
|
|
|
16263 };
|
|
|
16264 };
|
|
|
16265
|
|
|
16266 //=== VK_EXT_non_seamless_cube_map ===
|
|
|
16267 template <>
|
|
|
16268 struct StructExtends<PhysicalDeviceNonSeamlessCubeMapFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
16269 {
|
|
|
16270 enum
|
|
|
16271 {
|
|
|
16272 value = true
|
|
|
16273 };
|
|
|
16274 };
|
|
|
16275
|
|
|
16276 template <>
|
|
|
16277 struct StructExtends<PhysicalDeviceNonSeamlessCubeMapFeaturesEXT, DeviceCreateInfo>
|
|
|
16278 {
|
|
|
16279 enum
|
|
|
16280 {
|
|
|
16281 value = true
|
|
|
16282 };
|
|
|
16283 };
|
|
|
16284
|
|
|
16285 //=== VK_ARM_render_pass_striped ===
|
|
|
16286 template <>
|
|
|
16287 struct StructExtends<PhysicalDeviceRenderPassStripedFeaturesARM, PhysicalDeviceFeatures2>
|
|
|
16288 {
|
|
|
16289 enum
|
|
|
16290 {
|
|
|
16291 value = true
|
|
|
16292 };
|
|
|
16293 };
|
|
|
16294
|
|
|
16295 template <>
|
|
|
16296 struct StructExtends<PhysicalDeviceRenderPassStripedFeaturesARM, DeviceCreateInfo>
|
|
|
16297 {
|
|
|
16298 enum
|
|
|
16299 {
|
|
|
16300 value = true
|
|
|
16301 };
|
|
|
16302 };
|
|
|
16303
|
|
|
16304 template <>
|
|
|
16305 struct StructExtends<PhysicalDeviceRenderPassStripedPropertiesARM, PhysicalDeviceProperties2>
|
|
|
16306 {
|
|
|
16307 enum
|
|
|
16308 {
|
|
|
16309 value = true
|
|
|
16310 };
|
|
|
16311 };
|
|
|
16312
|
|
|
16313 template <>
|
|
|
16314 struct StructExtends<RenderPassStripeBeginInfoARM, RenderingInfo>
|
|
|
16315 {
|
|
|
16316 enum
|
|
|
16317 {
|
|
|
16318 value = true
|
|
|
16319 };
|
|
|
16320 };
|
|
|
16321
|
|
|
16322 template <>
|
|
|
16323 struct StructExtends<RenderPassStripeBeginInfoARM, RenderPassBeginInfo>
|
|
|
16324 {
|
|
|
16325 enum
|
|
|
16326 {
|
|
|
16327 value = true
|
|
|
16328 };
|
|
|
16329 };
|
|
|
16330
|
|
|
16331 template <>
|
|
|
16332 struct StructExtends<RenderPassStripeSubmitInfoARM, CommandBufferSubmitInfo>
|
|
|
16333 {
|
|
|
16334 enum
|
|
|
16335 {
|
|
|
16336 value = true
|
|
|
16337 };
|
|
|
16338 };
|
|
|
16339
|
|
|
16340 //=== VK_NV_copy_memory_indirect ===
|
|
|
16341 template <>
|
|
|
16342 struct StructExtends<PhysicalDeviceCopyMemoryIndirectFeaturesNV, PhysicalDeviceFeatures2>
|
|
|
16343 {
|
|
|
16344 enum
|
|
|
16345 {
|
|
|
16346 value = true
|
|
|
16347 };
|
|
|
16348 };
|
|
|
16349
|
|
|
16350 template <>
|
|
|
16351 struct StructExtends<PhysicalDeviceCopyMemoryIndirectFeaturesNV, DeviceCreateInfo>
|
|
|
16352 {
|
|
|
16353 enum
|
|
|
16354 {
|
|
|
16355 value = true
|
|
|
16356 };
|
|
|
16357 };
|
|
|
16358
|
|
|
16359 //=== VK_NV_device_generated_commands_compute ===
|
|
|
16360 template <>
|
|
|
16361 struct StructExtends<PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV, PhysicalDeviceFeatures2>
|
|
|
16362 {
|
|
|
16363 enum
|
|
|
16364 {
|
|
|
16365 value = true
|
|
|
16366 };
|
|
|
16367 };
|
|
|
16368
|
|
|
16369 template <>
|
|
|
16370 struct StructExtends<PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV, DeviceCreateInfo>
|
|
|
16371 {
|
|
|
16372 enum
|
|
|
16373 {
|
|
|
16374 value = true
|
|
|
16375 };
|
|
|
16376 };
|
|
|
16377
|
|
|
16378 template <>
|
|
|
16379 struct StructExtends<ComputePipelineIndirectBufferInfoNV, ComputePipelineCreateInfo>
|
|
|
16380 {
|
|
|
16381 enum
|
|
|
16382 {
|
|
|
16383 value = true
|
|
|
16384 };
|
|
|
16385 };
|
|
|
16386
|
|
|
16387 //=== VK_NV_ray_tracing_linear_swept_spheres ===
|
|
|
16388 template <>
|
|
|
16389 struct StructExtends<PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV, PhysicalDeviceFeatures2>
|
|
|
16390 {
|
|
|
16391 enum
|
|
|
16392 {
|
|
|
16393 value = true
|
|
|
16394 };
|
|
|
16395 };
|
|
|
16396
|
|
|
16397 template <>
|
|
|
16398 struct StructExtends<PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV, DeviceCreateInfo>
|
|
|
16399 {
|
|
|
16400 enum
|
|
|
16401 {
|
|
|
16402 value = true
|
|
|
16403 };
|
|
|
16404 };
|
|
|
16405
|
|
|
16406 template <>
|
|
|
16407 struct StructExtends<AccelerationStructureGeometryLinearSweptSpheresDataNV, AccelerationStructureGeometryKHR>
|
|
|
16408 {
|
|
|
16409 enum
|
|
|
16410 {
|
|
|
16411 value = true
|
|
|
16412 };
|
|
|
16413 };
|
|
|
16414
|
|
|
16415 template <>
|
|
|
16416 struct StructExtends<AccelerationStructureGeometrySpheresDataNV, AccelerationStructureGeometryKHR>
|
|
|
16417 {
|
|
|
16418 enum
|
|
|
16419 {
|
|
|
16420 value = true
|
|
|
16421 };
|
|
|
16422 };
|
|
|
16423
|
|
|
16424 //=== VK_NV_linear_color_attachment ===
|
|
|
16425 template <>
|
|
|
16426 struct StructExtends<PhysicalDeviceLinearColorAttachmentFeaturesNV, PhysicalDeviceFeatures2>
|
|
|
16427 {
|
|
|
16428 enum
|
|
|
16429 {
|
|
|
16430 value = true
|
|
|
16431 };
|
|
|
16432 };
|
|
|
16433
|
|
|
16434 template <>
|
|
|
16435 struct StructExtends<PhysicalDeviceLinearColorAttachmentFeaturesNV, DeviceCreateInfo>
|
|
|
16436 {
|
|
|
16437 enum
|
|
|
16438 {
|
|
|
16439 value = true
|
|
|
16440 };
|
|
|
16441 };
|
|
|
16442
|
|
|
16443 //=== VK_KHR_shader_maximal_reconvergence ===
|
|
|
16444 template <>
|
|
|
16445 struct StructExtends<PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR, PhysicalDeviceFeatures2>
|
|
|
16446 {
|
|
|
16447 enum
|
|
|
16448 {
|
|
|
16449 value = true
|
|
|
16450 };
|
|
|
16451 };
|
|
|
16452
|
|
|
16453 template <>
|
|
|
16454 struct StructExtends<PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR, DeviceCreateInfo>
|
|
|
16455 {
|
|
|
16456 enum
|
|
|
16457 {
|
|
|
16458 value = true
|
|
|
16459 };
|
|
|
16460 };
|
|
|
16461
|
|
|
16462 //=== VK_EXT_image_compression_control_swapchain ===
|
|
|
16463 template <>
|
|
|
16464 struct StructExtends<PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
16465 {
|
|
|
16466 enum
|
|
|
16467 {
|
|
|
16468 value = true
|
|
|
16469 };
|
|
|
16470 };
|
|
|
16471
|
|
|
16472 template <>
|
|
|
16473 struct StructExtends<PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT, DeviceCreateInfo>
|
|
|
16474 {
|
|
|
16475 enum
|
|
|
16476 {
|
|
|
16477 value = true
|
|
|
16478 };
|
|
|
16479 };
|
|
|
16480
|
|
|
16481 //=== VK_QCOM_image_processing ===
|
|
|
16482 template <>
|
|
|
16483 struct StructExtends<ImageViewSampleWeightCreateInfoQCOM, ImageViewCreateInfo>
|
|
|
16484 {
|
|
|
16485 enum
|
|
|
16486 {
|
|
|
16487 value = true
|
|
|
16488 };
|
|
|
16489 };
|
|
|
16490
|
|
|
16491 template <>
|
|
|
16492 struct StructExtends<PhysicalDeviceImageProcessingFeaturesQCOM, PhysicalDeviceFeatures2>
|
|
|
16493 {
|
|
|
16494 enum
|
|
|
16495 {
|
|
|
16496 value = true
|
|
|
16497 };
|
|
|
16498 };
|
|
|
16499
|
|
|
16500 template <>
|
|
|
16501 struct StructExtends<PhysicalDeviceImageProcessingFeaturesQCOM, DeviceCreateInfo>
|
|
|
16502 {
|
|
|
16503 enum
|
|
|
16504 {
|
|
|
16505 value = true
|
|
|
16506 };
|
|
|
16507 };
|
|
|
16508
|
|
|
16509 template <>
|
|
|
16510 struct StructExtends<PhysicalDeviceImageProcessingPropertiesQCOM, PhysicalDeviceProperties2>
|
|
|
16511 {
|
|
|
16512 enum
|
|
|
16513 {
|
|
|
16514 value = true
|
|
|
16515 };
|
|
|
16516 };
|
|
|
16517
|
|
|
16518 //=== VK_EXT_nested_command_buffer ===
|
|
|
16519 template <>
|
|
|
16520 struct StructExtends<PhysicalDeviceNestedCommandBufferFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
16521 {
|
|
|
16522 enum
|
|
|
16523 {
|
|
|
16524 value = true
|
|
|
16525 };
|
|
|
16526 };
|
|
|
16527
|
|
|
16528 template <>
|
|
|
16529 struct StructExtends<PhysicalDeviceNestedCommandBufferFeaturesEXT, DeviceCreateInfo>
|
|
|
16530 {
|
|
|
16531 enum
|
|
|
16532 {
|
|
|
16533 value = true
|
|
|
16534 };
|
|
|
16535 };
|
|
|
16536
|
|
|
16537 template <>
|
|
|
16538 struct StructExtends<PhysicalDeviceNestedCommandBufferPropertiesEXT, PhysicalDeviceProperties2>
|
|
|
16539 {
|
|
|
16540 enum
|
|
|
16541 {
|
|
|
16542 value = true
|
|
|
16543 };
|
|
|
16544 };
|
|
|
16545
|
|
|
16546 # if defined( VK_USE_PLATFORM_OHOS )
|
|
|
16547 //=== VK_OHOS_external_memory ===
|
|
|
16548 template <>
|
|
|
16549 struct StructExtends<NativeBufferUsageOHOS, ImageFormatProperties2>
|
|
|
16550 {
|
|
|
16551 enum
|
|
|
16552 {
|
|
|
16553 value = true
|
|
|
16554 };
|
|
|
16555 };
|
|
|
16556
|
|
|
16557 template <>
|
|
|
16558 struct StructExtends<NativeBufferFormatPropertiesOHOS, NativeBufferPropertiesOHOS>
|
|
|
16559 {
|
|
|
16560 enum
|
|
|
16561 {
|
|
|
16562 value = true
|
|
|
16563 };
|
|
|
16564 };
|
|
|
16565
|
|
|
16566 template <>
|
|
|
16567 struct StructExtends<ImportNativeBufferInfoOHOS, MemoryAllocateInfo>
|
|
|
16568 {
|
|
|
16569 enum
|
|
|
16570 {
|
|
|
16571 value = true
|
|
|
16572 };
|
|
|
16573 };
|
|
|
16574
|
|
|
16575 template <>
|
|
|
16576 struct StructExtends<ExternalFormatOHOS, ImageCreateInfo>
|
|
|
16577 {
|
|
|
16578 enum
|
|
|
16579 {
|
|
|
16580 value = true
|
|
|
16581 };
|
|
|
16582 };
|
|
|
16583
|
|
|
16584 template <>
|
|
|
16585 struct StructExtends<ExternalFormatOHOS, SamplerYcbcrConversionCreateInfo>
|
|
|
16586 {
|
|
|
16587 enum
|
|
|
16588 {
|
|
|
16589 value = true
|
|
|
16590 };
|
|
|
16591 };
|
|
|
16592
|
|
|
16593 template <>
|
|
|
16594 struct StructExtends<ExternalFormatOHOS, AttachmentDescription2>
|
|
|
16595 {
|
|
|
16596 enum
|
|
|
16597 {
|
|
|
16598 value = true
|
|
|
16599 };
|
|
|
16600 };
|
|
|
16601
|
|
|
16602 template <>
|
|
|
16603 struct StructExtends<ExternalFormatOHOS, GraphicsPipelineCreateInfo>
|
|
|
16604 {
|
|
|
16605 enum
|
|
|
16606 {
|
|
|
16607 value = true
|
|
|
16608 };
|
|
|
16609 };
|
|
|
16610
|
|
|
16611 template <>
|
|
|
16612 struct StructExtends<ExternalFormatOHOS, CommandBufferInheritanceInfo>
|
|
|
16613 {
|
|
|
16614 enum
|
|
|
16615 {
|
|
|
16616 value = true
|
|
|
16617 };
|
|
|
16618 };
|
|
|
16619 # endif /*VK_USE_PLATFORM_OHOS*/
|
|
|
16620
|
|
|
16621 //=== VK_EXT_external_memory_acquire_unmodified ===
|
|
|
16622 template <>
|
|
|
16623 struct StructExtends<ExternalMemoryAcquireUnmodifiedEXT, BufferMemoryBarrier>
|
|
|
16624 {
|
|
|
16625 enum
|
|
|
16626 {
|
|
|
16627 value = true
|
|
|
16628 };
|
|
|
16629 };
|
|
|
16630
|
|
|
16631 template <>
|
|
|
16632 struct StructExtends<ExternalMemoryAcquireUnmodifiedEXT, BufferMemoryBarrier2>
|
|
|
16633 {
|
|
|
16634 enum
|
|
|
16635 {
|
|
|
16636 value = true
|
|
|
16637 };
|
|
|
16638 };
|
|
|
16639
|
|
|
16640 template <>
|
|
|
16641 struct StructExtends<ExternalMemoryAcquireUnmodifiedEXT, ImageMemoryBarrier>
|
|
|
16642 {
|
|
|
16643 enum
|
|
|
16644 {
|
|
|
16645 value = true
|
|
|
16646 };
|
|
|
16647 };
|
|
|
16648
|
|
|
16649 template <>
|
|
|
16650 struct StructExtends<ExternalMemoryAcquireUnmodifiedEXT, ImageMemoryBarrier2>
|
|
|
16651 {
|
|
|
16652 enum
|
|
|
16653 {
|
|
|
16654 value = true
|
|
|
16655 };
|
|
|
16656 };
|
|
|
16657
|
|
|
16658 //=== VK_EXT_extended_dynamic_state3 ===
|
|
|
16659 template <>
|
|
|
16660 struct StructExtends<PhysicalDeviceExtendedDynamicState3FeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
16661 {
|
|
|
16662 enum
|
|
|
16663 {
|
|
|
16664 value = true
|
|
|
16665 };
|
|
|
16666 };
|
|
|
16667
|
|
|
16668 template <>
|
|
|
16669 struct StructExtends<PhysicalDeviceExtendedDynamicState3FeaturesEXT, DeviceCreateInfo>
|
|
|
16670 {
|
|
|
16671 enum
|
|
|
16672 {
|
|
|
16673 value = true
|
|
|
16674 };
|
|
|
16675 };
|
|
|
16676
|
|
|
16677 template <>
|
|
|
16678 struct StructExtends<PhysicalDeviceExtendedDynamicState3PropertiesEXT, PhysicalDeviceProperties2>
|
|
|
16679 {
|
|
|
16680 enum
|
|
|
16681 {
|
|
|
16682 value = true
|
|
|
16683 };
|
|
|
16684 };
|
|
|
16685
|
|
|
16686 //=== VK_EXT_subpass_merge_feedback ===
|
|
|
16687 template <>
|
|
|
16688 struct StructExtends<PhysicalDeviceSubpassMergeFeedbackFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
16689 {
|
|
|
16690 enum
|
|
|
16691 {
|
|
|
16692 value = true
|
|
|
16693 };
|
|
|
16694 };
|
|
|
16695
|
|
|
16696 template <>
|
|
|
16697 struct StructExtends<PhysicalDeviceSubpassMergeFeedbackFeaturesEXT, DeviceCreateInfo>
|
|
|
16698 {
|
|
|
16699 enum
|
|
|
16700 {
|
|
|
16701 value = true
|
|
|
16702 };
|
|
|
16703 };
|
|
|
16704
|
|
|
16705 template <>
|
|
|
16706 struct StructExtends<RenderPassCreationControlEXT, RenderPassCreateInfo2>
|
|
|
16707 {
|
|
|
16708 enum
|
|
|
16709 {
|
|
|
16710 value = true
|
|
|
16711 };
|
|
|
16712 };
|
|
|
16713
|
|
|
16714 template <>
|
|
|
16715 struct StructExtends<RenderPassCreationControlEXT, SubpassDescription2>
|
|
|
16716 {
|
|
|
16717 enum
|
|
|
16718 {
|
|
|
16719 value = true
|
|
|
16720 };
|
|
|
16721 };
|
|
|
16722
|
|
|
16723 template <>
|
|
|
16724 struct StructExtends<RenderPassCreationFeedbackCreateInfoEXT, RenderPassCreateInfo2>
|
|
|
16725 {
|
|
|
16726 enum
|
|
|
16727 {
|
|
|
16728 value = true
|
|
|
16729 };
|
|
|
16730 };
|
|
|
16731
|
|
|
16732 template <>
|
|
|
16733 struct StructExtends<RenderPassSubpassFeedbackCreateInfoEXT, SubpassDescription2>
|
|
|
16734 {
|
|
|
16735 enum
|
|
|
16736 {
|
|
|
16737 value = true
|
|
|
16738 };
|
|
|
16739 };
|
|
|
16740
|
|
|
16741 //=== VK_LUNARG_direct_driver_loading ===
|
|
|
16742 template <>
|
|
|
16743 struct StructExtends<DirectDriverLoadingListLUNARG, InstanceCreateInfo>
|
|
|
16744 {
|
|
|
16745 enum
|
|
|
16746 {
|
|
|
16747 value = true
|
|
|
16748 };
|
|
|
16749 };
|
|
|
16750
|
|
|
16751 //=== VK_ARM_tensors ===
|
|
|
16752 template <>
|
|
|
16753 struct StructExtends<TensorDescriptionARM, DataGraphPipelineResourceInfoARM>
|
|
|
16754 {
|
|
|
16755 enum
|
|
|
16756 {
|
|
|
16757 value = true
|
|
|
16758 };
|
|
|
16759 };
|
|
|
16760
|
|
|
16761 template <>
|
|
|
16762 struct StructExtends<TensorDescriptionARM, DataGraphPipelineConstantARM>
|
|
|
16763 {
|
|
|
16764 enum
|
|
|
16765 {
|
|
|
16766 value = true
|
|
|
16767 };
|
|
|
16768 };
|
|
|
16769
|
|
|
16770 template <>
|
|
|
16771 struct StructExtends<WriteDescriptorSetTensorARM, WriteDescriptorSet>
|
|
|
16772 {
|
|
|
16773 enum
|
|
|
16774 {
|
|
|
16775 value = true
|
|
|
16776 };
|
|
|
16777 };
|
|
|
16778
|
|
|
16779 template <>
|
|
|
16780 struct StructExtends<TensorFormatPropertiesARM, FormatProperties2>
|
|
|
16781 {
|
|
|
16782 enum
|
|
|
16783 {
|
|
|
16784 value = true
|
|
|
16785 };
|
|
|
16786 };
|
|
|
16787
|
|
|
16788 template <>
|
|
|
16789 struct StructExtends<PhysicalDeviceTensorPropertiesARM, PhysicalDeviceProperties2>
|
|
|
16790 {
|
|
|
16791 enum
|
|
|
16792 {
|
|
|
16793 value = true
|
|
|
16794 };
|
|
|
16795 };
|
|
|
16796
|
|
|
16797 template <>
|
|
|
16798 struct StructExtends<TensorMemoryBarrierARM, DependencyInfo>
|
|
|
16799 {
|
|
|
16800 enum
|
|
|
16801 {
|
|
|
16802 value = true
|
|
|
16803 };
|
|
|
16804 };
|
|
|
16805
|
|
|
16806 template <>
|
|
|
16807 struct StructExtends<TensorDependencyInfoARM, DependencyInfo>
|
|
|
16808 {
|
|
|
16809 enum
|
|
|
16810 {
|
|
|
16811 value = true
|
|
|
16812 };
|
|
|
16813 };
|
|
|
16814
|
|
|
16815 template <>
|
|
|
16816 struct StructExtends<PhysicalDeviceTensorFeaturesARM, PhysicalDeviceFeatures2>
|
|
|
16817 {
|
|
|
16818 enum
|
|
|
16819 {
|
|
|
16820 value = true
|
|
|
16821 };
|
|
|
16822 };
|
|
|
16823
|
|
|
16824 template <>
|
|
|
16825 struct StructExtends<PhysicalDeviceTensorFeaturesARM, DeviceCreateInfo>
|
|
|
16826 {
|
|
|
16827 enum
|
|
|
16828 {
|
|
|
16829 value = true
|
|
|
16830 };
|
|
|
16831 };
|
|
|
16832
|
|
|
16833 template <>
|
|
|
16834 struct StructExtends<MemoryDedicatedAllocateInfoTensorARM, MemoryAllocateInfo>
|
|
|
16835 {
|
|
|
16836 enum
|
|
|
16837 {
|
|
|
16838 value = true
|
|
|
16839 };
|
|
|
16840 };
|
|
|
16841
|
|
|
16842 template <>
|
|
|
16843 struct StructExtends<ExternalMemoryTensorCreateInfoARM, TensorCreateInfoARM>
|
|
|
16844 {
|
|
|
16845 enum
|
|
|
16846 {
|
|
|
16847 value = true
|
|
|
16848 };
|
|
|
16849 };
|
|
|
16850
|
|
|
16851 template <>
|
|
|
16852 struct StructExtends<PhysicalDeviceDescriptorBufferTensorFeaturesARM, PhysicalDeviceFeatures2>
|
|
|
16853 {
|
|
|
16854 enum
|
|
|
16855 {
|
|
|
16856 value = true
|
|
|
16857 };
|
|
|
16858 };
|
|
|
16859
|
|
|
16860 template <>
|
|
|
16861 struct StructExtends<PhysicalDeviceDescriptorBufferTensorFeaturesARM, DeviceCreateInfo>
|
|
|
16862 {
|
|
|
16863 enum
|
|
|
16864 {
|
|
|
16865 value = true
|
|
|
16866 };
|
|
|
16867 };
|
|
|
16868
|
|
|
16869 template <>
|
|
|
16870 struct StructExtends<PhysicalDeviceDescriptorBufferTensorPropertiesARM, PhysicalDeviceProperties2>
|
|
|
16871 {
|
|
|
16872 enum
|
|
|
16873 {
|
|
|
16874 value = true
|
|
|
16875 };
|
|
|
16876 };
|
|
|
16877
|
|
|
16878 template <>
|
|
|
16879 struct StructExtends<DescriptorGetTensorInfoARM, DescriptorGetInfoEXT>
|
|
|
16880 {
|
|
|
16881 enum
|
|
|
16882 {
|
|
|
16883 value = true
|
|
|
16884 };
|
|
|
16885 };
|
|
|
16886
|
|
|
16887 template <>
|
|
|
16888 struct StructExtends<FrameBoundaryTensorsARM, SubmitInfo>
|
|
|
16889 {
|
|
|
16890 enum
|
|
|
16891 {
|
|
|
16892 value = true
|
|
|
16893 };
|
|
|
16894 };
|
|
|
16895
|
|
|
16896 template <>
|
|
|
16897 struct StructExtends<FrameBoundaryTensorsARM, SubmitInfo2>
|
|
|
16898 {
|
|
|
16899 enum
|
|
|
16900 {
|
|
|
16901 value = true
|
|
|
16902 };
|
|
|
16903 };
|
|
|
16904
|
|
|
16905 template <>
|
|
|
16906 struct StructExtends<FrameBoundaryTensorsARM, PresentInfoKHR>
|
|
|
16907 {
|
|
|
16908 enum
|
|
|
16909 {
|
|
|
16910 value = true
|
|
|
16911 };
|
|
|
16912 };
|
|
|
16913
|
|
|
16914 template <>
|
|
|
16915 struct StructExtends<FrameBoundaryTensorsARM, BindSparseInfo>
|
|
|
16916 {
|
|
|
16917 enum
|
|
|
16918 {
|
|
|
16919 value = true
|
|
|
16920 };
|
|
|
16921 };
|
|
|
16922
|
|
|
16923 //=== VK_EXT_shader_module_identifier ===
|
|
|
16924 template <>
|
|
|
16925 struct StructExtends<PhysicalDeviceShaderModuleIdentifierFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
16926 {
|
|
|
16927 enum
|
|
|
16928 {
|
|
|
16929 value = true
|
|
|
16930 };
|
|
|
16931 };
|
|
|
16932
|
|
|
16933 template <>
|
|
|
16934 struct StructExtends<PhysicalDeviceShaderModuleIdentifierFeaturesEXT, DeviceCreateInfo>
|
|
|
16935 {
|
|
|
16936 enum
|
|
|
16937 {
|
|
|
16938 value = true
|
|
|
16939 };
|
|
|
16940 };
|
|
|
16941
|
|
|
16942 template <>
|
|
|
16943 struct StructExtends<PhysicalDeviceShaderModuleIdentifierPropertiesEXT, PhysicalDeviceProperties2>
|
|
|
16944 {
|
|
|
16945 enum
|
|
|
16946 {
|
|
|
16947 value = true
|
|
|
16948 };
|
|
|
16949 };
|
|
|
16950
|
|
|
16951 template <>
|
|
|
16952 struct StructExtends<PipelineShaderStageModuleIdentifierCreateInfoEXT, PipelineShaderStageCreateInfo>
|
|
|
16953 {
|
|
|
16954 enum
|
|
|
16955 {
|
|
|
16956 value = true
|
|
|
16957 };
|
|
|
16958 };
|
|
|
16959
|
|
|
16960 //=== VK_EXT_rasterization_order_attachment_access ===
|
|
|
16961 template <>
|
|
|
16962 struct StructExtends<PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
16963 {
|
|
|
16964 enum
|
|
|
16965 {
|
|
|
16966 value = true
|
|
|
16967 };
|
|
|
16968 };
|
|
|
16969
|
|
|
16970 template <>
|
|
|
16971 struct StructExtends<PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT, DeviceCreateInfo>
|
|
|
16972 {
|
|
|
16973 enum
|
|
|
16974 {
|
|
|
16975 value = true
|
|
|
16976 };
|
|
|
16977 };
|
|
|
16978
|
|
|
16979 //=== VK_NV_optical_flow ===
|
|
|
16980 template <>
|
|
|
16981 struct StructExtends<PhysicalDeviceOpticalFlowFeaturesNV, PhysicalDeviceFeatures2>
|
|
|
16982 {
|
|
|
16983 enum
|
|
|
16984 {
|
|
|
16985 value = true
|
|
|
16986 };
|
|
|
16987 };
|
|
|
16988
|
|
|
16989 template <>
|
|
|
16990 struct StructExtends<PhysicalDeviceOpticalFlowFeaturesNV, DeviceCreateInfo>
|
|
|
16991 {
|
|
|
16992 enum
|
|
|
16993 {
|
|
|
16994 value = true
|
|
|
16995 };
|
|
|
16996 };
|
|
|
16997
|
|
|
16998 template <>
|
|
|
16999 struct StructExtends<PhysicalDeviceOpticalFlowPropertiesNV, PhysicalDeviceProperties2>
|
|
|
17000 {
|
|
|
17001 enum
|
|
|
17002 {
|
|
|
17003 value = true
|
|
|
17004 };
|
|
|
17005 };
|
|
|
17006
|
|
|
17007 template <>
|
|
|
17008 struct StructExtends<OpticalFlowImageFormatInfoNV, PhysicalDeviceImageFormatInfo2>
|
|
|
17009 {
|
|
|
17010 enum
|
|
|
17011 {
|
|
|
17012 value = true
|
|
|
17013 };
|
|
|
17014 };
|
|
|
17015
|
|
|
17016 template <>
|
|
|
17017 struct StructExtends<OpticalFlowImageFormatInfoNV, ImageCreateInfo>
|
|
|
17018 {
|
|
|
17019 enum
|
|
|
17020 {
|
|
|
17021 value = true
|
|
|
17022 };
|
|
|
17023 };
|
|
|
17024
|
|
|
17025 template <>
|
|
|
17026 struct StructExtends<OpticalFlowSessionCreatePrivateDataInfoNV, OpticalFlowSessionCreateInfoNV>
|
|
|
17027 {
|
|
|
17028 enum
|
|
|
17029 {
|
|
|
17030 value = true
|
|
|
17031 };
|
|
|
17032 };
|
|
|
17033
|
|
|
17034 //=== VK_EXT_legacy_dithering ===
|
|
|
17035 template <>
|
|
|
17036 struct StructExtends<PhysicalDeviceLegacyDitheringFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
17037 {
|
|
|
17038 enum
|
|
|
17039 {
|
|
|
17040 value = true
|
|
|
17041 };
|
|
|
17042 };
|
|
|
17043
|
|
|
17044 template <>
|
|
|
17045 struct StructExtends<PhysicalDeviceLegacyDitheringFeaturesEXT, DeviceCreateInfo>
|
|
|
17046 {
|
|
|
17047 enum
|
|
|
17048 {
|
|
|
17049 value = true
|
|
|
17050 };
|
|
|
17051 };
|
|
|
17052
|
|
|
17053 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
|
|
17054 //=== VK_ANDROID_external_format_resolve ===
|
|
|
17055 template <>
|
|
|
17056 struct StructExtends<PhysicalDeviceExternalFormatResolveFeaturesANDROID, PhysicalDeviceFeatures2>
|
|
|
17057 {
|
|
|
17058 enum
|
|
|
17059 {
|
|
|
17060 value = true
|
|
|
17061 };
|
|
|
17062 };
|
|
|
17063
|
|
|
17064 template <>
|
|
|
17065 struct StructExtends<PhysicalDeviceExternalFormatResolveFeaturesANDROID, DeviceCreateInfo>
|
|
|
17066 {
|
|
|
17067 enum
|
|
|
17068 {
|
|
|
17069 value = true
|
|
|
17070 };
|
|
|
17071 };
|
|
|
17072
|
|
|
17073 template <>
|
|
|
17074 struct StructExtends<PhysicalDeviceExternalFormatResolvePropertiesANDROID, PhysicalDeviceProperties2>
|
|
|
17075 {
|
|
|
17076 enum
|
|
|
17077 {
|
|
|
17078 value = true
|
|
|
17079 };
|
|
|
17080 };
|
|
|
17081
|
|
|
17082 template <>
|
|
|
17083 struct StructExtends<AndroidHardwareBufferFormatResolvePropertiesANDROID, AndroidHardwareBufferPropertiesANDROID>
|
|
|
17084 {
|
|
|
17085 enum
|
|
|
17086 {
|
|
|
17087 value = true
|
|
|
17088 };
|
|
|
17089 };
|
|
|
17090 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
|
|
17091
|
|
|
17092 //=== VK_AMD_anti_lag ===
|
|
|
17093 template <>
|
|
|
17094 struct StructExtends<PhysicalDeviceAntiLagFeaturesAMD, PhysicalDeviceFeatures2>
|
|
|
17095 {
|
|
|
17096 enum
|
|
|
17097 {
|
|
|
17098 value = true
|
|
|
17099 };
|
|
|
17100 };
|
|
|
17101
|
|
|
17102 template <>
|
|
|
17103 struct StructExtends<PhysicalDeviceAntiLagFeaturesAMD, DeviceCreateInfo>
|
|
|
17104 {
|
|
|
17105 enum
|
|
|
17106 {
|
|
|
17107 value = true
|
|
|
17108 };
|
|
|
17109 };
|
|
|
17110
|
|
|
17111 # if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
17112 //=== VK_AMDX_dense_geometry_format ===
|
|
|
17113 template <>
|
|
|
17114 struct StructExtends<PhysicalDeviceDenseGeometryFormatFeaturesAMDX, PhysicalDeviceFeatures2>
|
|
|
17115 {
|
|
|
17116 enum
|
|
|
17117 {
|
|
|
17118 value = true
|
|
|
17119 };
|
|
|
17120 };
|
|
|
17121
|
|
|
17122 template <>
|
|
|
17123 struct StructExtends<PhysicalDeviceDenseGeometryFormatFeaturesAMDX, DeviceCreateInfo>
|
|
|
17124 {
|
|
|
17125 enum
|
|
|
17126 {
|
|
|
17127 value = true
|
|
|
17128 };
|
|
|
17129 };
|
|
|
17130
|
|
|
17131 template <>
|
|
|
17132 struct StructExtends<AccelerationStructureDenseGeometryFormatTrianglesDataAMDX, AccelerationStructureGeometryKHR>
|
|
|
17133 {
|
|
|
17134 enum
|
|
|
17135 {
|
|
|
17136 value = true
|
|
|
17137 };
|
|
|
17138 };
|
|
|
17139 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
17140
|
|
|
17141 //=== VK_KHR_present_id2 ===
|
|
|
17142 template <>
|
|
|
17143 struct StructExtends<SurfaceCapabilitiesPresentId2KHR, SurfaceCapabilities2KHR>
|
|
|
17144 {
|
|
|
17145 enum
|
|
|
17146 {
|
|
|
17147 value = true
|
|
|
17148 };
|
|
|
17149 };
|
|
|
17150
|
|
|
17151 template <>
|
|
|
17152 struct StructExtends<PresentId2KHR, PresentInfoKHR>
|
|
|
17153 {
|
|
|
17154 enum
|
|
|
17155 {
|
|
|
17156 value = true
|
|
|
17157 };
|
|
|
17158 };
|
|
|
17159
|
|
|
17160 template <>
|
|
|
17161 struct StructExtends<PhysicalDevicePresentId2FeaturesKHR, PhysicalDeviceFeatures2>
|
|
|
17162 {
|
|
|
17163 enum
|
|
|
17164 {
|
|
|
17165 value = true
|
|
|
17166 };
|
|
|
17167 };
|
|
|
17168
|
|
|
17169 template <>
|
|
|
17170 struct StructExtends<PhysicalDevicePresentId2FeaturesKHR, DeviceCreateInfo>
|
|
|
17171 {
|
|
|
17172 enum
|
|
|
17173 {
|
|
|
17174 value = true
|
|
|
17175 };
|
|
|
17176 };
|
|
|
17177
|
|
|
17178 //=== VK_KHR_present_wait2 ===
|
|
|
17179 template <>
|
|
|
17180 struct StructExtends<SurfaceCapabilitiesPresentWait2KHR, SurfaceCapabilities2KHR>
|
|
|
17181 {
|
|
|
17182 enum
|
|
|
17183 {
|
|
|
17184 value = true
|
|
|
17185 };
|
|
|
17186 };
|
|
|
17187
|
|
|
17188 template <>
|
|
|
17189 struct StructExtends<PhysicalDevicePresentWait2FeaturesKHR, PhysicalDeviceFeatures2>
|
|
|
17190 {
|
|
|
17191 enum
|
|
|
17192 {
|
|
|
17193 value = true
|
|
|
17194 };
|
|
|
17195 };
|
|
|
17196
|
|
|
17197 template <>
|
|
|
17198 struct StructExtends<PhysicalDevicePresentWait2FeaturesKHR, DeviceCreateInfo>
|
|
|
17199 {
|
|
|
17200 enum
|
|
|
17201 {
|
|
|
17202 value = true
|
|
|
17203 };
|
|
|
17204 };
|
|
|
17205
|
|
|
17206 //=== VK_KHR_ray_tracing_position_fetch ===
|
|
|
17207 template <>
|
|
|
17208 struct StructExtends<PhysicalDeviceRayTracingPositionFetchFeaturesKHR, PhysicalDeviceFeatures2>
|
|
|
17209 {
|
|
|
17210 enum
|
|
|
17211 {
|
|
|
17212 value = true
|
|
|
17213 };
|
|
|
17214 };
|
|
|
17215
|
|
|
17216 template <>
|
|
|
17217 struct StructExtends<PhysicalDeviceRayTracingPositionFetchFeaturesKHR, DeviceCreateInfo>
|
|
|
17218 {
|
|
|
17219 enum
|
|
|
17220 {
|
|
|
17221 value = true
|
|
|
17222 };
|
|
|
17223 };
|
|
|
17224
|
|
|
17225 //=== VK_EXT_shader_object ===
|
|
|
17226 template <>
|
|
|
17227 struct StructExtends<PhysicalDeviceShaderObjectFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
17228 {
|
|
|
17229 enum
|
|
|
17230 {
|
|
|
17231 value = true
|
|
|
17232 };
|
|
|
17233 };
|
|
|
17234
|
|
|
17235 template <>
|
|
|
17236 struct StructExtends<PhysicalDeviceShaderObjectFeaturesEXT, DeviceCreateInfo>
|
|
|
17237 {
|
|
|
17238 enum
|
|
|
17239 {
|
|
|
17240 value = true
|
|
|
17241 };
|
|
|
17242 };
|
|
|
17243
|
|
|
17244 template <>
|
|
|
17245 struct StructExtends<PhysicalDeviceShaderObjectPropertiesEXT, PhysicalDeviceProperties2>
|
|
|
17246 {
|
|
|
17247 enum
|
|
|
17248 {
|
|
|
17249 value = true
|
|
|
17250 };
|
|
|
17251 };
|
|
|
17252
|
|
|
17253 //=== VK_KHR_pipeline_binary ===
|
|
|
17254 template <>
|
|
|
17255 struct StructExtends<PhysicalDevicePipelineBinaryFeaturesKHR, PhysicalDeviceFeatures2>
|
|
|
17256 {
|
|
|
17257 enum
|
|
|
17258 {
|
|
|
17259 value = true
|
|
|
17260 };
|
|
|
17261 };
|
|
|
17262
|
|
|
17263 template <>
|
|
|
17264 struct StructExtends<PhysicalDevicePipelineBinaryFeaturesKHR, DeviceCreateInfo>
|
|
|
17265 {
|
|
|
17266 enum
|
|
|
17267 {
|
|
|
17268 value = true
|
|
|
17269 };
|
|
|
17270 };
|
|
|
17271
|
|
|
17272 template <>
|
|
|
17273 struct StructExtends<PhysicalDevicePipelineBinaryPropertiesKHR, PhysicalDeviceProperties2>
|
|
|
17274 {
|
|
|
17275 enum
|
|
|
17276 {
|
|
|
17277 value = true
|
|
|
17278 };
|
|
|
17279 };
|
|
|
17280
|
|
|
17281 template <>
|
|
|
17282 struct StructExtends<DevicePipelineBinaryInternalCacheControlKHR, DeviceCreateInfo>
|
|
|
17283 {
|
|
|
17284 enum
|
|
|
17285 {
|
|
|
17286 value = true
|
|
|
17287 };
|
|
|
17288 };
|
|
|
17289
|
|
|
17290 template <>
|
|
|
17291 struct StructExtends<PipelineBinaryInfoKHR, GraphicsPipelineCreateInfo>
|
|
|
17292 {
|
|
|
17293 enum
|
|
|
17294 {
|
|
|
17295 value = true
|
|
|
17296 };
|
|
|
17297 };
|
|
|
17298
|
|
|
17299 template <>
|
|
|
17300 struct StructExtends<PipelineBinaryInfoKHR, ComputePipelineCreateInfo>
|
|
|
17301 {
|
|
|
17302 enum
|
|
|
17303 {
|
|
|
17304 value = true
|
|
|
17305 };
|
|
|
17306 };
|
|
|
17307
|
|
|
17308 template <>
|
|
|
17309 struct StructExtends<PipelineBinaryInfoKHR, RayTracingPipelineCreateInfoKHR>
|
|
|
17310 {
|
|
|
17311 enum
|
|
|
17312 {
|
|
|
17313 value = true
|
|
|
17314 };
|
|
|
17315 };
|
|
|
17316
|
|
|
17317 //=== VK_QCOM_tile_properties ===
|
|
|
17318 template <>
|
|
|
17319 struct StructExtends<PhysicalDeviceTilePropertiesFeaturesQCOM, PhysicalDeviceFeatures2>
|
|
|
17320 {
|
|
|
17321 enum
|
|
|
17322 {
|
|
|
17323 value = true
|
|
|
17324 };
|
|
|
17325 };
|
|
|
17326
|
|
|
17327 template <>
|
|
|
17328 struct StructExtends<PhysicalDeviceTilePropertiesFeaturesQCOM, DeviceCreateInfo>
|
|
|
17329 {
|
|
|
17330 enum
|
|
|
17331 {
|
|
|
17332 value = true
|
|
|
17333 };
|
|
|
17334 };
|
|
|
17335
|
|
|
17336 //=== VK_SEC_amigo_profiling ===
|
|
|
17337 template <>
|
|
|
17338 struct StructExtends<PhysicalDeviceAmigoProfilingFeaturesSEC, PhysicalDeviceFeatures2>
|
|
|
17339 {
|
|
|
17340 enum
|
|
|
17341 {
|
|
|
17342 value = true
|
|
|
17343 };
|
|
|
17344 };
|
|
|
17345
|
|
|
17346 template <>
|
|
|
17347 struct StructExtends<PhysicalDeviceAmigoProfilingFeaturesSEC, DeviceCreateInfo>
|
|
|
17348 {
|
|
|
17349 enum
|
|
|
17350 {
|
|
|
17351 value = true
|
|
|
17352 };
|
|
|
17353 };
|
|
|
17354
|
|
|
17355 template <>
|
|
|
17356 struct StructExtends<AmigoProfilingSubmitInfoSEC, SubmitInfo>
|
|
|
17357 {
|
|
|
17358 enum
|
|
|
17359 {
|
|
|
17360 value = true
|
|
|
17361 };
|
|
|
17362 };
|
|
|
17363
|
|
|
17364 //=== VK_KHR_surface_maintenance1 ===
|
|
|
17365 template <>
|
|
|
17366 struct StructExtends<SurfacePresentModeKHR, PhysicalDeviceSurfaceInfo2KHR>
|
|
|
17367 {
|
|
|
17368 enum
|
|
|
17369 {
|
|
|
17370 value = true
|
|
|
17371 };
|
|
|
17372 };
|
|
|
17373
|
|
|
17374 template <>
|
|
|
17375 struct StructExtends<SurfacePresentScalingCapabilitiesKHR, SurfaceCapabilities2KHR>
|
|
|
17376 {
|
|
|
17377 enum
|
|
|
17378 {
|
|
|
17379 value = true
|
|
|
17380 };
|
|
|
17381 };
|
|
|
17382
|
|
|
17383 template <>
|
|
|
17384 struct StructExtends<SurfacePresentModeCompatibilityKHR, SurfaceCapabilities2KHR>
|
|
|
17385 {
|
|
|
17386 enum
|
|
|
17387 {
|
|
|
17388 value = true
|
|
|
17389 };
|
|
|
17390 };
|
|
|
17391
|
|
|
17392 //=== VK_KHR_swapchain_maintenance1 ===
|
|
|
17393 template <>
|
|
|
17394 struct StructExtends<PhysicalDeviceSwapchainMaintenance1FeaturesKHR, PhysicalDeviceFeatures2>
|
|
|
17395 {
|
|
|
17396 enum
|
|
|
17397 {
|
|
|
17398 value = true
|
|
|
17399 };
|
|
|
17400 };
|
|
|
17401
|
|
|
17402 template <>
|
|
|
17403 struct StructExtends<PhysicalDeviceSwapchainMaintenance1FeaturesKHR, DeviceCreateInfo>
|
|
|
17404 {
|
|
|
17405 enum
|
|
|
17406 {
|
|
|
17407 value = true
|
|
|
17408 };
|
|
|
17409 };
|
|
|
17410
|
|
|
17411 template <>
|
|
|
17412 struct StructExtends<SwapchainPresentFenceInfoKHR, PresentInfoKHR>
|
|
|
17413 {
|
|
|
17414 enum
|
|
|
17415 {
|
|
|
17416 value = true
|
|
|
17417 };
|
|
|
17418 };
|
|
|
17419
|
|
|
17420 template <>
|
|
|
17421 struct StructExtends<SwapchainPresentModesCreateInfoKHR, SwapchainCreateInfoKHR>
|
|
|
17422 {
|
|
|
17423 enum
|
|
|
17424 {
|
|
|
17425 value = true
|
|
|
17426 };
|
|
|
17427 };
|
|
|
17428
|
|
|
17429 template <>
|
|
|
17430 struct StructExtends<SwapchainPresentModeInfoKHR, PresentInfoKHR>
|
|
|
17431 {
|
|
|
17432 enum
|
|
|
17433 {
|
|
|
17434 value = true
|
|
|
17435 };
|
|
|
17436 };
|
|
|
17437
|
|
|
17438 template <>
|
|
|
17439 struct StructExtends<SwapchainPresentScalingCreateInfoKHR, SwapchainCreateInfoKHR>
|
|
|
17440 {
|
|
|
17441 enum
|
|
|
17442 {
|
|
|
17443 value = true
|
|
|
17444 };
|
|
|
17445 };
|
|
|
17446
|
|
|
17447 //=== VK_QCOM_multiview_per_view_viewports ===
|
|
|
17448 template <>
|
|
|
17449 struct StructExtends<PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM, PhysicalDeviceFeatures2>
|
|
|
17450 {
|
|
|
17451 enum
|
|
|
17452 {
|
|
|
17453 value = true
|
|
|
17454 };
|
|
|
17455 };
|
|
|
17456
|
|
|
17457 template <>
|
|
|
17458 struct StructExtends<PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM, DeviceCreateInfo>
|
|
|
17459 {
|
|
|
17460 enum
|
|
|
17461 {
|
|
|
17462 value = true
|
|
|
17463 };
|
|
|
17464 };
|
|
|
17465
|
|
|
17466 //=== VK_NV_ray_tracing_invocation_reorder ===
|
|
|
17467 template <>
|
|
|
17468 struct StructExtends<PhysicalDeviceRayTracingInvocationReorderPropertiesNV, PhysicalDeviceProperties2>
|
|
|
17469 {
|
|
|
17470 enum
|
|
|
17471 {
|
|
|
17472 value = true
|
|
|
17473 };
|
|
|
17474 };
|
|
|
17475
|
|
|
17476 template <>
|
|
|
17477 struct StructExtends<PhysicalDeviceRayTracingInvocationReorderFeaturesNV, PhysicalDeviceFeatures2>
|
|
|
17478 {
|
|
|
17479 enum
|
|
|
17480 {
|
|
|
17481 value = true
|
|
|
17482 };
|
|
|
17483 };
|
|
|
17484
|
|
|
17485 template <>
|
|
|
17486 struct StructExtends<PhysicalDeviceRayTracingInvocationReorderFeaturesNV, DeviceCreateInfo>
|
|
|
17487 {
|
|
|
17488 enum
|
|
|
17489 {
|
|
|
17490 value = true
|
|
|
17491 };
|
|
|
17492 };
|
|
|
17493
|
|
|
17494 //=== VK_NV_cooperative_vector ===
|
|
|
17495 template <>
|
|
|
17496 struct StructExtends<PhysicalDeviceCooperativeVectorPropertiesNV, PhysicalDeviceProperties2>
|
|
|
17497 {
|
|
|
17498 enum
|
|
|
17499 {
|
|
|
17500 value = true
|
|
|
17501 };
|
|
|
17502 };
|
|
|
17503
|
|
|
17504 template <>
|
|
|
17505 struct StructExtends<PhysicalDeviceCooperativeVectorFeaturesNV, PhysicalDeviceFeatures2>
|
|
|
17506 {
|
|
|
17507 enum
|
|
|
17508 {
|
|
|
17509 value = true
|
|
|
17510 };
|
|
|
17511 };
|
|
|
17512
|
|
|
17513 template <>
|
|
|
17514 struct StructExtends<PhysicalDeviceCooperativeVectorFeaturesNV, DeviceCreateInfo>
|
|
|
17515 {
|
|
|
17516 enum
|
|
|
17517 {
|
|
|
17518 value = true
|
|
|
17519 };
|
|
|
17520 };
|
|
|
17521
|
|
|
17522 //=== VK_NV_extended_sparse_address_space ===
|
|
|
17523 template <>
|
|
|
17524 struct StructExtends<PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV, PhysicalDeviceFeatures2>
|
|
|
17525 {
|
|
|
17526 enum
|
|
|
17527 {
|
|
|
17528 value = true
|
|
|
17529 };
|
|
|
17530 };
|
|
|
17531
|
|
|
17532 template <>
|
|
|
17533 struct StructExtends<PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV, DeviceCreateInfo>
|
|
|
17534 {
|
|
|
17535 enum
|
|
|
17536 {
|
|
|
17537 value = true
|
|
|
17538 };
|
|
|
17539 };
|
|
|
17540
|
|
|
17541 template <>
|
|
|
17542 struct StructExtends<PhysicalDeviceExtendedSparseAddressSpacePropertiesNV, PhysicalDeviceProperties2>
|
|
|
17543 {
|
|
|
17544 enum
|
|
|
17545 {
|
|
|
17546 value = true
|
|
|
17547 };
|
|
|
17548 };
|
|
|
17549
|
|
|
17550 //=== VK_EXT_mutable_descriptor_type ===
|
|
|
17551 template <>
|
|
|
17552 struct StructExtends<PhysicalDeviceMutableDescriptorTypeFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
17553 {
|
|
|
17554 enum
|
|
|
17555 {
|
|
|
17556 value = true
|
|
|
17557 };
|
|
|
17558 };
|
|
|
17559
|
|
|
17560 template <>
|
|
|
17561 struct StructExtends<PhysicalDeviceMutableDescriptorTypeFeaturesEXT, DeviceCreateInfo>
|
|
|
17562 {
|
|
|
17563 enum
|
|
|
17564 {
|
|
|
17565 value = true
|
|
|
17566 };
|
|
|
17567 };
|
|
|
17568
|
|
|
17569 template <>
|
|
|
17570 struct StructExtends<MutableDescriptorTypeCreateInfoEXT, DescriptorSetLayoutCreateInfo>
|
|
|
17571 {
|
|
|
17572 enum
|
|
|
17573 {
|
|
|
17574 value = true
|
|
|
17575 };
|
|
|
17576 };
|
|
|
17577
|
|
|
17578 template <>
|
|
|
17579 struct StructExtends<MutableDescriptorTypeCreateInfoEXT, DescriptorPoolCreateInfo>
|
|
|
17580 {
|
|
|
17581 enum
|
|
|
17582 {
|
|
|
17583 value = true
|
|
|
17584 };
|
|
|
17585 };
|
|
|
17586
|
|
|
17587 //=== VK_EXT_legacy_vertex_attributes ===
|
|
|
17588 template <>
|
|
|
17589 struct StructExtends<PhysicalDeviceLegacyVertexAttributesFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
17590 {
|
|
|
17591 enum
|
|
|
17592 {
|
|
|
17593 value = true
|
|
|
17594 };
|
|
|
17595 };
|
|
|
17596
|
|
|
17597 template <>
|
|
|
17598 struct StructExtends<PhysicalDeviceLegacyVertexAttributesFeaturesEXT, DeviceCreateInfo>
|
|
|
17599 {
|
|
|
17600 enum
|
|
|
17601 {
|
|
|
17602 value = true
|
|
|
17603 };
|
|
|
17604 };
|
|
|
17605
|
|
|
17606 template <>
|
|
|
17607 struct StructExtends<PhysicalDeviceLegacyVertexAttributesPropertiesEXT, PhysicalDeviceProperties2>
|
|
|
17608 {
|
|
|
17609 enum
|
|
|
17610 {
|
|
|
17611 value = true
|
|
|
17612 };
|
|
|
17613 };
|
|
|
17614
|
|
|
17615 //=== VK_EXT_layer_settings ===
|
|
|
17616 template <>
|
|
|
17617 struct StructExtends<LayerSettingsCreateInfoEXT, InstanceCreateInfo>
|
|
|
17618 {
|
|
|
17619 enum
|
|
|
17620 {
|
|
|
17621 value = true
|
|
|
17622 };
|
|
|
17623 };
|
|
|
17624
|
|
|
17625 //=== VK_ARM_shader_core_builtins ===
|
|
|
17626 template <>
|
|
|
17627 struct StructExtends<PhysicalDeviceShaderCoreBuiltinsFeaturesARM, PhysicalDeviceFeatures2>
|
|
|
17628 {
|
|
|
17629 enum
|
|
|
17630 {
|
|
|
17631 value = true
|
|
|
17632 };
|
|
|
17633 };
|
|
|
17634
|
|
|
17635 template <>
|
|
|
17636 struct StructExtends<PhysicalDeviceShaderCoreBuiltinsFeaturesARM, DeviceCreateInfo>
|
|
|
17637 {
|
|
|
17638 enum
|
|
|
17639 {
|
|
|
17640 value = true
|
|
|
17641 };
|
|
|
17642 };
|
|
|
17643
|
|
|
17644 template <>
|
|
|
17645 struct StructExtends<PhysicalDeviceShaderCoreBuiltinsPropertiesARM, PhysicalDeviceProperties2>
|
|
|
17646 {
|
|
|
17647 enum
|
|
|
17648 {
|
|
|
17649 value = true
|
|
|
17650 };
|
|
|
17651 };
|
|
|
17652
|
|
|
17653 //=== VK_EXT_pipeline_library_group_handles ===
|
|
|
17654 template <>
|
|
|
17655 struct StructExtends<PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
17656 {
|
|
|
17657 enum
|
|
|
17658 {
|
|
|
17659 value = true
|
|
|
17660 };
|
|
|
17661 };
|
|
|
17662
|
|
|
17663 template <>
|
|
|
17664 struct StructExtends<PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT, DeviceCreateInfo>
|
|
|
17665 {
|
|
|
17666 enum
|
|
|
17667 {
|
|
|
17668 value = true
|
|
|
17669 };
|
|
|
17670 };
|
|
|
17671
|
|
|
17672 //=== VK_EXT_dynamic_rendering_unused_attachments ===
|
|
|
17673 template <>
|
|
|
17674 struct StructExtends<PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
17675 {
|
|
|
17676 enum
|
|
|
17677 {
|
|
|
17678 value = true
|
|
|
17679 };
|
|
|
17680 };
|
|
|
17681
|
|
|
17682 template <>
|
|
|
17683 struct StructExtends<PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT, DeviceCreateInfo>
|
|
|
17684 {
|
|
|
17685 enum
|
|
|
17686 {
|
|
|
17687 value = true
|
|
|
17688 };
|
|
|
17689 };
|
|
|
17690
|
|
|
17691 //=== VK_NV_low_latency2 ===
|
|
|
17692 template <>
|
|
|
17693 struct StructExtends<LatencySubmissionPresentIdNV, SubmitInfo>
|
|
|
17694 {
|
|
|
17695 enum
|
|
|
17696 {
|
|
|
17697 value = true
|
|
|
17698 };
|
|
|
17699 };
|
|
|
17700
|
|
|
17701 template <>
|
|
|
17702 struct StructExtends<LatencySubmissionPresentIdNV, SubmitInfo2>
|
|
|
17703 {
|
|
|
17704 enum
|
|
|
17705 {
|
|
|
17706 value = true
|
|
|
17707 };
|
|
|
17708 };
|
|
|
17709
|
|
|
17710 template <>
|
|
|
17711 struct StructExtends<SwapchainLatencyCreateInfoNV, SwapchainCreateInfoKHR>
|
|
|
17712 {
|
|
|
17713 enum
|
|
|
17714 {
|
|
|
17715 value = true
|
|
|
17716 };
|
|
|
17717 };
|
|
|
17718
|
|
|
17719 template <>
|
|
|
17720 struct StructExtends<LatencySurfaceCapabilitiesNV, SurfaceCapabilities2KHR>
|
|
|
17721 {
|
|
|
17722 enum
|
|
|
17723 {
|
|
|
17724 value = true
|
|
|
17725 };
|
|
|
17726 };
|
|
|
17727
|
|
|
17728 //=== VK_KHR_cooperative_matrix ===
|
|
|
17729 template <>
|
|
|
17730 struct StructExtends<PhysicalDeviceCooperativeMatrixFeaturesKHR, PhysicalDeviceFeatures2>
|
|
|
17731 {
|
|
|
17732 enum
|
|
|
17733 {
|
|
|
17734 value = true
|
|
|
17735 };
|
|
|
17736 };
|
|
|
17737
|
|
|
17738 template <>
|
|
|
17739 struct StructExtends<PhysicalDeviceCooperativeMatrixFeaturesKHR, DeviceCreateInfo>
|
|
|
17740 {
|
|
|
17741 enum
|
|
|
17742 {
|
|
|
17743 value = true
|
|
|
17744 };
|
|
|
17745 };
|
|
|
17746
|
|
|
17747 template <>
|
|
|
17748 struct StructExtends<PhysicalDeviceCooperativeMatrixPropertiesKHR, PhysicalDeviceProperties2>
|
|
|
17749 {
|
|
|
17750 enum
|
|
|
17751 {
|
|
|
17752 value = true
|
|
|
17753 };
|
|
|
17754 };
|
|
|
17755
|
|
|
17756 //=== VK_ARM_data_graph ===
|
|
|
17757 template <>
|
|
|
17758 struct StructExtends<PhysicalDeviceDataGraphFeaturesARM, PhysicalDeviceFeatures2>
|
|
|
17759 {
|
|
|
17760 enum
|
|
|
17761 {
|
|
|
17762 value = true
|
|
|
17763 };
|
|
|
17764 };
|
|
|
17765
|
|
|
17766 template <>
|
|
|
17767 struct StructExtends<PhysicalDeviceDataGraphFeaturesARM, DeviceCreateInfo>
|
|
|
17768 {
|
|
|
17769 enum
|
|
|
17770 {
|
|
|
17771 value = true
|
|
|
17772 };
|
|
|
17773 };
|
|
|
17774
|
|
|
17775 template <>
|
|
|
17776 struct StructExtends<DataGraphPipelineCompilerControlCreateInfoARM, DataGraphPipelineCreateInfoARM>
|
|
|
17777 {
|
|
|
17778 enum
|
|
|
17779 {
|
|
|
17780 value = true
|
|
|
17781 };
|
|
|
17782 };
|
|
|
17783
|
|
|
17784 template <>
|
|
|
17785 struct StructExtends<DataGraphPipelineShaderModuleCreateInfoARM, DataGraphPipelineCreateInfoARM>
|
|
|
17786 {
|
|
|
17787 enum
|
|
|
17788 {
|
|
|
17789 value = true
|
|
|
17790 };
|
|
|
17791 };
|
|
|
17792
|
|
|
17793 template <>
|
|
|
17794 struct StructExtends<DataGraphPipelineIdentifierCreateInfoARM, DataGraphPipelineCreateInfoARM>
|
|
|
17795 {
|
|
|
17796 enum
|
|
|
17797 {
|
|
|
17798 value = true
|
|
|
17799 };
|
|
|
17800 };
|
|
|
17801
|
|
|
17802 template <>
|
|
|
17803 struct StructExtends<DataGraphProcessingEngineCreateInfoARM, DataGraphPipelineCreateInfoARM>
|
|
|
17804 {
|
|
|
17805 enum
|
|
|
17806 {
|
|
|
17807 value = true
|
|
|
17808 };
|
|
|
17809 };
|
|
|
17810
|
|
|
17811 template <>
|
|
|
17812 struct StructExtends<DataGraphProcessingEngineCreateInfoARM, DescriptorPoolCreateInfo>
|
|
|
17813 {
|
|
|
17814 enum
|
|
|
17815 {
|
|
|
17816 value = true
|
|
|
17817 };
|
|
|
17818 };
|
|
|
17819
|
|
|
17820 template <>
|
|
|
17821 struct StructExtends<DataGraphProcessingEngineCreateInfoARM, CommandPoolCreateInfo>
|
|
|
17822 {
|
|
|
17823 enum
|
|
|
17824 {
|
|
|
17825 value = true
|
|
|
17826 };
|
|
|
17827 };
|
|
|
17828
|
|
|
17829 template <>
|
|
|
17830 struct StructExtends<DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM, DataGraphPipelineConstantARM>
|
|
|
17831 {
|
|
|
17832 enum
|
|
|
17833 {
|
|
|
17834 value = true
|
|
|
17835 };
|
|
|
17836 };
|
|
|
17837
|
|
|
17838 //=== VK_QCOM_multiview_per_view_render_areas ===
|
|
|
17839 template <>
|
|
|
17840 struct StructExtends<PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM, PhysicalDeviceFeatures2>
|
|
|
17841 {
|
|
|
17842 enum
|
|
|
17843 {
|
|
|
17844 value = true
|
|
|
17845 };
|
|
|
17846 };
|
|
|
17847
|
|
|
17848 template <>
|
|
|
17849 struct StructExtends<PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM, DeviceCreateInfo>
|
|
|
17850 {
|
|
|
17851 enum
|
|
|
17852 {
|
|
|
17853 value = true
|
|
|
17854 };
|
|
|
17855 };
|
|
|
17856
|
|
|
17857 template <>
|
|
|
17858 struct StructExtends<MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM, RenderPassBeginInfo>
|
|
|
17859 {
|
|
|
17860 enum
|
|
|
17861 {
|
|
|
17862 value = true
|
|
|
17863 };
|
|
|
17864 };
|
|
|
17865
|
|
|
17866 template <>
|
|
|
17867 struct StructExtends<MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM, RenderingInfo>
|
|
|
17868 {
|
|
|
17869 enum
|
|
|
17870 {
|
|
|
17871 value = true
|
|
|
17872 };
|
|
|
17873 };
|
|
|
17874
|
|
|
17875 //=== VK_KHR_compute_shader_derivatives ===
|
|
|
17876 template <>
|
|
|
17877 struct StructExtends<PhysicalDeviceComputeShaderDerivativesFeaturesKHR, PhysicalDeviceFeatures2>
|
|
|
17878 {
|
|
|
17879 enum
|
|
|
17880 {
|
|
|
17881 value = true
|
|
|
17882 };
|
|
|
17883 };
|
|
|
17884
|
|
|
17885 template <>
|
|
|
17886 struct StructExtends<PhysicalDeviceComputeShaderDerivativesFeaturesKHR, DeviceCreateInfo>
|
|
|
17887 {
|
|
|
17888 enum
|
|
|
17889 {
|
|
|
17890 value = true
|
|
|
17891 };
|
|
|
17892 };
|
|
|
17893
|
|
|
17894 template <>
|
|
|
17895 struct StructExtends<PhysicalDeviceComputeShaderDerivativesPropertiesKHR, PhysicalDeviceProperties2>
|
|
|
17896 {
|
|
|
17897 enum
|
|
|
17898 {
|
|
|
17899 value = true
|
|
|
17900 };
|
|
|
17901 };
|
|
|
17902
|
|
|
17903 //=== VK_KHR_video_decode_av1 ===
|
|
|
17904 template <>
|
|
|
17905 struct StructExtends<VideoDecodeAV1ProfileInfoKHR, VideoProfileInfoKHR>
|
|
|
17906 {
|
|
|
17907 enum
|
|
|
17908 {
|
|
|
17909 value = true
|
|
|
17910 };
|
|
|
17911 };
|
|
|
17912
|
|
|
17913 template <>
|
|
|
17914 struct StructExtends<VideoDecodeAV1ProfileInfoKHR, QueryPoolCreateInfo>
|
|
|
17915 {
|
|
|
17916 enum
|
|
|
17917 {
|
|
|
17918 value = true
|
|
|
17919 };
|
|
|
17920 };
|
|
|
17921
|
|
|
17922 template <>
|
|
|
17923 struct StructExtends<VideoDecodeAV1CapabilitiesKHR, VideoCapabilitiesKHR>
|
|
|
17924 {
|
|
|
17925 enum
|
|
|
17926 {
|
|
|
17927 value = true
|
|
|
17928 };
|
|
|
17929 };
|
|
|
17930
|
|
|
17931 template <>
|
|
|
17932 struct StructExtends<VideoDecodeAV1SessionParametersCreateInfoKHR, VideoSessionParametersCreateInfoKHR>
|
|
|
17933 {
|
|
|
17934 enum
|
|
|
17935 {
|
|
|
17936 value = true
|
|
|
17937 };
|
|
|
17938 };
|
|
|
17939
|
|
|
17940 template <>
|
|
|
17941 struct StructExtends<VideoDecodeAV1PictureInfoKHR, VideoDecodeInfoKHR>
|
|
|
17942 {
|
|
|
17943 enum
|
|
|
17944 {
|
|
|
17945 value = true
|
|
|
17946 };
|
|
|
17947 };
|
|
|
17948
|
|
|
17949 template <>
|
|
|
17950 struct StructExtends<VideoDecodeAV1DpbSlotInfoKHR, VideoReferenceSlotInfoKHR>
|
|
|
17951 {
|
|
|
17952 enum
|
|
|
17953 {
|
|
|
17954 value = true
|
|
|
17955 };
|
|
|
17956 };
|
|
|
17957
|
|
|
17958 //=== VK_KHR_video_encode_av1 ===
|
|
|
17959 template <>
|
|
|
17960 struct StructExtends<PhysicalDeviceVideoEncodeAV1FeaturesKHR, PhysicalDeviceFeatures2>
|
|
|
17961 {
|
|
|
17962 enum
|
|
|
17963 {
|
|
|
17964 value = true
|
|
|
17965 };
|
|
|
17966 };
|
|
|
17967
|
|
|
17968 template <>
|
|
|
17969 struct StructExtends<PhysicalDeviceVideoEncodeAV1FeaturesKHR, DeviceCreateInfo>
|
|
|
17970 {
|
|
|
17971 enum
|
|
|
17972 {
|
|
|
17973 value = true
|
|
|
17974 };
|
|
|
17975 };
|
|
|
17976
|
|
|
17977 template <>
|
|
|
17978 struct StructExtends<VideoEncodeAV1CapabilitiesKHR, VideoCapabilitiesKHR>
|
|
|
17979 {
|
|
|
17980 enum
|
|
|
17981 {
|
|
|
17982 value = true
|
|
|
17983 };
|
|
|
17984 };
|
|
|
17985
|
|
|
17986 template <>
|
|
|
17987 struct StructExtends<VideoEncodeAV1QualityLevelPropertiesKHR, VideoEncodeQualityLevelPropertiesKHR>
|
|
|
17988 {
|
|
|
17989 enum
|
|
|
17990 {
|
|
|
17991 value = true
|
|
|
17992 };
|
|
|
17993 };
|
|
|
17994
|
|
|
17995 template <>
|
|
|
17996 struct StructExtends<VideoEncodeAV1SessionCreateInfoKHR, VideoSessionCreateInfoKHR>
|
|
|
17997 {
|
|
|
17998 enum
|
|
|
17999 {
|
|
|
18000 value = true
|
|
|
18001 };
|
|
|
18002 };
|
|
|
18003
|
|
|
18004 template <>
|
|
|
18005 struct StructExtends<VideoEncodeAV1SessionParametersCreateInfoKHR, VideoSessionParametersCreateInfoKHR>
|
|
|
18006 {
|
|
|
18007 enum
|
|
|
18008 {
|
|
|
18009 value = true
|
|
|
18010 };
|
|
|
18011 };
|
|
|
18012
|
|
|
18013 template <>
|
|
|
18014 struct StructExtends<VideoEncodeAV1PictureInfoKHR, VideoEncodeInfoKHR>
|
|
|
18015 {
|
|
|
18016 enum
|
|
|
18017 {
|
|
|
18018 value = true
|
|
|
18019 };
|
|
|
18020 };
|
|
|
18021
|
|
|
18022 template <>
|
|
|
18023 struct StructExtends<VideoEncodeAV1DpbSlotInfoKHR, VideoReferenceSlotInfoKHR>
|
|
|
18024 {
|
|
|
18025 enum
|
|
|
18026 {
|
|
|
18027 value = true
|
|
|
18028 };
|
|
|
18029 };
|
|
|
18030
|
|
|
18031 template <>
|
|
|
18032 struct StructExtends<VideoEncodeAV1ProfileInfoKHR, VideoProfileInfoKHR>
|
|
|
18033 {
|
|
|
18034 enum
|
|
|
18035 {
|
|
|
18036 value = true
|
|
|
18037 };
|
|
|
18038 };
|
|
|
18039
|
|
|
18040 template <>
|
|
|
18041 struct StructExtends<VideoEncodeAV1ProfileInfoKHR, QueryPoolCreateInfo>
|
|
|
18042 {
|
|
|
18043 enum
|
|
|
18044 {
|
|
|
18045 value = true
|
|
|
18046 };
|
|
|
18047 };
|
|
|
18048
|
|
|
18049 template <>
|
|
|
18050 struct StructExtends<VideoEncodeAV1GopRemainingFrameInfoKHR, VideoBeginCodingInfoKHR>
|
|
|
18051 {
|
|
|
18052 enum
|
|
|
18053 {
|
|
|
18054 value = true
|
|
|
18055 };
|
|
|
18056 };
|
|
|
18057
|
|
|
18058 template <>
|
|
|
18059 struct StructExtends<VideoEncodeAV1RateControlInfoKHR, VideoCodingControlInfoKHR>
|
|
|
18060 {
|
|
|
18061 enum
|
|
|
18062 {
|
|
|
18063 value = true
|
|
|
18064 };
|
|
|
18065 };
|
|
|
18066
|
|
|
18067 template <>
|
|
|
18068 struct StructExtends<VideoEncodeAV1RateControlInfoKHR, VideoBeginCodingInfoKHR>
|
|
|
18069 {
|
|
|
18070 enum
|
|
|
18071 {
|
|
|
18072 value = true
|
|
|
18073 };
|
|
|
18074 };
|
|
|
18075
|
|
|
18076 template <>
|
|
|
18077 struct StructExtends<VideoEncodeAV1RateControlLayerInfoKHR, VideoEncodeRateControlLayerInfoKHR>
|
|
|
18078 {
|
|
|
18079 enum
|
|
|
18080 {
|
|
|
18081 value = true
|
|
|
18082 };
|
|
|
18083 };
|
|
|
18084
|
|
|
18085 //=== VK_KHR_video_decode_vp9 ===
|
|
|
18086 template <>
|
|
|
18087 struct StructExtends<PhysicalDeviceVideoDecodeVP9FeaturesKHR, PhysicalDeviceFeatures2>
|
|
|
18088 {
|
|
|
18089 enum
|
|
|
18090 {
|
|
|
18091 value = true
|
|
|
18092 };
|
|
|
18093 };
|
|
|
18094
|
|
|
18095 template <>
|
|
|
18096 struct StructExtends<PhysicalDeviceVideoDecodeVP9FeaturesKHR, DeviceCreateInfo>
|
|
|
18097 {
|
|
|
18098 enum
|
|
|
18099 {
|
|
|
18100 value = true
|
|
|
18101 };
|
|
|
18102 };
|
|
|
18103
|
|
|
18104 template <>
|
|
|
18105 struct StructExtends<VideoDecodeVP9ProfileInfoKHR, VideoProfileInfoKHR>
|
|
|
18106 {
|
|
|
18107 enum
|
|
|
18108 {
|
|
|
18109 value = true
|
|
|
18110 };
|
|
|
18111 };
|
|
|
18112
|
|
|
18113 template <>
|
|
|
18114 struct StructExtends<VideoDecodeVP9ProfileInfoKHR, QueryPoolCreateInfo>
|
|
|
18115 {
|
|
|
18116 enum
|
|
|
18117 {
|
|
|
18118 value = true
|
|
|
18119 };
|
|
|
18120 };
|
|
|
18121
|
|
|
18122 template <>
|
|
|
18123 struct StructExtends<VideoDecodeVP9CapabilitiesKHR, VideoCapabilitiesKHR>
|
|
|
18124 {
|
|
|
18125 enum
|
|
|
18126 {
|
|
|
18127 value = true
|
|
|
18128 };
|
|
|
18129 };
|
|
|
18130
|
|
|
18131 template <>
|
|
|
18132 struct StructExtends<VideoDecodeVP9PictureInfoKHR, VideoDecodeInfoKHR>
|
|
|
18133 {
|
|
|
18134 enum
|
|
|
18135 {
|
|
|
18136 value = true
|
|
|
18137 };
|
|
|
18138 };
|
|
|
18139
|
|
|
18140 //=== VK_KHR_video_maintenance1 ===
|
|
|
18141 template <>
|
|
|
18142 struct StructExtends<PhysicalDeviceVideoMaintenance1FeaturesKHR, PhysicalDeviceFeatures2>
|
|
|
18143 {
|
|
|
18144 enum
|
|
|
18145 {
|
|
|
18146 value = true
|
|
|
18147 };
|
|
|
18148 };
|
|
|
18149
|
|
|
18150 template <>
|
|
|
18151 struct StructExtends<PhysicalDeviceVideoMaintenance1FeaturesKHR, DeviceCreateInfo>
|
|
|
18152 {
|
|
|
18153 enum
|
|
|
18154 {
|
|
|
18155 value = true
|
|
|
18156 };
|
|
|
18157 };
|
|
|
18158
|
|
|
18159 template <>
|
|
|
18160 struct StructExtends<VideoInlineQueryInfoKHR, VideoDecodeInfoKHR>
|
|
|
18161 {
|
|
|
18162 enum
|
|
|
18163 {
|
|
|
18164 value = true
|
|
|
18165 };
|
|
|
18166 };
|
|
|
18167
|
|
|
18168 template <>
|
|
|
18169 struct StructExtends<VideoInlineQueryInfoKHR, VideoEncodeInfoKHR>
|
|
|
18170 {
|
|
|
18171 enum
|
|
|
18172 {
|
|
|
18173 value = true
|
|
|
18174 };
|
|
|
18175 };
|
|
|
18176
|
|
|
18177 //=== VK_NV_per_stage_descriptor_set ===
|
|
|
18178 template <>
|
|
|
18179 struct StructExtends<PhysicalDevicePerStageDescriptorSetFeaturesNV, PhysicalDeviceFeatures2>
|
|
|
18180 {
|
|
|
18181 enum
|
|
|
18182 {
|
|
|
18183 value = true
|
|
|
18184 };
|
|
|
18185 };
|
|
|
18186
|
|
|
18187 template <>
|
|
|
18188 struct StructExtends<PhysicalDevicePerStageDescriptorSetFeaturesNV, DeviceCreateInfo>
|
|
|
18189 {
|
|
|
18190 enum
|
|
|
18191 {
|
|
|
18192 value = true
|
|
|
18193 };
|
|
|
18194 };
|
|
|
18195
|
|
|
18196 //=== VK_QCOM_image_processing2 ===
|
|
|
18197 template <>
|
|
|
18198 struct StructExtends<PhysicalDeviceImageProcessing2FeaturesQCOM, PhysicalDeviceFeatures2>
|
|
|
18199 {
|
|
|
18200 enum
|
|
|
18201 {
|
|
|
18202 value = true
|
|
|
18203 };
|
|
|
18204 };
|
|
|
18205
|
|
|
18206 template <>
|
|
|
18207 struct StructExtends<PhysicalDeviceImageProcessing2FeaturesQCOM, DeviceCreateInfo>
|
|
|
18208 {
|
|
|
18209 enum
|
|
|
18210 {
|
|
|
18211 value = true
|
|
|
18212 };
|
|
|
18213 };
|
|
|
18214
|
|
|
18215 template <>
|
|
|
18216 struct StructExtends<PhysicalDeviceImageProcessing2PropertiesQCOM, PhysicalDeviceProperties2>
|
|
|
18217 {
|
|
|
18218 enum
|
|
|
18219 {
|
|
|
18220 value = true
|
|
|
18221 };
|
|
|
18222 };
|
|
|
18223
|
|
|
18224 template <>
|
|
|
18225 struct StructExtends<SamplerBlockMatchWindowCreateInfoQCOM, SamplerCreateInfo>
|
|
|
18226 {
|
|
|
18227 enum
|
|
|
18228 {
|
|
|
18229 value = true
|
|
|
18230 };
|
|
|
18231 };
|
|
|
18232
|
|
|
18233 //=== VK_QCOM_filter_cubic_weights ===
|
|
|
18234 template <>
|
|
|
18235 struct StructExtends<PhysicalDeviceCubicWeightsFeaturesQCOM, PhysicalDeviceFeatures2>
|
|
|
18236 {
|
|
|
18237 enum
|
|
|
18238 {
|
|
|
18239 value = true
|
|
|
18240 };
|
|
|
18241 };
|
|
|
18242
|
|
|
18243 template <>
|
|
|
18244 struct StructExtends<PhysicalDeviceCubicWeightsFeaturesQCOM, DeviceCreateInfo>
|
|
|
18245 {
|
|
|
18246 enum
|
|
|
18247 {
|
|
|
18248 value = true
|
|
|
18249 };
|
|
|
18250 };
|
|
|
18251
|
|
|
18252 template <>
|
|
|
18253 struct StructExtends<SamplerCubicWeightsCreateInfoQCOM, SamplerCreateInfo>
|
|
|
18254 {
|
|
|
18255 enum
|
|
|
18256 {
|
|
|
18257 value = true
|
|
|
18258 };
|
|
|
18259 };
|
|
|
18260
|
|
|
18261 template <>
|
|
|
18262 struct StructExtends<BlitImageCubicWeightsInfoQCOM, BlitImageInfo2>
|
|
|
18263 {
|
|
|
18264 enum
|
|
|
18265 {
|
|
|
18266 value = true
|
|
|
18267 };
|
|
|
18268 };
|
|
|
18269
|
|
|
18270 //=== VK_QCOM_ycbcr_degamma ===
|
|
|
18271 template <>
|
|
|
18272 struct StructExtends<PhysicalDeviceYcbcrDegammaFeaturesQCOM, PhysicalDeviceFeatures2>
|
|
|
18273 {
|
|
|
18274 enum
|
|
|
18275 {
|
|
|
18276 value = true
|
|
|
18277 };
|
|
|
18278 };
|
|
|
18279
|
|
|
18280 template <>
|
|
|
18281 struct StructExtends<PhysicalDeviceYcbcrDegammaFeaturesQCOM, DeviceCreateInfo>
|
|
|
18282 {
|
|
|
18283 enum
|
|
|
18284 {
|
|
|
18285 value = true
|
|
|
18286 };
|
|
|
18287 };
|
|
|
18288
|
|
|
18289 template <>
|
|
|
18290 struct StructExtends<SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM, SamplerYcbcrConversionCreateInfo>
|
|
|
18291 {
|
|
|
18292 enum
|
|
|
18293 {
|
|
|
18294 value = true
|
|
|
18295 };
|
|
|
18296 };
|
|
|
18297
|
|
|
18298 //=== VK_QCOM_filter_cubic_clamp ===
|
|
|
18299 template <>
|
|
|
18300 struct StructExtends<PhysicalDeviceCubicClampFeaturesQCOM, PhysicalDeviceFeatures2>
|
|
|
18301 {
|
|
|
18302 enum
|
|
|
18303 {
|
|
|
18304 value = true
|
|
|
18305 };
|
|
|
18306 };
|
|
|
18307
|
|
|
18308 template <>
|
|
|
18309 struct StructExtends<PhysicalDeviceCubicClampFeaturesQCOM, DeviceCreateInfo>
|
|
|
18310 {
|
|
|
18311 enum
|
|
|
18312 {
|
|
|
18313 value = true
|
|
|
18314 };
|
|
|
18315 };
|
|
|
18316
|
|
|
18317 //=== VK_EXT_attachment_feedback_loop_dynamic_state ===
|
|
|
18318 template <>
|
|
|
18319 struct StructExtends<PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
18320 {
|
|
|
18321 enum
|
|
|
18322 {
|
|
|
18323 value = true
|
|
|
18324 };
|
|
|
18325 };
|
|
|
18326
|
|
|
18327 template <>
|
|
|
18328 struct StructExtends<PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT, DeviceCreateInfo>
|
|
|
18329 {
|
|
|
18330 enum
|
|
|
18331 {
|
|
|
18332 value = true
|
|
|
18333 };
|
|
|
18334 };
|
|
|
18335
|
|
|
18336 //=== VK_KHR_unified_image_layouts ===
|
|
|
18337 template <>
|
|
|
18338 struct StructExtends<PhysicalDeviceUnifiedImageLayoutsFeaturesKHR, PhysicalDeviceFeatures2>
|
|
|
18339 {
|
|
|
18340 enum
|
|
|
18341 {
|
|
|
18342 value = true
|
|
|
18343 };
|
|
|
18344 };
|
|
|
18345
|
|
|
18346 template <>
|
|
|
18347 struct StructExtends<PhysicalDeviceUnifiedImageLayoutsFeaturesKHR, DeviceCreateInfo>
|
|
|
18348 {
|
|
|
18349 enum
|
|
|
18350 {
|
|
|
18351 value = true
|
|
|
18352 };
|
|
|
18353 };
|
|
|
18354
|
|
|
18355 template <>
|
|
|
18356 struct StructExtends<AttachmentFeedbackLoopInfoEXT, RenderingAttachmentInfo>
|
|
|
18357 {
|
|
|
18358 enum
|
|
|
18359 {
|
|
|
18360 value = true
|
|
|
18361 };
|
|
|
18362 };
|
|
|
18363
|
|
|
18364 # if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
|
|
18365 //=== VK_QNX_external_memory_screen_buffer ===
|
|
|
18366 template <>
|
|
|
18367 struct StructExtends<ScreenBufferFormatPropertiesQNX, ScreenBufferPropertiesQNX>
|
|
|
18368 {
|
|
|
18369 enum
|
|
|
18370 {
|
|
|
18371 value = true
|
|
|
18372 };
|
|
|
18373 };
|
|
|
18374
|
|
|
18375 template <>
|
|
|
18376 struct StructExtends<ImportScreenBufferInfoQNX, MemoryAllocateInfo>
|
|
|
18377 {
|
|
|
18378 enum
|
|
|
18379 {
|
|
|
18380 value = true
|
|
|
18381 };
|
|
|
18382 };
|
|
|
18383
|
|
|
18384 template <>
|
|
|
18385 struct StructExtends<ExternalFormatQNX, ImageCreateInfo>
|
|
|
18386 {
|
|
|
18387 enum
|
|
|
18388 {
|
|
|
18389 value = true
|
|
|
18390 };
|
|
|
18391 };
|
|
|
18392
|
|
|
18393 template <>
|
|
|
18394 struct StructExtends<ExternalFormatQNX, SamplerYcbcrConversionCreateInfo>
|
|
|
18395 {
|
|
|
18396 enum
|
|
|
18397 {
|
|
|
18398 value = true
|
|
|
18399 };
|
|
|
18400 };
|
|
|
18401
|
|
|
18402 template <>
|
|
|
18403 struct StructExtends<PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX, PhysicalDeviceFeatures2>
|
|
|
18404 {
|
|
|
18405 enum
|
|
|
18406 {
|
|
|
18407 value = true
|
|
|
18408 };
|
|
|
18409 };
|
|
|
18410
|
|
|
18411 template <>
|
|
|
18412 struct StructExtends<PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX, DeviceCreateInfo>
|
|
|
18413 {
|
|
|
18414 enum
|
|
|
18415 {
|
|
|
18416 value = true
|
|
|
18417 };
|
|
|
18418 };
|
|
|
18419 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
|
|
18420
|
|
|
18421 //=== VK_MSFT_layered_driver ===
|
|
|
18422 template <>
|
|
|
18423 struct StructExtends<PhysicalDeviceLayeredDriverPropertiesMSFT, PhysicalDeviceProperties2>
|
|
|
18424 {
|
|
|
18425 enum
|
|
|
18426 {
|
|
|
18427 value = true
|
|
|
18428 };
|
|
|
18429 };
|
|
|
18430
|
|
|
18431 //=== VK_NV_descriptor_pool_overallocation ===
|
|
|
18432 template <>
|
|
|
18433 struct StructExtends<PhysicalDeviceDescriptorPoolOverallocationFeaturesNV, PhysicalDeviceFeatures2>
|
|
|
18434 {
|
|
|
18435 enum
|
|
|
18436 {
|
|
|
18437 value = true
|
|
|
18438 };
|
|
|
18439 };
|
|
|
18440
|
|
|
18441 template <>
|
|
|
18442 struct StructExtends<PhysicalDeviceDescriptorPoolOverallocationFeaturesNV, DeviceCreateInfo>
|
|
|
18443 {
|
|
|
18444 enum
|
|
|
18445 {
|
|
|
18446 value = true
|
|
|
18447 };
|
|
|
18448 };
|
|
|
18449
|
|
|
18450 //=== VK_QCOM_tile_memory_heap ===
|
|
|
18451 template <>
|
|
|
18452 struct StructExtends<PhysicalDeviceTileMemoryHeapFeaturesQCOM, PhysicalDeviceFeatures2>
|
|
|
18453 {
|
|
|
18454 enum
|
|
|
18455 {
|
|
|
18456 value = true
|
|
|
18457 };
|
|
|
18458 };
|
|
|
18459
|
|
|
18460 template <>
|
|
|
18461 struct StructExtends<PhysicalDeviceTileMemoryHeapFeaturesQCOM, DeviceCreateInfo>
|
|
|
18462 {
|
|
|
18463 enum
|
|
|
18464 {
|
|
|
18465 value = true
|
|
|
18466 };
|
|
|
18467 };
|
|
|
18468
|
|
|
18469 template <>
|
|
|
18470 struct StructExtends<PhysicalDeviceTileMemoryHeapPropertiesQCOM, PhysicalDeviceProperties2>
|
|
|
18471 {
|
|
|
18472 enum
|
|
|
18473 {
|
|
|
18474 value = true
|
|
|
18475 };
|
|
|
18476 };
|
|
|
18477
|
|
|
18478 template <>
|
|
|
18479 struct StructExtends<TileMemoryRequirementsQCOM, MemoryRequirements2>
|
|
|
18480 {
|
|
|
18481 enum
|
|
|
18482 {
|
|
|
18483 value = true
|
|
|
18484 };
|
|
|
18485 };
|
|
|
18486
|
|
|
18487 template <>
|
|
|
18488 struct StructExtends<TileMemoryBindInfoQCOM, CommandBufferInheritanceInfo>
|
|
|
18489 {
|
|
|
18490 enum
|
|
|
18491 {
|
|
|
18492 value = true
|
|
|
18493 };
|
|
|
18494 };
|
|
|
18495
|
|
|
18496 template <>
|
|
|
18497 struct StructExtends<TileMemorySizeInfoQCOM, RenderPassCreateInfo>
|
|
|
18498 {
|
|
|
18499 enum
|
|
|
18500 {
|
|
|
18501 value = true
|
|
|
18502 };
|
|
|
18503 };
|
|
|
18504
|
|
|
18505 template <>
|
|
|
18506 struct StructExtends<TileMemorySizeInfoQCOM, RenderPassCreateInfo2>
|
|
|
18507 {
|
|
|
18508 enum
|
|
|
18509 {
|
|
|
18510 value = true
|
|
|
18511 };
|
|
|
18512 };
|
|
|
18513
|
|
|
18514 template <>
|
|
|
18515 struct StructExtends<TileMemorySizeInfoQCOM, RenderingInfo>
|
|
|
18516 {
|
|
|
18517 enum
|
|
|
18518 {
|
|
|
18519 value = true
|
|
|
18520 };
|
|
|
18521 };
|
|
|
18522
|
|
|
18523 //=== VK_KHR_copy_memory_indirect ===
|
|
|
18524 template <>
|
|
|
18525 struct StructExtends<PhysicalDeviceCopyMemoryIndirectFeaturesKHR, PhysicalDeviceFeatures2>
|
|
|
18526 {
|
|
|
18527 enum
|
|
|
18528 {
|
|
|
18529 value = true
|
|
|
18530 };
|
|
|
18531 };
|
|
|
18532
|
|
|
18533 template <>
|
|
|
18534 struct StructExtends<PhysicalDeviceCopyMemoryIndirectFeaturesKHR, DeviceCreateInfo>
|
|
|
18535 {
|
|
|
18536 enum
|
|
|
18537 {
|
|
|
18538 value = true
|
|
|
18539 };
|
|
|
18540 };
|
|
|
18541
|
|
|
18542 template <>
|
|
|
18543 struct StructExtends<PhysicalDeviceCopyMemoryIndirectPropertiesKHR, PhysicalDeviceProperties2>
|
|
|
18544 {
|
|
|
18545 enum
|
|
|
18546 {
|
|
|
18547 value = true
|
|
|
18548 };
|
|
|
18549 };
|
|
|
18550
|
|
|
18551 //=== VK_EXT_memory_decompression ===
|
|
|
18552 template <>
|
|
|
18553 struct StructExtends<PhysicalDeviceMemoryDecompressionFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
18554 {
|
|
|
18555 enum
|
|
|
18556 {
|
|
|
18557 value = true
|
|
|
18558 };
|
|
|
18559 };
|
|
|
18560
|
|
|
18561 template <>
|
|
|
18562 struct StructExtends<PhysicalDeviceMemoryDecompressionFeaturesEXT, DeviceCreateInfo>
|
|
|
18563 {
|
|
|
18564 enum
|
|
|
18565 {
|
|
|
18566 value = true
|
|
|
18567 };
|
|
|
18568 };
|
|
|
18569
|
|
|
18570 template <>
|
|
|
18571 struct StructExtends<PhysicalDeviceMemoryDecompressionPropertiesEXT, PhysicalDeviceProperties2>
|
|
|
18572 {
|
|
|
18573 enum
|
|
|
18574 {
|
|
|
18575 value = true
|
|
|
18576 };
|
|
|
18577 };
|
|
|
18578
|
|
|
18579 //=== VK_NV_display_stereo ===
|
|
|
18580 template <>
|
|
|
18581 struct StructExtends<DisplaySurfaceStereoCreateInfoNV, DisplaySurfaceCreateInfoKHR>
|
|
|
18582 {
|
|
|
18583 enum
|
|
|
18584 {
|
|
|
18585 value = true
|
|
|
18586 };
|
|
|
18587 };
|
|
|
18588
|
|
|
18589 template <>
|
|
|
18590 struct StructExtends<DisplayModeStereoPropertiesNV, DisplayModeProperties2KHR>
|
|
|
18591 {
|
|
|
18592 enum
|
|
|
18593 {
|
|
|
18594 value = true
|
|
|
18595 };
|
|
|
18596 };
|
|
|
18597
|
|
|
18598 //=== VK_KHR_video_encode_intra_refresh ===
|
|
|
18599 template <>
|
|
|
18600 struct StructExtends<VideoEncodeIntraRefreshCapabilitiesKHR, VideoCapabilitiesKHR>
|
|
|
18601 {
|
|
|
18602 enum
|
|
|
18603 {
|
|
|
18604 value = true
|
|
|
18605 };
|
|
|
18606 };
|
|
|
18607
|
|
|
18608 template <>
|
|
|
18609 struct StructExtends<VideoEncodeSessionIntraRefreshCreateInfoKHR, VideoSessionCreateInfoKHR>
|
|
|
18610 {
|
|
|
18611 enum
|
|
|
18612 {
|
|
|
18613 value = true
|
|
|
18614 };
|
|
|
18615 };
|
|
|
18616
|
|
|
18617 template <>
|
|
|
18618 struct StructExtends<VideoEncodeIntraRefreshInfoKHR, VideoEncodeInfoKHR>
|
|
|
18619 {
|
|
|
18620 enum
|
|
|
18621 {
|
|
|
18622 value = true
|
|
|
18623 };
|
|
|
18624 };
|
|
|
18625
|
|
|
18626 template <>
|
|
|
18627 struct StructExtends<VideoReferenceIntraRefreshInfoKHR, VideoReferenceSlotInfoKHR>
|
|
|
18628 {
|
|
|
18629 enum
|
|
|
18630 {
|
|
|
18631 value = true
|
|
|
18632 };
|
|
|
18633 };
|
|
|
18634
|
|
|
18635 template <>
|
|
|
18636 struct StructExtends<PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR, PhysicalDeviceFeatures2>
|
|
|
18637 {
|
|
|
18638 enum
|
|
|
18639 {
|
|
|
18640 value = true
|
|
|
18641 };
|
|
|
18642 };
|
|
|
18643
|
|
|
18644 template <>
|
|
|
18645 struct StructExtends<PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR, DeviceCreateInfo>
|
|
|
18646 {
|
|
|
18647 enum
|
|
|
18648 {
|
|
|
18649 value = true
|
|
|
18650 };
|
|
|
18651 };
|
|
|
18652
|
|
|
18653 //=== VK_KHR_video_encode_quantization_map ===
|
|
|
18654 template <>
|
|
|
18655 struct StructExtends<VideoEncodeQuantizationMapCapabilitiesKHR, VideoCapabilitiesKHR>
|
|
|
18656 {
|
|
|
18657 enum
|
|
|
18658 {
|
|
|
18659 value = true
|
|
|
18660 };
|
|
|
18661 };
|
|
|
18662
|
|
|
18663 template <>
|
|
|
18664 struct StructExtends<VideoFormatQuantizationMapPropertiesKHR, VideoFormatPropertiesKHR>
|
|
|
18665 {
|
|
|
18666 enum
|
|
|
18667 {
|
|
|
18668 value = true
|
|
|
18669 };
|
|
|
18670 };
|
|
|
18671
|
|
|
18672 template <>
|
|
|
18673 struct StructExtends<VideoEncodeQuantizationMapInfoKHR, VideoEncodeInfoKHR>
|
|
|
18674 {
|
|
|
18675 enum
|
|
|
18676 {
|
|
|
18677 value = true
|
|
|
18678 };
|
|
|
18679 };
|
|
|
18680
|
|
|
18681 template <>
|
|
|
18682 struct StructExtends<VideoEncodeQuantizationMapSessionParametersCreateInfoKHR, VideoSessionParametersCreateInfoKHR>
|
|
|
18683 {
|
|
|
18684 enum
|
|
|
18685 {
|
|
|
18686 value = true
|
|
|
18687 };
|
|
|
18688 };
|
|
|
18689
|
|
|
18690 template <>
|
|
|
18691 struct StructExtends<PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR, PhysicalDeviceFeatures2>
|
|
|
18692 {
|
|
|
18693 enum
|
|
|
18694 {
|
|
|
18695 value = true
|
|
|
18696 };
|
|
|
18697 };
|
|
|
18698
|
|
|
18699 template <>
|
|
|
18700 struct StructExtends<PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR, DeviceCreateInfo>
|
|
|
18701 {
|
|
|
18702 enum
|
|
|
18703 {
|
|
|
18704 value = true
|
|
|
18705 };
|
|
|
18706 };
|
|
|
18707
|
|
|
18708 template <>
|
|
|
18709 struct StructExtends<VideoEncodeH264QuantizationMapCapabilitiesKHR, VideoCapabilitiesKHR>
|
|
|
18710 {
|
|
|
18711 enum
|
|
|
18712 {
|
|
|
18713 value = true
|
|
|
18714 };
|
|
|
18715 };
|
|
|
18716
|
|
|
18717 template <>
|
|
|
18718 struct StructExtends<VideoEncodeH265QuantizationMapCapabilitiesKHR, VideoCapabilitiesKHR>
|
|
|
18719 {
|
|
|
18720 enum
|
|
|
18721 {
|
|
|
18722 value = true
|
|
|
18723 };
|
|
|
18724 };
|
|
|
18725
|
|
|
18726 template <>
|
|
|
18727 struct StructExtends<VideoFormatH265QuantizationMapPropertiesKHR, VideoFormatPropertiesKHR>
|
|
|
18728 {
|
|
|
18729 enum
|
|
|
18730 {
|
|
|
18731 value = true
|
|
|
18732 };
|
|
|
18733 };
|
|
|
18734
|
|
|
18735 template <>
|
|
|
18736 struct StructExtends<VideoEncodeAV1QuantizationMapCapabilitiesKHR, VideoCapabilitiesKHR>
|
|
|
18737 {
|
|
|
18738 enum
|
|
|
18739 {
|
|
|
18740 value = true
|
|
|
18741 };
|
|
|
18742 };
|
|
|
18743
|
|
|
18744 template <>
|
|
|
18745 struct StructExtends<VideoFormatAV1QuantizationMapPropertiesKHR, VideoFormatPropertiesKHR>
|
|
|
18746 {
|
|
|
18747 enum
|
|
|
18748 {
|
|
|
18749 value = true
|
|
|
18750 };
|
|
|
18751 };
|
|
|
18752
|
|
|
18753 //=== VK_NV_raw_access_chains ===
|
|
|
18754 template <>
|
|
|
18755 struct StructExtends<PhysicalDeviceRawAccessChainsFeaturesNV, PhysicalDeviceFeatures2>
|
|
|
18756 {
|
|
|
18757 enum
|
|
|
18758 {
|
|
|
18759 value = true
|
|
|
18760 };
|
|
|
18761 };
|
|
|
18762
|
|
|
18763 template <>
|
|
|
18764 struct StructExtends<PhysicalDeviceRawAccessChainsFeaturesNV, DeviceCreateInfo>
|
|
|
18765 {
|
|
|
18766 enum
|
|
|
18767 {
|
|
|
18768 value = true
|
|
|
18769 };
|
|
|
18770 };
|
|
|
18771
|
|
|
18772 //=== VK_NV_external_compute_queue ===
|
|
|
18773 template <>
|
|
|
18774 struct StructExtends<ExternalComputeQueueDeviceCreateInfoNV, DeviceCreateInfo>
|
|
|
18775 {
|
|
|
18776 enum
|
|
|
18777 {
|
|
|
18778 value = true
|
|
|
18779 };
|
|
|
18780 };
|
|
|
18781
|
|
|
18782 template <>
|
|
|
18783 struct StructExtends<PhysicalDeviceExternalComputeQueuePropertiesNV, PhysicalDeviceProperties2>
|
|
|
18784 {
|
|
|
18785 enum
|
|
|
18786 {
|
|
|
18787 value = true
|
|
|
18788 };
|
|
|
18789 };
|
|
|
18790
|
|
|
18791 //=== VK_KHR_shader_relaxed_extended_instruction ===
|
|
|
18792 template <>
|
|
|
18793 struct StructExtends<PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR, PhysicalDeviceFeatures2>
|
|
|
18794 {
|
|
|
18795 enum
|
|
|
18796 {
|
|
|
18797 value = true
|
|
|
18798 };
|
|
|
18799 };
|
|
|
18800
|
|
|
18801 template <>
|
|
|
18802 struct StructExtends<PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR, DeviceCreateInfo>
|
|
|
18803 {
|
|
|
18804 enum
|
|
|
18805 {
|
|
|
18806 value = true
|
|
|
18807 };
|
|
|
18808 };
|
|
|
18809
|
|
|
18810 //=== VK_NV_command_buffer_inheritance ===
|
|
|
18811 template <>
|
|
|
18812 struct StructExtends<PhysicalDeviceCommandBufferInheritanceFeaturesNV, PhysicalDeviceFeatures2>
|
|
|
18813 {
|
|
|
18814 enum
|
|
|
18815 {
|
|
|
18816 value = true
|
|
|
18817 };
|
|
|
18818 };
|
|
|
18819
|
|
|
18820 template <>
|
|
|
18821 struct StructExtends<PhysicalDeviceCommandBufferInheritanceFeaturesNV, DeviceCreateInfo>
|
|
|
18822 {
|
|
|
18823 enum
|
|
|
18824 {
|
|
|
18825 value = true
|
|
|
18826 };
|
|
|
18827 };
|
|
|
18828
|
|
|
18829 //=== VK_KHR_maintenance7 ===
|
|
|
18830 template <>
|
|
|
18831 struct StructExtends<PhysicalDeviceMaintenance7FeaturesKHR, PhysicalDeviceFeatures2>
|
|
|
18832 {
|
|
|
18833 enum
|
|
|
18834 {
|
|
|
18835 value = true
|
|
|
18836 };
|
|
|
18837 };
|
|
|
18838
|
|
|
18839 template <>
|
|
|
18840 struct StructExtends<PhysicalDeviceMaintenance7FeaturesKHR, DeviceCreateInfo>
|
|
|
18841 {
|
|
|
18842 enum
|
|
|
18843 {
|
|
|
18844 value = true
|
|
|
18845 };
|
|
|
18846 };
|
|
|
18847
|
|
|
18848 template <>
|
|
|
18849 struct StructExtends<PhysicalDeviceMaintenance7PropertiesKHR, PhysicalDeviceProperties2>
|
|
|
18850 {
|
|
|
18851 enum
|
|
|
18852 {
|
|
|
18853 value = true
|
|
|
18854 };
|
|
|
18855 };
|
|
|
18856
|
|
|
18857 template <>
|
|
|
18858 struct StructExtends<PhysicalDeviceLayeredApiPropertiesListKHR, PhysicalDeviceProperties2>
|
|
|
18859 {
|
|
|
18860 enum
|
|
|
18861 {
|
|
|
18862 value = true
|
|
|
18863 };
|
|
|
18864 };
|
|
|
18865
|
|
|
18866 template <>
|
|
|
18867 struct StructExtends<PhysicalDeviceLayeredApiVulkanPropertiesKHR, PhysicalDeviceLayeredApiPropertiesKHR>
|
|
|
18868 {
|
|
|
18869 enum
|
|
|
18870 {
|
|
|
18871 value = true
|
|
|
18872 };
|
|
|
18873 };
|
|
|
18874
|
|
|
18875 //=== VK_NV_shader_atomic_float16_vector ===
|
|
|
18876 template <>
|
|
|
18877 struct StructExtends<PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV, PhysicalDeviceFeatures2>
|
|
|
18878 {
|
|
|
18879 enum
|
|
|
18880 {
|
|
|
18881 value = true
|
|
|
18882 };
|
|
|
18883 };
|
|
|
18884
|
|
|
18885 template <>
|
|
|
18886 struct StructExtends<PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV, DeviceCreateInfo>
|
|
|
18887 {
|
|
|
18888 enum
|
|
|
18889 {
|
|
|
18890 value = true
|
|
|
18891 };
|
|
|
18892 };
|
|
|
18893
|
|
|
18894 //=== VK_EXT_shader_replicated_composites ===
|
|
|
18895 template <>
|
|
|
18896 struct StructExtends<PhysicalDeviceShaderReplicatedCompositesFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
18897 {
|
|
|
18898 enum
|
|
|
18899 {
|
|
|
18900 value = true
|
|
|
18901 };
|
|
|
18902 };
|
|
|
18903
|
|
|
18904 template <>
|
|
|
18905 struct StructExtends<PhysicalDeviceShaderReplicatedCompositesFeaturesEXT, DeviceCreateInfo>
|
|
|
18906 {
|
|
|
18907 enum
|
|
|
18908 {
|
|
|
18909 value = true
|
|
|
18910 };
|
|
|
18911 };
|
|
|
18912
|
|
|
18913 //=== VK_EXT_shader_float8 ===
|
|
|
18914 template <>
|
|
|
18915 struct StructExtends<PhysicalDeviceShaderFloat8FeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
18916 {
|
|
|
18917 enum
|
|
|
18918 {
|
|
|
18919 value = true
|
|
|
18920 };
|
|
|
18921 };
|
|
|
18922
|
|
|
18923 template <>
|
|
|
18924 struct StructExtends<PhysicalDeviceShaderFloat8FeaturesEXT, DeviceCreateInfo>
|
|
|
18925 {
|
|
|
18926 enum
|
|
|
18927 {
|
|
|
18928 value = true
|
|
|
18929 };
|
|
|
18930 };
|
|
|
18931
|
|
|
18932 //=== VK_NV_ray_tracing_validation ===
|
|
|
18933 template <>
|
|
|
18934 struct StructExtends<PhysicalDeviceRayTracingValidationFeaturesNV, PhysicalDeviceFeatures2>
|
|
|
18935 {
|
|
|
18936 enum
|
|
|
18937 {
|
|
|
18938 value = true
|
|
|
18939 };
|
|
|
18940 };
|
|
|
18941
|
|
|
18942 template <>
|
|
|
18943 struct StructExtends<PhysicalDeviceRayTracingValidationFeaturesNV, DeviceCreateInfo>
|
|
|
18944 {
|
|
|
18945 enum
|
|
|
18946 {
|
|
|
18947 value = true
|
|
|
18948 };
|
|
|
18949 };
|
|
|
18950
|
|
|
18951 //=== VK_NV_cluster_acceleration_structure ===
|
|
|
18952 template <>
|
|
|
18953 struct StructExtends<PhysicalDeviceClusterAccelerationStructureFeaturesNV, PhysicalDeviceFeatures2>
|
|
|
18954 {
|
|
|
18955 enum
|
|
|
18956 {
|
|
|
18957 value = true
|
|
|
18958 };
|
|
|
18959 };
|
|
|
18960
|
|
|
18961 template <>
|
|
|
18962 struct StructExtends<PhysicalDeviceClusterAccelerationStructureFeaturesNV, DeviceCreateInfo>
|
|
|
18963 {
|
|
|
18964 enum
|
|
|
18965 {
|
|
|
18966 value = true
|
|
|
18967 };
|
|
|
18968 };
|
|
|
18969
|
|
|
18970 template <>
|
|
|
18971 struct StructExtends<PhysicalDeviceClusterAccelerationStructurePropertiesNV, PhysicalDeviceProperties2>
|
|
|
18972 {
|
|
|
18973 enum
|
|
|
18974 {
|
|
|
18975 value = true
|
|
|
18976 };
|
|
|
18977 };
|
|
|
18978
|
|
|
18979 template <>
|
|
|
18980 struct StructExtends<RayTracingPipelineClusterAccelerationStructureCreateInfoNV, RayTracingPipelineCreateInfoKHR>
|
|
|
18981 {
|
|
|
18982 enum
|
|
|
18983 {
|
|
|
18984 value = true
|
|
|
18985 };
|
|
|
18986 };
|
|
|
18987
|
|
|
18988 //=== VK_NV_partitioned_acceleration_structure ===
|
|
|
18989 template <>
|
|
|
18990 struct StructExtends<PhysicalDevicePartitionedAccelerationStructureFeaturesNV, PhysicalDeviceFeatures2>
|
|
|
18991 {
|
|
|
18992 enum
|
|
|
18993 {
|
|
|
18994 value = true
|
|
|
18995 };
|
|
|
18996 };
|
|
|
18997
|
|
|
18998 template <>
|
|
|
18999 struct StructExtends<PhysicalDevicePartitionedAccelerationStructureFeaturesNV, DeviceCreateInfo>
|
|
|
19000 {
|
|
|
19001 enum
|
|
|
19002 {
|
|
|
19003 value = true
|
|
|
19004 };
|
|
|
19005 };
|
|
|
19006
|
|
|
19007 template <>
|
|
|
19008 struct StructExtends<PhysicalDevicePartitionedAccelerationStructurePropertiesNV, PhysicalDeviceProperties2>
|
|
|
19009 {
|
|
|
19010 enum
|
|
|
19011 {
|
|
|
19012 value = true
|
|
|
19013 };
|
|
|
19014 };
|
|
|
19015
|
|
|
19016 template <>
|
|
|
19017 struct StructExtends<PartitionedAccelerationStructureFlagsNV, PartitionedAccelerationStructureInstancesInputNV>
|
|
|
19018 {
|
|
|
19019 enum
|
|
|
19020 {
|
|
|
19021 value = true
|
|
|
19022 };
|
|
|
19023 };
|
|
|
19024
|
|
|
19025 template <>
|
|
|
19026 struct StructExtends<WriteDescriptorSetPartitionedAccelerationStructureNV, WriteDescriptorSet>
|
|
|
19027 {
|
|
|
19028 enum
|
|
|
19029 {
|
|
|
19030 value = true
|
|
|
19031 };
|
|
|
19032 };
|
|
|
19033
|
|
|
19034 //=== VK_EXT_device_generated_commands ===
|
|
|
19035 template <>
|
|
|
19036 struct StructExtends<PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
19037 {
|
|
|
19038 enum
|
|
|
19039 {
|
|
|
19040 value = true
|
|
|
19041 };
|
|
|
19042 };
|
|
|
19043
|
|
|
19044 template <>
|
|
|
19045 struct StructExtends<PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT, DeviceCreateInfo>
|
|
|
19046 {
|
|
|
19047 enum
|
|
|
19048 {
|
|
|
19049 value = true
|
|
|
19050 };
|
|
|
19051 };
|
|
|
19052
|
|
|
19053 template <>
|
|
|
19054 struct StructExtends<PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT, PhysicalDeviceProperties2>
|
|
|
19055 {
|
|
|
19056 enum
|
|
|
19057 {
|
|
|
19058 value = true
|
|
|
19059 };
|
|
|
19060 };
|
|
|
19061
|
|
|
19062 template <>
|
|
|
19063 struct StructExtends<GeneratedCommandsPipelineInfoEXT, GeneratedCommandsInfoEXT>
|
|
|
19064 {
|
|
|
19065 enum
|
|
|
19066 {
|
|
|
19067 value = true
|
|
|
19068 };
|
|
|
19069 };
|
|
|
19070
|
|
|
19071 template <>
|
|
|
19072 struct StructExtends<GeneratedCommandsPipelineInfoEXT, GeneratedCommandsMemoryRequirementsInfoEXT>
|
|
|
19073 {
|
|
|
19074 enum
|
|
|
19075 {
|
|
|
19076 value = true
|
|
|
19077 };
|
|
|
19078 };
|
|
|
19079
|
|
|
19080 template <>
|
|
|
19081 struct StructExtends<GeneratedCommandsShaderInfoEXT, GeneratedCommandsInfoEXT>
|
|
|
19082 {
|
|
|
19083 enum
|
|
|
19084 {
|
|
|
19085 value = true
|
|
|
19086 };
|
|
|
19087 };
|
|
|
19088
|
|
|
19089 template <>
|
|
|
19090 struct StructExtends<GeneratedCommandsShaderInfoEXT, GeneratedCommandsMemoryRequirementsInfoEXT>
|
|
|
19091 {
|
|
|
19092 enum
|
|
|
19093 {
|
|
|
19094 value = true
|
|
|
19095 };
|
|
|
19096 };
|
|
|
19097
|
|
|
19098 //=== VK_KHR_maintenance8 ===
|
|
|
19099 template <>
|
|
|
19100 struct StructExtends<MemoryBarrierAccessFlags3KHR, SubpassDependency2>
|
|
|
19101 {
|
|
|
19102 enum
|
|
|
19103 {
|
|
|
19104 value = true
|
|
|
19105 };
|
|
|
19106 };
|
|
|
19107
|
|
|
19108 template <>
|
|
|
19109 struct StructExtends<MemoryBarrierAccessFlags3KHR, BufferMemoryBarrier2>
|
|
|
19110 {
|
|
|
19111 enum
|
|
|
19112 {
|
|
|
19113 value = true
|
|
|
19114 };
|
|
|
19115 };
|
|
|
19116
|
|
|
19117 template <>
|
|
|
19118 struct StructExtends<MemoryBarrierAccessFlags3KHR, ImageMemoryBarrier2>
|
|
|
19119 {
|
|
|
19120 enum
|
|
|
19121 {
|
|
|
19122 value = true
|
|
|
19123 };
|
|
|
19124 };
|
|
|
19125
|
|
|
19126 template <>
|
|
|
19127 struct StructExtends<PhysicalDeviceMaintenance8FeaturesKHR, PhysicalDeviceFeatures2>
|
|
|
19128 {
|
|
|
19129 enum
|
|
|
19130 {
|
|
|
19131 value = true
|
|
|
19132 };
|
|
|
19133 };
|
|
|
19134
|
|
|
19135 template <>
|
|
|
19136 struct StructExtends<PhysicalDeviceMaintenance8FeaturesKHR, DeviceCreateInfo>
|
|
|
19137 {
|
|
|
19138 enum
|
|
|
19139 {
|
|
|
19140 value = true
|
|
|
19141 };
|
|
|
19142 };
|
|
|
19143
|
|
|
19144 //=== VK_MESA_image_alignment_control ===
|
|
|
19145 template <>
|
|
|
19146 struct StructExtends<PhysicalDeviceImageAlignmentControlFeaturesMESA, PhysicalDeviceFeatures2>
|
|
|
19147 {
|
|
|
19148 enum
|
|
|
19149 {
|
|
|
19150 value = true
|
|
|
19151 };
|
|
|
19152 };
|
|
|
19153
|
|
|
19154 template <>
|
|
|
19155 struct StructExtends<PhysicalDeviceImageAlignmentControlFeaturesMESA, DeviceCreateInfo>
|
|
|
19156 {
|
|
|
19157 enum
|
|
|
19158 {
|
|
|
19159 value = true
|
|
|
19160 };
|
|
|
19161 };
|
|
|
19162
|
|
|
19163 template <>
|
|
|
19164 struct StructExtends<PhysicalDeviceImageAlignmentControlPropertiesMESA, PhysicalDeviceProperties2>
|
|
|
19165 {
|
|
|
19166 enum
|
|
|
19167 {
|
|
|
19168 value = true
|
|
|
19169 };
|
|
|
19170 };
|
|
|
19171
|
|
|
19172 template <>
|
|
|
19173 struct StructExtends<ImageAlignmentControlCreateInfoMESA, ImageCreateInfo>
|
|
|
19174 {
|
|
|
19175 enum
|
|
|
19176 {
|
|
|
19177 value = true
|
|
|
19178 };
|
|
|
19179 };
|
|
|
19180
|
|
|
19181 //=== VK_KHR_shader_fma ===
|
|
|
19182 template <>
|
|
|
19183 struct StructExtends<PhysicalDeviceShaderFmaFeaturesKHR, PhysicalDeviceFeatures2>
|
|
|
19184 {
|
|
|
19185 enum
|
|
|
19186 {
|
|
|
19187 value = true
|
|
|
19188 };
|
|
|
19189 };
|
|
|
19190
|
|
|
19191 template <>
|
|
|
19192 struct StructExtends<PhysicalDeviceShaderFmaFeaturesKHR, DeviceCreateInfo>
|
|
|
19193 {
|
|
|
19194 enum
|
|
|
19195 {
|
|
|
19196 value = true
|
|
|
19197 };
|
|
|
19198 };
|
|
|
19199
|
|
|
19200 //=== VK_EXT_ray_tracing_invocation_reorder ===
|
|
|
19201 template <>
|
|
|
19202 struct StructExtends<PhysicalDeviceRayTracingInvocationReorderPropertiesEXT, PhysicalDeviceProperties2>
|
|
|
19203 {
|
|
|
19204 enum
|
|
|
19205 {
|
|
|
19206 value = true
|
|
|
19207 };
|
|
|
19208 };
|
|
|
19209
|
|
|
19210 template <>
|
|
|
19211 struct StructExtends<PhysicalDeviceRayTracingInvocationReorderFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
19212 {
|
|
|
19213 enum
|
|
|
19214 {
|
|
|
19215 value = true
|
|
|
19216 };
|
|
|
19217 };
|
|
|
19218
|
|
|
19219 template <>
|
|
|
19220 struct StructExtends<PhysicalDeviceRayTracingInvocationReorderFeaturesEXT, DeviceCreateInfo>
|
|
|
19221 {
|
|
|
19222 enum
|
|
|
19223 {
|
|
|
19224 value = true
|
|
|
19225 };
|
|
|
19226 };
|
|
|
19227
|
|
|
19228 //=== VK_EXT_depth_clamp_control ===
|
|
|
19229 template <>
|
|
|
19230 struct StructExtends<PhysicalDeviceDepthClampControlFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
19231 {
|
|
|
19232 enum
|
|
|
19233 {
|
|
|
19234 value = true
|
|
|
19235 };
|
|
|
19236 };
|
|
|
19237
|
|
|
19238 template <>
|
|
|
19239 struct StructExtends<PhysicalDeviceDepthClampControlFeaturesEXT, DeviceCreateInfo>
|
|
|
19240 {
|
|
|
19241 enum
|
|
|
19242 {
|
|
|
19243 value = true
|
|
|
19244 };
|
|
|
19245 };
|
|
|
19246
|
|
|
19247 template <>
|
|
|
19248 struct StructExtends<PipelineViewportDepthClampControlCreateInfoEXT, PipelineViewportStateCreateInfo>
|
|
|
19249 {
|
|
|
19250 enum
|
|
|
19251 {
|
|
|
19252 value = true
|
|
|
19253 };
|
|
|
19254 };
|
|
|
19255
|
|
|
19256 //=== VK_KHR_maintenance9 ===
|
|
|
19257 template <>
|
|
|
19258 struct StructExtends<PhysicalDeviceMaintenance9FeaturesKHR, PhysicalDeviceFeatures2>
|
|
|
19259 {
|
|
|
19260 enum
|
|
|
19261 {
|
|
|
19262 value = true
|
|
|
19263 };
|
|
|
19264 };
|
|
|
19265
|
|
|
19266 template <>
|
|
|
19267 struct StructExtends<PhysicalDeviceMaintenance9FeaturesKHR, DeviceCreateInfo>
|
|
|
19268 {
|
|
|
19269 enum
|
|
|
19270 {
|
|
|
19271 value = true
|
|
|
19272 };
|
|
|
19273 };
|
|
|
19274
|
|
|
19275 template <>
|
|
|
19276 struct StructExtends<PhysicalDeviceMaintenance9PropertiesKHR, PhysicalDeviceProperties2>
|
|
|
19277 {
|
|
|
19278 enum
|
|
|
19279 {
|
|
|
19280 value = true
|
|
|
19281 };
|
|
|
19282 };
|
|
|
19283
|
|
|
19284 template <>
|
|
|
19285 struct StructExtends<QueueFamilyOwnershipTransferPropertiesKHR, QueueFamilyProperties2>
|
|
|
19286 {
|
|
|
19287 enum
|
|
|
19288 {
|
|
|
19289 value = true
|
|
|
19290 };
|
|
|
19291 };
|
|
|
19292
|
|
|
19293 //=== VK_KHR_video_maintenance2 ===
|
|
|
19294 template <>
|
|
|
19295 struct StructExtends<PhysicalDeviceVideoMaintenance2FeaturesKHR, PhysicalDeviceFeatures2>
|
|
|
19296 {
|
|
|
19297 enum
|
|
|
19298 {
|
|
|
19299 value = true
|
|
|
19300 };
|
|
|
19301 };
|
|
|
19302
|
|
|
19303 template <>
|
|
|
19304 struct StructExtends<PhysicalDeviceVideoMaintenance2FeaturesKHR, DeviceCreateInfo>
|
|
|
19305 {
|
|
|
19306 enum
|
|
|
19307 {
|
|
|
19308 value = true
|
|
|
19309 };
|
|
|
19310 };
|
|
|
19311
|
|
|
19312 template <>
|
|
|
19313 struct StructExtends<VideoDecodeH264InlineSessionParametersInfoKHR, VideoDecodeInfoKHR>
|
|
|
19314 {
|
|
|
19315 enum
|
|
|
19316 {
|
|
|
19317 value = true
|
|
|
19318 };
|
|
|
19319 };
|
|
|
19320
|
|
|
19321 template <>
|
|
|
19322 struct StructExtends<VideoDecodeH265InlineSessionParametersInfoKHR, VideoDecodeInfoKHR>
|
|
|
19323 {
|
|
|
19324 enum
|
|
|
19325 {
|
|
|
19326 value = true
|
|
|
19327 };
|
|
|
19328 };
|
|
|
19329
|
|
|
19330 template <>
|
|
|
19331 struct StructExtends<VideoDecodeAV1InlineSessionParametersInfoKHR, VideoDecodeInfoKHR>
|
|
|
19332 {
|
|
|
19333 enum
|
|
|
19334 {
|
|
|
19335 value = true
|
|
|
19336 };
|
|
|
19337 };
|
|
|
19338
|
|
|
19339 # if defined( VK_USE_PLATFORM_OHOS )
|
|
|
19340 //=== VK_OHOS_native_buffer ===
|
|
|
19341 template <>
|
|
|
19342 struct StructExtends<NativeBufferOHOS, ImageCreateInfo>
|
|
|
19343 {
|
|
|
19344 enum
|
|
|
19345 {
|
|
|
19346 value = true
|
|
|
19347 };
|
|
|
19348 };
|
|
|
19349
|
|
|
19350 template <>
|
|
|
19351 struct StructExtends<NativeBufferOHOS, BindImageMemoryInfo>
|
|
|
19352 {
|
|
|
19353 enum
|
|
|
19354 {
|
|
|
19355 value = true
|
|
|
19356 };
|
|
|
19357 };
|
|
|
19358
|
|
|
19359 template <>
|
|
|
19360 struct StructExtends<SwapchainImageCreateInfoOHOS, ImageCreateInfo>
|
|
|
19361 {
|
|
|
19362 enum
|
|
|
19363 {
|
|
|
19364 value = true
|
|
|
19365 };
|
|
|
19366 };
|
|
|
19367
|
|
|
19368 template <>
|
|
|
19369 struct StructExtends<PhysicalDevicePresentationPropertiesOHOS, PhysicalDeviceProperties2>
|
|
|
19370 {
|
|
|
19371 enum
|
|
|
19372 {
|
|
|
19373 value = true
|
|
|
19374 };
|
|
|
19375 };
|
|
|
19376 # endif /*VK_USE_PLATFORM_OHOS*/
|
|
|
19377
|
|
|
19378 //=== VK_HUAWEI_hdr_vivid ===
|
|
|
19379 template <>
|
|
|
19380 struct StructExtends<PhysicalDeviceHdrVividFeaturesHUAWEI, PhysicalDeviceFeatures2>
|
|
|
19381 {
|
|
|
19382 enum
|
|
|
19383 {
|
|
|
19384 value = true
|
|
|
19385 };
|
|
|
19386 };
|
|
|
19387
|
|
|
19388 template <>
|
|
|
19389 struct StructExtends<PhysicalDeviceHdrVividFeaturesHUAWEI, DeviceCreateInfo>
|
|
|
19390 {
|
|
|
19391 enum
|
|
|
19392 {
|
|
|
19393 value = true
|
|
|
19394 };
|
|
|
19395 };
|
|
|
19396
|
|
|
19397 template <>
|
|
|
19398 struct StructExtends<HdrVividDynamicMetadataHUAWEI, HdrMetadataEXT>
|
|
|
19399 {
|
|
|
19400 enum
|
|
|
19401 {
|
|
|
19402 value = true
|
|
|
19403 };
|
|
|
19404 };
|
|
|
19405
|
|
|
19406 //=== VK_NV_cooperative_matrix2 ===
|
|
|
19407 template <>
|
|
|
19408 struct StructExtends<PhysicalDeviceCooperativeMatrix2FeaturesNV, PhysicalDeviceFeatures2>
|
|
|
19409 {
|
|
|
19410 enum
|
|
|
19411 {
|
|
|
19412 value = true
|
|
|
19413 };
|
|
|
19414 };
|
|
|
19415
|
|
|
19416 template <>
|
|
|
19417 struct StructExtends<PhysicalDeviceCooperativeMatrix2FeaturesNV, DeviceCreateInfo>
|
|
|
19418 {
|
|
|
19419 enum
|
|
|
19420 {
|
|
|
19421 value = true
|
|
|
19422 };
|
|
|
19423 };
|
|
|
19424
|
|
|
19425 template <>
|
|
|
19426 struct StructExtends<PhysicalDeviceCooperativeMatrix2PropertiesNV, PhysicalDeviceProperties2>
|
|
|
19427 {
|
|
|
19428 enum
|
|
|
19429 {
|
|
|
19430 value = true
|
|
|
19431 };
|
|
|
19432 };
|
|
|
19433
|
|
|
19434 //=== VK_ARM_pipeline_opacity_micromap ===
|
|
|
19435 template <>
|
|
|
19436 struct StructExtends<PhysicalDevicePipelineOpacityMicromapFeaturesARM, PhysicalDeviceFeatures2>
|
|
|
19437 {
|
|
|
19438 enum
|
|
|
19439 {
|
|
|
19440 value = true
|
|
|
19441 };
|
|
|
19442 };
|
|
|
19443
|
|
|
19444 template <>
|
|
|
19445 struct StructExtends<PhysicalDevicePipelineOpacityMicromapFeaturesARM, DeviceCreateInfo>
|
|
|
19446 {
|
|
|
19447 enum
|
|
|
19448 {
|
|
|
19449 value = true
|
|
|
19450 };
|
|
|
19451 };
|
|
|
19452
|
|
|
19453 # if defined( VK_USE_PLATFORM_METAL_EXT )
|
|
|
19454 //=== VK_EXT_external_memory_metal ===
|
|
|
19455 template <>
|
|
|
19456 struct StructExtends<ImportMemoryMetalHandleInfoEXT, MemoryAllocateInfo>
|
|
|
19457 {
|
|
|
19458 enum
|
|
|
19459 {
|
|
|
19460 value = true
|
|
|
19461 };
|
|
|
19462 };
|
|
|
19463 # endif /*VK_USE_PLATFORM_METAL_EXT*/
|
|
|
19464
|
|
|
19465 //=== VK_KHR_depth_clamp_zero_one ===
|
|
|
19466 template <>
|
|
|
19467 struct StructExtends<PhysicalDeviceDepthClampZeroOneFeaturesKHR, PhysicalDeviceFeatures2>
|
|
|
19468 {
|
|
|
19469 enum
|
|
|
19470 {
|
|
|
19471 value = true
|
|
|
19472 };
|
|
|
19473 };
|
|
|
19474
|
|
|
19475 template <>
|
|
|
19476 struct StructExtends<PhysicalDeviceDepthClampZeroOneFeaturesKHR, DeviceCreateInfo>
|
|
|
19477 {
|
|
|
19478 enum
|
|
|
19479 {
|
|
|
19480 value = true
|
|
|
19481 };
|
|
|
19482 };
|
|
|
19483
|
|
|
19484 //=== VK_ARM_performance_counters_by_region ===
|
|
|
19485 template <>
|
|
|
19486 struct StructExtends<PhysicalDevicePerformanceCountersByRegionFeaturesARM, PhysicalDeviceFeatures2>
|
|
|
19487 {
|
|
|
19488 enum
|
|
|
19489 {
|
|
|
19490 value = true
|
|
|
19491 };
|
|
|
19492 };
|
|
|
19493
|
|
|
19494 template <>
|
|
|
19495 struct StructExtends<PhysicalDevicePerformanceCountersByRegionFeaturesARM, DeviceCreateInfo>
|
|
|
19496 {
|
|
|
19497 enum
|
|
|
19498 {
|
|
|
19499 value = true
|
|
|
19500 };
|
|
|
19501 };
|
|
|
19502
|
|
|
19503 template <>
|
|
|
19504 struct StructExtends<PhysicalDevicePerformanceCountersByRegionPropertiesARM, PhysicalDeviceProperties2>
|
|
|
19505 {
|
|
|
19506 enum
|
|
|
19507 {
|
|
|
19508 value = true
|
|
|
19509 };
|
|
|
19510 };
|
|
|
19511
|
|
|
19512 template <>
|
|
|
19513 struct StructExtends<RenderPassPerformanceCountersByRegionBeginInfoARM, RenderPassBeginInfo>
|
|
|
19514 {
|
|
|
19515 enum
|
|
|
19516 {
|
|
|
19517 value = true
|
|
|
19518 };
|
|
|
19519 };
|
|
|
19520
|
|
|
19521 template <>
|
|
|
19522 struct StructExtends<RenderPassPerformanceCountersByRegionBeginInfoARM, RenderingInfo>
|
|
|
19523 {
|
|
|
19524 enum
|
|
|
19525 {
|
|
|
19526 value = true
|
|
|
19527 };
|
|
|
19528 };
|
|
|
19529
|
|
|
19530 //=== VK_EXT_vertex_attribute_robustness ===
|
|
|
19531 template <>
|
|
|
19532 struct StructExtends<PhysicalDeviceVertexAttributeRobustnessFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
19533 {
|
|
|
19534 enum
|
|
|
19535 {
|
|
|
19536 value = true
|
|
|
19537 };
|
|
|
19538 };
|
|
|
19539
|
|
|
19540 template <>
|
|
|
19541 struct StructExtends<PhysicalDeviceVertexAttributeRobustnessFeaturesEXT, DeviceCreateInfo>
|
|
|
19542 {
|
|
|
19543 enum
|
|
|
19544 {
|
|
|
19545 value = true
|
|
|
19546 };
|
|
|
19547 };
|
|
|
19548
|
|
|
19549 //=== VK_ARM_format_pack ===
|
|
|
19550 template <>
|
|
|
19551 struct StructExtends<PhysicalDeviceFormatPackFeaturesARM, PhysicalDeviceFeatures2>
|
|
|
19552 {
|
|
|
19553 enum
|
|
|
19554 {
|
|
|
19555 value = true
|
|
|
19556 };
|
|
|
19557 };
|
|
|
19558
|
|
|
19559 template <>
|
|
|
19560 struct StructExtends<PhysicalDeviceFormatPackFeaturesARM, DeviceCreateInfo>
|
|
|
19561 {
|
|
|
19562 enum
|
|
|
19563 {
|
|
|
19564 value = true
|
|
|
19565 };
|
|
|
19566 };
|
|
|
19567
|
|
|
19568 //=== VK_VALVE_fragment_density_map_layered ===
|
|
|
19569 template <>
|
|
|
19570 struct StructExtends<PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE, PhysicalDeviceFeatures2>
|
|
|
19571 {
|
|
|
19572 enum
|
|
|
19573 {
|
|
|
19574 value = true
|
|
|
19575 };
|
|
|
19576 };
|
|
|
19577
|
|
|
19578 template <>
|
|
|
19579 struct StructExtends<PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE, DeviceCreateInfo>
|
|
|
19580 {
|
|
|
19581 enum
|
|
|
19582 {
|
|
|
19583 value = true
|
|
|
19584 };
|
|
|
19585 };
|
|
|
19586
|
|
|
19587 template <>
|
|
|
19588 struct StructExtends<PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE, PhysicalDeviceProperties2>
|
|
|
19589 {
|
|
|
19590 enum
|
|
|
19591 {
|
|
|
19592 value = true
|
|
|
19593 };
|
|
|
19594 };
|
|
|
19595
|
|
|
19596 template <>
|
|
|
19597 struct StructExtends<PipelineFragmentDensityMapLayeredCreateInfoVALVE, GraphicsPipelineCreateInfo>
|
|
|
19598 {
|
|
|
19599 enum
|
|
|
19600 {
|
|
|
19601 value = true
|
|
|
19602 };
|
|
|
19603 };
|
|
|
19604
|
|
|
19605 //=== VK_KHR_robustness2 ===
|
|
|
19606 template <>
|
|
|
19607 struct StructExtends<PhysicalDeviceRobustness2FeaturesKHR, PhysicalDeviceFeatures2>
|
|
|
19608 {
|
|
|
19609 enum
|
|
|
19610 {
|
|
|
19611 value = true
|
|
|
19612 };
|
|
|
19613 };
|
|
|
19614
|
|
|
19615 template <>
|
|
|
19616 struct StructExtends<PhysicalDeviceRobustness2FeaturesKHR, DeviceCreateInfo>
|
|
|
19617 {
|
|
|
19618 enum
|
|
|
19619 {
|
|
|
19620 value = true
|
|
|
19621 };
|
|
|
19622 };
|
|
|
19623
|
|
|
19624 template <>
|
|
|
19625 struct StructExtends<PhysicalDeviceRobustness2PropertiesKHR, PhysicalDeviceProperties2>
|
|
|
19626 {
|
|
|
19627 enum
|
|
|
19628 {
|
|
|
19629 value = true
|
|
|
19630 };
|
|
|
19631 };
|
|
|
19632
|
|
|
19633 # if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
19634 //=== VK_NV_present_metering ===
|
|
|
19635 template <>
|
|
|
19636 struct StructExtends<SetPresentConfigNV, PresentInfoKHR>
|
|
|
19637 {
|
|
|
19638 enum
|
|
|
19639 {
|
|
|
19640 value = true
|
|
|
19641 };
|
|
|
19642 };
|
|
|
19643
|
|
|
19644 template <>
|
|
|
19645 struct StructExtends<PhysicalDevicePresentMeteringFeaturesNV, PhysicalDeviceFeatures2>
|
|
|
19646 {
|
|
|
19647 enum
|
|
|
19648 {
|
|
|
19649 value = true
|
|
|
19650 };
|
|
|
19651 };
|
|
|
19652
|
|
|
19653 template <>
|
|
|
19654 struct StructExtends<PhysicalDevicePresentMeteringFeaturesNV, DeviceCreateInfo>
|
|
|
19655 {
|
|
|
19656 enum
|
|
|
19657 {
|
|
|
19658 value = true
|
|
|
19659 };
|
|
|
19660 };
|
|
|
19661 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
19662
|
|
|
19663 //=== VK_EXT_fragment_density_map_offset ===
|
|
|
19664 template <>
|
|
|
19665 struct StructExtends<PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
19666 {
|
|
|
19667 enum
|
|
|
19668 {
|
|
|
19669 value = true
|
|
|
19670 };
|
|
|
19671 };
|
|
|
19672
|
|
|
19673 template <>
|
|
|
19674 struct StructExtends<PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT, DeviceCreateInfo>
|
|
|
19675 {
|
|
|
19676 enum
|
|
|
19677 {
|
|
|
19678 value = true
|
|
|
19679 };
|
|
|
19680 };
|
|
|
19681
|
|
|
19682 template <>
|
|
|
19683 struct StructExtends<PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT, PhysicalDeviceProperties2>
|
|
|
19684 {
|
|
|
19685 enum
|
|
|
19686 {
|
|
|
19687 value = true
|
|
|
19688 };
|
|
|
19689 };
|
|
|
19690
|
|
|
19691 template <>
|
|
|
19692 struct StructExtends<RenderPassFragmentDensityMapOffsetEndInfoEXT, SubpassEndInfo>
|
|
|
19693 {
|
|
|
19694 enum
|
|
|
19695 {
|
|
|
19696 value = true
|
|
|
19697 };
|
|
|
19698 };
|
|
|
19699
|
|
|
19700 template <>
|
|
|
19701 struct StructExtends<RenderPassFragmentDensityMapOffsetEndInfoEXT, RenderingEndInfoKHR>
|
|
|
19702 {
|
|
|
19703 enum
|
|
|
19704 {
|
|
|
19705 value = true
|
|
|
19706 };
|
|
|
19707 };
|
|
|
19708
|
|
|
19709 //=== VK_EXT_zero_initialize_device_memory ===
|
|
|
19710 template <>
|
|
|
19711 struct StructExtends<PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
19712 {
|
|
|
19713 enum
|
|
|
19714 {
|
|
|
19715 value = true
|
|
|
19716 };
|
|
|
19717 };
|
|
|
19718
|
|
|
19719 template <>
|
|
|
19720 struct StructExtends<PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT, DeviceCreateInfo>
|
|
|
19721 {
|
|
|
19722 enum
|
|
|
19723 {
|
|
|
19724 value = true
|
|
|
19725 };
|
|
|
19726 };
|
|
|
19727
|
|
|
19728 //=== VK_KHR_present_mode_fifo_latest_ready ===
|
|
|
19729 template <>
|
|
|
19730 struct StructExtends<PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR, PhysicalDeviceFeatures2>
|
|
|
19731 {
|
|
|
19732 enum
|
|
|
19733 {
|
|
|
19734 value = true
|
|
|
19735 };
|
|
|
19736 };
|
|
|
19737
|
|
|
19738 template <>
|
|
|
19739 struct StructExtends<PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR, DeviceCreateInfo>
|
|
|
19740 {
|
|
|
19741 enum
|
|
|
19742 {
|
|
|
19743 value = true
|
|
|
19744 };
|
|
|
19745 };
|
|
|
19746
|
|
|
19747 //=== VK_EXT_shader_64bit_indexing ===
|
|
|
19748 template <>
|
|
|
19749 struct StructExtends<PhysicalDeviceShader64BitIndexingFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
19750 {
|
|
|
19751 enum
|
|
|
19752 {
|
|
|
19753 value = true
|
|
|
19754 };
|
|
|
19755 };
|
|
|
19756
|
|
|
19757 template <>
|
|
|
19758 struct StructExtends<PhysicalDeviceShader64BitIndexingFeaturesEXT, DeviceCreateInfo>
|
|
|
19759 {
|
|
|
19760 enum
|
|
|
19761 {
|
|
|
19762 value = true
|
|
|
19763 };
|
|
|
19764 };
|
|
|
19765
|
|
|
19766 //=== VK_EXT_custom_resolve ===
|
|
|
19767 template <>
|
|
|
19768 struct StructExtends<PhysicalDeviceCustomResolveFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
19769 {
|
|
|
19770 enum
|
|
|
19771 {
|
|
|
19772 value = true
|
|
|
19773 };
|
|
|
19774 };
|
|
|
19775
|
|
|
19776 template <>
|
|
|
19777 struct StructExtends<PhysicalDeviceCustomResolveFeaturesEXT, DeviceCreateInfo>
|
|
|
19778 {
|
|
|
19779 enum
|
|
|
19780 {
|
|
|
19781 value = true
|
|
|
19782 };
|
|
|
19783 };
|
|
|
19784
|
|
|
19785 template <>
|
|
|
19786 struct StructExtends<CustomResolveCreateInfoEXT, GraphicsPipelineCreateInfo>
|
|
|
19787 {
|
|
|
19788 enum
|
|
|
19789 {
|
|
|
19790 value = true
|
|
|
19791 };
|
|
|
19792 };
|
|
|
19793
|
|
|
19794 template <>
|
|
|
19795 struct StructExtends<CustomResolveCreateInfoEXT, CommandBufferInheritanceInfo>
|
|
|
19796 {
|
|
|
19797 enum
|
|
|
19798 {
|
|
|
19799 value = true
|
|
|
19800 };
|
|
|
19801 };
|
|
|
19802
|
|
|
19803 template <>
|
|
|
19804 struct StructExtends<CustomResolveCreateInfoEXT, ShaderCreateInfoEXT>
|
|
|
19805 {
|
|
|
19806 enum
|
|
|
19807 {
|
|
|
19808 value = true
|
|
|
19809 };
|
|
|
19810 };
|
|
|
19811
|
|
|
19812 //=== VK_QCOM_data_graph_model ===
|
|
|
19813 template <>
|
|
|
19814 struct StructExtends<DataGraphPipelineBuiltinModelCreateInfoQCOM, DataGraphPipelineCreateInfoARM>
|
|
|
19815 {
|
|
|
19816 enum
|
|
|
19817 {
|
|
|
19818 value = true
|
|
|
19819 };
|
|
|
19820 };
|
|
|
19821
|
|
|
19822 template <>
|
|
|
19823 struct StructExtends<PhysicalDeviceDataGraphModelFeaturesQCOM, PhysicalDeviceFeatures2>
|
|
|
19824 {
|
|
|
19825 enum
|
|
|
19826 {
|
|
|
19827 value = true
|
|
|
19828 };
|
|
|
19829 };
|
|
|
19830
|
|
|
19831 template <>
|
|
|
19832 struct StructExtends<PhysicalDeviceDataGraphModelFeaturesQCOM, DeviceCreateInfo>
|
|
|
19833 {
|
|
|
19834 enum
|
|
|
19835 {
|
|
|
19836 value = true
|
|
|
19837 };
|
|
|
19838 };
|
|
|
19839
|
|
|
19840 //=== VK_KHR_maintenance10 ===
|
|
|
19841 template <>
|
|
|
19842 struct StructExtends<PhysicalDeviceMaintenance10FeaturesKHR, PhysicalDeviceFeatures2>
|
|
|
19843 {
|
|
|
19844 enum
|
|
|
19845 {
|
|
|
19846 value = true
|
|
|
19847 };
|
|
|
19848 };
|
|
|
19849
|
|
|
19850 template <>
|
|
|
19851 struct StructExtends<PhysicalDeviceMaintenance10FeaturesKHR, DeviceCreateInfo>
|
|
|
19852 {
|
|
|
19853 enum
|
|
|
19854 {
|
|
|
19855 value = true
|
|
|
19856 };
|
|
|
19857 };
|
|
|
19858
|
|
|
19859 template <>
|
|
|
19860 struct StructExtends<PhysicalDeviceMaintenance10PropertiesKHR, PhysicalDeviceProperties2>
|
|
|
19861 {
|
|
|
19862 enum
|
|
|
19863 {
|
|
|
19864 value = true
|
|
|
19865 };
|
|
|
19866 };
|
|
|
19867
|
|
|
19868 template <>
|
|
|
19869 struct StructExtends<RenderingAttachmentFlagsInfoKHR, RenderingAttachmentInfo>
|
|
|
19870 {
|
|
|
19871 enum
|
|
|
19872 {
|
|
|
19873 value = true
|
|
|
19874 };
|
|
|
19875 };
|
|
|
19876
|
|
|
19877 template <>
|
|
|
19878 struct StructExtends<ResolveImageModeInfoKHR, ResolveImageInfo2>
|
|
|
19879 {
|
|
|
19880 enum
|
|
|
19881 {
|
|
|
19882 value = true
|
|
|
19883 };
|
|
|
19884 };
|
|
|
19885
|
|
|
19886 //=== VK_SEC_pipeline_cache_incremental_mode ===
|
|
|
19887 template <>
|
|
|
19888 struct StructExtends<PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC, PhysicalDeviceFeatures2>
|
|
|
19889 {
|
|
|
19890 enum
|
|
|
19891 {
|
|
|
19892 value = true
|
|
|
19893 };
|
|
|
19894 };
|
|
|
19895
|
|
|
19896 template <>
|
|
|
19897 struct StructExtends<PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC, DeviceCreateInfo>
|
|
|
19898 {
|
|
|
19899 enum
|
|
|
19900 {
|
|
|
19901 value = true
|
|
|
19902 };
|
|
|
19903 };
|
|
|
19904
|
|
|
19905 //=== VK_EXT_shader_uniform_buffer_unsized_array ===
|
|
|
19906 template <>
|
|
|
19907 struct StructExtends<PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT, PhysicalDeviceFeatures2>
|
|
|
19908 {
|
|
|
19909 enum
|
|
|
19910 {
|
|
|
19911 value = true
|
|
|
19912 };
|
|
|
19913 };
|
|
|
19914
|
|
|
19915 template <>
|
|
|
19916 struct StructExtends<PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT, DeviceCreateInfo>
|
|
|
19917 {
|
|
|
19918 enum
|
|
|
19919 {
|
|
|
19920 value = true
|
|
|
19921 };
|
|
|
19922 };
|
|
|
19923
|
|
|
19924 #endif // VULKAN_HPP_DISABLE_ENHANCED_MODE
|
|
|
19925
|
|
|
19926 namespace detail
|
|
|
19927 {
|
|
|
19928 #if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
|
|
|
19929 class DynamicLoader
|
|
|
19930 {
|
|
|
19931 public:
|
|
|
19932 # ifdef VULKAN_HPP_NO_EXCEPTIONS
|
|
|
19933 DynamicLoader( std::string const & vulkanLibraryName = {} ) VULKAN_HPP_NOEXCEPT
|
|
|
19934 # else
|
|
|
19935 DynamicLoader( std::string const & vulkanLibraryName = {} )
|
|
|
19936 # endif
|
|
|
19937 {
|
|
|
19938 if ( !vulkanLibraryName.empty() )
|
|
|
19939 {
|
|
|
19940 # if defined( _WIN32 )
|
|
|
19941 m_library = ::LoadLibraryA( vulkanLibraryName.c_str() );
|
|
|
19942 # elif defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNX__ ) || defined( __Fuchsia__ )
|
|
|
19943 m_library = dlopen( vulkanLibraryName.c_str(), RTLD_NOW | RTLD_LOCAL );
|
|
|
19944 # else
|
|
|
19945 # error unsupported platform
|
|
|
19946 # endif
|
|
|
19947 }
|
|
|
19948 else
|
|
|
19949 {
|
|
|
19950 # if defined( _WIN32 )
|
|
|
19951 m_library = ::LoadLibraryA( "vulkan-1.dll" );
|
|
|
19952 # elif defined( __APPLE__ )
|
|
|
19953 m_library = dlopen( "libvulkan.dylib", RTLD_NOW | RTLD_LOCAL );
|
|
|
19954 if ( !m_library )
|
|
|
19955 {
|
|
|
19956 m_library = dlopen( "libvulkan.1.dylib", RTLD_NOW | RTLD_LOCAL );
|
|
|
19957 }
|
|
|
19958 // modern versions of macOS don't search /usr/local/lib automatically contrary to what man dlopen says
|
|
|
19959 // Vulkan SDK uses this as the system-wide installation location, so we're going to fallback to this if all else fails
|
|
|
19960 if ( !m_library && ( getenv( "DYLD_FALLBACK_LIBRARY_PATH" ) == NULL ) )
|
|
|
19961 {
|
|
|
19962 m_library = dlopen( "/usr/local/lib/libvulkan.dylib", RTLD_NOW | RTLD_LOCAL );
|
|
|
19963 }
|
|
|
19964 if ( !m_library )
|
|
|
19965 {
|
|
|
19966 m_library = dlopen( "libMoltenVK.dylib", RTLD_NOW | RTLD_LOCAL );
|
|
|
19967 }
|
|
|
19968 // Add support for using Vulkan and MoltenVK in a Framework. App store rules for iOS
|
|
|
19969 // strictly enforce no .dylib's. If they aren't found it just falls through
|
|
|
19970 if ( !m_library )
|
|
|
19971 {
|
|
|
19972 m_library = dlopen( "vulkan.framework/vulkan", RTLD_NOW | RTLD_LOCAL );
|
|
|
19973 }
|
|
|
19974 if ( !m_library )
|
|
|
19975 {
|
|
|
19976 m_library = dlopen( "MoltenVK.framework/MoltenVK", RTLD_NOW | RTLD_LOCAL );
|
|
|
19977 }
|
|
|
19978 # elif defined( __unix__ ) || defined( __QNX__ ) || defined( __Fuchsia__ )
|
|
|
19979 m_library = dlopen( "libvulkan.so", RTLD_NOW | RTLD_LOCAL );
|
|
|
19980 if ( !m_library )
|
|
|
19981 {
|
|
|
19982 m_library = dlopen( "libvulkan.so.1", RTLD_NOW | RTLD_LOCAL );
|
|
|
19983 }
|
|
|
19984 # else
|
|
|
19985 # error unsupported platform
|
|
|
19986 # endif
|
|
|
19987 }
|
|
|
19988
|
|
|
19989 # ifndef VULKAN_HPP_NO_EXCEPTIONS
|
|
|
19990 if ( !m_library )
|
|
|
19991 {
|
|
|
19992 // NOTE there should be an InitializationFailedError, but msvc insists on the symbol does not exist within the scope of this function.
|
|
|
19993 throw std::runtime_error( "Failed to load vulkan library!" );
|
|
|
19994 }
|
|
|
19995 # endif
|
|
|
19996 }
|
|
|
19997
|
|
|
19998 DynamicLoader( DynamicLoader const & ) = delete;
|
|
|
19999
|
|
|
20000 DynamicLoader( DynamicLoader && other ) VULKAN_HPP_NOEXCEPT : m_library( other.m_library )
|
|
|
20001 {
|
|
|
20002 other.m_library = nullptr;
|
|
|
20003 }
|
|
|
20004
|
|
|
20005 DynamicLoader & operator=( DynamicLoader const & ) = delete;
|
|
|
20006
|
|
|
20007 DynamicLoader & operator=( DynamicLoader && other ) VULKAN_HPP_NOEXCEPT
|
|
|
20008 {
|
|
|
20009 std::swap( m_library, other.m_library );
|
|
|
20010 return *this;
|
|
|
20011 }
|
|
|
20012
|
|
|
20013 ~DynamicLoader() VULKAN_HPP_NOEXCEPT
|
|
|
20014 {
|
|
|
20015 if ( m_library )
|
|
|
20016 {
|
|
|
20017 # if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNX__ ) || defined( __Fuchsia__ )
|
|
|
20018 dlclose( m_library );
|
|
|
20019 # elif defined( _WIN32 )
|
|
|
20020 ::FreeLibrary( m_library );
|
|
|
20021 # else
|
|
|
20022 # error unsupported platform
|
|
|
20023 # endif
|
|
|
20024 }
|
|
|
20025 }
|
|
|
20026
|
|
|
20027 template <typename T>
|
|
|
20028 T getProcAddress( const char * function ) const VULKAN_HPP_NOEXCEPT
|
|
|
20029 {
|
|
|
20030 # if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNX__ ) || defined( __Fuchsia__ )
|
|
|
20031 return (T)(void *)dlsym( m_library, function );
|
|
|
20032 # elif defined( _WIN32 )
|
|
|
20033 return (T)(void *)::GetProcAddress( m_library, function );
|
|
|
20034 # else
|
|
|
20035 # error unsupported platform
|
|
|
20036 # endif
|
|
|
20037 }
|
|
|
20038
|
|
|
20039 bool success() const VULKAN_HPP_NOEXCEPT
|
|
|
20040 {
|
|
|
20041 return m_library != nullptr;
|
|
|
20042 }
|
|
|
20043
|
|
|
20044 private:
|
|
|
20045 # if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNX__ ) || defined( __Fuchsia__ )
|
|
|
20046 void * m_library;
|
|
|
20047 # elif defined( _WIN32 )
|
|
|
20048 ::HINSTANCE m_library;
|
|
|
20049 # else
|
|
|
20050 # error unsupported platform
|
|
|
20051 # endif
|
|
|
20052 };
|
|
|
20053 #endif
|
|
|
20054
|
|
|
20055 using PFN_dummy = void ( * )();
|
|
|
20056
|
|
|
20057 class DispatchLoaderDynamic : public DispatchLoaderBase
|
|
|
20058 {
|
|
|
20059 public:
|
|
|
20060 //=== VK_VERSION_1_0 ===
|
|
|
20061 PFN_vkCreateInstance vkCreateInstance = 0;
|
|
|
20062 PFN_vkDestroyInstance vkDestroyInstance = 0;
|
|
|
20063 PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices = 0;
|
|
|
20064 PFN_vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures = 0;
|
|
|
20065 PFN_vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties = 0;
|
|
|
20066 PFN_vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceImageFormatProperties = 0;
|
|
|
20067 PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties = 0;
|
|
|
20068 PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties = 0;
|
|
|
20069 PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties = 0;
|
|
|
20070 PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = 0;
|
|
|
20071 PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr = 0;
|
|
|
20072 PFN_vkCreateDevice vkCreateDevice = 0;
|
|
|
20073 PFN_vkDestroyDevice vkDestroyDevice = 0;
|
|
|
20074 PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties = 0;
|
|
|
20075 PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties = 0;
|
|
|
20076 PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties = 0;
|
|
|
20077 PFN_vkEnumerateDeviceLayerProperties vkEnumerateDeviceLayerProperties = 0;
|
|
|
20078 PFN_vkGetDeviceQueue vkGetDeviceQueue = 0;
|
|
|
20079 PFN_vkQueueSubmit vkQueueSubmit = 0;
|
|
|
20080 PFN_vkQueueWaitIdle vkQueueWaitIdle = 0;
|
|
|
20081 PFN_vkDeviceWaitIdle vkDeviceWaitIdle = 0;
|
|
|
20082 PFN_vkAllocateMemory vkAllocateMemory = 0;
|
|
|
20083 PFN_vkFreeMemory vkFreeMemory = 0;
|
|
|
20084 PFN_vkMapMemory vkMapMemory = 0;
|
|
|
20085 PFN_vkUnmapMemory vkUnmapMemory = 0;
|
|
|
20086 PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges = 0;
|
|
|
20087 PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges = 0;
|
|
|
20088 PFN_vkGetDeviceMemoryCommitment vkGetDeviceMemoryCommitment = 0;
|
|
|
20089 PFN_vkBindBufferMemory vkBindBufferMemory = 0;
|
|
|
20090 PFN_vkBindImageMemory vkBindImageMemory = 0;
|
|
|
20091 PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements = 0;
|
|
|
20092 PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements = 0;
|
|
|
20093 PFN_vkGetImageSparseMemoryRequirements vkGetImageSparseMemoryRequirements = 0;
|
|
|
20094 PFN_vkGetPhysicalDeviceSparseImageFormatProperties vkGetPhysicalDeviceSparseImageFormatProperties = 0;
|
|
|
20095 PFN_vkQueueBindSparse vkQueueBindSparse = 0;
|
|
|
20096 PFN_vkCreateFence vkCreateFence = 0;
|
|
|
20097 PFN_vkDestroyFence vkDestroyFence = 0;
|
|
|
20098 PFN_vkResetFences vkResetFences = 0;
|
|
|
20099 PFN_vkGetFenceStatus vkGetFenceStatus = 0;
|
|
|
20100 PFN_vkWaitForFences vkWaitForFences = 0;
|
|
|
20101 PFN_vkCreateSemaphore vkCreateSemaphore = 0;
|
|
|
20102 PFN_vkDestroySemaphore vkDestroySemaphore = 0;
|
|
|
20103 PFN_vkCreateQueryPool vkCreateQueryPool = 0;
|
|
|
20104 PFN_vkDestroyQueryPool vkDestroyQueryPool = 0;
|
|
|
20105 PFN_vkGetQueryPoolResults vkGetQueryPoolResults = 0;
|
|
|
20106 PFN_vkCreateBuffer vkCreateBuffer = 0;
|
|
|
20107 PFN_vkDestroyBuffer vkDestroyBuffer = 0;
|
|
|
20108 PFN_vkCreateImage vkCreateImage = 0;
|
|
|
20109 PFN_vkDestroyImage vkDestroyImage = 0;
|
|
|
20110 PFN_vkGetImageSubresourceLayout vkGetImageSubresourceLayout = 0;
|
|
|
20111 PFN_vkCreateImageView vkCreateImageView = 0;
|
|
|
20112 PFN_vkDestroyImageView vkDestroyImageView = 0;
|
|
|
20113 PFN_vkCreateCommandPool vkCreateCommandPool = 0;
|
|
|
20114 PFN_vkDestroyCommandPool vkDestroyCommandPool = 0;
|
|
|
20115 PFN_vkResetCommandPool vkResetCommandPool = 0;
|
|
|
20116 PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers = 0;
|
|
|
20117 PFN_vkFreeCommandBuffers vkFreeCommandBuffers = 0;
|
|
|
20118 PFN_vkBeginCommandBuffer vkBeginCommandBuffer = 0;
|
|
|
20119 PFN_vkEndCommandBuffer vkEndCommandBuffer = 0;
|
|
|
20120 PFN_vkResetCommandBuffer vkResetCommandBuffer = 0;
|
|
|
20121 PFN_vkCmdCopyBuffer vkCmdCopyBuffer = 0;
|
|
|
20122 PFN_vkCmdCopyImage vkCmdCopyImage = 0;
|
|
|
20123 PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage = 0;
|
|
|
20124 PFN_vkCmdCopyImageToBuffer vkCmdCopyImageToBuffer = 0;
|
|
|
20125 PFN_vkCmdUpdateBuffer vkCmdUpdateBuffer = 0;
|
|
|
20126 PFN_vkCmdFillBuffer vkCmdFillBuffer = 0;
|
|
|
20127 PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier = 0;
|
|
|
20128 PFN_vkCmdBeginQuery vkCmdBeginQuery = 0;
|
|
|
20129 PFN_vkCmdEndQuery vkCmdEndQuery = 0;
|
|
|
20130 PFN_vkCmdResetQueryPool vkCmdResetQueryPool = 0;
|
|
|
20131 PFN_vkCmdWriteTimestamp vkCmdWriteTimestamp = 0;
|
|
|
20132 PFN_vkCmdCopyQueryPoolResults vkCmdCopyQueryPoolResults = 0;
|
|
|
20133 PFN_vkCmdExecuteCommands vkCmdExecuteCommands = 0;
|
|
|
20134 PFN_vkCreateEvent vkCreateEvent = 0;
|
|
|
20135 PFN_vkDestroyEvent vkDestroyEvent = 0;
|
|
|
20136 PFN_vkGetEventStatus vkGetEventStatus = 0;
|
|
|
20137 PFN_vkSetEvent vkSetEvent = 0;
|
|
|
20138 PFN_vkResetEvent vkResetEvent = 0;
|
|
|
20139 PFN_vkCreateBufferView vkCreateBufferView = 0;
|
|
|
20140 PFN_vkDestroyBufferView vkDestroyBufferView = 0;
|
|
|
20141 PFN_vkCreateShaderModule vkCreateShaderModule = 0;
|
|
|
20142 PFN_vkDestroyShaderModule vkDestroyShaderModule = 0;
|
|
|
20143 PFN_vkCreatePipelineCache vkCreatePipelineCache = 0;
|
|
|
20144 PFN_vkDestroyPipelineCache vkDestroyPipelineCache = 0;
|
|
|
20145 PFN_vkGetPipelineCacheData vkGetPipelineCacheData = 0;
|
|
|
20146 PFN_vkMergePipelineCaches vkMergePipelineCaches = 0;
|
|
|
20147 PFN_vkCreateComputePipelines vkCreateComputePipelines = 0;
|
|
|
20148 PFN_vkDestroyPipeline vkDestroyPipeline = 0;
|
|
|
20149 PFN_vkCreatePipelineLayout vkCreatePipelineLayout = 0;
|
|
|
20150 PFN_vkDestroyPipelineLayout vkDestroyPipelineLayout = 0;
|
|
|
20151 PFN_vkCreateSampler vkCreateSampler = 0;
|
|
|
20152 PFN_vkDestroySampler vkDestroySampler = 0;
|
|
|
20153 PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout = 0;
|
|
|
20154 PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout = 0;
|
|
|
20155 PFN_vkCreateDescriptorPool vkCreateDescriptorPool = 0;
|
|
|
20156 PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool = 0;
|
|
|
20157 PFN_vkResetDescriptorPool vkResetDescriptorPool = 0;
|
|
|
20158 PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets = 0;
|
|
|
20159 PFN_vkFreeDescriptorSets vkFreeDescriptorSets = 0;
|
|
|
20160 PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets = 0;
|
|
|
20161 PFN_vkCmdBindPipeline vkCmdBindPipeline = 0;
|
|
|
20162 PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets = 0;
|
|
|
20163 PFN_vkCmdClearColorImage vkCmdClearColorImage = 0;
|
|
|
20164 PFN_vkCmdDispatch vkCmdDispatch = 0;
|
|
|
20165 PFN_vkCmdDispatchIndirect vkCmdDispatchIndirect = 0;
|
|
|
20166 PFN_vkCmdSetEvent vkCmdSetEvent = 0;
|
|
|
20167 PFN_vkCmdResetEvent vkCmdResetEvent = 0;
|
|
|
20168 PFN_vkCmdWaitEvents vkCmdWaitEvents = 0;
|
|
|
20169 PFN_vkCmdPushConstants vkCmdPushConstants = 0;
|
|
|
20170 PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines = 0;
|
|
|
20171 PFN_vkCreateFramebuffer vkCreateFramebuffer = 0;
|
|
|
20172 PFN_vkDestroyFramebuffer vkDestroyFramebuffer = 0;
|
|
|
20173 PFN_vkCreateRenderPass vkCreateRenderPass = 0;
|
|
|
20174 PFN_vkDestroyRenderPass vkDestroyRenderPass = 0;
|
|
|
20175 PFN_vkGetRenderAreaGranularity vkGetRenderAreaGranularity = 0;
|
|
|
20176 PFN_vkCmdSetViewport vkCmdSetViewport = 0;
|
|
|
20177 PFN_vkCmdSetScissor vkCmdSetScissor = 0;
|
|
|
20178 PFN_vkCmdSetLineWidth vkCmdSetLineWidth = 0;
|
|
|
20179 PFN_vkCmdSetDepthBias vkCmdSetDepthBias = 0;
|
|
|
20180 PFN_vkCmdSetBlendConstants vkCmdSetBlendConstants = 0;
|
|
|
20181 PFN_vkCmdSetDepthBounds vkCmdSetDepthBounds = 0;
|
|
|
20182 PFN_vkCmdSetStencilCompareMask vkCmdSetStencilCompareMask = 0;
|
|
|
20183 PFN_vkCmdSetStencilWriteMask vkCmdSetStencilWriteMask = 0;
|
|
|
20184 PFN_vkCmdSetStencilReference vkCmdSetStencilReference = 0;
|
|
|
20185 PFN_vkCmdBindIndexBuffer vkCmdBindIndexBuffer = 0;
|
|
|
20186 PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers = 0;
|
|
|
20187 PFN_vkCmdDraw vkCmdDraw = 0;
|
|
|
20188 PFN_vkCmdDrawIndexed vkCmdDrawIndexed = 0;
|
|
|
20189 PFN_vkCmdDrawIndirect vkCmdDrawIndirect = 0;
|
|
|
20190 PFN_vkCmdDrawIndexedIndirect vkCmdDrawIndexedIndirect = 0;
|
|
|
20191 PFN_vkCmdBlitImage vkCmdBlitImage = 0;
|
|
|
20192 PFN_vkCmdClearDepthStencilImage vkCmdClearDepthStencilImage = 0;
|
|
|
20193 PFN_vkCmdClearAttachments vkCmdClearAttachments = 0;
|
|
|
20194 PFN_vkCmdResolveImage vkCmdResolveImage = 0;
|
|
|
20195 PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass = 0;
|
|
|
20196 PFN_vkCmdNextSubpass vkCmdNextSubpass = 0;
|
|
|
20197 PFN_vkCmdEndRenderPass vkCmdEndRenderPass = 0;
|
|
|
20198
|
|
|
20199 //=== VK_VERSION_1_1 ===
|
|
|
20200 PFN_vkEnumerateInstanceVersion vkEnumerateInstanceVersion = 0;
|
|
|
20201 PFN_vkBindBufferMemory2 vkBindBufferMemory2 = 0;
|
|
|
20202 PFN_vkBindImageMemory2 vkBindImageMemory2 = 0;
|
|
|
20203 PFN_vkGetDeviceGroupPeerMemoryFeatures vkGetDeviceGroupPeerMemoryFeatures = 0;
|
|
|
20204 PFN_vkCmdSetDeviceMask vkCmdSetDeviceMask = 0;
|
|
|
20205 PFN_vkEnumeratePhysicalDeviceGroups vkEnumeratePhysicalDeviceGroups = 0;
|
|
|
20206 PFN_vkGetImageMemoryRequirements2 vkGetImageMemoryRequirements2 = 0;
|
|
|
20207 PFN_vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2 = 0;
|
|
|
20208 PFN_vkGetImageSparseMemoryRequirements2 vkGetImageSparseMemoryRequirements2 = 0;
|
|
|
20209 PFN_vkGetPhysicalDeviceFeatures2 vkGetPhysicalDeviceFeatures2 = 0;
|
|
|
20210 PFN_vkGetPhysicalDeviceProperties2 vkGetPhysicalDeviceProperties2 = 0;
|
|
|
20211 PFN_vkGetPhysicalDeviceFormatProperties2 vkGetPhysicalDeviceFormatProperties2 = 0;
|
|
|
20212 PFN_vkGetPhysicalDeviceImageFormatProperties2 vkGetPhysicalDeviceImageFormatProperties2 = 0;
|
|
|
20213 PFN_vkGetPhysicalDeviceQueueFamilyProperties2 vkGetPhysicalDeviceQueueFamilyProperties2 = 0;
|
|
|
20214 PFN_vkGetPhysicalDeviceMemoryProperties2 vkGetPhysicalDeviceMemoryProperties2 = 0;
|
|
|
20215 PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 vkGetPhysicalDeviceSparseImageFormatProperties2 = 0;
|
|
|
20216 PFN_vkTrimCommandPool vkTrimCommandPool = 0;
|
|
|
20217 PFN_vkGetDeviceQueue2 vkGetDeviceQueue2 = 0;
|
|
|
20218 PFN_vkGetPhysicalDeviceExternalBufferProperties vkGetPhysicalDeviceExternalBufferProperties = 0;
|
|
|
20219 PFN_vkGetPhysicalDeviceExternalFenceProperties vkGetPhysicalDeviceExternalFenceProperties = 0;
|
|
|
20220 PFN_vkGetPhysicalDeviceExternalSemaphoreProperties vkGetPhysicalDeviceExternalSemaphoreProperties = 0;
|
|
|
20221 PFN_vkCmdDispatchBase vkCmdDispatchBase = 0;
|
|
|
20222 PFN_vkCreateDescriptorUpdateTemplate vkCreateDescriptorUpdateTemplate = 0;
|
|
|
20223 PFN_vkDestroyDescriptorUpdateTemplate vkDestroyDescriptorUpdateTemplate = 0;
|
|
|
20224 PFN_vkUpdateDescriptorSetWithTemplate vkUpdateDescriptorSetWithTemplate = 0;
|
|
|
20225 PFN_vkGetDescriptorSetLayoutSupport vkGetDescriptorSetLayoutSupport = 0;
|
|
|
20226 PFN_vkCreateSamplerYcbcrConversion vkCreateSamplerYcbcrConversion = 0;
|
|
|
20227 PFN_vkDestroySamplerYcbcrConversion vkDestroySamplerYcbcrConversion = 0;
|
|
|
20228
|
|
|
20229 //=== VK_VERSION_1_2 ===
|
|
|
20230 PFN_vkResetQueryPool vkResetQueryPool = 0;
|
|
|
20231 PFN_vkGetSemaphoreCounterValue vkGetSemaphoreCounterValue = 0;
|
|
|
20232 PFN_vkWaitSemaphores vkWaitSemaphores = 0;
|
|
|
20233 PFN_vkSignalSemaphore vkSignalSemaphore = 0;
|
|
|
20234 PFN_vkGetBufferDeviceAddress vkGetBufferDeviceAddress = 0;
|
|
|
20235 PFN_vkGetBufferOpaqueCaptureAddress vkGetBufferOpaqueCaptureAddress = 0;
|
|
|
20236 PFN_vkGetDeviceMemoryOpaqueCaptureAddress vkGetDeviceMemoryOpaqueCaptureAddress = 0;
|
|
|
20237 PFN_vkCmdDrawIndirectCount vkCmdDrawIndirectCount = 0;
|
|
|
20238 PFN_vkCmdDrawIndexedIndirectCount vkCmdDrawIndexedIndirectCount = 0;
|
|
|
20239 PFN_vkCreateRenderPass2 vkCreateRenderPass2 = 0;
|
|
|
20240 PFN_vkCmdBeginRenderPass2 vkCmdBeginRenderPass2 = 0;
|
|
|
20241 PFN_vkCmdNextSubpass2 vkCmdNextSubpass2 = 0;
|
|
|
20242 PFN_vkCmdEndRenderPass2 vkCmdEndRenderPass2 = 0;
|
|
|
20243
|
|
|
20244 //=== VK_VERSION_1_3 ===
|
|
|
20245 PFN_vkGetPhysicalDeviceToolProperties vkGetPhysicalDeviceToolProperties = 0;
|
|
|
20246 PFN_vkCreatePrivateDataSlot vkCreatePrivateDataSlot = 0;
|
|
|
20247 PFN_vkDestroyPrivateDataSlot vkDestroyPrivateDataSlot = 0;
|
|
|
20248 PFN_vkSetPrivateData vkSetPrivateData = 0;
|
|
|
20249 PFN_vkGetPrivateData vkGetPrivateData = 0;
|
|
|
20250 PFN_vkCmdPipelineBarrier2 vkCmdPipelineBarrier2 = 0;
|
|
|
20251 PFN_vkCmdWriteTimestamp2 vkCmdWriteTimestamp2 = 0;
|
|
|
20252 PFN_vkQueueSubmit2 vkQueueSubmit2 = 0;
|
|
|
20253 PFN_vkCmdCopyBuffer2 vkCmdCopyBuffer2 = 0;
|
|
|
20254 PFN_vkCmdCopyImage2 vkCmdCopyImage2 = 0;
|
|
|
20255 PFN_vkCmdCopyBufferToImage2 vkCmdCopyBufferToImage2 = 0;
|
|
|
20256 PFN_vkCmdCopyImageToBuffer2 vkCmdCopyImageToBuffer2 = 0;
|
|
|
20257 PFN_vkGetDeviceBufferMemoryRequirements vkGetDeviceBufferMemoryRequirements = 0;
|
|
|
20258 PFN_vkGetDeviceImageMemoryRequirements vkGetDeviceImageMemoryRequirements = 0;
|
|
|
20259 PFN_vkGetDeviceImageSparseMemoryRequirements vkGetDeviceImageSparseMemoryRequirements = 0;
|
|
|
20260 PFN_vkCmdSetEvent2 vkCmdSetEvent2 = 0;
|
|
|
20261 PFN_vkCmdResetEvent2 vkCmdResetEvent2 = 0;
|
|
|
20262 PFN_vkCmdWaitEvents2 vkCmdWaitEvents2 = 0;
|
|
|
20263 PFN_vkCmdBlitImage2 vkCmdBlitImage2 = 0;
|
|
|
20264 PFN_vkCmdResolveImage2 vkCmdResolveImage2 = 0;
|
|
|
20265 PFN_vkCmdBeginRendering vkCmdBeginRendering = 0;
|
|
|
20266 PFN_vkCmdEndRendering vkCmdEndRendering = 0;
|
|
|
20267 PFN_vkCmdSetCullMode vkCmdSetCullMode = 0;
|
|
|
20268 PFN_vkCmdSetFrontFace vkCmdSetFrontFace = 0;
|
|
|
20269 PFN_vkCmdSetPrimitiveTopology vkCmdSetPrimitiveTopology = 0;
|
|
|
20270 PFN_vkCmdSetViewportWithCount vkCmdSetViewportWithCount = 0;
|
|
|
20271 PFN_vkCmdSetScissorWithCount vkCmdSetScissorWithCount = 0;
|
|
|
20272 PFN_vkCmdBindVertexBuffers2 vkCmdBindVertexBuffers2 = 0;
|
|
|
20273 PFN_vkCmdSetDepthTestEnable vkCmdSetDepthTestEnable = 0;
|
|
|
20274 PFN_vkCmdSetDepthWriteEnable vkCmdSetDepthWriteEnable = 0;
|
|
|
20275 PFN_vkCmdSetDepthCompareOp vkCmdSetDepthCompareOp = 0;
|
|
|
20276 PFN_vkCmdSetDepthBoundsTestEnable vkCmdSetDepthBoundsTestEnable = 0;
|
|
|
20277 PFN_vkCmdSetStencilTestEnable vkCmdSetStencilTestEnable = 0;
|
|
|
20278 PFN_vkCmdSetStencilOp vkCmdSetStencilOp = 0;
|
|
|
20279 PFN_vkCmdSetRasterizerDiscardEnable vkCmdSetRasterizerDiscardEnable = 0;
|
|
|
20280 PFN_vkCmdSetDepthBiasEnable vkCmdSetDepthBiasEnable = 0;
|
|
|
20281 PFN_vkCmdSetPrimitiveRestartEnable vkCmdSetPrimitiveRestartEnable = 0;
|
|
|
20282
|
|
|
20283 //=== VK_VERSION_1_4 ===
|
|
|
20284 PFN_vkMapMemory2 vkMapMemory2 = 0;
|
|
|
20285 PFN_vkUnmapMemory2 vkUnmapMemory2 = 0;
|
|
|
20286 PFN_vkGetDeviceImageSubresourceLayout vkGetDeviceImageSubresourceLayout = 0;
|
|
|
20287 PFN_vkGetImageSubresourceLayout2 vkGetImageSubresourceLayout2 = 0;
|
|
|
20288 PFN_vkCopyMemoryToImage vkCopyMemoryToImage = 0;
|
|
|
20289 PFN_vkCopyImageToMemory vkCopyImageToMemory = 0;
|
|
|
20290 PFN_vkCopyImageToImage vkCopyImageToImage = 0;
|
|
|
20291 PFN_vkTransitionImageLayout vkTransitionImageLayout = 0;
|
|
|
20292 PFN_vkCmdPushDescriptorSet vkCmdPushDescriptorSet = 0;
|
|
|
20293 PFN_vkCmdPushDescriptorSetWithTemplate vkCmdPushDescriptorSetWithTemplate = 0;
|
|
|
20294 PFN_vkCmdBindDescriptorSets2 vkCmdBindDescriptorSets2 = 0;
|
|
|
20295 PFN_vkCmdPushConstants2 vkCmdPushConstants2 = 0;
|
|
|
20296 PFN_vkCmdPushDescriptorSet2 vkCmdPushDescriptorSet2 = 0;
|
|
|
20297 PFN_vkCmdPushDescriptorSetWithTemplate2 vkCmdPushDescriptorSetWithTemplate2 = 0;
|
|
|
20298 PFN_vkCmdSetLineStipple vkCmdSetLineStipple = 0;
|
|
|
20299 PFN_vkCmdBindIndexBuffer2 vkCmdBindIndexBuffer2 = 0;
|
|
|
20300 PFN_vkGetRenderingAreaGranularity vkGetRenderingAreaGranularity = 0;
|
|
|
20301 PFN_vkCmdSetRenderingAttachmentLocations vkCmdSetRenderingAttachmentLocations = 0;
|
|
|
20302 PFN_vkCmdSetRenderingInputAttachmentIndices vkCmdSetRenderingInputAttachmentIndices = 0;
|
|
|
20303
|
|
|
20304 //=== VK_KHR_surface ===
|
|
|
20305 PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR = 0;
|
|
|
20306 PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR = 0;
|
|
|
20307 PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceCapabilitiesKHR = 0;
|
|
|
20308 PFN_vkGetPhysicalDeviceSurfaceFormatsKHR vkGetPhysicalDeviceSurfaceFormatsKHR = 0;
|
|
|
20309 PFN_vkGetPhysicalDeviceSurfacePresentModesKHR vkGetPhysicalDeviceSurfacePresentModesKHR = 0;
|
|
|
20310
|
|
|
20311 //=== VK_KHR_swapchain ===
|
|
|
20312 PFN_vkCreateSwapchainKHR vkCreateSwapchainKHR = 0;
|
|
|
20313 PFN_vkDestroySwapchainKHR vkDestroySwapchainKHR = 0;
|
|
|
20314 PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR = 0;
|
|
|
20315 PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR = 0;
|
|
|
20316 PFN_vkQueuePresentKHR vkQueuePresentKHR = 0;
|
|
|
20317 PFN_vkGetDeviceGroupPresentCapabilitiesKHR vkGetDeviceGroupPresentCapabilitiesKHR = 0;
|
|
|
20318 PFN_vkGetDeviceGroupSurfacePresentModesKHR vkGetDeviceGroupSurfacePresentModesKHR = 0;
|
|
|
20319 PFN_vkGetPhysicalDevicePresentRectanglesKHR vkGetPhysicalDevicePresentRectanglesKHR = 0;
|
|
|
20320 PFN_vkAcquireNextImage2KHR vkAcquireNextImage2KHR = 0;
|
|
|
20321
|
|
|
20322 //=== VK_KHR_display ===
|
|
|
20323 PFN_vkGetPhysicalDeviceDisplayPropertiesKHR vkGetPhysicalDeviceDisplayPropertiesKHR = 0;
|
|
|
20324 PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR vkGetPhysicalDeviceDisplayPlanePropertiesKHR = 0;
|
|
|
20325 PFN_vkGetDisplayPlaneSupportedDisplaysKHR vkGetDisplayPlaneSupportedDisplaysKHR = 0;
|
|
|
20326 PFN_vkGetDisplayModePropertiesKHR vkGetDisplayModePropertiesKHR = 0;
|
|
|
20327 PFN_vkCreateDisplayModeKHR vkCreateDisplayModeKHR = 0;
|
|
|
20328 PFN_vkGetDisplayPlaneCapabilitiesKHR vkGetDisplayPlaneCapabilitiesKHR = 0;
|
|
|
20329 PFN_vkCreateDisplayPlaneSurfaceKHR vkCreateDisplayPlaneSurfaceKHR = 0;
|
|
|
20330
|
|
|
20331 //=== VK_KHR_display_swapchain ===
|
|
|
20332 PFN_vkCreateSharedSwapchainsKHR vkCreateSharedSwapchainsKHR = 0;
|
|
|
20333
|
|
|
20334 #if defined( VK_USE_PLATFORM_XLIB_KHR )
|
|
|
20335 //=== VK_KHR_xlib_surface ===
|
|
|
20336 PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHR = 0;
|
|
|
20337 PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR vkGetPhysicalDeviceXlibPresentationSupportKHR = 0;
|
|
|
20338 #else
|
|
|
20339 PFN_dummy vkCreateXlibSurfaceKHR_placeholder = 0;
|
|
|
20340 PFN_dummy vkGetPhysicalDeviceXlibPresentationSupportKHR_placeholder = 0;
|
|
|
20341 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
|
|
|
20342
|
|
|
20343 #if defined( VK_USE_PLATFORM_XCB_KHR )
|
|
|
20344 //=== VK_KHR_xcb_surface ===
|
|
|
20345 PFN_vkCreateXcbSurfaceKHR vkCreateXcbSurfaceKHR = 0;
|
|
|
20346 PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR vkGetPhysicalDeviceXcbPresentationSupportKHR = 0;
|
|
|
20347 #else
|
|
|
20348 PFN_dummy vkCreateXcbSurfaceKHR_placeholder = 0;
|
|
|
20349 PFN_dummy vkGetPhysicalDeviceXcbPresentationSupportKHR_placeholder = 0;
|
|
|
20350 #endif /*VK_USE_PLATFORM_XCB_KHR*/
|
|
|
20351
|
|
|
20352 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )
|
|
|
20353 //=== VK_KHR_wayland_surface ===
|
|
|
20354 PFN_vkCreateWaylandSurfaceKHR vkCreateWaylandSurfaceKHR = 0;
|
|
|
20355 PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR vkGetPhysicalDeviceWaylandPresentationSupportKHR = 0;
|
|
|
20356 #else
|
|
|
20357 PFN_dummy vkCreateWaylandSurfaceKHR_placeholder = 0;
|
|
|
20358 PFN_dummy vkGetPhysicalDeviceWaylandPresentationSupportKHR_placeholder = 0;
|
|
|
20359 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
|
|
|
20360
|
|
|
20361 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
|
|
20362 //=== VK_KHR_android_surface ===
|
|
|
20363 PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR = 0;
|
|
|
20364 #else
|
|
|
20365 PFN_dummy vkCreateAndroidSurfaceKHR_placeholder = 0;
|
|
|
20366 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
|
|
20367
|
|
|
20368 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
20369 //=== VK_KHR_win32_surface ===
|
|
|
20370 PFN_vkCreateWin32SurfaceKHR vkCreateWin32SurfaceKHR = 0;
|
|
|
20371 PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR vkGetPhysicalDeviceWin32PresentationSupportKHR = 0;
|
|
|
20372 #else
|
|
|
20373 PFN_dummy vkCreateWin32SurfaceKHR_placeholder = 0;
|
|
|
20374 PFN_dummy vkGetPhysicalDeviceWin32PresentationSupportKHR_placeholder = 0;
|
|
|
20375 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
20376
|
|
|
20377 //=== VK_EXT_debug_report ===
|
|
|
20378 PFN_vkCreateDebugReportCallbackEXT vkCreateDebugReportCallbackEXT = 0;
|
|
|
20379 PFN_vkDestroyDebugReportCallbackEXT vkDestroyDebugReportCallbackEXT = 0;
|
|
|
20380 PFN_vkDebugReportMessageEXT vkDebugReportMessageEXT = 0;
|
|
|
20381
|
|
|
20382 //=== VK_EXT_debug_marker ===
|
|
|
20383 PFN_vkDebugMarkerSetObjectTagEXT vkDebugMarkerSetObjectTagEXT = 0;
|
|
|
20384 PFN_vkDebugMarkerSetObjectNameEXT vkDebugMarkerSetObjectNameEXT = 0;
|
|
|
20385 PFN_vkCmdDebugMarkerBeginEXT vkCmdDebugMarkerBeginEXT = 0;
|
|
|
20386 PFN_vkCmdDebugMarkerEndEXT vkCmdDebugMarkerEndEXT = 0;
|
|
|
20387 PFN_vkCmdDebugMarkerInsertEXT vkCmdDebugMarkerInsertEXT = 0;
|
|
|
20388
|
|
|
20389 //=== VK_KHR_video_queue ===
|
|
|
20390 PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR vkGetPhysicalDeviceVideoCapabilitiesKHR = 0;
|
|
|
20391 PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR vkGetPhysicalDeviceVideoFormatPropertiesKHR = 0;
|
|
|
20392 PFN_vkCreateVideoSessionKHR vkCreateVideoSessionKHR = 0;
|
|
|
20393 PFN_vkDestroyVideoSessionKHR vkDestroyVideoSessionKHR = 0;
|
|
|
20394 PFN_vkGetVideoSessionMemoryRequirementsKHR vkGetVideoSessionMemoryRequirementsKHR = 0;
|
|
|
20395 PFN_vkBindVideoSessionMemoryKHR vkBindVideoSessionMemoryKHR = 0;
|
|
|
20396 PFN_vkCreateVideoSessionParametersKHR vkCreateVideoSessionParametersKHR = 0;
|
|
|
20397 PFN_vkUpdateVideoSessionParametersKHR vkUpdateVideoSessionParametersKHR = 0;
|
|
|
20398 PFN_vkDestroyVideoSessionParametersKHR vkDestroyVideoSessionParametersKHR = 0;
|
|
|
20399 PFN_vkCmdBeginVideoCodingKHR vkCmdBeginVideoCodingKHR = 0;
|
|
|
20400 PFN_vkCmdEndVideoCodingKHR vkCmdEndVideoCodingKHR = 0;
|
|
|
20401 PFN_vkCmdControlVideoCodingKHR vkCmdControlVideoCodingKHR = 0;
|
|
|
20402
|
|
|
20403 //=== VK_KHR_video_decode_queue ===
|
|
|
20404 PFN_vkCmdDecodeVideoKHR vkCmdDecodeVideoKHR = 0;
|
|
|
20405
|
|
|
20406 //=== VK_EXT_transform_feedback ===
|
|
|
20407 PFN_vkCmdBindTransformFeedbackBuffersEXT vkCmdBindTransformFeedbackBuffersEXT = 0;
|
|
|
20408 PFN_vkCmdBeginTransformFeedbackEXT vkCmdBeginTransformFeedbackEXT = 0;
|
|
|
20409 PFN_vkCmdEndTransformFeedbackEXT vkCmdEndTransformFeedbackEXT = 0;
|
|
|
20410 PFN_vkCmdBeginQueryIndexedEXT vkCmdBeginQueryIndexedEXT = 0;
|
|
|
20411 PFN_vkCmdEndQueryIndexedEXT vkCmdEndQueryIndexedEXT = 0;
|
|
|
20412 PFN_vkCmdDrawIndirectByteCountEXT vkCmdDrawIndirectByteCountEXT = 0;
|
|
|
20413
|
|
|
20414 //=== VK_NVX_binary_import ===
|
|
|
20415 PFN_vkCreateCuModuleNVX vkCreateCuModuleNVX = 0;
|
|
|
20416 PFN_vkCreateCuFunctionNVX vkCreateCuFunctionNVX = 0;
|
|
|
20417 PFN_vkDestroyCuModuleNVX vkDestroyCuModuleNVX = 0;
|
|
|
20418 PFN_vkDestroyCuFunctionNVX vkDestroyCuFunctionNVX = 0;
|
|
|
20419 PFN_vkCmdCuLaunchKernelNVX vkCmdCuLaunchKernelNVX = 0;
|
|
|
20420
|
|
|
20421 //=== VK_NVX_image_view_handle ===
|
|
|
20422 PFN_vkGetImageViewHandleNVX vkGetImageViewHandleNVX = 0;
|
|
|
20423 PFN_vkGetImageViewHandle64NVX vkGetImageViewHandle64NVX = 0;
|
|
|
20424 PFN_vkGetImageViewAddressNVX vkGetImageViewAddressNVX = 0;
|
|
|
20425
|
|
|
20426 //=== VK_AMD_draw_indirect_count ===
|
|
|
20427 PFN_vkCmdDrawIndirectCountAMD vkCmdDrawIndirectCountAMD = 0;
|
|
|
20428 PFN_vkCmdDrawIndexedIndirectCountAMD vkCmdDrawIndexedIndirectCountAMD = 0;
|
|
|
20429
|
|
|
20430 //=== VK_AMD_shader_info ===
|
|
|
20431 PFN_vkGetShaderInfoAMD vkGetShaderInfoAMD = 0;
|
|
|
20432
|
|
|
20433 //=== VK_KHR_dynamic_rendering ===
|
|
|
20434 PFN_vkCmdBeginRenderingKHR vkCmdBeginRenderingKHR = 0;
|
|
|
20435 PFN_vkCmdEndRenderingKHR vkCmdEndRenderingKHR = 0;
|
|
|
20436
|
|
|
20437 #if defined( VK_USE_PLATFORM_GGP )
|
|
|
20438 //=== VK_GGP_stream_descriptor_surface ===
|
|
|
20439 PFN_vkCreateStreamDescriptorSurfaceGGP vkCreateStreamDescriptorSurfaceGGP = 0;
|
|
|
20440 #else
|
|
|
20441 PFN_dummy vkCreateStreamDescriptorSurfaceGGP_placeholder = 0;
|
|
|
20442 #endif /*VK_USE_PLATFORM_GGP*/
|
|
|
20443
|
|
|
20444 //=== VK_NV_external_memory_capabilities ===
|
|
|
20445 PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV vkGetPhysicalDeviceExternalImageFormatPropertiesNV = 0;
|
|
|
20446
|
|
|
20447 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
20448 //=== VK_NV_external_memory_win32 ===
|
|
|
20449 PFN_vkGetMemoryWin32HandleNV vkGetMemoryWin32HandleNV = 0;
|
|
|
20450 #else
|
|
|
20451 PFN_dummy vkGetMemoryWin32HandleNV_placeholder = 0;
|
|
|
20452 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
20453
|
|
|
20454 //=== VK_KHR_get_physical_device_properties2 ===
|
|
|
20455 PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR = 0;
|
|
|
20456 PFN_vkGetPhysicalDeviceProperties2KHR vkGetPhysicalDeviceProperties2KHR = 0;
|
|
|
20457 PFN_vkGetPhysicalDeviceFormatProperties2KHR vkGetPhysicalDeviceFormatProperties2KHR = 0;
|
|
|
20458 PFN_vkGetPhysicalDeviceImageFormatProperties2KHR vkGetPhysicalDeviceImageFormatProperties2KHR = 0;
|
|
|
20459 PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR vkGetPhysicalDeviceQueueFamilyProperties2KHR = 0;
|
|
|
20460 PFN_vkGetPhysicalDeviceMemoryProperties2KHR vkGetPhysicalDeviceMemoryProperties2KHR = 0;
|
|
|
20461 PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR vkGetPhysicalDeviceSparseImageFormatProperties2KHR = 0;
|
|
|
20462
|
|
|
20463 //=== VK_KHR_device_group ===
|
|
|
20464 PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR vkGetDeviceGroupPeerMemoryFeaturesKHR = 0;
|
|
|
20465 PFN_vkCmdSetDeviceMaskKHR vkCmdSetDeviceMaskKHR = 0;
|
|
|
20466 PFN_vkCmdDispatchBaseKHR vkCmdDispatchBaseKHR = 0;
|
|
|
20467
|
|
|
20468 #if defined( VK_USE_PLATFORM_VI_NN )
|
|
|
20469 //=== VK_NN_vi_surface ===
|
|
|
20470 PFN_vkCreateViSurfaceNN vkCreateViSurfaceNN = 0;
|
|
|
20471 #else
|
|
|
20472 PFN_dummy vkCreateViSurfaceNN_placeholder = 0;
|
|
|
20473 #endif /*VK_USE_PLATFORM_VI_NN*/
|
|
|
20474
|
|
|
20475 //=== VK_KHR_maintenance1 ===
|
|
|
20476 PFN_vkTrimCommandPoolKHR vkTrimCommandPoolKHR = 0;
|
|
|
20477
|
|
|
20478 //=== VK_KHR_device_group_creation ===
|
|
|
20479 PFN_vkEnumeratePhysicalDeviceGroupsKHR vkEnumeratePhysicalDeviceGroupsKHR = 0;
|
|
|
20480
|
|
|
20481 //=== VK_KHR_external_memory_capabilities ===
|
|
|
20482 PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR vkGetPhysicalDeviceExternalBufferPropertiesKHR = 0;
|
|
|
20483
|
|
|
20484 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
20485 //=== VK_KHR_external_memory_win32 ===
|
|
|
20486 PFN_vkGetMemoryWin32HandleKHR vkGetMemoryWin32HandleKHR = 0;
|
|
|
20487 PFN_vkGetMemoryWin32HandlePropertiesKHR vkGetMemoryWin32HandlePropertiesKHR = 0;
|
|
|
20488 #else
|
|
|
20489 PFN_dummy vkGetMemoryWin32HandleKHR_placeholder = 0;
|
|
|
20490 PFN_dummy vkGetMemoryWin32HandlePropertiesKHR_placeholder = 0;
|
|
|
20491 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
20492
|
|
|
20493 //=== VK_KHR_external_memory_fd ===
|
|
|
20494 PFN_vkGetMemoryFdKHR vkGetMemoryFdKHR = 0;
|
|
|
20495 PFN_vkGetMemoryFdPropertiesKHR vkGetMemoryFdPropertiesKHR = 0;
|
|
|
20496
|
|
|
20497 //=== VK_KHR_external_semaphore_capabilities ===
|
|
|
20498 PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = 0;
|
|
|
20499
|
|
|
20500 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
20501 //=== VK_KHR_external_semaphore_win32 ===
|
|
|
20502 PFN_vkImportSemaphoreWin32HandleKHR vkImportSemaphoreWin32HandleKHR = 0;
|
|
|
20503 PFN_vkGetSemaphoreWin32HandleKHR vkGetSemaphoreWin32HandleKHR = 0;
|
|
|
20504 #else
|
|
|
20505 PFN_dummy vkImportSemaphoreWin32HandleKHR_placeholder = 0;
|
|
|
20506 PFN_dummy vkGetSemaphoreWin32HandleKHR_placeholder = 0;
|
|
|
20507 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
20508
|
|
|
20509 //=== VK_KHR_external_semaphore_fd ===
|
|
|
20510 PFN_vkImportSemaphoreFdKHR vkImportSemaphoreFdKHR = 0;
|
|
|
20511 PFN_vkGetSemaphoreFdKHR vkGetSemaphoreFdKHR = 0;
|
|
|
20512
|
|
|
20513 //=== VK_KHR_push_descriptor ===
|
|
|
20514 PFN_vkCmdPushDescriptorSetKHR vkCmdPushDescriptorSetKHR = 0;
|
|
|
20515 PFN_vkCmdPushDescriptorSetWithTemplateKHR vkCmdPushDescriptorSetWithTemplateKHR = 0;
|
|
|
20516
|
|
|
20517 //=== VK_EXT_conditional_rendering ===
|
|
|
20518 PFN_vkCmdBeginConditionalRenderingEXT vkCmdBeginConditionalRenderingEXT = 0;
|
|
|
20519 PFN_vkCmdEndConditionalRenderingEXT vkCmdEndConditionalRenderingEXT = 0;
|
|
|
20520
|
|
|
20521 //=== VK_KHR_descriptor_update_template ===
|
|
|
20522 PFN_vkCreateDescriptorUpdateTemplateKHR vkCreateDescriptorUpdateTemplateKHR = 0;
|
|
|
20523 PFN_vkDestroyDescriptorUpdateTemplateKHR vkDestroyDescriptorUpdateTemplateKHR = 0;
|
|
|
20524 PFN_vkUpdateDescriptorSetWithTemplateKHR vkUpdateDescriptorSetWithTemplateKHR = 0;
|
|
|
20525
|
|
|
20526 //=== VK_NV_clip_space_w_scaling ===
|
|
|
20527 PFN_vkCmdSetViewportWScalingNV vkCmdSetViewportWScalingNV = 0;
|
|
|
20528
|
|
|
20529 //=== VK_EXT_direct_mode_display ===
|
|
|
20530 PFN_vkReleaseDisplayEXT vkReleaseDisplayEXT = 0;
|
|
|
20531
|
|
|
20532 #if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
|
|
|
20533 //=== VK_EXT_acquire_xlib_display ===
|
|
|
20534 PFN_vkAcquireXlibDisplayEXT vkAcquireXlibDisplayEXT = 0;
|
|
|
20535 PFN_vkGetRandROutputDisplayEXT vkGetRandROutputDisplayEXT = 0;
|
|
|
20536 #else
|
|
|
20537 PFN_dummy vkAcquireXlibDisplayEXT_placeholder = 0;
|
|
|
20538 PFN_dummy vkGetRandROutputDisplayEXT_placeholder = 0;
|
|
|
20539 #endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
|
|
|
20540
|
|
|
20541 //=== VK_EXT_display_surface_counter ===
|
|
|
20542 PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT vkGetPhysicalDeviceSurfaceCapabilities2EXT = 0;
|
|
|
20543
|
|
|
20544 //=== VK_EXT_display_control ===
|
|
|
20545 PFN_vkDisplayPowerControlEXT vkDisplayPowerControlEXT = 0;
|
|
|
20546 PFN_vkRegisterDeviceEventEXT vkRegisterDeviceEventEXT = 0;
|
|
|
20547 PFN_vkRegisterDisplayEventEXT vkRegisterDisplayEventEXT = 0;
|
|
|
20548 PFN_vkGetSwapchainCounterEXT vkGetSwapchainCounterEXT = 0;
|
|
|
20549
|
|
|
20550 //=== VK_GOOGLE_display_timing ===
|
|
|
20551 PFN_vkGetRefreshCycleDurationGOOGLE vkGetRefreshCycleDurationGOOGLE = 0;
|
|
|
20552 PFN_vkGetPastPresentationTimingGOOGLE vkGetPastPresentationTimingGOOGLE = 0;
|
|
|
20553
|
|
|
20554 //=== VK_EXT_discard_rectangles ===
|
|
|
20555 PFN_vkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXT = 0;
|
|
|
20556 PFN_vkCmdSetDiscardRectangleEnableEXT vkCmdSetDiscardRectangleEnableEXT = 0;
|
|
|
20557 PFN_vkCmdSetDiscardRectangleModeEXT vkCmdSetDiscardRectangleModeEXT = 0;
|
|
|
20558
|
|
|
20559 //=== VK_EXT_hdr_metadata ===
|
|
|
20560 PFN_vkSetHdrMetadataEXT vkSetHdrMetadataEXT = 0;
|
|
|
20561
|
|
|
20562 //=== VK_KHR_create_renderpass2 ===
|
|
|
20563 PFN_vkCreateRenderPass2KHR vkCreateRenderPass2KHR = 0;
|
|
|
20564 PFN_vkCmdBeginRenderPass2KHR vkCmdBeginRenderPass2KHR = 0;
|
|
|
20565 PFN_vkCmdNextSubpass2KHR vkCmdNextSubpass2KHR = 0;
|
|
|
20566 PFN_vkCmdEndRenderPass2KHR vkCmdEndRenderPass2KHR = 0;
|
|
|
20567
|
|
|
20568 //=== VK_KHR_shared_presentable_image ===
|
|
|
20569 PFN_vkGetSwapchainStatusKHR vkGetSwapchainStatusKHR = 0;
|
|
|
20570
|
|
|
20571 //=== VK_KHR_external_fence_capabilities ===
|
|
|
20572 PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR vkGetPhysicalDeviceExternalFencePropertiesKHR = 0;
|
|
|
20573
|
|
|
20574 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
20575 //=== VK_KHR_external_fence_win32 ===
|
|
|
20576 PFN_vkImportFenceWin32HandleKHR vkImportFenceWin32HandleKHR = 0;
|
|
|
20577 PFN_vkGetFenceWin32HandleKHR vkGetFenceWin32HandleKHR = 0;
|
|
|
20578 #else
|
|
|
20579 PFN_dummy vkImportFenceWin32HandleKHR_placeholder = 0;
|
|
|
20580 PFN_dummy vkGetFenceWin32HandleKHR_placeholder = 0;
|
|
|
20581 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
20582
|
|
|
20583 //=== VK_KHR_external_fence_fd ===
|
|
|
20584 PFN_vkImportFenceFdKHR vkImportFenceFdKHR = 0;
|
|
|
20585 PFN_vkGetFenceFdKHR vkGetFenceFdKHR = 0;
|
|
|
20586
|
|
|
20587 //=== VK_KHR_performance_query ===
|
|
|
20588 PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = 0;
|
|
|
20589 PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = 0;
|
|
|
20590 PFN_vkAcquireProfilingLockKHR vkAcquireProfilingLockKHR = 0;
|
|
|
20591 PFN_vkReleaseProfilingLockKHR vkReleaseProfilingLockKHR = 0;
|
|
|
20592
|
|
|
20593 //=== VK_KHR_get_surface_capabilities2 ===
|
|
|
20594 PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR vkGetPhysicalDeviceSurfaceCapabilities2KHR = 0;
|
|
|
20595 PFN_vkGetPhysicalDeviceSurfaceFormats2KHR vkGetPhysicalDeviceSurfaceFormats2KHR = 0;
|
|
|
20596
|
|
|
20597 //=== VK_KHR_get_display_properties2 ===
|
|
|
20598 PFN_vkGetPhysicalDeviceDisplayProperties2KHR vkGetPhysicalDeviceDisplayProperties2KHR = 0;
|
|
|
20599 PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR vkGetPhysicalDeviceDisplayPlaneProperties2KHR = 0;
|
|
|
20600 PFN_vkGetDisplayModeProperties2KHR vkGetDisplayModeProperties2KHR = 0;
|
|
|
20601 PFN_vkGetDisplayPlaneCapabilities2KHR vkGetDisplayPlaneCapabilities2KHR = 0;
|
|
|
20602
|
|
|
20603 #if defined( VK_USE_PLATFORM_IOS_MVK )
|
|
|
20604 //=== VK_MVK_ios_surface ===
|
|
|
20605 PFN_vkCreateIOSSurfaceMVK vkCreateIOSSurfaceMVK = 0;
|
|
|
20606 #else
|
|
|
20607 PFN_dummy vkCreateIOSSurfaceMVK_placeholder = 0;
|
|
|
20608 #endif /*VK_USE_PLATFORM_IOS_MVK*/
|
|
|
20609
|
|
|
20610 #if defined( VK_USE_PLATFORM_MACOS_MVK )
|
|
|
20611 //=== VK_MVK_macos_surface ===
|
|
|
20612 PFN_vkCreateMacOSSurfaceMVK vkCreateMacOSSurfaceMVK = 0;
|
|
|
20613 #else
|
|
|
20614 PFN_dummy vkCreateMacOSSurfaceMVK_placeholder = 0;
|
|
|
20615 #endif /*VK_USE_PLATFORM_MACOS_MVK*/
|
|
|
20616
|
|
|
20617 //=== VK_EXT_debug_utils ===
|
|
|
20618 PFN_vkSetDebugUtilsObjectNameEXT vkSetDebugUtilsObjectNameEXT = 0;
|
|
|
20619 PFN_vkSetDebugUtilsObjectTagEXT vkSetDebugUtilsObjectTagEXT = 0;
|
|
|
20620 PFN_vkQueueBeginDebugUtilsLabelEXT vkQueueBeginDebugUtilsLabelEXT = 0;
|
|
|
20621 PFN_vkQueueEndDebugUtilsLabelEXT vkQueueEndDebugUtilsLabelEXT = 0;
|
|
|
20622 PFN_vkQueueInsertDebugUtilsLabelEXT vkQueueInsertDebugUtilsLabelEXT = 0;
|
|
|
20623 PFN_vkCmdBeginDebugUtilsLabelEXT vkCmdBeginDebugUtilsLabelEXT = 0;
|
|
|
20624 PFN_vkCmdEndDebugUtilsLabelEXT vkCmdEndDebugUtilsLabelEXT = 0;
|
|
|
20625 PFN_vkCmdInsertDebugUtilsLabelEXT vkCmdInsertDebugUtilsLabelEXT = 0;
|
|
|
20626 PFN_vkCreateDebugUtilsMessengerEXT vkCreateDebugUtilsMessengerEXT = 0;
|
|
|
20627 PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT = 0;
|
|
|
20628 PFN_vkSubmitDebugUtilsMessageEXT vkSubmitDebugUtilsMessageEXT = 0;
|
|
|
20629
|
|
|
20630 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
|
|
20631 //=== VK_ANDROID_external_memory_android_hardware_buffer ===
|
|
|
20632 PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID = 0;
|
|
|
20633 PFN_vkGetMemoryAndroidHardwareBufferANDROID vkGetMemoryAndroidHardwareBufferANDROID = 0;
|
|
|
20634 #else
|
|
|
20635 PFN_dummy vkGetAndroidHardwareBufferPropertiesANDROID_placeholder = 0;
|
|
|
20636 PFN_dummy vkGetMemoryAndroidHardwareBufferANDROID_placeholder = 0;
|
|
|
20637 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
|
|
20638
|
|
|
20639 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
20640 //=== VK_AMDX_shader_enqueue ===
|
|
|
20641 PFN_vkCreateExecutionGraphPipelinesAMDX vkCreateExecutionGraphPipelinesAMDX = 0;
|
|
|
20642 PFN_vkGetExecutionGraphPipelineScratchSizeAMDX vkGetExecutionGraphPipelineScratchSizeAMDX = 0;
|
|
|
20643 PFN_vkGetExecutionGraphPipelineNodeIndexAMDX vkGetExecutionGraphPipelineNodeIndexAMDX = 0;
|
|
|
20644 PFN_vkCmdInitializeGraphScratchMemoryAMDX vkCmdInitializeGraphScratchMemoryAMDX = 0;
|
|
|
20645 PFN_vkCmdDispatchGraphAMDX vkCmdDispatchGraphAMDX = 0;
|
|
|
20646 PFN_vkCmdDispatchGraphIndirectAMDX vkCmdDispatchGraphIndirectAMDX = 0;
|
|
|
20647 PFN_vkCmdDispatchGraphIndirectCountAMDX vkCmdDispatchGraphIndirectCountAMDX = 0;
|
|
|
20648 #else
|
|
|
20649 PFN_dummy vkCreateExecutionGraphPipelinesAMDX_placeholder = 0;
|
|
|
20650 PFN_dummy vkGetExecutionGraphPipelineScratchSizeAMDX_placeholder = 0;
|
|
|
20651 PFN_dummy vkGetExecutionGraphPipelineNodeIndexAMDX_placeholder = 0;
|
|
|
20652 PFN_dummy vkCmdInitializeGraphScratchMemoryAMDX_placeholder = 0;
|
|
|
20653 PFN_dummy vkCmdDispatchGraphAMDX_placeholder = 0;
|
|
|
20654 PFN_dummy vkCmdDispatchGraphIndirectAMDX_placeholder = 0;
|
|
|
20655 PFN_dummy vkCmdDispatchGraphIndirectCountAMDX_placeholder = 0;
|
|
|
20656 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
20657
|
|
|
20658 //=== VK_EXT_sample_locations ===
|
|
|
20659 PFN_vkCmdSetSampleLocationsEXT vkCmdSetSampleLocationsEXT = 0;
|
|
|
20660 PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT vkGetPhysicalDeviceMultisamplePropertiesEXT = 0;
|
|
|
20661
|
|
|
20662 //=== VK_KHR_get_memory_requirements2 ===
|
|
|
20663 PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR = 0;
|
|
|
20664 PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR = 0;
|
|
|
20665 PFN_vkGetImageSparseMemoryRequirements2KHR vkGetImageSparseMemoryRequirements2KHR = 0;
|
|
|
20666
|
|
|
20667 //=== VK_KHR_acceleration_structure ===
|
|
|
20668 PFN_vkCreateAccelerationStructureKHR vkCreateAccelerationStructureKHR = 0;
|
|
|
20669 PFN_vkDestroyAccelerationStructureKHR vkDestroyAccelerationStructureKHR = 0;
|
|
|
20670 PFN_vkCmdBuildAccelerationStructuresKHR vkCmdBuildAccelerationStructuresKHR = 0;
|
|
|
20671 PFN_vkCmdBuildAccelerationStructuresIndirectKHR vkCmdBuildAccelerationStructuresIndirectKHR = 0;
|
|
|
20672 PFN_vkBuildAccelerationStructuresKHR vkBuildAccelerationStructuresKHR = 0;
|
|
|
20673 PFN_vkCopyAccelerationStructureKHR vkCopyAccelerationStructureKHR = 0;
|
|
|
20674 PFN_vkCopyAccelerationStructureToMemoryKHR vkCopyAccelerationStructureToMemoryKHR = 0;
|
|
|
20675 PFN_vkCopyMemoryToAccelerationStructureKHR vkCopyMemoryToAccelerationStructureKHR = 0;
|
|
|
20676 PFN_vkWriteAccelerationStructuresPropertiesKHR vkWriteAccelerationStructuresPropertiesKHR = 0;
|
|
|
20677 PFN_vkCmdCopyAccelerationStructureKHR vkCmdCopyAccelerationStructureKHR = 0;
|
|
|
20678 PFN_vkCmdCopyAccelerationStructureToMemoryKHR vkCmdCopyAccelerationStructureToMemoryKHR = 0;
|
|
|
20679 PFN_vkCmdCopyMemoryToAccelerationStructureKHR vkCmdCopyMemoryToAccelerationStructureKHR = 0;
|
|
|
20680 PFN_vkGetAccelerationStructureDeviceAddressKHR vkGetAccelerationStructureDeviceAddressKHR = 0;
|
|
|
20681 PFN_vkCmdWriteAccelerationStructuresPropertiesKHR vkCmdWriteAccelerationStructuresPropertiesKHR = 0;
|
|
|
20682 PFN_vkGetDeviceAccelerationStructureCompatibilityKHR vkGetDeviceAccelerationStructureCompatibilityKHR = 0;
|
|
|
20683 PFN_vkGetAccelerationStructureBuildSizesKHR vkGetAccelerationStructureBuildSizesKHR = 0;
|
|
|
20684
|
|
|
20685 //=== VK_KHR_ray_tracing_pipeline ===
|
|
|
20686 PFN_vkCmdTraceRaysKHR vkCmdTraceRaysKHR = 0;
|
|
|
20687 PFN_vkCreateRayTracingPipelinesKHR vkCreateRayTracingPipelinesKHR = 0;
|
|
|
20688 PFN_vkGetRayTracingShaderGroupHandlesKHR vkGetRayTracingShaderGroupHandlesKHR = 0;
|
|
|
20689 PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = 0;
|
|
|
20690 PFN_vkCmdTraceRaysIndirectKHR vkCmdTraceRaysIndirectKHR = 0;
|
|
|
20691 PFN_vkGetRayTracingShaderGroupStackSizeKHR vkGetRayTracingShaderGroupStackSizeKHR = 0;
|
|
|
20692 PFN_vkCmdSetRayTracingPipelineStackSizeKHR vkCmdSetRayTracingPipelineStackSizeKHR = 0;
|
|
|
20693
|
|
|
20694 //=== VK_KHR_sampler_ycbcr_conversion ===
|
|
|
20695 PFN_vkCreateSamplerYcbcrConversionKHR vkCreateSamplerYcbcrConversionKHR = 0;
|
|
|
20696 PFN_vkDestroySamplerYcbcrConversionKHR vkDestroySamplerYcbcrConversionKHR = 0;
|
|
|
20697
|
|
|
20698 //=== VK_KHR_bind_memory2 ===
|
|
|
20699 PFN_vkBindBufferMemory2KHR vkBindBufferMemory2KHR = 0;
|
|
|
20700 PFN_vkBindImageMemory2KHR vkBindImageMemory2KHR = 0;
|
|
|
20701
|
|
|
20702 //=== VK_EXT_image_drm_format_modifier ===
|
|
|
20703 PFN_vkGetImageDrmFormatModifierPropertiesEXT vkGetImageDrmFormatModifierPropertiesEXT = 0;
|
|
|
20704
|
|
|
20705 //=== VK_EXT_validation_cache ===
|
|
|
20706 PFN_vkCreateValidationCacheEXT vkCreateValidationCacheEXT = 0;
|
|
|
20707 PFN_vkDestroyValidationCacheEXT vkDestroyValidationCacheEXT = 0;
|
|
|
20708 PFN_vkMergeValidationCachesEXT vkMergeValidationCachesEXT = 0;
|
|
|
20709 PFN_vkGetValidationCacheDataEXT vkGetValidationCacheDataEXT = 0;
|
|
|
20710
|
|
|
20711 //=== VK_NV_shading_rate_image ===
|
|
|
20712 PFN_vkCmdBindShadingRateImageNV vkCmdBindShadingRateImageNV = 0;
|
|
|
20713 PFN_vkCmdSetViewportShadingRatePaletteNV vkCmdSetViewportShadingRatePaletteNV = 0;
|
|
|
20714 PFN_vkCmdSetCoarseSampleOrderNV vkCmdSetCoarseSampleOrderNV = 0;
|
|
|
20715
|
|
|
20716 //=== VK_NV_ray_tracing ===
|
|
|
20717 PFN_vkCreateAccelerationStructureNV vkCreateAccelerationStructureNV = 0;
|
|
|
20718 PFN_vkDestroyAccelerationStructureNV vkDestroyAccelerationStructureNV = 0;
|
|
|
20719 PFN_vkGetAccelerationStructureMemoryRequirementsNV vkGetAccelerationStructureMemoryRequirementsNV = 0;
|
|
|
20720 PFN_vkBindAccelerationStructureMemoryNV vkBindAccelerationStructureMemoryNV = 0;
|
|
|
20721 PFN_vkCmdBuildAccelerationStructureNV vkCmdBuildAccelerationStructureNV = 0;
|
|
|
20722 PFN_vkCmdCopyAccelerationStructureNV vkCmdCopyAccelerationStructureNV = 0;
|
|
|
20723 PFN_vkCmdTraceRaysNV vkCmdTraceRaysNV = 0;
|
|
|
20724 PFN_vkCreateRayTracingPipelinesNV vkCreateRayTracingPipelinesNV = 0;
|
|
|
20725 PFN_vkGetRayTracingShaderGroupHandlesNV vkGetRayTracingShaderGroupHandlesNV = 0;
|
|
|
20726 PFN_vkGetAccelerationStructureHandleNV vkGetAccelerationStructureHandleNV = 0;
|
|
|
20727 PFN_vkCmdWriteAccelerationStructuresPropertiesNV vkCmdWriteAccelerationStructuresPropertiesNV = 0;
|
|
|
20728 PFN_vkCompileDeferredNV vkCompileDeferredNV = 0;
|
|
|
20729
|
|
|
20730 //=== VK_KHR_maintenance3 ===
|
|
|
20731 PFN_vkGetDescriptorSetLayoutSupportKHR vkGetDescriptorSetLayoutSupportKHR = 0;
|
|
|
20732
|
|
|
20733 //=== VK_KHR_draw_indirect_count ===
|
|
|
20734 PFN_vkCmdDrawIndirectCountKHR vkCmdDrawIndirectCountKHR = 0;
|
|
|
20735 PFN_vkCmdDrawIndexedIndirectCountKHR vkCmdDrawIndexedIndirectCountKHR = 0;
|
|
|
20736
|
|
|
20737 //=== VK_EXT_external_memory_host ===
|
|
|
20738 PFN_vkGetMemoryHostPointerPropertiesEXT vkGetMemoryHostPointerPropertiesEXT = 0;
|
|
|
20739
|
|
|
20740 //=== VK_AMD_buffer_marker ===
|
|
|
20741 PFN_vkCmdWriteBufferMarkerAMD vkCmdWriteBufferMarkerAMD = 0;
|
|
|
20742 PFN_vkCmdWriteBufferMarker2AMD vkCmdWriteBufferMarker2AMD = 0;
|
|
|
20743
|
|
|
20744 //=== VK_EXT_calibrated_timestamps ===
|
|
|
20745 PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = 0;
|
|
|
20746 PFN_vkGetCalibratedTimestampsEXT vkGetCalibratedTimestampsEXT = 0;
|
|
|
20747
|
|
|
20748 //=== VK_NV_mesh_shader ===
|
|
|
20749 PFN_vkCmdDrawMeshTasksNV vkCmdDrawMeshTasksNV = 0;
|
|
|
20750 PFN_vkCmdDrawMeshTasksIndirectNV vkCmdDrawMeshTasksIndirectNV = 0;
|
|
|
20751 PFN_vkCmdDrawMeshTasksIndirectCountNV vkCmdDrawMeshTasksIndirectCountNV = 0;
|
|
|
20752
|
|
|
20753 //=== VK_NV_scissor_exclusive ===
|
|
|
20754 PFN_vkCmdSetExclusiveScissorEnableNV vkCmdSetExclusiveScissorEnableNV = 0;
|
|
|
20755 PFN_vkCmdSetExclusiveScissorNV vkCmdSetExclusiveScissorNV = 0;
|
|
|
20756
|
|
|
20757 //=== VK_NV_device_diagnostic_checkpoints ===
|
|
|
20758 PFN_vkCmdSetCheckpointNV vkCmdSetCheckpointNV = 0;
|
|
|
20759 PFN_vkGetQueueCheckpointDataNV vkGetQueueCheckpointDataNV = 0;
|
|
|
20760 PFN_vkGetQueueCheckpointData2NV vkGetQueueCheckpointData2NV = 0;
|
|
|
20761
|
|
|
20762 //=== VK_KHR_timeline_semaphore ===
|
|
|
20763 PFN_vkGetSemaphoreCounterValueKHR vkGetSemaphoreCounterValueKHR = 0;
|
|
|
20764 PFN_vkWaitSemaphoresKHR vkWaitSemaphoresKHR = 0;
|
|
|
20765 PFN_vkSignalSemaphoreKHR vkSignalSemaphoreKHR = 0;
|
|
|
20766
|
|
|
20767 //=== VK_INTEL_performance_query ===
|
|
|
20768 PFN_vkInitializePerformanceApiINTEL vkInitializePerformanceApiINTEL = 0;
|
|
|
20769 PFN_vkUninitializePerformanceApiINTEL vkUninitializePerformanceApiINTEL = 0;
|
|
|
20770 PFN_vkCmdSetPerformanceMarkerINTEL vkCmdSetPerformanceMarkerINTEL = 0;
|
|
|
20771 PFN_vkCmdSetPerformanceStreamMarkerINTEL vkCmdSetPerformanceStreamMarkerINTEL = 0;
|
|
|
20772 PFN_vkCmdSetPerformanceOverrideINTEL vkCmdSetPerformanceOverrideINTEL = 0;
|
|
|
20773 PFN_vkAcquirePerformanceConfigurationINTEL vkAcquirePerformanceConfigurationINTEL = 0;
|
|
|
20774 PFN_vkReleasePerformanceConfigurationINTEL vkReleasePerformanceConfigurationINTEL = 0;
|
|
|
20775 PFN_vkQueueSetPerformanceConfigurationINTEL vkQueueSetPerformanceConfigurationINTEL = 0;
|
|
|
20776 PFN_vkGetPerformanceParameterINTEL vkGetPerformanceParameterINTEL = 0;
|
|
|
20777
|
|
|
20778 //=== VK_AMD_display_native_hdr ===
|
|
|
20779 PFN_vkSetLocalDimmingAMD vkSetLocalDimmingAMD = 0;
|
|
|
20780
|
|
|
20781 #if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
|
20782 //=== VK_FUCHSIA_imagepipe_surface ===
|
|
|
20783 PFN_vkCreateImagePipeSurfaceFUCHSIA vkCreateImagePipeSurfaceFUCHSIA = 0;
|
|
|
20784 #else
|
|
|
20785 PFN_dummy vkCreateImagePipeSurfaceFUCHSIA_placeholder = 0;
|
|
|
20786 #endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
20787
|
|
|
20788 #if defined( VK_USE_PLATFORM_METAL_EXT )
|
|
|
20789 //=== VK_EXT_metal_surface ===
|
|
|
20790 PFN_vkCreateMetalSurfaceEXT vkCreateMetalSurfaceEXT = 0;
|
|
|
20791 #else
|
|
|
20792 PFN_dummy vkCreateMetalSurfaceEXT_placeholder = 0;
|
|
|
20793 #endif /*VK_USE_PLATFORM_METAL_EXT*/
|
|
|
20794
|
|
|
20795 //=== VK_KHR_fragment_shading_rate ===
|
|
|
20796 PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR vkGetPhysicalDeviceFragmentShadingRatesKHR = 0;
|
|
|
20797 PFN_vkCmdSetFragmentShadingRateKHR vkCmdSetFragmentShadingRateKHR = 0;
|
|
|
20798
|
|
|
20799 //=== VK_KHR_dynamic_rendering_local_read ===
|
|
|
20800 PFN_vkCmdSetRenderingAttachmentLocationsKHR vkCmdSetRenderingAttachmentLocationsKHR = 0;
|
|
|
20801 PFN_vkCmdSetRenderingInputAttachmentIndicesKHR vkCmdSetRenderingInputAttachmentIndicesKHR = 0;
|
|
|
20802
|
|
|
20803 //=== VK_EXT_buffer_device_address ===
|
|
|
20804 PFN_vkGetBufferDeviceAddressEXT vkGetBufferDeviceAddressEXT = 0;
|
|
|
20805
|
|
|
20806 //=== VK_EXT_tooling_info ===
|
|
|
20807 PFN_vkGetPhysicalDeviceToolPropertiesEXT vkGetPhysicalDeviceToolPropertiesEXT = 0;
|
|
|
20808
|
|
|
20809 //=== VK_KHR_present_wait ===
|
|
|
20810 PFN_vkWaitForPresentKHR vkWaitForPresentKHR = 0;
|
|
|
20811
|
|
|
20812 //=== VK_NV_cooperative_matrix ===
|
|
|
20813 PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = 0;
|
|
|
20814
|
|
|
20815 //=== VK_NV_coverage_reduction_mode ===
|
|
|
20816 PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = 0;
|
|
|
20817
|
|
|
20818 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
20819 //=== VK_EXT_full_screen_exclusive ===
|
|
|
20820 PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT vkGetPhysicalDeviceSurfacePresentModes2EXT = 0;
|
|
|
20821 PFN_vkAcquireFullScreenExclusiveModeEXT vkAcquireFullScreenExclusiveModeEXT = 0;
|
|
|
20822 PFN_vkReleaseFullScreenExclusiveModeEXT vkReleaseFullScreenExclusiveModeEXT = 0;
|
|
|
20823 PFN_vkGetDeviceGroupSurfacePresentModes2EXT vkGetDeviceGroupSurfacePresentModes2EXT = 0;
|
|
|
20824 #else
|
|
|
20825 PFN_dummy vkGetPhysicalDeviceSurfacePresentModes2EXT_placeholder = 0;
|
|
|
20826 PFN_dummy vkAcquireFullScreenExclusiveModeEXT_placeholder = 0;
|
|
|
20827 PFN_dummy vkReleaseFullScreenExclusiveModeEXT_placeholder = 0;
|
|
|
20828 PFN_dummy vkGetDeviceGroupSurfacePresentModes2EXT_placeholder = 0;
|
|
|
20829 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
20830
|
|
|
20831 //=== VK_EXT_headless_surface ===
|
|
|
20832 PFN_vkCreateHeadlessSurfaceEXT vkCreateHeadlessSurfaceEXT = 0;
|
|
|
20833
|
|
|
20834 //=== VK_KHR_buffer_device_address ===
|
|
|
20835 PFN_vkGetBufferDeviceAddressKHR vkGetBufferDeviceAddressKHR = 0;
|
|
|
20836 PFN_vkGetBufferOpaqueCaptureAddressKHR vkGetBufferOpaqueCaptureAddressKHR = 0;
|
|
|
20837 PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR vkGetDeviceMemoryOpaqueCaptureAddressKHR = 0;
|
|
|
20838
|
|
|
20839 //=== VK_EXT_line_rasterization ===
|
|
|
20840 PFN_vkCmdSetLineStippleEXT vkCmdSetLineStippleEXT = 0;
|
|
|
20841
|
|
|
20842 //=== VK_EXT_host_query_reset ===
|
|
|
20843 PFN_vkResetQueryPoolEXT vkResetQueryPoolEXT = 0;
|
|
|
20844
|
|
|
20845 //=== VK_EXT_extended_dynamic_state ===
|
|
|
20846 PFN_vkCmdSetCullModeEXT vkCmdSetCullModeEXT = 0;
|
|
|
20847 PFN_vkCmdSetFrontFaceEXT vkCmdSetFrontFaceEXT = 0;
|
|
|
20848 PFN_vkCmdSetPrimitiveTopologyEXT vkCmdSetPrimitiveTopologyEXT = 0;
|
|
|
20849 PFN_vkCmdSetViewportWithCountEXT vkCmdSetViewportWithCountEXT = 0;
|
|
|
20850 PFN_vkCmdSetScissorWithCountEXT vkCmdSetScissorWithCountEXT = 0;
|
|
|
20851 PFN_vkCmdBindVertexBuffers2EXT vkCmdBindVertexBuffers2EXT = 0;
|
|
|
20852 PFN_vkCmdSetDepthTestEnableEXT vkCmdSetDepthTestEnableEXT = 0;
|
|
|
20853 PFN_vkCmdSetDepthWriteEnableEXT vkCmdSetDepthWriteEnableEXT = 0;
|
|
|
20854 PFN_vkCmdSetDepthCompareOpEXT vkCmdSetDepthCompareOpEXT = 0;
|
|
|
20855 PFN_vkCmdSetDepthBoundsTestEnableEXT vkCmdSetDepthBoundsTestEnableEXT = 0;
|
|
|
20856 PFN_vkCmdSetStencilTestEnableEXT vkCmdSetStencilTestEnableEXT = 0;
|
|
|
20857 PFN_vkCmdSetStencilOpEXT vkCmdSetStencilOpEXT = 0;
|
|
|
20858
|
|
|
20859 //=== VK_KHR_deferred_host_operations ===
|
|
|
20860 PFN_vkCreateDeferredOperationKHR vkCreateDeferredOperationKHR = 0;
|
|
|
20861 PFN_vkDestroyDeferredOperationKHR vkDestroyDeferredOperationKHR = 0;
|
|
|
20862 PFN_vkGetDeferredOperationMaxConcurrencyKHR vkGetDeferredOperationMaxConcurrencyKHR = 0;
|
|
|
20863 PFN_vkGetDeferredOperationResultKHR vkGetDeferredOperationResultKHR = 0;
|
|
|
20864 PFN_vkDeferredOperationJoinKHR vkDeferredOperationJoinKHR = 0;
|
|
|
20865
|
|
|
20866 //=== VK_KHR_pipeline_executable_properties ===
|
|
|
20867 PFN_vkGetPipelineExecutablePropertiesKHR vkGetPipelineExecutablePropertiesKHR = 0;
|
|
|
20868 PFN_vkGetPipelineExecutableStatisticsKHR vkGetPipelineExecutableStatisticsKHR = 0;
|
|
|
20869 PFN_vkGetPipelineExecutableInternalRepresentationsKHR vkGetPipelineExecutableInternalRepresentationsKHR = 0;
|
|
|
20870
|
|
|
20871 //=== VK_EXT_host_image_copy ===
|
|
|
20872 PFN_vkCopyMemoryToImageEXT vkCopyMemoryToImageEXT = 0;
|
|
|
20873 PFN_vkCopyImageToMemoryEXT vkCopyImageToMemoryEXT = 0;
|
|
|
20874 PFN_vkCopyImageToImageEXT vkCopyImageToImageEXT = 0;
|
|
|
20875 PFN_vkTransitionImageLayoutEXT vkTransitionImageLayoutEXT = 0;
|
|
|
20876 PFN_vkGetImageSubresourceLayout2EXT vkGetImageSubresourceLayout2EXT = 0;
|
|
|
20877
|
|
|
20878 //=== VK_KHR_map_memory2 ===
|
|
|
20879 PFN_vkMapMemory2KHR vkMapMemory2KHR = 0;
|
|
|
20880 PFN_vkUnmapMemory2KHR vkUnmapMemory2KHR = 0;
|
|
|
20881
|
|
|
20882 //=== VK_EXT_swapchain_maintenance1 ===
|
|
|
20883 PFN_vkReleaseSwapchainImagesEXT vkReleaseSwapchainImagesEXT = 0;
|
|
|
20884
|
|
|
20885 //=== VK_NV_device_generated_commands ===
|
|
|
20886 PFN_vkGetGeneratedCommandsMemoryRequirementsNV vkGetGeneratedCommandsMemoryRequirementsNV = 0;
|
|
|
20887 PFN_vkCmdPreprocessGeneratedCommandsNV vkCmdPreprocessGeneratedCommandsNV = 0;
|
|
|
20888 PFN_vkCmdExecuteGeneratedCommandsNV vkCmdExecuteGeneratedCommandsNV = 0;
|
|
|
20889 PFN_vkCmdBindPipelineShaderGroupNV vkCmdBindPipelineShaderGroupNV = 0;
|
|
|
20890 PFN_vkCreateIndirectCommandsLayoutNV vkCreateIndirectCommandsLayoutNV = 0;
|
|
|
20891 PFN_vkDestroyIndirectCommandsLayoutNV vkDestroyIndirectCommandsLayoutNV = 0;
|
|
|
20892
|
|
|
20893 //=== VK_EXT_depth_bias_control ===
|
|
|
20894 PFN_vkCmdSetDepthBias2EXT vkCmdSetDepthBias2EXT = 0;
|
|
|
20895
|
|
|
20896 //=== VK_EXT_acquire_drm_display ===
|
|
|
20897 PFN_vkAcquireDrmDisplayEXT vkAcquireDrmDisplayEXT = 0;
|
|
|
20898 PFN_vkGetDrmDisplayEXT vkGetDrmDisplayEXT = 0;
|
|
|
20899
|
|
|
20900 //=== VK_EXT_private_data ===
|
|
|
20901 PFN_vkCreatePrivateDataSlotEXT vkCreatePrivateDataSlotEXT = 0;
|
|
|
20902 PFN_vkDestroyPrivateDataSlotEXT vkDestroyPrivateDataSlotEXT = 0;
|
|
|
20903 PFN_vkSetPrivateDataEXT vkSetPrivateDataEXT = 0;
|
|
|
20904 PFN_vkGetPrivateDataEXT vkGetPrivateDataEXT = 0;
|
|
|
20905
|
|
|
20906 //=== VK_KHR_video_encode_queue ===
|
|
|
20907 PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = 0;
|
|
|
20908 PFN_vkGetEncodedVideoSessionParametersKHR vkGetEncodedVideoSessionParametersKHR = 0;
|
|
|
20909 PFN_vkCmdEncodeVideoKHR vkCmdEncodeVideoKHR = 0;
|
|
|
20910
|
|
|
20911 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
20912 //=== VK_NV_cuda_kernel_launch ===
|
|
|
20913 PFN_vkCreateCudaModuleNV vkCreateCudaModuleNV = 0;
|
|
|
20914 PFN_vkGetCudaModuleCacheNV vkGetCudaModuleCacheNV = 0;
|
|
|
20915 PFN_vkCreateCudaFunctionNV vkCreateCudaFunctionNV = 0;
|
|
|
20916 PFN_vkDestroyCudaModuleNV vkDestroyCudaModuleNV = 0;
|
|
|
20917 PFN_vkDestroyCudaFunctionNV vkDestroyCudaFunctionNV = 0;
|
|
|
20918 PFN_vkCmdCudaLaunchKernelNV vkCmdCudaLaunchKernelNV = 0;
|
|
|
20919 #else
|
|
|
20920 PFN_dummy vkCreateCudaModuleNV_placeholder = 0;
|
|
|
20921 PFN_dummy vkGetCudaModuleCacheNV_placeholder = 0;
|
|
|
20922 PFN_dummy vkCreateCudaFunctionNV_placeholder = 0;
|
|
|
20923 PFN_dummy vkDestroyCudaModuleNV_placeholder = 0;
|
|
|
20924 PFN_dummy vkDestroyCudaFunctionNV_placeholder = 0;
|
|
|
20925 PFN_dummy vkCmdCudaLaunchKernelNV_placeholder = 0;
|
|
|
20926 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
20927
|
|
|
20928 //=== VK_QCOM_tile_shading ===
|
|
|
20929 PFN_vkCmdDispatchTileQCOM vkCmdDispatchTileQCOM = 0;
|
|
|
20930 PFN_vkCmdBeginPerTileExecutionQCOM vkCmdBeginPerTileExecutionQCOM = 0;
|
|
|
20931 PFN_vkCmdEndPerTileExecutionQCOM vkCmdEndPerTileExecutionQCOM = 0;
|
|
|
20932
|
|
|
20933 #if defined( VK_USE_PLATFORM_METAL_EXT )
|
|
|
20934 //=== VK_EXT_metal_objects ===
|
|
|
20935 PFN_vkExportMetalObjectsEXT vkExportMetalObjectsEXT = 0;
|
|
|
20936 #else
|
|
|
20937 PFN_dummy vkExportMetalObjectsEXT_placeholder = 0;
|
|
|
20938 #endif /*VK_USE_PLATFORM_METAL_EXT*/
|
|
|
20939
|
|
|
20940 //=== VK_KHR_synchronization2 ===
|
|
|
20941 PFN_vkCmdSetEvent2KHR vkCmdSetEvent2KHR = 0;
|
|
|
20942 PFN_vkCmdResetEvent2KHR vkCmdResetEvent2KHR = 0;
|
|
|
20943 PFN_vkCmdWaitEvents2KHR vkCmdWaitEvents2KHR = 0;
|
|
|
20944 PFN_vkCmdPipelineBarrier2KHR vkCmdPipelineBarrier2KHR = 0;
|
|
|
20945 PFN_vkCmdWriteTimestamp2KHR vkCmdWriteTimestamp2KHR = 0;
|
|
|
20946 PFN_vkQueueSubmit2KHR vkQueueSubmit2KHR = 0;
|
|
|
20947
|
|
|
20948 //=== VK_EXT_descriptor_buffer ===
|
|
|
20949 PFN_vkGetDescriptorSetLayoutSizeEXT vkGetDescriptorSetLayoutSizeEXT = 0;
|
|
|
20950 PFN_vkGetDescriptorSetLayoutBindingOffsetEXT vkGetDescriptorSetLayoutBindingOffsetEXT = 0;
|
|
|
20951 PFN_vkGetDescriptorEXT vkGetDescriptorEXT = 0;
|
|
|
20952 PFN_vkCmdBindDescriptorBuffersEXT vkCmdBindDescriptorBuffersEXT = 0;
|
|
|
20953 PFN_vkCmdSetDescriptorBufferOffsetsEXT vkCmdSetDescriptorBufferOffsetsEXT = 0;
|
|
|
20954 PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT vkCmdBindDescriptorBufferEmbeddedSamplersEXT = 0;
|
|
|
20955 PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT vkGetBufferOpaqueCaptureDescriptorDataEXT = 0;
|
|
|
20956 PFN_vkGetImageOpaqueCaptureDescriptorDataEXT vkGetImageOpaqueCaptureDescriptorDataEXT = 0;
|
|
|
20957 PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT vkGetImageViewOpaqueCaptureDescriptorDataEXT = 0;
|
|
|
20958 PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT vkGetSamplerOpaqueCaptureDescriptorDataEXT = 0;
|
|
|
20959 PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = 0;
|
|
|
20960
|
|
|
20961 //=== VK_NV_fragment_shading_rate_enums ===
|
|
|
20962 PFN_vkCmdSetFragmentShadingRateEnumNV vkCmdSetFragmentShadingRateEnumNV = 0;
|
|
|
20963
|
|
|
20964 //=== VK_EXT_mesh_shader ===
|
|
|
20965 PFN_vkCmdDrawMeshTasksEXT vkCmdDrawMeshTasksEXT = 0;
|
|
|
20966 PFN_vkCmdDrawMeshTasksIndirectEXT vkCmdDrawMeshTasksIndirectEXT = 0;
|
|
|
20967 PFN_vkCmdDrawMeshTasksIndirectCountEXT vkCmdDrawMeshTasksIndirectCountEXT = 0;
|
|
|
20968
|
|
|
20969 //=== VK_KHR_copy_commands2 ===
|
|
|
20970 PFN_vkCmdCopyBuffer2KHR vkCmdCopyBuffer2KHR = 0;
|
|
|
20971 PFN_vkCmdCopyImage2KHR vkCmdCopyImage2KHR = 0;
|
|
|
20972 PFN_vkCmdCopyBufferToImage2KHR vkCmdCopyBufferToImage2KHR = 0;
|
|
|
20973 PFN_vkCmdCopyImageToBuffer2KHR vkCmdCopyImageToBuffer2KHR = 0;
|
|
|
20974 PFN_vkCmdBlitImage2KHR vkCmdBlitImage2KHR = 0;
|
|
|
20975 PFN_vkCmdResolveImage2KHR vkCmdResolveImage2KHR = 0;
|
|
|
20976
|
|
|
20977 //=== VK_EXT_device_fault ===
|
|
|
20978 PFN_vkGetDeviceFaultInfoEXT vkGetDeviceFaultInfoEXT = 0;
|
|
|
20979
|
|
|
20980 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
20981 //=== VK_NV_acquire_winrt_display ===
|
|
|
20982 PFN_vkAcquireWinrtDisplayNV vkAcquireWinrtDisplayNV = 0;
|
|
|
20983 PFN_vkGetWinrtDisplayNV vkGetWinrtDisplayNV = 0;
|
|
|
20984 #else
|
|
|
20985 PFN_dummy vkAcquireWinrtDisplayNV_placeholder = 0;
|
|
|
20986 PFN_dummy vkGetWinrtDisplayNV_placeholder = 0;
|
|
|
20987 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
20988
|
|
|
20989 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
|
|
|
20990 //=== VK_EXT_directfb_surface ===
|
|
|
20991 PFN_vkCreateDirectFBSurfaceEXT vkCreateDirectFBSurfaceEXT = 0;
|
|
|
20992 PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT vkGetPhysicalDeviceDirectFBPresentationSupportEXT = 0;
|
|
|
20993 #else
|
|
|
20994 PFN_dummy vkCreateDirectFBSurfaceEXT_placeholder = 0;
|
|
|
20995 PFN_dummy vkGetPhysicalDeviceDirectFBPresentationSupportEXT_placeholder = 0;
|
|
|
20996 #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
|
|
|
20997
|
|
|
20998 //=== VK_EXT_vertex_input_dynamic_state ===
|
|
|
20999 PFN_vkCmdSetVertexInputEXT vkCmdSetVertexInputEXT = 0;
|
|
|
21000
|
|
|
21001 #if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
|
21002 //=== VK_FUCHSIA_external_memory ===
|
|
|
21003 PFN_vkGetMemoryZirconHandleFUCHSIA vkGetMemoryZirconHandleFUCHSIA = 0;
|
|
|
21004 PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA vkGetMemoryZirconHandlePropertiesFUCHSIA = 0;
|
|
|
21005 #else
|
|
|
21006 PFN_dummy vkGetMemoryZirconHandleFUCHSIA_placeholder = 0;
|
|
|
21007 PFN_dummy vkGetMemoryZirconHandlePropertiesFUCHSIA_placeholder = 0;
|
|
|
21008 #endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
21009
|
|
|
21010 #if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
|
21011 //=== VK_FUCHSIA_external_semaphore ===
|
|
|
21012 PFN_vkImportSemaphoreZirconHandleFUCHSIA vkImportSemaphoreZirconHandleFUCHSIA = 0;
|
|
|
21013 PFN_vkGetSemaphoreZirconHandleFUCHSIA vkGetSemaphoreZirconHandleFUCHSIA = 0;
|
|
|
21014 #else
|
|
|
21015 PFN_dummy vkImportSemaphoreZirconHandleFUCHSIA_placeholder = 0;
|
|
|
21016 PFN_dummy vkGetSemaphoreZirconHandleFUCHSIA_placeholder = 0;
|
|
|
21017 #endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
21018
|
|
|
21019 #if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
|
21020 //=== VK_FUCHSIA_buffer_collection ===
|
|
|
21021 PFN_vkCreateBufferCollectionFUCHSIA vkCreateBufferCollectionFUCHSIA = 0;
|
|
|
21022 PFN_vkSetBufferCollectionImageConstraintsFUCHSIA vkSetBufferCollectionImageConstraintsFUCHSIA = 0;
|
|
|
21023 PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA vkSetBufferCollectionBufferConstraintsFUCHSIA = 0;
|
|
|
21024 PFN_vkDestroyBufferCollectionFUCHSIA vkDestroyBufferCollectionFUCHSIA = 0;
|
|
|
21025 PFN_vkGetBufferCollectionPropertiesFUCHSIA vkGetBufferCollectionPropertiesFUCHSIA = 0;
|
|
|
21026 #else
|
|
|
21027 PFN_dummy vkCreateBufferCollectionFUCHSIA_placeholder = 0;
|
|
|
21028 PFN_dummy vkSetBufferCollectionImageConstraintsFUCHSIA_placeholder = 0;
|
|
|
21029 PFN_dummy vkSetBufferCollectionBufferConstraintsFUCHSIA_placeholder = 0;
|
|
|
21030 PFN_dummy vkDestroyBufferCollectionFUCHSIA_placeholder = 0;
|
|
|
21031 PFN_dummy vkGetBufferCollectionPropertiesFUCHSIA_placeholder = 0;
|
|
|
21032 #endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
21033
|
|
|
21034 //=== VK_HUAWEI_subpass_shading ===
|
|
|
21035 PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = 0;
|
|
|
21036 PFN_vkCmdSubpassShadingHUAWEI vkCmdSubpassShadingHUAWEI = 0;
|
|
|
21037
|
|
|
21038 //=== VK_HUAWEI_invocation_mask ===
|
|
|
21039 PFN_vkCmdBindInvocationMaskHUAWEI vkCmdBindInvocationMaskHUAWEI = 0;
|
|
|
21040
|
|
|
21041 //=== VK_NV_external_memory_rdma ===
|
|
|
21042 PFN_vkGetMemoryRemoteAddressNV vkGetMemoryRemoteAddressNV = 0;
|
|
|
21043
|
|
|
21044 //=== VK_EXT_pipeline_properties ===
|
|
|
21045 PFN_vkGetPipelinePropertiesEXT vkGetPipelinePropertiesEXT = 0;
|
|
|
21046
|
|
|
21047 //=== VK_EXT_extended_dynamic_state2 ===
|
|
|
21048 PFN_vkCmdSetPatchControlPointsEXT vkCmdSetPatchControlPointsEXT = 0;
|
|
|
21049 PFN_vkCmdSetRasterizerDiscardEnableEXT vkCmdSetRasterizerDiscardEnableEXT = 0;
|
|
|
21050 PFN_vkCmdSetDepthBiasEnableEXT vkCmdSetDepthBiasEnableEXT = 0;
|
|
|
21051 PFN_vkCmdSetLogicOpEXT vkCmdSetLogicOpEXT = 0;
|
|
|
21052 PFN_vkCmdSetPrimitiveRestartEnableEXT vkCmdSetPrimitiveRestartEnableEXT = 0;
|
|
|
21053
|
|
|
21054 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
|
|
21055 //=== VK_QNX_screen_surface ===
|
|
|
21056 PFN_vkCreateScreenSurfaceQNX vkCreateScreenSurfaceQNX = 0;
|
|
|
21057 PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX vkGetPhysicalDeviceScreenPresentationSupportQNX = 0;
|
|
|
21058 #else
|
|
|
21059 PFN_dummy vkCreateScreenSurfaceQNX_placeholder = 0;
|
|
|
21060 PFN_dummy vkGetPhysicalDeviceScreenPresentationSupportQNX_placeholder = 0;
|
|
|
21061 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
|
|
21062
|
|
|
21063 //=== VK_EXT_color_write_enable ===
|
|
|
21064 PFN_vkCmdSetColorWriteEnableEXT vkCmdSetColorWriteEnableEXT = 0;
|
|
|
21065
|
|
|
21066 //=== VK_KHR_ray_tracing_maintenance1 ===
|
|
|
21067 PFN_vkCmdTraceRaysIndirect2KHR vkCmdTraceRaysIndirect2KHR = 0;
|
|
|
21068
|
|
|
21069 //=== VK_EXT_multi_draw ===
|
|
|
21070 PFN_vkCmdDrawMultiEXT vkCmdDrawMultiEXT = 0;
|
|
|
21071 PFN_vkCmdDrawMultiIndexedEXT vkCmdDrawMultiIndexedEXT = 0;
|
|
|
21072
|
|
|
21073 //=== VK_EXT_opacity_micromap ===
|
|
|
21074 PFN_vkCreateMicromapEXT vkCreateMicromapEXT = 0;
|
|
|
21075 PFN_vkDestroyMicromapEXT vkDestroyMicromapEXT = 0;
|
|
|
21076 PFN_vkCmdBuildMicromapsEXT vkCmdBuildMicromapsEXT = 0;
|
|
|
21077 PFN_vkBuildMicromapsEXT vkBuildMicromapsEXT = 0;
|
|
|
21078 PFN_vkCopyMicromapEXT vkCopyMicromapEXT = 0;
|
|
|
21079 PFN_vkCopyMicromapToMemoryEXT vkCopyMicromapToMemoryEXT = 0;
|
|
|
21080 PFN_vkCopyMemoryToMicromapEXT vkCopyMemoryToMicromapEXT = 0;
|
|
|
21081 PFN_vkWriteMicromapsPropertiesEXT vkWriteMicromapsPropertiesEXT = 0;
|
|
|
21082 PFN_vkCmdCopyMicromapEXT vkCmdCopyMicromapEXT = 0;
|
|
|
21083 PFN_vkCmdCopyMicromapToMemoryEXT vkCmdCopyMicromapToMemoryEXT = 0;
|
|
|
21084 PFN_vkCmdCopyMemoryToMicromapEXT vkCmdCopyMemoryToMicromapEXT = 0;
|
|
|
21085 PFN_vkCmdWriteMicromapsPropertiesEXT vkCmdWriteMicromapsPropertiesEXT = 0;
|
|
|
21086 PFN_vkGetDeviceMicromapCompatibilityEXT vkGetDeviceMicromapCompatibilityEXT = 0;
|
|
|
21087 PFN_vkGetMicromapBuildSizesEXT vkGetMicromapBuildSizesEXT = 0;
|
|
|
21088
|
|
|
21089 //=== VK_HUAWEI_cluster_culling_shader ===
|
|
|
21090 PFN_vkCmdDrawClusterHUAWEI vkCmdDrawClusterHUAWEI = 0;
|
|
|
21091 PFN_vkCmdDrawClusterIndirectHUAWEI vkCmdDrawClusterIndirectHUAWEI = 0;
|
|
|
21092
|
|
|
21093 //=== VK_EXT_pageable_device_local_memory ===
|
|
|
21094 PFN_vkSetDeviceMemoryPriorityEXT vkSetDeviceMemoryPriorityEXT = 0;
|
|
|
21095
|
|
|
21096 //=== VK_KHR_maintenance4 ===
|
|
|
21097 PFN_vkGetDeviceBufferMemoryRequirementsKHR vkGetDeviceBufferMemoryRequirementsKHR = 0;
|
|
|
21098 PFN_vkGetDeviceImageMemoryRequirementsKHR vkGetDeviceImageMemoryRequirementsKHR = 0;
|
|
|
21099 PFN_vkGetDeviceImageSparseMemoryRequirementsKHR vkGetDeviceImageSparseMemoryRequirementsKHR = 0;
|
|
|
21100
|
|
|
21101 //=== VK_VALVE_descriptor_set_host_mapping ===
|
|
|
21102 PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE vkGetDescriptorSetLayoutHostMappingInfoVALVE = 0;
|
|
|
21103 PFN_vkGetDescriptorSetHostMappingVALVE vkGetDescriptorSetHostMappingVALVE = 0;
|
|
|
21104
|
|
|
21105 //=== VK_NV_copy_memory_indirect ===
|
|
|
21106 PFN_vkCmdCopyMemoryIndirectNV vkCmdCopyMemoryIndirectNV = 0;
|
|
|
21107 PFN_vkCmdCopyMemoryToImageIndirectNV vkCmdCopyMemoryToImageIndirectNV = 0;
|
|
|
21108
|
|
|
21109 //=== VK_NV_memory_decompression ===
|
|
|
21110 PFN_vkCmdDecompressMemoryNV vkCmdDecompressMemoryNV = 0;
|
|
|
21111 PFN_vkCmdDecompressMemoryIndirectCountNV vkCmdDecompressMemoryIndirectCountNV = 0;
|
|
|
21112
|
|
|
21113 //=== VK_NV_device_generated_commands_compute ===
|
|
|
21114 PFN_vkGetPipelineIndirectMemoryRequirementsNV vkGetPipelineIndirectMemoryRequirementsNV = 0;
|
|
|
21115 PFN_vkCmdUpdatePipelineIndirectBufferNV vkCmdUpdatePipelineIndirectBufferNV = 0;
|
|
|
21116 PFN_vkGetPipelineIndirectDeviceAddressNV vkGetPipelineIndirectDeviceAddressNV = 0;
|
|
|
21117
|
|
|
21118 #if defined( VK_USE_PLATFORM_OHOS )
|
|
|
21119 //=== VK_OHOS_external_memory ===
|
|
|
21120 PFN_vkGetNativeBufferPropertiesOHOS vkGetNativeBufferPropertiesOHOS = 0;
|
|
|
21121 PFN_vkGetMemoryNativeBufferOHOS vkGetMemoryNativeBufferOHOS = 0;
|
|
|
21122 #else
|
|
|
21123 PFN_dummy vkGetNativeBufferPropertiesOHOS_placeholder = 0;
|
|
|
21124 PFN_dummy vkGetMemoryNativeBufferOHOS_placeholder = 0;
|
|
|
21125 #endif /*VK_USE_PLATFORM_OHOS*/
|
|
|
21126
|
|
|
21127 //=== VK_EXT_extended_dynamic_state3 ===
|
|
|
21128 PFN_vkCmdSetDepthClampEnableEXT vkCmdSetDepthClampEnableEXT = 0;
|
|
|
21129 PFN_vkCmdSetPolygonModeEXT vkCmdSetPolygonModeEXT = 0;
|
|
|
21130 PFN_vkCmdSetRasterizationSamplesEXT vkCmdSetRasterizationSamplesEXT = 0;
|
|
|
21131 PFN_vkCmdSetSampleMaskEXT vkCmdSetSampleMaskEXT = 0;
|
|
|
21132 PFN_vkCmdSetAlphaToCoverageEnableEXT vkCmdSetAlphaToCoverageEnableEXT = 0;
|
|
|
21133 PFN_vkCmdSetAlphaToOneEnableEXT vkCmdSetAlphaToOneEnableEXT = 0;
|
|
|
21134 PFN_vkCmdSetLogicOpEnableEXT vkCmdSetLogicOpEnableEXT = 0;
|
|
|
21135 PFN_vkCmdSetColorBlendEnableEXT vkCmdSetColorBlendEnableEXT = 0;
|
|
|
21136 PFN_vkCmdSetColorBlendEquationEXT vkCmdSetColorBlendEquationEXT = 0;
|
|
|
21137 PFN_vkCmdSetColorWriteMaskEXT vkCmdSetColorWriteMaskEXT = 0;
|
|
|
21138 PFN_vkCmdSetTessellationDomainOriginEXT vkCmdSetTessellationDomainOriginEXT = 0;
|
|
|
21139 PFN_vkCmdSetRasterizationStreamEXT vkCmdSetRasterizationStreamEXT = 0;
|
|
|
21140 PFN_vkCmdSetConservativeRasterizationModeEXT vkCmdSetConservativeRasterizationModeEXT = 0;
|
|
|
21141 PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT vkCmdSetExtraPrimitiveOverestimationSizeEXT = 0;
|
|
|
21142 PFN_vkCmdSetDepthClipEnableEXT vkCmdSetDepthClipEnableEXT = 0;
|
|
|
21143 PFN_vkCmdSetSampleLocationsEnableEXT vkCmdSetSampleLocationsEnableEXT = 0;
|
|
|
21144 PFN_vkCmdSetColorBlendAdvancedEXT vkCmdSetColorBlendAdvancedEXT = 0;
|
|
|
21145 PFN_vkCmdSetProvokingVertexModeEXT vkCmdSetProvokingVertexModeEXT = 0;
|
|
|
21146 PFN_vkCmdSetLineRasterizationModeEXT vkCmdSetLineRasterizationModeEXT = 0;
|
|
|
21147 PFN_vkCmdSetLineStippleEnableEXT vkCmdSetLineStippleEnableEXT = 0;
|
|
|
21148 PFN_vkCmdSetDepthClipNegativeOneToOneEXT vkCmdSetDepthClipNegativeOneToOneEXT = 0;
|
|
|
21149 PFN_vkCmdSetViewportWScalingEnableNV vkCmdSetViewportWScalingEnableNV = 0;
|
|
|
21150 PFN_vkCmdSetViewportSwizzleNV vkCmdSetViewportSwizzleNV = 0;
|
|
|
21151 PFN_vkCmdSetCoverageToColorEnableNV vkCmdSetCoverageToColorEnableNV = 0;
|
|
|
21152 PFN_vkCmdSetCoverageToColorLocationNV vkCmdSetCoverageToColorLocationNV = 0;
|
|
|
21153 PFN_vkCmdSetCoverageModulationModeNV vkCmdSetCoverageModulationModeNV = 0;
|
|
|
21154 PFN_vkCmdSetCoverageModulationTableEnableNV vkCmdSetCoverageModulationTableEnableNV = 0;
|
|
|
21155 PFN_vkCmdSetCoverageModulationTableNV vkCmdSetCoverageModulationTableNV = 0;
|
|
|
21156 PFN_vkCmdSetShadingRateImageEnableNV vkCmdSetShadingRateImageEnableNV = 0;
|
|
|
21157 PFN_vkCmdSetRepresentativeFragmentTestEnableNV vkCmdSetRepresentativeFragmentTestEnableNV = 0;
|
|
|
21158 PFN_vkCmdSetCoverageReductionModeNV vkCmdSetCoverageReductionModeNV = 0;
|
|
|
21159
|
|
|
21160 //=== VK_ARM_tensors ===
|
|
|
21161 PFN_vkCreateTensorARM vkCreateTensorARM = 0;
|
|
|
21162 PFN_vkDestroyTensorARM vkDestroyTensorARM = 0;
|
|
|
21163 PFN_vkCreateTensorViewARM vkCreateTensorViewARM = 0;
|
|
|
21164 PFN_vkDestroyTensorViewARM vkDestroyTensorViewARM = 0;
|
|
|
21165 PFN_vkGetTensorMemoryRequirementsARM vkGetTensorMemoryRequirementsARM = 0;
|
|
|
21166 PFN_vkBindTensorMemoryARM vkBindTensorMemoryARM = 0;
|
|
|
21167 PFN_vkGetDeviceTensorMemoryRequirementsARM vkGetDeviceTensorMemoryRequirementsARM = 0;
|
|
|
21168 PFN_vkCmdCopyTensorARM vkCmdCopyTensorARM = 0;
|
|
|
21169 PFN_vkGetPhysicalDeviceExternalTensorPropertiesARM vkGetPhysicalDeviceExternalTensorPropertiesARM = 0;
|
|
|
21170 PFN_vkGetTensorOpaqueCaptureDescriptorDataARM vkGetTensorOpaqueCaptureDescriptorDataARM = 0;
|
|
|
21171 PFN_vkGetTensorViewOpaqueCaptureDescriptorDataARM vkGetTensorViewOpaqueCaptureDescriptorDataARM = 0;
|
|
|
21172
|
|
|
21173 //=== VK_EXT_shader_module_identifier ===
|
|
|
21174 PFN_vkGetShaderModuleIdentifierEXT vkGetShaderModuleIdentifierEXT = 0;
|
|
|
21175 PFN_vkGetShaderModuleCreateInfoIdentifierEXT vkGetShaderModuleCreateInfoIdentifierEXT = 0;
|
|
|
21176
|
|
|
21177 //=== VK_NV_optical_flow ===
|
|
|
21178 PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV vkGetPhysicalDeviceOpticalFlowImageFormatsNV = 0;
|
|
|
21179 PFN_vkCreateOpticalFlowSessionNV vkCreateOpticalFlowSessionNV = 0;
|
|
|
21180 PFN_vkDestroyOpticalFlowSessionNV vkDestroyOpticalFlowSessionNV = 0;
|
|
|
21181 PFN_vkBindOpticalFlowSessionImageNV vkBindOpticalFlowSessionImageNV = 0;
|
|
|
21182 PFN_vkCmdOpticalFlowExecuteNV vkCmdOpticalFlowExecuteNV = 0;
|
|
|
21183
|
|
|
21184 //=== VK_KHR_maintenance5 ===
|
|
|
21185 PFN_vkCmdBindIndexBuffer2KHR vkCmdBindIndexBuffer2KHR = 0;
|
|
|
21186 PFN_vkGetRenderingAreaGranularityKHR vkGetRenderingAreaGranularityKHR = 0;
|
|
|
21187 PFN_vkGetDeviceImageSubresourceLayoutKHR vkGetDeviceImageSubresourceLayoutKHR = 0;
|
|
|
21188 PFN_vkGetImageSubresourceLayout2KHR vkGetImageSubresourceLayout2KHR = 0;
|
|
|
21189
|
|
|
21190 //=== VK_AMD_anti_lag ===
|
|
|
21191 PFN_vkAntiLagUpdateAMD vkAntiLagUpdateAMD = 0;
|
|
|
21192
|
|
|
21193 //=== VK_KHR_present_wait2 ===
|
|
|
21194 PFN_vkWaitForPresent2KHR vkWaitForPresent2KHR = 0;
|
|
|
21195
|
|
|
21196 //=== VK_EXT_shader_object ===
|
|
|
21197 PFN_vkCreateShadersEXT vkCreateShadersEXT = 0;
|
|
|
21198 PFN_vkDestroyShaderEXT vkDestroyShaderEXT = 0;
|
|
|
21199 PFN_vkGetShaderBinaryDataEXT vkGetShaderBinaryDataEXT = 0;
|
|
|
21200 PFN_vkCmdBindShadersEXT vkCmdBindShadersEXT = 0;
|
|
|
21201 PFN_vkCmdSetDepthClampRangeEXT vkCmdSetDepthClampRangeEXT = 0;
|
|
|
21202
|
|
|
21203 //=== VK_KHR_pipeline_binary ===
|
|
|
21204 PFN_vkCreatePipelineBinariesKHR vkCreatePipelineBinariesKHR = 0;
|
|
|
21205 PFN_vkDestroyPipelineBinaryKHR vkDestroyPipelineBinaryKHR = 0;
|
|
|
21206 PFN_vkGetPipelineKeyKHR vkGetPipelineKeyKHR = 0;
|
|
|
21207 PFN_vkGetPipelineBinaryDataKHR vkGetPipelineBinaryDataKHR = 0;
|
|
|
21208 PFN_vkReleaseCapturedPipelineDataKHR vkReleaseCapturedPipelineDataKHR = 0;
|
|
|
21209
|
|
|
21210 //=== VK_QCOM_tile_properties ===
|
|
|
21211 PFN_vkGetFramebufferTilePropertiesQCOM vkGetFramebufferTilePropertiesQCOM = 0;
|
|
|
21212 PFN_vkGetDynamicRenderingTilePropertiesQCOM vkGetDynamicRenderingTilePropertiesQCOM = 0;
|
|
|
21213
|
|
|
21214 //=== VK_KHR_swapchain_maintenance1 ===
|
|
|
21215 PFN_vkReleaseSwapchainImagesKHR vkReleaseSwapchainImagesKHR = 0;
|
|
|
21216
|
|
|
21217 //=== VK_NV_cooperative_vector ===
|
|
|
21218 PFN_vkGetPhysicalDeviceCooperativeVectorPropertiesNV vkGetPhysicalDeviceCooperativeVectorPropertiesNV = 0;
|
|
|
21219 PFN_vkConvertCooperativeVectorMatrixNV vkConvertCooperativeVectorMatrixNV = 0;
|
|
|
21220 PFN_vkCmdConvertCooperativeVectorMatrixNV vkCmdConvertCooperativeVectorMatrixNV = 0;
|
|
|
21221
|
|
|
21222 //=== VK_NV_low_latency2 ===
|
|
|
21223 PFN_vkSetLatencySleepModeNV vkSetLatencySleepModeNV = 0;
|
|
|
21224 PFN_vkLatencySleepNV vkLatencySleepNV = 0;
|
|
|
21225 PFN_vkSetLatencyMarkerNV vkSetLatencyMarkerNV = 0;
|
|
|
21226 PFN_vkGetLatencyTimingsNV vkGetLatencyTimingsNV = 0;
|
|
|
21227 PFN_vkQueueNotifyOutOfBandNV vkQueueNotifyOutOfBandNV = 0;
|
|
|
21228
|
|
|
21229 //=== VK_KHR_cooperative_matrix ===
|
|
|
21230 PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = 0;
|
|
|
21231
|
|
|
21232 //=== VK_ARM_data_graph ===
|
|
|
21233 PFN_vkCreateDataGraphPipelinesARM vkCreateDataGraphPipelinesARM = 0;
|
|
|
21234 PFN_vkCreateDataGraphPipelineSessionARM vkCreateDataGraphPipelineSessionARM = 0;
|
|
|
21235 PFN_vkGetDataGraphPipelineSessionBindPointRequirementsARM vkGetDataGraphPipelineSessionBindPointRequirementsARM = 0;
|
|
|
21236 PFN_vkGetDataGraphPipelineSessionMemoryRequirementsARM vkGetDataGraphPipelineSessionMemoryRequirementsARM = 0;
|
|
|
21237 PFN_vkBindDataGraphPipelineSessionMemoryARM vkBindDataGraphPipelineSessionMemoryARM = 0;
|
|
|
21238 PFN_vkDestroyDataGraphPipelineSessionARM vkDestroyDataGraphPipelineSessionARM = 0;
|
|
|
21239 PFN_vkCmdDispatchDataGraphARM vkCmdDispatchDataGraphARM = 0;
|
|
|
21240 PFN_vkGetDataGraphPipelineAvailablePropertiesARM vkGetDataGraphPipelineAvailablePropertiesARM = 0;
|
|
|
21241 PFN_vkGetDataGraphPipelinePropertiesARM vkGetDataGraphPipelinePropertiesARM = 0;
|
|
|
21242 PFN_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM = 0;
|
|
|
21243 PFN_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM = 0;
|
|
|
21244
|
|
|
21245 //=== VK_EXT_attachment_feedback_loop_dynamic_state ===
|
|
|
21246 PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT vkCmdSetAttachmentFeedbackLoopEnableEXT = 0;
|
|
|
21247
|
|
|
21248 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
|
|
21249 //=== VK_QNX_external_memory_screen_buffer ===
|
|
|
21250 PFN_vkGetScreenBufferPropertiesQNX vkGetScreenBufferPropertiesQNX = 0;
|
|
|
21251 #else
|
|
|
21252 PFN_dummy vkGetScreenBufferPropertiesQNX_placeholder = 0;
|
|
|
21253 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
|
|
21254
|
|
|
21255 //=== VK_KHR_line_rasterization ===
|
|
|
21256 PFN_vkCmdSetLineStippleKHR vkCmdSetLineStippleKHR = 0;
|
|
|
21257
|
|
|
21258 //=== VK_KHR_calibrated_timestamps ===
|
|
|
21259 PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = 0;
|
|
|
21260 PFN_vkGetCalibratedTimestampsKHR vkGetCalibratedTimestampsKHR = 0;
|
|
|
21261
|
|
|
21262 //=== VK_KHR_maintenance6 ===
|
|
|
21263 PFN_vkCmdBindDescriptorSets2KHR vkCmdBindDescriptorSets2KHR = 0;
|
|
|
21264 PFN_vkCmdPushConstants2KHR vkCmdPushConstants2KHR = 0;
|
|
|
21265 PFN_vkCmdPushDescriptorSet2KHR vkCmdPushDescriptorSet2KHR = 0;
|
|
|
21266 PFN_vkCmdPushDescriptorSetWithTemplate2KHR vkCmdPushDescriptorSetWithTemplate2KHR = 0;
|
|
|
21267 PFN_vkCmdSetDescriptorBufferOffsets2EXT vkCmdSetDescriptorBufferOffsets2EXT = 0;
|
|
|
21268 PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = 0;
|
|
|
21269
|
|
|
21270 //=== VK_QCOM_tile_memory_heap ===
|
|
|
21271 PFN_vkCmdBindTileMemoryQCOM vkCmdBindTileMemoryQCOM = 0;
|
|
|
21272
|
|
|
21273 //=== VK_KHR_copy_memory_indirect ===
|
|
|
21274 PFN_vkCmdCopyMemoryIndirectKHR vkCmdCopyMemoryIndirectKHR = 0;
|
|
|
21275 PFN_vkCmdCopyMemoryToImageIndirectKHR vkCmdCopyMemoryToImageIndirectKHR = 0;
|
|
|
21276
|
|
|
21277 //=== VK_EXT_memory_decompression ===
|
|
|
21278 PFN_vkCmdDecompressMemoryEXT vkCmdDecompressMemoryEXT = 0;
|
|
|
21279 PFN_vkCmdDecompressMemoryIndirectCountEXT vkCmdDecompressMemoryIndirectCountEXT = 0;
|
|
|
21280
|
|
|
21281 //=== VK_NV_external_compute_queue ===
|
|
|
21282 PFN_vkCreateExternalComputeQueueNV vkCreateExternalComputeQueueNV = 0;
|
|
|
21283 PFN_vkDestroyExternalComputeQueueNV vkDestroyExternalComputeQueueNV = 0;
|
|
|
21284 PFN_vkGetExternalComputeQueueDataNV vkGetExternalComputeQueueDataNV = 0;
|
|
|
21285
|
|
|
21286 //=== VK_NV_cluster_acceleration_structure ===
|
|
|
21287 PFN_vkGetClusterAccelerationStructureBuildSizesNV vkGetClusterAccelerationStructureBuildSizesNV = 0;
|
|
|
21288 PFN_vkCmdBuildClusterAccelerationStructureIndirectNV vkCmdBuildClusterAccelerationStructureIndirectNV = 0;
|
|
|
21289
|
|
|
21290 //=== VK_NV_partitioned_acceleration_structure ===
|
|
|
21291 PFN_vkGetPartitionedAccelerationStructuresBuildSizesNV vkGetPartitionedAccelerationStructuresBuildSizesNV = 0;
|
|
|
21292 PFN_vkCmdBuildPartitionedAccelerationStructuresNV vkCmdBuildPartitionedAccelerationStructuresNV = 0;
|
|
|
21293
|
|
|
21294 //=== VK_EXT_device_generated_commands ===
|
|
|
21295 PFN_vkGetGeneratedCommandsMemoryRequirementsEXT vkGetGeneratedCommandsMemoryRequirementsEXT = 0;
|
|
|
21296 PFN_vkCmdPreprocessGeneratedCommandsEXT vkCmdPreprocessGeneratedCommandsEXT = 0;
|
|
|
21297 PFN_vkCmdExecuteGeneratedCommandsEXT vkCmdExecuteGeneratedCommandsEXT = 0;
|
|
|
21298 PFN_vkCreateIndirectCommandsLayoutEXT vkCreateIndirectCommandsLayoutEXT = 0;
|
|
|
21299 PFN_vkDestroyIndirectCommandsLayoutEXT vkDestroyIndirectCommandsLayoutEXT = 0;
|
|
|
21300 PFN_vkCreateIndirectExecutionSetEXT vkCreateIndirectExecutionSetEXT = 0;
|
|
|
21301 PFN_vkDestroyIndirectExecutionSetEXT vkDestroyIndirectExecutionSetEXT = 0;
|
|
|
21302 PFN_vkUpdateIndirectExecutionSetPipelineEXT vkUpdateIndirectExecutionSetPipelineEXT = 0;
|
|
|
21303 PFN_vkUpdateIndirectExecutionSetShaderEXT vkUpdateIndirectExecutionSetShaderEXT = 0;
|
|
|
21304
|
|
|
21305 #if defined( VK_USE_PLATFORM_OHOS )
|
|
|
21306 //=== VK_OHOS_surface ===
|
|
|
21307 PFN_vkCreateSurfaceOHOS vkCreateSurfaceOHOS = 0;
|
|
|
21308 #else
|
|
|
21309 PFN_dummy vkCreateSurfaceOHOS_placeholder = 0;
|
|
|
21310 #endif /*VK_USE_PLATFORM_OHOS*/
|
|
|
21311
|
|
|
21312 #if defined( VK_USE_PLATFORM_OHOS )
|
|
|
21313 //=== VK_OHOS_native_buffer ===
|
|
|
21314 PFN_vkGetSwapchainGrallocUsageOHOS vkGetSwapchainGrallocUsageOHOS = 0;
|
|
|
21315 PFN_vkAcquireImageOHOS vkAcquireImageOHOS = 0;
|
|
|
21316 PFN_vkQueueSignalReleaseImageOHOS vkQueueSignalReleaseImageOHOS = 0;
|
|
|
21317 #else
|
|
|
21318 PFN_dummy vkGetSwapchainGrallocUsageOHOS_placeholder = 0;
|
|
|
21319 PFN_dummy vkAcquireImageOHOS_placeholder = 0;
|
|
|
21320 PFN_dummy vkQueueSignalReleaseImageOHOS_placeholder = 0;
|
|
|
21321 #endif /*VK_USE_PLATFORM_OHOS*/
|
|
|
21322
|
|
|
21323 //=== VK_NV_cooperative_matrix2 ===
|
|
|
21324 PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV = 0;
|
|
|
21325
|
|
|
21326 #if defined( VK_USE_PLATFORM_METAL_EXT )
|
|
|
21327 //=== VK_EXT_external_memory_metal ===
|
|
|
21328 PFN_vkGetMemoryMetalHandleEXT vkGetMemoryMetalHandleEXT = 0;
|
|
|
21329 PFN_vkGetMemoryMetalHandlePropertiesEXT vkGetMemoryMetalHandlePropertiesEXT = 0;
|
|
|
21330 #else
|
|
|
21331 PFN_dummy vkGetMemoryMetalHandleEXT_placeholder = 0;
|
|
|
21332 PFN_dummy vkGetMemoryMetalHandlePropertiesEXT_placeholder = 0;
|
|
|
21333 #endif /*VK_USE_PLATFORM_METAL_EXT*/
|
|
|
21334
|
|
|
21335 //=== VK_ARM_performance_counters_by_region ===
|
|
|
21336 PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM = 0;
|
|
|
21337
|
|
|
21338 //=== VK_EXT_fragment_density_map_offset ===
|
|
|
21339 PFN_vkCmdEndRendering2EXT vkCmdEndRendering2EXT = 0;
|
|
|
21340
|
|
|
21341 //=== VK_EXT_custom_resolve ===
|
|
|
21342 PFN_vkCmdBeginCustomResolveEXT vkCmdBeginCustomResolveEXT = 0;
|
|
|
21343
|
|
|
21344 //=== VK_KHR_maintenance10 ===
|
|
|
21345 PFN_vkCmdEndRendering2KHR vkCmdEndRendering2KHR = 0;
|
|
|
21346
|
|
|
21347 public:
|
|
|
21348 DispatchLoaderDynamic() VULKAN_HPP_NOEXCEPT = default;
|
|
|
21349 DispatchLoaderDynamic( DispatchLoaderDynamic const & rhs ) VULKAN_HPP_NOEXCEPT = default;
|
|
|
21350
|
|
|
21351 DispatchLoaderDynamic( PFN_vkGetInstanceProcAddr getInstanceProcAddr ) VULKAN_HPP_NOEXCEPT
|
|
|
21352 {
|
|
|
21353 init( getInstanceProcAddr );
|
|
|
21354 }
|
|
|
21355
|
|
|
21356 // This interface does not require a linked vulkan library.
|
|
|
21357 DispatchLoaderDynamic( VkInstance instance,
|
|
|
21358 PFN_vkGetInstanceProcAddr getInstanceProcAddr,
|
|
|
21359 VkDevice device = {},
|
|
|
21360 PFN_vkGetDeviceProcAddr getDeviceProcAddr = nullptr ) VULKAN_HPP_NOEXCEPT
|
|
|
21361 {
|
|
|
21362 init( instance, getInstanceProcAddr, device, getDeviceProcAddr );
|
|
|
21363 }
|
|
|
21364
|
|
|
21365 template <typename DynamicLoader
|
|
|
21366 #if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
|
|
|
21367 = VULKAN_HPP_NAMESPACE::detail::DynamicLoader
|
|
|
21368 #endif
|
|
|
21369 >
|
|
|
21370 void init()
|
|
|
21371 {
|
|
|
21372 static DynamicLoader dl;
|
|
|
21373 init( dl );
|
|
|
21374 }
|
|
|
21375
|
|
|
21376 template <typename DynamicLoader>
|
|
|
21377 void init( DynamicLoader const & dl ) VULKAN_HPP_NOEXCEPT
|
|
|
21378 {
|
|
|
21379 PFN_vkGetInstanceProcAddr getInstanceProcAddr = dl.template getProcAddress<PFN_vkGetInstanceProcAddr>( "vkGetInstanceProcAddr" );
|
|
|
21380 init( getInstanceProcAddr );
|
|
|
21381 }
|
|
|
21382
|
|
|
21383 void init( PFN_vkGetInstanceProcAddr getInstanceProcAddr ) VULKAN_HPP_NOEXCEPT
|
|
|
21384 {
|
|
|
21385 VULKAN_HPP_ASSERT( getInstanceProcAddr );
|
|
|
21386
|
|
|
21387 vkGetInstanceProcAddr = getInstanceProcAddr;
|
|
|
21388
|
|
|
21389 //=== VK_VERSION_1_0 ===
|
|
|
21390 vkCreateInstance = PFN_vkCreateInstance( vkGetInstanceProcAddr( NULL, "vkCreateInstance" ) );
|
|
|
21391 vkEnumerateInstanceExtensionProperties =
|
|
|
21392 PFN_vkEnumerateInstanceExtensionProperties( vkGetInstanceProcAddr( NULL, "vkEnumerateInstanceExtensionProperties" ) );
|
|
|
21393 vkEnumerateInstanceLayerProperties = PFN_vkEnumerateInstanceLayerProperties( vkGetInstanceProcAddr( NULL, "vkEnumerateInstanceLayerProperties" ) );
|
|
|
21394
|
|
|
21395 //=== VK_VERSION_1_1 ===
|
|
|
21396 vkEnumerateInstanceVersion = PFN_vkEnumerateInstanceVersion( vkGetInstanceProcAddr( NULL, "vkEnumerateInstanceVersion" ) );
|
|
|
21397 }
|
|
|
21398
|
|
|
21399 // This interface does not require a linked vulkan library.
|
|
|
21400 void init( VkInstance instance,
|
|
|
21401 PFN_vkGetInstanceProcAddr getInstanceProcAddr,
|
|
|
21402 VkDevice device = {},
|
|
|
21403 PFN_vkGetDeviceProcAddr /*getDeviceProcAddr*/ = nullptr ) VULKAN_HPP_NOEXCEPT
|
|
|
21404 {
|
|
|
21405 VULKAN_HPP_ASSERT( instance && getInstanceProcAddr );
|
|
|
21406 vkGetInstanceProcAddr = getInstanceProcAddr;
|
|
|
21407 init( Instance( instance ) );
|
|
|
21408 if ( device )
|
|
|
21409 {
|
|
|
21410 init( Device( device ) );
|
|
|
21411 }
|
|
|
21412 }
|
|
|
21413
|
|
|
21414 void init( Instance instanceCpp ) VULKAN_HPP_NOEXCEPT
|
|
|
21415 {
|
|
|
21416 VkInstance instance = static_cast<VkInstance>( instanceCpp );
|
|
|
21417
|
|
|
21418 //=== VK_VERSION_1_0 ===
|
|
|
21419 vkDestroyInstance = PFN_vkDestroyInstance( vkGetInstanceProcAddr( instance, "vkDestroyInstance" ) );
|
|
|
21420 vkEnumeratePhysicalDevices = PFN_vkEnumeratePhysicalDevices( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDevices" ) );
|
|
|
21421 vkGetPhysicalDeviceFeatures = PFN_vkGetPhysicalDeviceFeatures( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures" ) );
|
|
|
21422 vkGetPhysicalDeviceFormatProperties =
|
|
|
21423 PFN_vkGetPhysicalDeviceFormatProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties" ) );
|
|
|
21424 vkGetPhysicalDeviceImageFormatProperties =
|
|
|
21425 PFN_vkGetPhysicalDeviceImageFormatProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties" ) );
|
|
|
21426 vkGetPhysicalDeviceProperties = PFN_vkGetPhysicalDeviceProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties" ) );
|
|
|
21427 vkGetPhysicalDeviceQueueFamilyProperties =
|
|
|
21428 PFN_vkGetPhysicalDeviceQueueFamilyProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties" ) );
|
|
|
21429 vkGetPhysicalDeviceMemoryProperties =
|
|
|
21430 PFN_vkGetPhysicalDeviceMemoryProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties" ) );
|
|
|
21431 vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr( vkGetInstanceProcAddr( instance, "vkGetDeviceProcAddr" ) );
|
|
|
21432 vkCreateDevice = PFN_vkCreateDevice( vkGetInstanceProcAddr( instance, "vkCreateDevice" ) );
|
|
|
21433 vkDestroyDevice = PFN_vkDestroyDevice( vkGetInstanceProcAddr( instance, "vkDestroyDevice" ) );
|
|
|
21434 vkEnumerateDeviceExtensionProperties =
|
|
|
21435 PFN_vkEnumerateDeviceExtensionProperties( vkGetInstanceProcAddr( instance, "vkEnumerateDeviceExtensionProperties" ) );
|
|
|
21436 vkEnumerateDeviceLayerProperties = PFN_vkEnumerateDeviceLayerProperties( vkGetInstanceProcAddr( instance, "vkEnumerateDeviceLayerProperties" ) );
|
|
|
21437 vkGetDeviceQueue = PFN_vkGetDeviceQueue( vkGetInstanceProcAddr( instance, "vkGetDeviceQueue" ) );
|
|
|
21438 vkQueueSubmit = PFN_vkQueueSubmit( vkGetInstanceProcAddr( instance, "vkQueueSubmit" ) );
|
|
|
21439 vkQueueWaitIdle = PFN_vkQueueWaitIdle( vkGetInstanceProcAddr( instance, "vkQueueWaitIdle" ) );
|
|
|
21440 vkDeviceWaitIdle = PFN_vkDeviceWaitIdle( vkGetInstanceProcAddr( instance, "vkDeviceWaitIdle" ) );
|
|
|
21441 vkAllocateMemory = PFN_vkAllocateMemory( vkGetInstanceProcAddr( instance, "vkAllocateMemory" ) );
|
|
|
21442 vkFreeMemory = PFN_vkFreeMemory( vkGetInstanceProcAddr( instance, "vkFreeMemory" ) );
|
|
|
21443 vkMapMemory = PFN_vkMapMemory( vkGetInstanceProcAddr( instance, "vkMapMemory" ) );
|
|
|
21444 vkUnmapMemory = PFN_vkUnmapMemory( vkGetInstanceProcAddr( instance, "vkUnmapMemory" ) );
|
|
|
21445 vkFlushMappedMemoryRanges = PFN_vkFlushMappedMemoryRanges( vkGetInstanceProcAddr( instance, "vkFlushMappedMemoryRanges" ) );
|
|
|
21446 vkInvalidateMappedMemoryRanges = PFN_vkInvalidateMappedMemoryRanges( vkGetInstanceProcAddr( instance, "vkInvalidateMappedMemoryRanges" ) );
|
|
|
21447 vkGetDeviceMemoryCommitment = PFN_vkGetDeviceMemoryCommitment( vkGetInstanceProcAddr( instance, "vkGetDeviceMemoryCommitment" ) );
|
|
|
21448 vkBindBufferMemory = PFN_vkBindBufferMemory( vkGetInstanceProcAddr( instance, "vkBindBufferMemory" ) );
|
|
|
21449 vkBindImageMemory = PFN_vkBindImageMemory( vkGetInstanceProcAddr( instance, "vkBindImageMemory" ) );
|
|
|
21450 vkGetBufferMemoryRequirements = PFN_vkGetBufferMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetBufferMemoryRequirements" ) );
|
|
|
21451 vkGetImageMemoryRequirements = PFN_vkGetImageMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetImageMemoryRequirements" ) );
|
|
|
21452 vkGetImageSparseMemoryRequirements = PFN_vkGetImageSparseMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetImageSparseMemoryRequirements" ) );
|
|
|
21453 vkGetPhysicalDeviceSparseImageFormatProperties =
|
|
|
21454 PFN_vkGetPhysicalDeviceSparseImageFormatProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties" ) );
|
|
|
21455 vkQueueBindSparse = PFN_vkQueueBindSparse( vkGetInstanceProcAddr( instance, "vkQueueBindSparse" ) );
|
|
|
21456 vkCreateFence = PFN_vkCreateFence( vkGetInstanceProcAddr( instance, "vkCreateFence" ) );
|
|
|
21457 vkDestroyFence = PFN_vkDestroyFence( vkGetInstanceProcAddr( instance, "vkDestroyFence" ) );
|
|
|
21458 vkResetFences = PFN_vkResetFences( vkGetInstanceProcAddr( instance, "vkResetFences" ) );
|
|
|
21459 vkGetFenceStatus = PFN_vkGetFenceStatus( vkGetInstanceProcAddr( instance, "vkGetFenceStatus" ) );
|
|
|
21460 vkWaitForFences = PFN_vkWaitForFences( vkGetInstanceProcAddr( instance, "vkWaitForFences" ) );
|
|
|
21461 vkCreateSemaphore = PFN_vkCreateSemaphore( vkGetInstanceProcAddr( instance, "vkCreateSemaphore" ) );
|
|
|
21462 vkDestroySemaphore = PFN_vkDestroySemaphore( vkGetInstanceProcAddr( instance, "vkDestroySemaphore" ) );
|
|
|
21463 vkCreateQueryPool = PFN_vkCreateQueryPool( vkGetInstanceProcAddr( instance, "vkCreateQueryPool" ) );
|
|
|
21464 vkDestroyQueryPool = PFN_vkDestroyQueryPool( vkGetInstanceProcAddr( instance, "vkDestroyQueryPool" ) );
|
|
|
21465 vkGetQueryPoolResults = PFN_vkGetQueryPoolResults( vkGetInstanceProcAddr( instance, "vkGetQueryPoolResults" ) );
|
|
|
21466 vkCreateBuffer = PFN_vkCreateBuffer( vkGetInstanceProcAddr( instance, "vkCreateBuffer" ) );
|
|
|
21467 vkDestroyBuffer = PFN_vkDestroyBuffer( vkGetInstanceProcAddr( instance, "vkDestroyBuffer" ) );
|
|
|
21468 vkCreateImage = PFN_vkCreateImage( vkGetInstanceProcAddr( instance, "vkCreateImage" ) );
|
|
|
21469 vkDestroyImage = PFN_vkDestroyImage( vkGetInstanceProcAddr( instance, "vkDestroyImage" ) );
|
|
|
21470 vkGetImageSubresourceLayout = PFN_vkGetImageSubresourceLayout( vkGetInstanceProcAddr( instance, "vkGetImageSubresourceLayout" ) );
|
|
|
21471 vkCreateImageView = PFN_vkCreateImageView( vkGetInstanceProcAddr( instance, "vkCreateImageView" ) );
|
|
|
21472 vkDestroyImageView = PFN_vkDestroyImageView( vkGetInstanceProcAddr( instance, "vkDestroyImageView" ) );
|
|
|
21473 vkCreateCommandPool = PFN_vkCreateCommandPool( vkGetInstanceProcAddr( instance, "vkCreateCommandPool" ) );
|
|
|
21474 vkDestroyCommandPool = PFN_vkDestroyCommandPool( vkGetInstanceProcAddr( instance, "vkDestroyCommandPool" ) );
|
|
|
21475 vkResetCommandPool = PFN_vkResetCommandPool( vkGetInstanceProcAddr( instance, "vkResetCommandPool" ) );
|
|
|
21476 vkAllocateCommandBuffers = PFN_vkAllocateCommandBuffers( vkGetInstanceProcAddr( instance, "vkAllocateCommandBuffers" ) );
|
|
|
21477 vkFreeCommandBuffers = PFN_vkFreeCommandBuffers( vkGetInstanceProcAddr( instance, "vkFreeCommandBuffers" ) );
|
|
|
21478 vkBeginCommandBuffer = PFN_vkBeginCommandBuffer( vkGetInstanceProcAddr( instance, "vkBeginCommandBuffer" ) );
|
|
|
21479 vkEndCommandBuffer = PFN_vkEndCommandBuffer( vkGetInstanceProcAddr( instance, "vkEndCommandBuffer" ) );
|
|
|
21480 vkResetCommandBuffer = PFN_vkResetCommandBuffer( vkGetInstanceProcAddr( instance, "vkResetCommandBuffer" ) );
|
|
|
21481 vkCmdCopyBuffer = PFN_vkCmdCopyBuffer( vkGetInstanceProcAddr( instance, "vkCmdCopyBuffer" ) );
|
|
|
21482 vkCmdCopyImage = PFN_vkCmdCopyImage( vkGetInstanceProcAddr( instance, "vkCmdCopyImage" ) );
|
|
|
21483 vkCmdCopyBufferToImage = PFN_vkCmdCopyBufferToImage( vkGetInstanceProcAddr( instance, "vkCmdCopyBufferToImage" ) );
|
|
|
21484 vkCmdCopyImageToBuffer = PFN_vkCmdCopyImageToBuffer( vkGetInstanceProcAddr( instance, "vkCmdCopyImageToBuffer" ) );
|
|
|
21485 vkCmdUpdateBuffer = PFN_vkCmdUpdateBuffer( vkGetInstanceProcAddr( instance, "vkCmdUpdateBuffer" ) );
|
|
|
21486 vkCmdFillBuffer = PFN_vkCmdFillBuffer( vkGetInstanceProcAddr( instance, "vkCmdFillBuffer" ) );
|
|
|
21487 vkCmdPipelineBarrier = PFN_vkCmdPipelineBarrier( vkGetInstanceProcAddr( instance, "vkCmdPipelineBarrier" ) );
|
|
|
21488 vkCmdBeginQuery = PFN_vkCmdBeginQuery( vkGetInstanceProcAddr( instance, "vkCmdBeginQuery" ) );
|
|
|
21489 vkCmdEndQuery = PFN_vkCmdEndQuery( vkGetInstanceProcAddr( instance, "vkCmdEndQuery" ) );
|
|
|
21490 vkCmdResetQueryPool = PFN_vkCmdResetQueryPool( vkGetInstanceProcAddr( instance, "vkCmdResetQueryPool" ) );
|
|
|
21491 vkCmdWriteTimestamp = PFN_vkCmdWriteTimestamp( vkGetInstanceProcAddr( instance, "vkCmdWriteTimestamp" ) );
|
|
|
21492 vkCmdCopyQueryPoolResults = PFN_vkCmdCopyQueryPoolResults( vkGetInstanceProcAddr( instance, "vkCmdCopyQueryPoolResults" ) );
|
|
|
21493 vkCmdExecuteCommands = PFN_vkCmdExecuteCommands( vkGetInstanceProcAddr( instance, "vkCmdExecuteCommands" ) );
|
|
|
21494 vkCreateEvent = PFN_vkCreateEvent( vkGetInstanceProcAddr( instance, "vkCreateEvent" ) );
|
|
|
21495 vkDestroyEvent = PFN_vkDestroyEvent( vkGetInstanceProcAddr( instance, "vkDestroyEvent" ) );
|
|
|
21496 vkGetEventStatus = PFN_vkGetEventStatus( vkGetInstanceProcAddr( instance, "vkGetEventStatus" ) );
|
|
|
21497 vkSetEvent = PFN_vkSetEvent( vkGetInstanceProcAddr( instance, "vkSetEvent" ) );
|
|
|
21498 vkResetEvent = PFN_vkResetEvent( vkGetInstanceProcAddr( instance, "vkResetEvent" ) );
|
|
|
21499 vkCreateBufferView = PFN_vkCreateBufferView( vkGetInstanceProcAddr( instance, "vkCreateBufferView" ) );
|
|
|
21500 vkDestroyBufferView = PFN_vkDestroyBufferView( vkGetInstanceProcAddr( instance, "vkDestroyBufferView" ) );
|
|
|
21501 vkCreateShaderModule = PFN_vkCreateShaderModule( vkGetInstanceProcAddr( instance, "vkCreateShaderModule" ) );
|
|
|
21502 vkDestroyShaderModule = PFN_vkDestroyShaderModule( vkGetInstanceProcAddr( instance, "vkDestroyShaderModule" ) );
|
|
|
21503 vkCreatePipelineCache = PFN_vkCreatePipelineCache( vkGetInstanceProcAddr( instance, "vkCreatePipelineCache" ) );
|
|
|
21504 vkDestroyPipelineCache = PFN_vkDestroyPipelineCache( vkGetInstanceProcAddr( instance, "vkDestroyPipelineCache" ) );
|
|
|
21505 vkGetPipelineCacheData = PFN_vkGetPipelineCacheData( vkGetInstanceProcAddr( instance, "vkGetPipelineCacheData" ) );
|
|
|
21506 vkMergePipelineCaches = PFN_vkMergePipelineCaches( vkGetInstanceProcAddr( instance, "vkMergePipelineCaches" ) );
|
|
|
21507 vkCreateComputePipelines = PFN_vkCreateComputePipelines( vkGetInstanceProcAddr( instance, "vkCreateComputePipelines" ) );
|
|
|
21508 vkDestroyPipeline = PFN_vkDestroyPipeline( vkGetInstanceProcAddr( instance, "vkDestroyPipeline" ) );
|
|
|
21509 vkCreatePipelineLayout = PFN_vkCreatePipelineLayout( vkGetInstanceProcAddr( instance, "vkCreatePipelineLayout" ) );
|
|
|
21510 vkDestroyPipelineLayout = PFN_vkDestroyPipelineLayout( vkGetInstanceProcAddr( instance, "vkDestroyPipelineLayout" ) );
|
|
|
21511 vkCreateSampler = PFN_vkCreateSampler( vkGetInstanceProcAddr( instance, "vkCreateSampler" ) );
|
|
|
21512 vkDestroySampler = PFN_vkDestroySampler( vkGetInstanceProcAddr( instance, "vkDestroySampler" ) );
|
|
|
21513 vkCreateDescriptorSetLayout = PFN_vkCreateDescriptorSetLayout( vkGetInstanceProcAddr( instance, "vkCreateDescriptorSetLayout" ) );
|
|
|
21514 vkDestroyDescriptorSetLayout = PFN_vkDestroyDescriptorSetLayout( vkGetInstanceProcAddr( instance, "vkDestroyDescriptorSetLayout" ) );
|
|
|
21515 vkCreateDescriptorPool = PFN_vkCreateDescriptorPool( vkGetInstanceProcAddr( instance, "vkCreateDescriptorPool" ) );
|
|
|
21516 vkDestroyDescriptorPool = PFN_vkDestroyDescriptorPool( vkGetInstanceProcAddr( instance, "vkDestroyDescriptorPool" ) );
|
|
|
21517 vkResetDescriptorPool = PFN_vkResetDescriptorPool( vkGetInstanceProcAddr( instance, "vkResetDescriptorPool" ) );
|
|
|
21518 vkAllocateDescriptorSets = PFN_vkAllocateDescriptorSets( vkGetInstanceProcAddr( instance, "vkAllocateDescriptorSets" ) );
|
|
|
21519 vkFreeDescriptorSets = PFN_vkFreeDescriptorSets( vkGetInstanceProcAddr( instance, "vkFreeDescriptorSets" ) );
|
|
|
21520 vkUpdateDescriptorSets = PFN_vkUpdateDescriptorSets( vkGetInstanceProcAddr( instance, "vkUpdateDescriptorSets" ) );
|
|
|
21521 vkCmdBindPipeline = PFN_vkCmdBindPipeline( vkGetInstanceProcAddr( instance, "vkCmdBindPipeline" ) );
|
|
|
21522 vkCmdBindDescriptorSets = PFN_vkCmdBindDescriptorSets( vkGetInstanceProcAddr( instance, "vkCmdBindDescriptorSets" ) );
|
|
|
21523 vkCmdClearColorImage = PFN_vkCmdClearColorImage( vkGetInstanceProcAddr( instance, "vkCmdClearColorImage" ) );
|
|
|
21524 vkCmdDispatch = PFN_vkCmdDispatch( vkGetInstanceProcAddr( instance, "vkCmdDispatch" ) );
|
|
|
21525 vkCmdDispatchIndirect = PFN_vkCmdDispatchIndirect( vkGetInstanceProcAddr( instance, "vkCmdDispatchIndirect" ) );
|
|
|
21526 vkCmdSetEvent = PFN_vkCmdSetEvent( vkGetInstanceProcAddr( instance, "vkCmdSetEvent" ) );
|
|
|
21527 vkCmdResetEvent = PFN_vkCmdResetEvent( vkGetInstanceProcAddr( instance, "vkCmdResetEvent" ) );
|
|
|
21528 vkCmdWaitEvents = PFN_vkCmdWaitEvents( vkGetInstanceProcAddr( instance, "vkCmdWaitEvents" ) );
|
|
|
21529 vkCmdPushConstants = PFN_vkCmdPushConstants( vkGetInstanceProcAddr( instance, "vkCmdPushConstants" ) );
|
|
|
21530 vkCreateGraphicsPipelines = PFN_vkCreateGraphicsPipelines( vkGetInstanceProcAddr( instance, "vkCreateGraphicsPipelines" ) );
|
|
|
21531 vkCreateFramebuffer = PFN_vkCreateFramebuffer( vkGetInstanceProcAddr( instance, "vkCreateFramebuffer" ) );
|
|
|
21532 vkDestroyFramebuffer = PFN_vkDestroyFramebuffer( vkGetInstanceProcAddr( instance, "vkDestroyFramebuffer" ) );
|
|
|
21533 vkCreateRenderPass = PFN_vkCreateRenderPass( vkGetInstanceProcAddr( instance, "vkCreateRenderPass" ) );
|
|
|
21534 vkDestroyRenderPass = PFN_vkDestroyRenderPass( vkGetInstanceProcAddr( instance, "vkDestroyRenderPass" ) );
|
|
|
21535 vkGetRenderAreaGranularity = PFN_vkGetRenderAreaGranularity( vkGetInstanceProcAddr( instance, "vkGetRenderAreaGranularity" ) );
|
|
|
21536 vkCmdSetViewport = PFN_vkCmdSetViewport( vkGetInstanceProcAddr( instance, "vkCmdSetViewport" ) );
|
|
|
21537 vkCmdSetScissor = PFN_vkCmdSetScissor( vkGetInstanceProcAddr( instance, "vkCmdSetScissor" ) );
|
|
|
21538 vkCmdSetLineWidth = PFN_vkCmdSetLineWidth( vkGetInstanceProcAddr( instance, "vkCmdSetLineWidth" ) );
|
|
|
21539 vkCmdSetDepthBias = PFN_vkCmdSetDepthBias( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBias" ) );
|
|
|
21540 vkCmdSetBlendConstants = PFN_vkCmdSetBlendConstants( vkGetInstanceProcAddr( instance, "vkCmdSetBlendConstants" ) );
|
|
|
21541 vkCmdSetDepthBounds = PFN_vkCmdSetDepthBounds( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBounds" ) );
|
|
|
21542 vkCmdSetStencilCompareMask = PFN_vkCmdSetStencilCompareMask( vkGetInstanceProcAddr( instance, "vkCmdSetStencilCompareMask" ) );
|
|
|
21543 vkCmdSetStencilWriteMask = PFN_vkCmdSetStencilWriteMask( vkGetInstanceProcAddr( instance, "vkCmdSetStencilWriteMask" ) );
|
|
|
21544 vkCmdSetStencilReference = PFN_vkCmdSetStencilReference( vkGetInstanceProcAddr( instance, "vkCmdSetStencilReference" ) );
|
|
|
21545 vkCmdBindIndexBuffer = PFN_vkCmdBindIndexBuffer( vkGetInstanceProcAddr( instance, "vkCmdBindIndexBuffer" ) );
|
|
|
21546 vkCmdBindVertexBuffers = PFN_vkCmdBindVertexBuffers( vkGetInstanceProcAddr( instance, "vkCmdBindVertexBuffers" ) );
|
|
|
21547 vkCmdDraw = PFN_vkCmdDraw( vkGetInstanceProcAddr( instance, "vkCmdDraw" ) );
|
|
|
21548 vkCmdDrawIndexed = PFN_vkCmdDrawIndexed( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexed" ) );
|
|
|
21549 vkCmdDrawIndirect = PFN_vkCmdDrawIndirect( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirect" ) );
|
|
|
21550 vkCmdDrawIndexedIndirect = PFN_vkCmdDrawIndexedIndirect( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirect" ) );
|
|
|
21551 vkCmdBlitImage = PFN_vkCmdBlitImage( vkGetInstanceProcAddr( instance, "vkCmdBlitImage" ) );
|
|
|
21552 vkCmdClearDepthStencilImage = PFN_vkCmdClearDepthStencilImage( vkGetInstanceProcAddr( instance, "vkCmdClearDepthStencilImage" ) );
|
|
|
21553 vkCmdClearAttachments = PFN_vkCmdClearAttachments( vkGetInstanceProcAddr( instance, "vkCmdClearAttachments" ) );
|
|
|
21554 vkCmdResolveImage = PFN_vkCmdResolveImage( vkGetInstanceProcAddr( instance, "vkCmdResolveImage" ) );
|
|
|
21555 vkCmdBeginRenderPass = PFN_vkCmdBeginRenderPass( vkGetInstanceProcAddr( instance, "vkCmdBeginRenderPass" ) );
|
|
|
21556 vkCmdNextSubpass = PFN_vkCmdNextSubpass( vkGetInstanceProcAddr( instance, "vkCmdNextSubpass" ) );
|
|
|
21557 vkCmdEndRenderPass = PFN_vkCmdEndRenderPass( vkGetInstanceProcAddr( instance, "vkCmdEndRenderPass" ) );
|
|
|
21558
|
|
|
21559 //=== VK_VERSION_1_1 ===
|
|
|
21560 vkBindBufferMemory2 = PFN_vkBindBufferMemory2( vkGetInstanceProcAddr( instance, "vkBindBufferMemory2" ) );
|
|
|
21561 vkBindImageMemory2 = PFN_vkBindImageMemory2( vkGetInstanceProcAddr( instance, "vkBindImageMemory2" ) );
|
|
|
21562 vkGetDeviceGroupPeerMemoryFeatures = PFN_vkGetDeviceGroupPeerMemoryFeatures( vkGetInstanceProcAddr( instance, "vkGetDeviceGroupPeerMemoryFeatures" ) );
|
|
|
21563 vkCmdSetDeviceMask = PFN_vkCmdSetDeviceMask( vkGetInstanceProcAddr( instance, "vkCmdSetDeviceMask" ) );
|
|
|
21564 vkEnumeratePhysicalDeviceGroups = PFN_vkEnumeratePhysicalDeviceGroups( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceGroups" ) );
|
|
|
21565 vkGetImageMemoryRequirements2 = PFN_vkGetImageMemoryRequirements2( vkGetInstanceProcAddr( instance, "vkGetImageMemoryRequirements2" ) );
|
|
|
21566 vkGetBufferMemoryRequirements2 = PFN_vkGetBufferMemoryRequirements2( vkGetInstanceProcAddr( instance, "vkGetBufferMemoryRequirements2" ) );
|
|
|
21567 vkGetImageSparseMemoryRequirements2 =
|
|
|
21568 PFN_vkGetImageSparseMemoryRequirements2( vkGetInstanceProcAddr( instance, "vkGetImageSparseMemoryRequirements2" ) );
|
|
|
21569 vkGetPhysicalDeviceFeatures2 = PFN_vkGetPhysicalDeviceFeatures2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures2" ) );
|
|
|
21570 vkGetPhysicalDeviceProperties2 = PFN_vkGetPhysicalDeviceProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties2" ) );
|
|
|
21571 vkGetPhysicalDeviceFormatProperties2 =
|
|
|
21572 PFN_vkGetPhysicalDeviceFormatProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties2" ) );
|
|
|
21573 vkGetPhysicalDeviceImageFormatProperties2 =
|
|
|
21574 PFN_vkGetPhysicalDeviceImageFormatProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties2" ) );
|
|
|
21575 vkGetPhysicalDeviceQueueFamilyProperties2 =
|
|
|
21576 PFN_vkGetPhysicalDeviceQueueFamilyProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties2" ) );
|
|
|
21577 vkGetPhysicalDeviceMemoryProperties2 =
|
|
|
21578 PFN_vkGetPhysicalDeviceMemoryProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties2" ) );
|
|
|
21579 vkGetPhysicalDeviceSparseImageFormatProperties2 =
|
|
|
21580 PFN_vkGetPhysicalDeviceSparseImageFormatProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties2" ) );
|
|
|
21581 vkTrimCommandPool = PFN_vkTrimCommandPool( vkGetInstanceProcAddr( instance, "vkTrimCommandPool" ) );
|
|
|
21582 vkGetDeviceQueue2 = PFN_vkGetDeviceQueue2( vkGetInstanceProcAddr( instance, "vkGetDeviceQueue2" ) );
|
|
|
21583 vkGetPhysicalDeviceExternalBufferProperties =
|
|
|
21584 PFN_vkGetPhysicalDeviceExternalBufferProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalBufferProperties" ) );
|
|
|
21585 vkGetPhysicalDeviceExternalFenceProperties =
|
|
|
21586 PFN_vkGetPhysicalDeviceExternalFenceProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalFenceProperties" ) );
|
|
|
21587 vkGetPhysicalDeviceExternalSemaphoreProperties =
|
|
|
21588 PFN_vkGetPhysicalDeviceExternalSemaphoreProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalSemaphoreProperties" ) );
|
|
|
21589 vkCmdDispatchBase = PFN_vkCmdDispatchBase( vkGetInstanceProcAddr( instance, "vkCmdDispatchBase" ) );
|
|
|
21590 vkCreateDescriptorUpdateTemplate = PFN_vkCreateDescriptorUpdateTemplate( vkGetInstanceProcAddr( instance, "vkCreateDescriptorUpdateTemplate" ) );
|
|
|
21591 vkDestroyDescriptorUpdateTemplate = PFN_vkDestroyDescriptorUpdateTemplate( vkGetInstanceProcAddr( instance, "vkDestroyDescriptorUpdateTemplate" ) );
|
|
|
21592 vkUpdateDescriptorSetWithTemplate = PFN_vkUpdateDescriptorSetWithTemplate( vkGetInstanceProcAddr( instance, "vkUpdateDescriptorSetWithTemplate" ) );
|
|
|
21593 vkGetDescriptorSetLayoutSupport = PFN_vkGetDescriptorSetLayoutSupport( vkGetInstanceProcAddr( instance, "vkGetDescriptorSetLayoutSupport" ) );
|
|
|
21594 vkCreateSamplerYcbcrConversion = PFN_vkCreateSamplerYcbcrConversion( vkGetInstanceProcAddr( instance, "vkCreateSamplerYcbcrConversion" ) );
|
|
|
21595 vkDestroySamplerYcbcrConversion = PFN_vkDestroySamplerYcbcrConversion( vkGetInstanceProcAddr( instance, "vkDestroySamplerYcbcrConversion" ) );
|
|
|
21596
|
|
|
21597 //=== VK_VERSION_1_2 ===
|
|
|
21598 vkResetQueryPool = PFN_vkResetQueryPool( vkGetInstanceProcAddr( instance, "vkResetQueryPool" ) );
|
|
|
21599 vkGetSemaphoreCounterValue = PFN_vkGetSemaphoreCounterValue( vkGetInstanceProcAddr( instance, "vkGetSemaphoreCounterValue" ) );
|
|
|
21600 vkWaitSemaphores = PFN_vkWaitSemaphores( vkGetInstanceProcAddr( instance, "vkWaitSemaphores" ) );
|
|
|
21601 vkSignalSemaphore = PFN_vkSignalSemaphore( vkGetInstanceProcAddr( instance, "vkSignalSemaphore" ) );
|
|
|
21602 vkGetBufferDeviceAddress = PFN_vkGetBufferDeviceAddress( vkGetInstanceProcAddr( instance, "vkGetBufferDeviceAddress" ) );
|
|
|
21603 vkGetBufferOpaqueCaptureAddress = PFN_vkGetBufferOpaqueCaptureAddress( vkGetInstanceProcAddr( instance, "vkGetBufferOpaqueCaptureAddress" ) );
|
|
|
21604 vkGetDeviceMemoryOpaqueCaptureAddress =
|
|
|
21605 PFN_vkGetDeviceMemoryOpaqueCaptureAddress( vkGetInstanceProcAddr( instance, "vkGetDeviceMemoryOpaqueCaptureAddress" ) );
|
|
|
21606 vkCmdDrawIndirectCount = PFN_vkCmdDrawIndirectCount( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectCount" ) );
|
|
|
21607 vkCmdDrawIndexedIndirectCount = PFN_vkCmdDrawIndexedIndirectCount( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirectCount" ) );
|
|
|
21608 vkCreateRenderPass2 = PFN_vkCreateRenderPass2( vkGetInstanceProcAddr( instance, "vkCreateRenderPass2" ) );
|
|
|
21609 vkCmdBeginRenderPass2 = PFN_vkCmdBeginRenderPass2( vkGetInstanceProcAddr( instance, "vkCmdBeginRenderPass2" ) );
|
|
|
21610 vkCmdNextSubpass2 = PFN_vkCmdNextSubpass2( vkGetInstanceProcAddr( instance, "vkCmdNextSubpass2" ) );
|
|
|
21611 vkCmdEndRenderPass2 = PFN_vkCmdEndRenderPass2( vkGetInstanceProcAddr( instance, "vkCmdEndRenderPass2" ) );
|
|
|
21612
|
|
|
21613 //=== VK_VERSION_1_3 ===
|
|
|
21614 vkGetPhysicalDeviceToolProperties = PFN_vkGetPhysicalDeviceToolProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceToolProperties" ) );
|
|
|
21615 vkCreatePrivateDataSlot = PFN_vkCreatePrivateDataSlot( vkGetInstanceProcAddr( instance, "vkCreatePrivateDataSlot" ) );
|
|
|
21616 vkDestroyPrivateDataSlot = PFN_vkDestroyPrivateDataSlot( vkGetInstanceProcAddr( instance, "vkDestroyPrivateDataSlot" ) );
|
|
|
21617 vkSetPrivateData = PFN_vkSetPrivateData( vkGetInstanceProcAddr( instance, "vkSetPrivateData" ) );
|
|
|
21618 vkGetPrivateData = PFN_vkGetPrivateData( vkGetInstanceProcAddr( instance, "vkGetPrivateData" ) );
|
|
|
21619 vkCmdPipelineBarrier2 = PFN_vkCmdPipelineBarrier2( vkGetInstanceProcAddr( instance, "vkCmdPipelineBarrier2" ) );
|
|
|
21620 vkCmdWriteTimestamp2 = PFN_vkCmdWriteTimestamp2( vkGetInstanceProcAddr( instance, "vkCmdWriteTimestamp2" ) );
|
|
|
21621 vkQueueSubmit2 = PFN_vkQueueSubmit2( vkGetInstanceProcAddr( instance, "vkQueueSubmit2" ) );
|
|
|
21622 vkCmdCopyBuffer2 = PFN_vkCmdCopyBuffer2( vkGetInstanceProcAddr( instance, "vkCmdCopyBuffer2" ) );
|
|
|
21623 vkCmdCopyImage2 = PFN_vkCmdCopyImage2( vkGetInstanceProcAddr( instance, "vkCmdCopyImage2" ) );
|
|
|
21624 vkCmdCopyBufferToImage2 = PFN_vkCmdCopyBufferToImage2( vkGetInstanceProcAddr( instance, "vkCmdCopyBufferToImage2" ) );
|
|
|
21625 vkCmdCopyImageToBuffer2 = PFN_vkCmdCopyImageToBuffer2( vkGetInstanceProcAddr( instance, "vkCmdCopyImageToBuffer2" ) );
|
|
|
21626 vkGetDeviceBufferMemoryRequirements =
|
|
|
21627 PFN_vkGetDeviceBufferMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetDeviceBufferMemoryRequirements" ) );
|
|
|
21628 vkGetDeviceImageMemoryRequirements = PFN_vkGetDeviceImageMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetDeviceImageMemoryRequirements" ) );
|
|
|
21629 vkGetDeviceImageSparseMemoryRequirements =
|
|
|
21630 PFN_vkGetDeviceImageSparseMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetDeviceImageSparseMemoryRequirements" ) );
|
|
|
21631 vkCmdSetEvent2 = PFN_vkCmdSetEvent2( vkGetInstanceProcAddr( instance, "vkCmdSetEvent2" ) );
|
|
|
21632 vkCmdResetEvent2 = PFN_vkCmdResetEvent2( vkGetInstanceProcAddr( instance, "vkCmdResetEvent2" ) );
|
|
|
21633 vkCmdWaitEvents2 = PFN_vkCmdWaitEvents2( vkGetInstanceProcAddr( instance, "vkCmdWaitEvents2" ) );
|
|
|
21634 vkCmdBlitImage2 = PFN_vkCmdBlitImage2( vkGetInstanceProcAddr( instance, "vkCmdBlitImage2" ) );
|
|
|
21635 vkCmdResolveImage2 = PFN_vkCmdResolveImage2( vkGetInstanceProcAddr( instance, "vkCmdResolveImage2" ) );
|
|
|
21636 vkCmdBeginRendering = PFN_vkCmdBeginRendering( vkGetInstanceProcAddr( instance, "vkCmdBeginRendering" ) );
|
|
|
21637 vkCmdEndRendering = PFN_vkCmdEndRendering( vkGetInstanceProcAddr( instance, "vkCmdEndRendering" ) );
|
|
|
21638 vkCmdSetCullMode = PFN_vkCmdSetCullMode( vkGetInstanceProcAddr( instance, "vkCmdSetCullMode" ) );
|
|
|
21639 vkCmdSetFrontFace = PFN_vkCmdSetFrontFace( vkGetInstanceProcAddr( instance, "vkCmdSetFrontFace" ) );
|
|
|
21640 vkCmdSetPrimitiveTopology = PFN_vkCmdSetPrimitiveTopology( vkGetInstanceProcAddr( instance, "vkCmdSetPrimitiveTopology" ) );
|
|
|
21641 vkCmdSetViewportWithCount = PFN_vkCmdSetViewportWithCount( vkGetInstanceProcAddr( instance, "vkCmdSetViewportWithCount" ) );
|
|
|
21642 vkCmdSetScissorWithCount = PFN_vkCmdSetScissorWithCount( vkGetInstanceProcAddr( instance, "vkCmdSetScissorWithCount" ) );
|
|
|
21643 vkCmdBindVertexBuffers2 = PFN_vkCmdBindVertexBuffers2( vkGetInstanceProcAddr( instance, "vkCmdBindVertexBuffers2" ) );
|
|
|
21644 vkCmdSetDepthTestEnable = PFN_vkCmdSetDepthTestEnable( vkGetInstanceProcAddr( instance, "vkCmdSetDepthTestEnable" ) );
|
|
|
21645 vkCmdSetDepthWriteEnable = PFN_vkCmdSetDepthWriteEnable( vkGetInstanceProcAddr( instance, "vkCmdSetDepthWriteEnable" ) );
|
|
|
21646 vkCmdSetDepthCompareOp = PFN_vkCmdSetDepthCompareOp( vkGetInstanceProcAddr( instance, "vkCmdSetDepthCompareOp" ) );
|
|
|
21647 vkCmdSetDepthBoundsTestEnable = PFN_vkCmdSetDepthBoundsTestEnable( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBoundsTestEnable" ) );
|
|
|
21648 vkCmdSetStencilTestEnable = PFN_vkCmdSetStencilTestEnable( vkGetInstanceProcAddr( instance, "vkCmdSetStencilTestEnable" ) );
|
|
|
21649 vkCmdSetStencilOp = PFN_vkCmdSetStencilOp( vkGetInstanceProcAddr( instance, "vkCmdSetStencilOp" ) );
|
|
|
21650 vkCmdSetRasterizerDiscardEnable = PFN_vkCmdSetRasterizerDiscardEnable( vkGetInstanceProcAddr( instance, "vkCmdSetRasterizerDiscardEnable" ) );
|
|
|
21651 vkCmdSetDepthBiasEnable = PFN_vkCmdSetDepthBiasEnable( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBiasEnable" ) );
|
|
|
21652 vkCmdSetPrimitiveRestartEnable = PFN_vkCmdSetPrimitiveRestartEnable( vkGetInstanceProcAddr( instance, "vkCmdSetPrimitiveRestartEnable" ) );
|
|
|
21653
|
|
|
21654 //=== VK_VERSION_1_4 ===
|
|
|
21655 vkMapMemory2 = PFN_vkMapMemory2( vkGetInstanceProcAddr( instance, "vkMapMemory2" ) );
|
|
|
21656 vkUnmapMemory2 = PFN_vkUnmapMemory2( vkGetInstanceProcAddr( instance, "vkUnmapMemory2" ) );
|
|
|
21657 vkGetDeviceImageSubresourceLayout = PFN_vkGetDeviceImageSubresourceLayout( vkGetInstanceProcAddr( instance, "vkGetDeviceImageSubresourceLayout" ) );
|
|
|
21658 vkGetImageSubresourceLayout2 = PFN_vkGetImageSubresourceLayout2( vkGetInstanceProcAddr( instance, "vkGetImageSubresourceLayout2" ) );
|
|
|
21659 vkCopyMemoryToImage = PFN_vkCopyMemoryToImage( vkGetInstanceProcAddr( instance, "vkCopyMemoryToImage" ) );
|
|
|
21660 vkCopyImageToMemory = PFN_vkCopyImageToMemory( vkGetInstanceProcAddr( instance, "vkCopyImageToMemory" ) );
|
|
|
21661 vkCopyImageToImage = PFN_vkCopyImageToImage( vkGetInstanceProcAddr( instance, "vkCopyImageToImage" ) );
|
|
|
21662 vkTransitionImageLayout = PFN_vkTransitionImageLayout( vkGetInstanceProcAddr( instance, "vkTransitionImageLayout" ) );
|
|
|
21663 vkCmdPushDescriptorSet = PFN_vkCmdPushDescriptorSet( vkGetInstanceProcAddr( instance, "vkCmdPushDescriptorSet" ) );
|
|
|
21664 vkCmdPushDescriptorSetWithTemplate = PFN_vkCmdPushDescriptorSetWithTemplate( vkGetInstanceProcAddr( instance, "vkCmdPushDescriptorSetWithTemplate" ) );
|
|
|
21665 vkCmdBindDescriptorSets2 = PFN_vkCmdBindDescriptorSets2( vkGetInstanceProcAddr( instance, "vkCmdBindDescriptorSets2" ) );
|
|
|
21666 vkCmdPushConstants2 = PFN_vkCmdPushConstants2( vkGetInstanceProcAddr( instance, "vkCmdPushConstants2" ) );
|
|
|
21667 vkCmdPushDescriptorSet2 = PFN_vkCmdPushDescriptorSet2( vkGetInstanceProcAddr( instance, "vkCmdPushDescriptorSet2" ) );
|
|
|
21668 vkCmdPushDescriptorSetWithTemplate2 =
|
|
|
21669 PFN_vkCmdPushDescriptorSetWithTemplate2( vkGetInstanceProcAddr( instance, "vkCmdPushDescriptorSetWithTemplate2" ) );
|
|
|
21670 vkCmdSetLineStipple = PFN_vkCmdSetLineStipple( vkGetInstanceProcAddr( instance, "vkCmdSetLineStipple" ) );
|
|
|
21671 vkCmdBindIndexBuffer2 = PFN_vkCmdBindIndexBuffer2( vkGetInstanceProcAddr( instance, "vkCmdBindIndexBuffer2" ) );
|
|
|
21672 vkGetRenderingAreaGranularity = PFN_vkGetRenderingAreaGranularity( vkGetInstanceProcAddr( instance, "vkGetRenderingAreaGranularity" ) );
|
|
|
21673 vkCmdSetRenderingAttachmentLocations =
|
|
|
21674 PFN_vkCmdSetRenderingAttachmentLocations( vkGetInstanceProcAddr( instance, "vkCmdSetRenderingAttachmentLocations" ) );
|
|
|
21675 vkCmdSetRenderingInputAttachmentIndices =
|
|
|
21676 PFN_vkCmdSetRenderingInputAttachmentIndices( vkGetInstanceProcAddr( instance, "vkCmdSetRenderingInputAttachmentIndices" ) );
|
|
|
21677
|
|
|
21678 //=== VK_KHR_surface ===
|
|
|
21679 vkDestroySurfaceKHR = PFN_vkDestroySurfaceKHR( vkGetInstanceProcAddr( instance, "vkDestroySurfaceKHR" ) );
|
|
|
21680 vkGetPhysicalDeviceSurfaceSupportKHR =
|
|
|
21681 PFN_vkGetPhysicalDeviceSurfaceSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceSupportKHR" ) );
|
|
|
21682 vkGetPhysicalDeviceSurfaceCapabilitiesKHR =
|
|
|
21683 PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR" ) );
|
|
|
21684 vkGetPhysicalDeviceSurfaceFormatsKHR =
|
|
|
21685 PFN_vkGetPhysicalDeviceSurfaceFormatsKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceFormatsKHR" ) );
|
|
|
21686 vkGetPhysicalDeviceSurfacePresentModesKHR =
|
|
|
21687 PFN_vkGetPhysicalDeviceSurfacePresentModesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfacePresentModesKHR" ) );
|
|
|
21688
|
|
|
21689 //=== VK_KHR_swapchain ===
|
|
|
21690 vkCreateSwapchainKHR = PFN_vkCreateSwapchainKHR( vkGetInstanceProcAddr( instance, "vkCreateSwapchainKHR" ) );
|
|
|
21691 vkDestroySwapchainKHR = PFN_vkDestroySwapchainKHR( vkGetInstanceProcAddr( instance, "vkDestroySwapchainKHR" ) );
|
|
|
21692 vkGetSwapchainImagesKHR = PFN_vkGetSwapchainImagesKHR( vkGetInstanceProcAddr( instance, "vkGetSwapchainImagesKHR" ) );
|
|
|
21693 vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR( vkGetInstanceProcAddr( instance, "vkAcquireNextImageKHR" ) );
|
|
|
21694 vkQueuePresentKHR = PFN_vkQueuePresentKHR( vkGetInstanceProcAddr( instance, "vkQueuePresentKHR" ) );
|
|
|
21695 vkGetDeviceGroupPresentCapabilitiesKHR =
|
|
|
21696 PFN_vkGetDeviceGroupPresentCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceGroupPresentCapabilitiesKHR" ) );
|
|
|
21697 vkGetDeviceGroupSurfacePresentModesKHR =
|
|
|
21698 PFN_vkGetDeviceGroupSurfacePresentModesKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceGroupSurfacePresentModesKHR" ) );
|
|
|
21699 vkGetPhysicalDevicePresentRectanglesKHR =
|
|
|
21700 PFN_vkGetPhysicalDevicePresentRectanglesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDevicePresentRectanglesKHR" ) );
|
|
|
21701 vkAcquireNextImage2KHR = PFN_vkAcquireNextImage2KHR( vkGetInstanceProcAddr( instance, "vkAcquireNextImage2KHR" ) );
|
|
|
21702
|
|
|
21703 //=== VK_KHR_display ===
|
|
|
21704 vkGetPhysicalDeviceDisplayPropertiesKHR =
|
|
|
21705 PFN_vkGetPhysicalDeviceDisplayPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPropertiesKHR" ) );
|
|
|
21706 vkGetPhysicalDeviceDisplayPlanePropertiesKHR =
|
|
|
21707 PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR" ) );
|
|
|
21708 vkGetDisplayPlaneSupportedDisplaysKHR =
|
|
|
21709 PFN_vkGetDisplayPlaneSupportedDisplaysKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneSupportedDisplaysKHR" ) );
|
|
|
21710 vkGetDisplayModePropertiesKHR = PFN_vkGetDisplayModePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayModePropertiesKHR" ) );
|
|
|
21711 vkCreateDisplayModeKHR = PFN_vkCreateDisplayModeKHR( vkGetInstanceProcAddr( instance, "vkCreateDisplayModeKHR" ) );
|
|
|
21712 vkGetDisplayPlaneCapabilitiesKHR = PFN_vkGetDisplayPlaneCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneCapabilitiesKHR" ) );
|
|
|
21713 vkCreateDisplayPlaneSurfaceKHR = PFN_vkCreateDisplayPlaneSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateDisplayPlaneSurfaceKHR" ) );
|
|
|
21714
|
|
|
21715 //=== VK_KHR_display_swapchain ===
|
|
|
21716 vkCreateSharedSwapchainsKHR = PFN_vkCreateSharedSwapchainsKHR( vkGetInstanceProcAddr( instance, "vkCreateSharedSwapchainsKHR" ) );
|
|
|
21717
|
|
|
21718 #if defined( VK_USE_PLATFORM_XLIB_KHR )
|
|
|
21719 //=== VK_KHR_xlib_surface ===
|
|
|
21720 vkCreateXlibSurfaceKHR = PFN_vkCreateXlibSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateXlibSurfaceKHR" ) );
|
|
|
21721 vkGetPhysicalDeviceXlibPresentationSupportKHR =
|
|
|
21722 PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceXlibPresentationSupportKHR" ) );
|
|
|
21723 #endif /*VK_USE_PLATFORM_XLIB_KHR*/
|
|
|
21724
|
|
|
21725 #if defined( VK_USE_PLATFORM_XCB_KHR )
|
|
|
21726 //=== VK_KHR_xcb_surface ===
|
|
|
21727 vkCreateXcbSurfaceKHR = PFN_vkCreateXcbSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateXcbSurfaceKHR" ) );
|
|
|
21728 vkGetPhysicalDeviceXcbPresentationSupportKHR =
|
|
|
21729 PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceXcbPresentationSupportKHR" ) );
|
|
|
21730 #endif /*VK_USE_PLATFORM_XCB_KHR*/
|
|
|
21731
|
|
|
21732 #if defined( VK_USE_PLATFORM_WAYLAND_KHR )
|
|
|
21733 //=== VK_KHR_wayland_surface ===
|
|
|
21734 vkCreateWaylandSurfaceKHR = PFN_vkCreateWaylandSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateWaylandSurfaceKHR" ) );
|
|
|
21735 vkGetPhysicalDeviceWaylandPresentationSupportKHR =
|
|
|
21736 PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceWaylandPresentationSupportKHR" ) );
|
|
|
21737 #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
|
|
|
21738
|
|
|
21739 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
|
|
21740 //=== VK_KHR_android_surface ===
|
|
|
21741 vkCreateAndroidSurfaceKHR = PFN_vkCreateAndroidSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateAndroidSurfaceKHR" ) );
|
|
|
21742 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
|
|
21743
|
|
|
21744 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
21745 //=== VK_KHR_win32_surface ===
|
|
|
21746 vkCreateWin32SurfaceKHR = PFN_vkCreateWin32SurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateWin32SurfaceKHR" ) );
|
|
|
21747 vkGetPhysicalDeviceWin32PresentationSupportKHR =
|
|
|
21748 PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceWin32PresentationSupportKHR" ) );
|
|
|
21749 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
21750
|
|
|
21751 //=== VK_EXT_debug_report ===
|
|
|
21752 vkCreateDebugReportCallbackEXT = PFN_vkCreateDebugReportCallbackEXT( vkGetInstanceProcAddr( instance, "vkCreateDebugReportCallbackEXT" ) );
|
|
|
21753 vkDestroyDebugReportCallbackEXT = PFN_vkDestroyDebugReportCallbackEXT( vkGetInstanceProcAddr( instance, "vkDestroyDebugReportCallbackEXT" ) );
|
|
|
21754 vkDebugReportMessageEXT = PFN_vkDebugReportMessageEXT( vkGetInstanceProcAddr( instance, "vkDebugReportMessageEXT" ) );
|
|
|
21755
|
|
|
21756 //=== VK_EXT_debug_marker ===
|
|
|
21757 vkDebugMarkerSetObjectTagEXT = PFN_vkDebugMarkerSetObjectTagEXT( vkGetInstanceProcAddr( instance, "vkDebugMarkerSetObjectTagEXT" ) );
|
|
|
21758 vkDebugMarkerSetObjectNameEXT = PFN_vkDebugMarkerSetObjectNameEXT( vkGetInstanceProcAddr( instance, "vkDebugMarkerSetObjectNameEXT" ) );
|
|
|
21759 vkCmdDebugMarkerBeginEXT = PFN_vkCmdDebugMarkerBeginEXT( vkGetInstanceProcAddr( instance, "vkCmdDebugMarkerBeginEXT" ) );
|
|
|
21760 vkCmdDebugMarkerEndEXT = PFN_vkCmdDebugMarkerEndEXT( vkGetInstanceProcAddr( instance, "vkCmdDebugMarkerEndEXT" ) );
|
|
|
21761 vkCmdDebugMarkerInsertEXT = PFN_vkCmdDebugMarkerInsertEXT( vkGetInstanceProcAddr( instance, "vkCmdDebugMarkerInsertEXT" ) );
|
|
|
21762
|
|
|
21763 //=== VK_KHR_video_queue ===
|
|
|
21764 vkGetPhysicalDeviceVideoCapabilitiesKHR =
|
|
|
21765 PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceVideoCapabilitiesKHR" ) );
|
|
|
21766 vkGetPhysicalDeviceVideoFormatPropertiesKHR =
|
|
|
21767 PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceVideoFormatPropertiesKHR" ) );
|
|
|
21768 vkCreateVideoSessionKHR = PFN_vkCreateVideoSessionKHR( vkGetInstanceProcAddr( instance, "vkCreateVideoSessionKHR" ) );
|
|
|
21769 vkDestroyVideoSessionKHR = PFN_vkDestroyVideoSessionKHR( vkGetInstanceProcAddr( instance, "vkDestroyVideoSessionKHR" ) );
|
|
|
21770 vkGetVideoSessionMemoryRequirementsKHR =
|
|
|
21771 PFN_vkGetVideoSessionMemoryRequirementsKHR( vkGetInstanceProcAddr( instance, "vkGetVideoSessionMemoryRequirementsKHR" ) );
|
|
|
21772 vkBindVideoSessionMemoryKHR = PFN_vkBindVideoSessionMemoryKHR( vkGetInstanceProcAddr( instance, "vkBindVideoSessionMemoryKHR" ) );
|
|
|
21773 vkCreateVideoSessionParametersKHR = PFN_vkCreateVideoSessionParametersKHR( vkGetInstanceProcAddr( instance, "vkCreateVideoSessionParametersKHR" ) );
|
|
|
21774 vkUpdateVideoSessionParametersKHR = PFN_vkUpdateVideoSessionParametersKHR( vkGetInstanceProcAddr( instance, "vkUpdateVideoSessionParametersKHR" ) );
|
|
|
21775 vkDestroyVideoSessionParametersKHR = PFN_vkDestroyVideoSessionParametersKHR( vkGetInstanceProcAddr( instance, "vkDestroyVideoSessionParametersKHR" ) );
|
|
|
21776 vkCmdBeginVideoCodingKHR = PFN_vkCmdBeginVideoCodingKHR( vkGetInstanceProcAddr( instance, "vkCmdBeginVideoCodingKHR" ) );
|
|
|
21777 vkCmdEndVideoCodingKHR = PFN_vkCmdEndVideoCodingKHR( vkGetInstanceProcAddr( instance, "vkCmdEndVideoCodingKHR" ) );
|
|
|
21778 vkCmdControlVideoCodingKHR = PFN_vkCmdControlVideoCodingKHR( vkGetInstanceProcAddr( instance, "vkCmdControlVideoCodingKHR" ) );
|
|
|
21779
|
|
|
21780 //=== VK_KHR_video_decode_queue ===
|
|
|
21781 vkCmdDecodeVideoKHR = PFN_vkCmdDecodeVideoKHR( vkGetInstanceProcAddr( instance, "vkCmdDecodeVideoKHR" ) );
|
|
|
21782
|
|
|
21783 //=== VK_EXT_transform_feedback ===
|
|
|
21784 vkCmdBindTransformFeedbackBuffersEXT =
|
|
|
21785 PFN_vkCmdBindTransformFeedbackBuffersEXT( vkGetInstanceProcAddr( instance, "vkCmdBindTransformFeedbackBuffersEXT" ) );
|
|
|
21786 vkCmdBeginTransformFeedbackEXT = PFN_vkCmdBeginTransformFeedbackEXT( vkGetInstanceProcAddr( instance, "vkCmdBeginTransformFeedbackEXT" ) );
|
|
|
21787 vkCmdEndTransformFeedbackEXT = PFN_vkCmdEndTransformFeedbackEXT( vkGetInstanceProcAddr( instance, "vkCmdEndTransformFeedbackEXT" ) );
|
|
|
21788 vkCmdBeginQueryIndexedEXT = PFN_vkCmdBeginQueryIndexedEXT( vkGetInstanceProcAddr( instance, "vkCmdBeginQueryIndexedEXT" ) );
|
|
|
21789 vkCmdEndQueryIndexedEXT = PFN_vkCmdEndQueryIndexedEXT( vkGetInstanceProcAddr( instance, "vkCmdEndQueryIndexedEXT" ) );
|
|
|
21790 vkCmdDrawIndirectByteCountEXT = PFN_vkCmdDrawIndirectByteCountEXT( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectByteCountEXT" ) );
|
|
|
21791
|
|
|
21792 //=== VK_NVX_binary_import ===
|
|
|
21793 vkCreateCuModuleNVX = PFN_vkCreateCuModuleNVX( vkGetInstanceProcAddr( instance, "vkCreateCuModuleNVX" ) );
|
|
|
21794 vkCreateCuFunctionNVX = PFN_vkCreateCuFunctionNVX( vkGetInstanceProcAddr( instance, "vkCreateCuFunctionNVX" ) );
|
|
|
21795 vkDestroyCuModuleNVX = PFN_vkDestroyCuModuleNVX( vkGetInstanceProcAddr( instance, "vkDestroyCuModuleNVX" ) );
|
|
|
21796 vkDestroyCuFunctionNVX = PFN_vkDestroyCuFunctionNVX( vkGetInstanceProcAddr( instance, "vkDestroyCuFunctionNVX" ) );
|
|
|
21797 vkCmdCuLaunchKernelNVX = PFN_vkCmdCuLaunchKernelNVX( vkGetInstanceProcAddr( instance, "vkCmdCuLaunchKernelNVX" ) );
|
|
|
21798
|
|
|
21799 //=== VK_NVX_image_view_handle ===
|
|
|
21800 vkGetImageViewHandleNVX = PFN_vkGetImageViewHandleNVX( vkGetInstanceProcAddr( instance, "vkGetImageViewHandleNVX" ) );
|
|
|
21801 vkGetImageViewHandle64NVX = PFN_vkGetImageViewHandle64NVX( vkGetInstanceProcAddr( instance, "vkGetImageViewHandle64NVX" ) );
|
|
|
21802 vkGetImageViewAddressNVX = PFN_vkGetImageViewAddressNVX( vkGetInstanceProcAddr( instance, "vkGetImageViewAddressNVX" ) );
|
|
|
21803
|
|
|
21804 //=== VK_AMD_draw_indirect_count ===
|
|
|
21805 vkCmdDrawIndirectCountAMD = PFN_vkCmdDrawIndirectCountAMD( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectCountAMD" ) );
|
|
|
21806 if ( !vkCmdDrawIndirectCount )
|
|
|
21807 vkCmdDrawIndirectCount = vkCmdDrawIndirectCountAMD;
|
|
|
21808 vkCmdDrawIndexedIndirectCountAMD = PFN_vkCmdDrawIndexedIndirectCountAMD( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirectCountAMD" ) );
|
|
|
21809 if ( !vkCmdDrawIndexedIndirectCount )
|
|
|
21810 vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountAMD;
|
|
|
21811
|
|
|
21812 //=== VK_AMD_shader_info ===
|
|
|
21813 vkGetShaderInfoAMD = PFN_vkGetShaderInfoAMD( vkGetInstanceProcAddr( instance, "vkGetShaderInfoAMD" ) );
|
|
|
21814
|
|
|
21815 //=== VK_KHR_dynamic_rendering ===
|
|
|
21816 vkCmdBeginRenderingKHR = PFN_vkCmdBeginRenderingKHR( vkGetInstanceProcAddr( instance, "vkCmdBeginRenderingKHR" ) );
|
|
|
21817 if ( !vkCmdBeginRendering )
|
|
|
21818 vkCmdBeginRendering = vkCmdBeginRenderingKHR;
|
|
|
21819 vkCmdEndRenderingKHR = PFN_vkCmdEndRenderingKHR( vkGetInstanceProcAddr( instance, "vkCmdEndRenderingKHR" ) );
|
|
|
21820 if ( !vkCmdEndRendering )
|
|
|
21821 vkCmdEndRendering = vkCmdEndRenderingKHR;
|
|
|
21822
|
|
|
21823 #if defined( VK_USE_PLATFORM_GGP )
|
|
|
21824 //=== VK_GGP_stream_descriptor_surface ===
|
|
|
21825 vkCreateStreamDescriptorSurfaceGGP = PFN_vkCreateStreamDescriptorSurfaceGGP( vkGetInstanceProcAddr( instance, "vkCreateStreamDescriptorSurfaceGGP" ) );
|
|
|
21826 #endif /*VK_USE_PLATFORM_GGP*/
|
|
|
21827
|
|
|
21828 //=== VK_NV_external_memory_capabilities ===
|
|
|
21829 vkGetPhysicalDeviceExternalImageFormatPropertiesNV =
|
|
|
21830 PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV" ) );
|
|
|
21831
|
|
|
21832 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
21833 //=== VK_NV_external_memory_win32 ===
|
|
|
21834 vkGetMemoryWin32HandleNV = PFN_vkGetMemoryWin32HandleNV( vkGetInstanceProcAddr( instance, "vkGetMemoryWin32HandleNV" ) );
|
|
|
21835 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
21836
|
|
|
21837 //=== VK_KHR_get_physical_device_properties2 ===
|
|
|
21838 vkGetPhysicalDeviceFeatures2KHR = PFN_vkGetPhysicalDeviceFeatures2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures2KHR" ) );
|
|
|
21839 if ( !vkGetPhysicalDeviceFeatures2 )
|
|
|
21840 vkGetPhysicalDeviceFeatures2 = vkGetPhysicalDeviceFeatures2KHR;
|
|
|
21841 vkGetPhysicalDeviceProperties2KHR = PFN_vkGetPhysicalDeviceProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties2KHR" ) );
|
|
|
21842 if ( !vkGetPhysicalDeviceProperties2 )
|
|
|
21843 vkGetPhysicalDeviceProperties2 = vkGetPhysicalDeviceProperties2KHR;
|
|
|
21844 vkGetPhysicalDeviceFormatProperties2KHR =
|
|
|
21845 PFN_vkGetPhysicalDeviceFormatProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties2KHR" ) );
|
|
|
21846 if ( !vkGetPhysicalDeviceFormatProperties2 )
|
|
|
21847 vkGetPhysicalDeviceFormatProperties2 = vkGetPhysicalDeviceFormatProperties2KHR;
|
|
|
21848 vkGetPhysicalDeviceImageFormatProperties2KHR =
|
|
|
21849 PFN_vkGetPhysicalDeviceImageFormatProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties2KHR" ) );
|
|
|
21850 if ( !vkGetPhysicalDeviceImageFormatProperties2 )
|
|
|
21851 vkGetPhysicalDeviceImageFormatProperties2 = vkGetPhysicalDeviceImageFormatProperties2KHR;
|
|
|
21852 vkGetPhysicalDeviceQueueFamilyProperties2KHR =
|
|
|
21853 PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties2KHR" ) );
|
|
|
21854 if ( !vkGetPhysicalDeviceQueueFamilyProperties2 )
|
|
|
21855 vkGetPhysicalDeviceQueueFamilyProperties2 = vkGetPhysicalDeviceQueueFamilyProperties2KHR;
|
|
|
21856 vkGetPhysicalDeviceMemoryProperties2KHR =
|
|
|
21857 PFN_vkGetPhysicalDeviceMemoryProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties2KHR" ) );
|
|
|
21858 if ( !vkGetPhysicalDeviceMemoryProperties2 )
|
|
|
21859 vkGetPhysicalDeviceMemoryProperties2 = vkGetPhysicalDeviceMemoryProperties2KHR;
|
|
|
21860 vkGetPhysicalDeviceSparseImageFormatProperties2KHR =
|
|
|
21861 PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR" ) );
|
|
|
21862 if ( !vkGetPhysicalDeviceSparseImageFormatProperties2 )
|
|
|
21863 vkGetPhysicalDeviceSparseImageFormatProperties2 = vkGetPhysicalDeviceSparseImageFormatProperties2KHR;
|
|
|
21864
|
|
|
21865 //=== VK_KHR_device_group ===
|
|
|
21866 vkGetDeviceGroupPeerMemoryFeaturesKHR =
|
|
|
21867 PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceGroupPeerMemoryFeaturesKHR" ) );
|
|
|
21868 if ( !vkGetDeviceGroupPeerMemoryFeatures )
|
|
|
21869 vkGetDeviceGroupPeerMemoryFeatures = vkGetDeviceGroupPeerMemoryFeaturesKHR;
|
|
|
21870 vkCmdSetDeviceMaskKHR = PFN_vkCmdSetDeviceMaskKHR( vkGetInstanceProcAddr( instance, "vkCmdSetDeviceMaskKHR" ) );
|
|
|
21871 if ( !vkCmdSetDeviceMask )
|
|
|
21872 vkCmdSetDeviceMask = vkCmdSetDeviceMaskKHR;
|
|
|
21873 vkCmdDispatchBaseKHR = PFN_vkCmdDispatchBaseKHR( vkGetInstanceProcAddr( instance, "vkCmdDispatchBaseKHR" ) );
|
|
|
21874 if ( !vkCmdDispatchBase )
|
|
|
21875 vkCmdDispatchBase = vkCmdDispatchBaseKHR;
|
|
|
21876
|
|
|
21877 #if defined( VK_USE_PLATFORM_VI_NN )
|
|
|
21878 //=== VK_NN_vi_surface ===
|
|
|
21879 vkCreateViSurfaceNN = PFN_vkCreateViSurfaceNN( vkGetInstanceProcAddr( instance, "vkCreateViSurfaceNN" ) );
|
|
|
21880 #endif /*VK_USE_PLATFORM_VI_NN*/
|
|
|
21881
|
|
|
21882 //=== VK_KHR_maintenance1 ===
|
|
|
21883 vkTrimCommandPoolKHR = PFN_vkTrimCommandPoolKHR( vkGetInstanceProcAddr( instance, "vkTrimCommandPoolKHR" ) );
|
|
|
21884 if ( !vkTrimCommandPool )
|
|
|
21885 vkTrimCommandPool = vkTrimCommandPoolKHR;
|
|
|
21886
|
|
|
21887 //=== VK_KHR_device_group_creation ===
|
|
|
21888 vkEnumeratePhysicalDeviceGroupsKHR = PFN_vkEnumeratePhysicalDeviceGroupsKHR( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceGroupsKHR" ) );
|
|
|
21889 if ( !vkEnumeratePhysicalDeviceGroups )
|
|
|
21890 vkEnumeratePhysicalDeviceGroups = vkEnumeratePhysicalDeviceGroupsKHR;
|
|
|
21891
|
|
|
21892 //=== VK_KHR_external_memory_capabilities ===
|
|
|
21893 vkGetPhysicalDeviceExternalBufferPropertiesKHR =
|
|
|
21894 PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalBufferPropertiesKHR" ) );
|
|
|
21895 if ( !vkGetPhysicalDeviceExternalBufferProperties )
|
|
|
21896 vkGetPhysicalDeviceExternalBufferProperties = vkGetPhysicalDeviceExternalBufferPropertiesKHR;
|
|
|
21897
|
|
|
21898 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
21899 //=== VK_KHR_external_memory_win32 ===
|
|
|
21900 vkGetMemoryWin32HandleKHR = PFN_vkGetMemoryWin32HandleKHR( vkGetInstanceProcAddr( instance, "vkGetMemoryWin32HandleKHR" ) );
|
|
|
21901 vkGetMemoryWin32HandlePropertiesKHR =
|
|
|
21902 PFN_vkGetMemoryWin32HandlePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetMemoryWin32HandlePropertiesKHR" ) );
|
|
|
21903 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
21904
|
|
|
21905 //=== VK_KHR_external_memory_fd ===
|
|
|
21906 vkGetMemoryFdKHR = PFN_vkGetMemoryFdKHR( vkGetInstanceProcAddr( instance, "vkGetMemoryFdKHR" ) );
|
|
|
21907 vkGetMemoryFdPropertiesKHR = PFN_vkGetMemoryFdPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetMemoryFdPropertiesKHR" ) );
|
|
|
21908
|
|
|
21909 //=== VK_KHR_external_semaphore_capabilities ===
|
|
|
21910 vkGetPhysicalDeviceExternalSemaphorePropertiesKHR =
|
|
|
21911 PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR" ) );
|
|
|
21912 if ( !vkGetPhysicalDeviceExternalSemaphoreProperties )
|
|
|
21913 vkGetPhysicalDeviceExternalSemaphoreProperties = vkGetPhysicalDeviceExternalSemaphorePropertiesKHR;
|
|
|
21914
|
|
|
21915 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
21916 //=== VK_KHR_external_semaphore_win32 ===
|
|
|
21917 vkImportSemaphoreWin32HandleKHR = PFN_vkImportSemaphoreWin32HandleKHR( vkGetInstanceProcAddr( instance, "vkImportSemaphoreWin32HandleKHR" ) );
|
|
|
21918 vkGetSemaphoreWin32HandleKHR = PFN_vkGetSemaphoreWin32HandleKHR( vkGetInstanceProcAddr( instance, "vkGetSemaphoreWin32HandleKHR" ) );
|
|
|
21919 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
21920
|
|
|
21921 //=== VK_KHR_external_semaphore_fd ===
|
|
|
21922 vkImportSemaphoreFdKHR = PFN_vkImportSemaphoreFdKHR( vkGetInstanceProcAddr( instance, "vkImportSemaphoreFdKHR" ) );
|
|
|
21923 vkGetSemaphoreFdKHR = PFN_vkGetSemaphoreFdKHR( vkGetInstanceProcAddr( instance, "vkGetSemaphoreFdKHR" ) );
|
|
|
21924
|
|
|
21925 //=== VK_KHR_push_descriptor ===
|
|
|
21926 vkCmdPushDescriptorSetKHR = PFN_vkCmdPushDescriptorSetKHR( vkGetInstanceProcAddr( instance, "vkCmdPushDescriptorSetKHR" ) );
|
|
|
21927 if ( !vkCmdPushDescriptorSet )
|
|
|
21928 vkCmdPushDescriptorSet = vkCmdPushDescriptorSetKHR;
|
|
|
21929 vkCmdPushDescriptorSetWithTemplateKHR =
|
|
|
21930 PFN_vkCmdPushDescriptorSetWithTemplateKHR( vkGetInstanceProcAddr( instance, "vkCmdPushDescriptorSetWithTemplateKHR" ) );
|
|
|
21931 if ( !vkCmdPushDescriptorSetWithTemplate )
|
|
|
21932 vkCmdPushDescriptorSetWithTemplate = vkCmdPushDescriptorSetWithTemplateKHR;
|
|
|
21933
|
|
|
21934 //=== VK_EXT_conditional_rendering ===
|
|
|
21935 vkCmdBeginConditionalRenderingEXT = PFN_vkCmdBeginConditionalRenderingEXT( vkGetInstanceProcAddr( instance, "vkCmdBeginConditionalRenderingEXT" ) );
|
|
|
21936 vkCmdEndConditionalRenderingEXT = PFN_vkCmdEndConditionalRenderingEXT( vkGetInstanceProcAddr( instance, "vkCmdEndConditionalRenderingEXT" ) );
|
|
|
21937
|
|
|
21938 //=== VK_KHR_descriptor_update_template ===
|
|
|
21939 vkCreateDescriptorUpdateTemplateKHR =
|
|
|
21940 PFN_vkCreateDescriptorUpdateTemplateKHR( vkGetInstanceProcAddr( instance, "vkCreateDescriptorUpdateTemplateKHR" ) );
|
|
|
21941 if ( !vkCreateDescriptorUpdateTemplate )
|
|
|
21942 vkCreateDescriptorUpdateTemplate = vkCreateDescriptorUpdateTemplateKHR;
|
|
|
21943 vkDestroyDescriptorUpdateTemplateKHR =
|
|
|
21944 PFN_vkDestroyDescriptorUpdateTemplateKHR( vkGetInstanceProcAddr( instance, "vkDestroyDescriptorUpdateTemplateKHR" ) );
|
|
|
21945 if ( !vkDestroyDescriptorUpdateTemplate )
|
|
|
21946 vkDestroyDescriptorUpdateTemplate = vkDestroyDescriptorUpdateTemplateKHR;
|
|
|
21947 vkUpdateDescriptorSetWithTemplateKHR =
|
|
|
21948 PFN_vkUpdateDescriptorSetWithTemplateKHR( vkGetInstanceProcAddr( instance, "vkUpdateDescriptorSetWithTemplateKHR" ) );
|
|
|
21949 if ( !vkUpdateDescriptorSetWithTemplate )
|
|
|
21950 vkUpdateDescriptorSetWithTemplate = vkUpdateDescriptorSetWithTemplateKHR;
|
|
|
21951
|
|
|
21952 //=== VK_NV_clip_space_w_scaling ===
|
|
|
21953 vkCmdSetViewportWScalingNV = PFN_vkCmdSetViewportWScalingNV( vkGetInstanceProcAddr( instance, "vkCmdSetViewportWScalingNV" ) );
|
|
|
21954
|
|
|
21955 //=== VK_EXT_direct_mode_display ===
|
|
|
21956 vkReleaseDisplayEXT = PFN_vkReleaseDisplayEXT( vkGetInstanceProcAddr( instance, "vkReleaseDisplayEXT" ) );
|
|
|
21957
|
|
|
21958 #if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
|
|
|
21959 //=== VK_EXT_acquire_xlib_display ===
|
|
|
21960 vkAcquireXlibDisplayEXT = PFN_vkAcquireXlibDisplayEXT( vkGetInstanceProcAddr( instance, "vkAcquireXlibDisplayEXT" ) );
|
|
|
21961 vkGetRandROutputDisplayEXT = PFN_vkGetRandROutputDisplayEXT( vkGetInstanceProcAddr( instance, "vkGetRandROutputDisplayEXT" ) );
|
|
|
21962 #endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
|
|
|
21963
|
|
|
21964 //=== VK_EXT_display_surface_counter ===
|
|
|
21965 vkGetPhysicalDeviceSurfaceCapabilities2EXT =
|
|
|
21966 PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilities2EXT" ) );
|
|
|
21967
|
|
|
21968 //=== VK_EXT_display_control ===
|
|
|
21969 vkDisplayPowerControlEXT = PFN_vkDisplayPowerControlEXT( vkGetInstanceProcAddr( instance, "vkDisplayPowerControlEXT" ) );
|
|
|
21970 vkRegisterDeviceEventEXT = PFN_vkRegisterDeviceEventEXT( vkGetInstanceProcAddr( instance, "vkRegisterDeviceEventEXT" ) );
|
|
|
21971 vkRegisterDisplayEventEXT = PFN_vkRegisterDisplayEventEXT( vkGetInstanceProcAddr( instance, "vkRegisterDisplayEventEXT" ) );
|
|
|
21972 vkGetSwapchainCounterEXT = PFN_vkGetSwapchainCounterEXT( vkGetInstanceProcAddr( instance, "vkGetSwapchainCounterEXT" ) );
|
|
|
21973
|
|
|
21974 //=== VK_GOOGLE_display_timing ===
|
|
|
21975 vkGetRefreshCycleDurationGOOGLE = PFN_vkGetRefreshCycleDurationGOOGLE( vkGetInstanceProcAddr( instance, "vkGetRefreshCycleDurationGOOGLE" ) );
|
|
|
21976 vkGetPastPresentationTimingGOOGLE = PFN_vkGetPastPresentationTimingGOOGLE( vkGetInstanceProcAddr( instance, "vkGetPastPresentationTimingGOOGLE" ) );
|
|
|
21977
|
|
|
21978 //=== VK_EXT_discard_rectangles ===
|
|
|
21979 vkCmdSetDiscardRectangleEXT = PFN_vkCmdSetDiscardRectangleEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDiscardRectangleEXT" ) );
|
|
|
21980 vkCmdSetDiscardRectangleEnableEXT = PFN_vkCmdSetDiscardRectangleEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDiscardRectangleEnableEXT" ) );
|
|
|
21981 vkCmdSetDiscardRectangleModeEXT = PFN_vkCmdSetDiscardRectangleModeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDiscardRectangleModeEXT" ) );
|
|
|
21982
|
|
|
21983 //=== VK_EXT_hdr_metadata ===
|
|
|
21984 vkSetHdrMetadataEXT = PFN_vkSetHdrMetadataEXT( vkGetInstanceProcAddr( instance, "vkSetHdrMetadataEXT" ) );
|
|
|
21985
|
|
|
21986 //=== VK_KHR_create_renderpass2 ===
|
|
|
21987 vkCreateRenderPass2KHR = PFN_vkCreateRenderPass2KHR( vkGetInstanceProcAddr( instance, "vkCreateRenderPass2KHR" ) );
|
|
|
21988 if ( !vkCreateRenderPass2 )
|
|
|
21989 vkCreateRenderPass2 = vkCreateRenderPass2KHR;
|
|
|
21990 vkCmdBeginRenderPass2KHR = PFN_vkCmdBeginRenderPass2KHR( vkGetInstanceProcAddr( instance, "vkCmdBeginRenderPass2KHR" ) );
|
|
|
21991 if ( !vkCmdBeginRenderPass2 )
|
|
|
21992 vkCmdBeginRenderPass2 = vkCmdBeginRenderPass2KHR;
|
|
|
21993 vkCmdNextSubpass2KHR = PFN_vkCmdNextSubpass2KHR( vkGetInstanceProcAddr( instance, "vkCmdNextSubpass2KHR" ) );
|
|
|
21994 if ( !vkCmdNextSubpass2 )
|
|
|
21995 vkCmdNextSubpass2 = vkCmdNextSubpass2KHR;
|
|
|
21996 vkCmdEndRenderPass2KHR = PFN_vkCmdEndRenderPass2KHR( vkGetInstanceProcAddr( instance, "vkCmdEndRenderPass2KHR" ) );
|
|
|
21997 if ( !vkCmdEndRenderPass2 )
|
|
|
21998 vkCmdEndRenderPass2 = vkCmdEndRenderPass2KHR;
|
|
|
21999
|
|
|
22000 //=== VK_KHR_shared_presentable_image ===
|
|
|
22001 vkGetSwapchainStatusKHR = PFN_vkGetSwapchainStatusKHR( vkGetInstanceProcAddr( instance, "vkGetSwapchainStatusKHR" ) );
|
|
|
22002
|
|
|
22003 //=== VK_KHR_external_fence_capabilities ===
|
|
|
22004 vkGetPhysicalDeviceExternalFencePropertiesKHR =
|
|
|
22005 PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalFencePropertiesKHR" ) );
|
|
|
22006 if ( !vkGetPhysicalDeviceExternalFenceProperties )
|
|
|
22007 vkGetPhysicalDeviceExternalFenceProperties = vkGetPhysicalDeviceExternalFencePropertiesKHR;
|
|
|
22008
|
|
|
22009 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
22010 //=== VK_KHR_external_fence_win32 ===
|
|
|
22011 vkImportFenceWin32HandleKHR = PFN_vkImportFenceWin32HandleKHR( vkGetInstanceProcAddr( instance, "vkImportFenceWin32HandleKHR" ) );
|
|
|
22012 vkGetFenceWin32HandleKHR = PFN_vkGetFenceWin32HandleKHR( vkGetInstanceProcAddr( instance, "vkGetFenceWin32HandleKHR" ) );
|
|
|
22013 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
22014
|
|
|
22015 //=== VK_KHR_external_fence_fd ===
|
|
|
22016 vkImportFenceFdKHR = PFN_vkImportFenceFdKHR( vkGetInstanceProcAddr( instance, "vkImportFenceFdKHR" ) );
|
|
|
22017 vkGetFenceFdKHR = PFN_vkGetFenceFdKHR( vkGetInstanceProcAddr( instance, "vkGetFenceFdKHR" ) );
|
|
|
22018
|
|
|
22019 //=== VK_KHR_performance_query ===
|
|
|
22020 vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
|
|
|
22021 vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR" ) );
|
|
|
22022 vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(
|
|
|
22023 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR" ) );
|
|
|
22024 vkAcquireProfilingLockKHR = PFN_vkAcquireProfilingLockKHR( vkGetInstanceProcAddr( instance, "vkAcquireProfilingLockKHR" ) );
|
|
|
22025 vkReleaseProfilingLockKHR = PFN_vkReleaseProfilingLockKHR( vkGetInstanceProcAddr( instance, "vkReleaseProfilingLockKHR" ) );
|
|
|
22026
|
|
|
22027 //=== VK_KHR_get_surface_capabilities2 ===
|
|
|
22028 vkGetPhysicalDeviceSurfaceCapabilities2KHR =
|
|
|
22029 PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilities2KHR" ) );
|
|
|
22030 vkGetPhysicalDeviceSurfaceFormats2KHR =
|
|
|
22031 PFN_vkGetPhysicalDeviceSurfaceFormats2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceFormats2KHR" ) );
|
|
|
22032
|
|
|
22033 //=== VK_KHR_get_display_properties2 ===
|
|
|
22034 vkGetPhysicalDeviceDisplayProperties2KHR =
|
|
|
22035 PFN_vkGetPhysicalDeviceDisplayProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayProperties2KHR" ) );
|
|
|
22036 vkGetPhysicalDeviceDisplayPlaneProperties2KHR =
|
|
|
22037 PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPlaneProperties2KHR" ) );
|
|
|
22038 vkGetDisplayModeProperties2KHR = PFN_vkGetDisplayModeProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetDisplayModeProperties2KHR" ) );
|
|
|
22039 vkGetDisplayPlaneCapabilities2KHR = PFN_vkGetDisplayPlaneCapabilities2KHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneCapabilities2KHR" ) );
|
|
|
22040
|
|
|
22041 #if defined( VK_USE_PLATFORM_IOS_MVK )
|
|
|
22042 //=== VK_MVK_ios_surface ===
|
|
|
22043 vkCreateIOSSurfaceMVK = PFN_vkCreateIOSSurfaceMVK( vkGetInstanceProcAddr( instance, "vkCreateIOSSurfaceMVK" ) );
|
|
|
22044 #endif /*VK_USE_PLATFORM_IOS_MVK*/
|
|
|
22045
|
|
|
22046 #if defined( VK_USE_PLATFORM_MACOS_MVK )
|
|
|
22047 //=== VK_MVK_macos_surface ===
|
|
|
22048 vkCreateMacOSSurfaceMVK = PFN_vkCreateMacOSSurfaceMVK( vkGetInstanceProcAddr( instance, "vkCreateMacOSSurfaceMVK" ) );
|
|
|
22049 #endif /*VK_USE_PLATFORM_MACOS_MVK*/
|
|
|
22050
|
|
|
22051 //=== VK_EXT_debug_utils ===
|
|
|
22052 vkSetDebugUtilsObjectNameEXT = PFN_vkSetDebugUtilsObjectNameEXT( vkGetInstanceProcAddr( instance, "vkSetDebugUtilsObjectNameEXT" ) );
|
|
|
22053 vkSetDebugUtilsObjectTagEXT = PFN_vkSetDebugUtilsObjectTagEXT( vkGetInstanceProcAddr( instance, "vkSetDebugUtilsObjectTagEXT" ) );
|
|
|
22054 vkQueueBeginDebugUtilsLabelEXT = PFN_vkQueueBeginDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkQueueBeginDebugUtilsLabelEXT" ) );
|
|
|
22055 vkQueueEndDebugUtilsLabelEXT = PFN_vkQueueEndDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkQueueEndDebugUtilsLabelEXT" ) );
|
|
|
22056 vkQueueInsertDebugUtilsLabelEXT = PFN_vkQueueInsertDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkQueueInsertDebugUtilsLabelEXT" ) );
|
|
|
22057 vkCmdBeginDebugUtilsLabelEXT = PFN_vkCmdBeginDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkCmdBeginDebugUtilsLabelEXT" ) );
|
|
|
22058 vkCmdEndDebugUtilsLabelEXT = PFN_vkCmdEndDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkCmdEndDebugUtilsLabelEXT" ) );
|
|
|
22059 vkCmdInsertDebugUtilsLabelEXT = PFN_vkCmdInsertDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkCmdInsertDebugUtilsLabelEXT" ) );
|
|
|
22060 vkCreateDebugUtilsMessengerEXT = PFN_vkCreateDebugUtilsMessengerEXT( vkGetInstanceProcAddr( instance, "vkCreateDebugUtilsMessengerEXT" ) );
|
|
|
22061 vkDestroyDebugUtilsMessengerEXT = PFN_vkDestroyDebugUtilsMessengerEXT( vkGetInstanceProcAddr( instance, "vkDestroyDebugUtilsMessengerEXT" ) );
|
|
|
22062 vkSubmitDebugUtilsMessageEXT = PFN_vkSubmitDebugUtilsMessageEXT( vkGetInstanceProcAddr( instance, "vkSubmitDebugUtilsMessageEXT" ) );
|
|
|
22063
|
|
|
22064 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
|
|
22065 //=== VK_ANDROID_external_memory_android_hardware_buffer ===
|
|
|
22066 vkGetAndroidHardwareBufferPropertiesANDROID =
|
|
|
22067 PFN_vkGetAndroidHardwareBufferPropertiesANDROID( vkGetInstanceProcAddr( instance, "vkGetAndroidHardwareBufferPropertiesANDROID" ) );
|
|
|
22068 vkGetMemoryAndroidHardwareBufferANDROID =
|
|
|
22069 PFN_vkGetMemoryAndroidHardwareBufferANDROID( vkGetInstanceProcAddr( instance, "vkGetMemoryAndroidHardwareBufferANDROID" ) );
|
|
|
22070 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
|
|
22071
|
|
|
22072 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
22073 //=== VK_AMDX_shader_enqueue ===
|
|
|
22074 vkCreateExecutionGraphPipelinesAMDX =
|
|
|
22075 PFN_vkCreateExecutionGraphPipelinesAMDX( vkGetInstanceProcAddr( instance, "vkCreateExecutionGraphPipelinesAMDX" ) );
|
|
|
22076 vkGetExecutionGraphPipelineScratchSizeAMDX =
|
|
|
22077 PFN_vkGetExecutionGraphPipelineScratchSizeAMDX( vkGetInstanceProcAddr( instance, "vkGetExecutionGraphPipelineScratchSizeAMDX" ) );
|
|
|
22078 vkGetExecutionGraphPipelineNodeIndexAMDX =
|
|
|
22079 PFN_vkGetExecutionGraphPipelineNodeIndexAMDX( vkGetInstanceProcAddr( instance, "vkGetExecutionGraphPipelineNodeIndexAMDX" ) );
|
|
|
22080 vkCmdInitializeGraphScratchMemoryAMDX =
|
|
|
22081 PFN_vkCmdInitializeGraphScratchMemoryAMDX( vkGetInstanceProcAddr( instance, "vkCmdInitializeGraphScratchMemoryAMDX" ) );
|
|
|
22082 vkCmdDispatchGraphAMDX = PFN_vkCmdDispatchGraphAMDX( vkGetInstanceProcAddr( instance, "vkCmdDispatchGraphAMDX" ) );
|
|
|
22083 vkCmdDispatchGraphIndirectAMDX = PFN_vkCmdDispatchGraphIndirectAMDX( vkGetInstanceProcAddr( instance, "vkCmdDispatchGraphIndirectAMDX" ) );
|
|
|
22084 vkCmdDispatchGraphIndirectCountAMDX =
|
|
|
22085 PFN_vkCmdDispatchGraphIndirectCountAMDX( vkGetInstanceProcAddr( instance, "vkCmdDispatchGraphIndirectCountAMDX" ) );
|
|
|
22086 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
22087
|
|
|
22088 //=== VK_EXT_sample_locations ===
|
|
|
22089 vkCmdSetSampleLocationsEXT = PFN_vkCmdSetSampleLocationsEXT( vkGetInstanceProcAddr( instance, "vkCmdSetSampleLocationsEXT" ) );
|
|
|
22090 vkGetPhysicalDeviceMultisamplePropertiesEXT =
|
|
|
22091 PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMultisamplePropertiesEXT" ) );
|
|
|
22092
|
|
|
22093 //=== VK_KHR_get_memory_requirements2 ===
|
|
|
22094 vkGetImageMemoryRequirements2KHR = PFN_vkGetImageMemoryRequirements2KHR( vkGetInstanceProcAddr( instance, "vkGetImageMemoryRequirements2KHR" ) );
|
|
|
22095 if ( !vkGetImageMemoryRequirements2 )
|
|
|
22096 vkGetImageMemoryRequirements2 = vkGetImageMemoryRequirements2KHR;
|
|
|
22097 vkGetBufferMemoryRequirements2KHR = PFN_vkGetBufferMemoryRequirements2KHR( vkGetInstanceProcAddr( instance, "vkGetBufferMemoryRequirements2KHR" ) );
|
|
|
22098 if ( !vkGetBufferMemoryRequirements2 )
|
|
|
22099 vkGetBufferMemoryRequirements2 = vkGetBufferMemoryRequirements2KHR;
|
|
|
22100 vkGetImageSparseMemoryRequirements2KHR =
|
|
|
22101 PFN_vkGetImageSparseMemoryRequirements2KHR( vkGetInstanceProcAddr( instance, "vkGetImageSparseMemoryRequirements2KHR" ) );
|
|
|
22102 if ( !vkGetImageSparseMemoryRequirements2 )
|
|
|
22103 vkGetImageSparseMemoryRequirements2 = vkGetImageSparseMemoryRequirements2KHR;
|
|
|
22104
|
|
|
22105 //=== VK_KHR_acceleration_structure ===
|
|
|
22106 vkCreateAccelerationStructureKHR = PFN_vkCreateAccelerationStructureKHR( vkGetInstanceProcAddr( instance, "vkCreateAccelerationStructureKHR" ) );
|
|
|
22107 vkDestroyAccelerationStructureKHR = PFN_vkDestroyAccelerationStructureKHR( vkGetInstanceProcAddr( instance, "vkDestroyAccelerationStructureKHR" ) );
|
|
|
22108 vkCmdBuildAccelerationStructuresKHR =
|
|
|
22109 PFN_vkCmdBuildAccelerationStructuresKHR( vkGetInstanceProcAddr( instance, "vkCmdBuildAccelerationStructuresKHR" ) );
|
|
|
22110 vkCmdBuildAccelerationStructuresIndirectKHR =
|
|
|
22111 PFN_vkCmdBuildAccelerationStructuresIndirectKHR( vkGetInstanceProcAddr( instance, "vkCmdBuildAccelerationStructuresIndirectKHR" ) );
|
|
|
22112 vkBuildAccelerationStructuresKHR = PFN_vkBuildAccelerationStructuresKHR( vkGetInstanceProcAddr( instance, "vkBuildAccelerationStructuresKHR" ) );
|
|
|
22113 vkCopyAccelerationStructureKHR = PFN_vkCopyAccelerationStructureKHR( vkGetInstanceProcAddr( instance, "vkCopyAccelerationStructureKHR" ) );
|
|
|
22114 vkCopyAccelerationStructureToMemoryKHR =
|
|
|
22115 PFN_vkCopyAccelerationStructureToMemoryKHR( vkGetInstanceProcAddr( instance, "vkCopyAccelerationStructureToMemoryKHR" ) );
|
|
|
22116 vkCopyMemoryToAccelerationStructureKHR =
|
|
|
22117 PFN_vkCopyMemoryToAccelerationStructureKHR( vkGetInstanceProcAddr( instance, "vkCopyMemoryToAccelerationStructureKHR" ) );
|
|
|
22118 vkWriteAccelerationStructuresPropertiesKHR =
|
|
|
22119 PFN_vkWriteAccelerationStructuresPropertiesKHR( vkGetInstanceProcAddr( instance, "vkWriteAccelerationStructuresPropertiesKHR" ) );
|
|
|
22120 vkCmdCopyAccelerationStructureKHR = PFN_vkCmdCopyAccelerationStructureKHR( vkGetInstanceProcAddr( instance, "vkCmdCopyAccelerationStructureKHR" ) );
|
|
|
22121 vkCmdCopyAccelerationStructureToMemoryKHR =
|
|
|
22122 PFN_vkCmdCopyAccelerationStructureToMemoryKHR( vkGetInstanceProcAddr( instance, "vkCmdCopyAccelerationStructureToMemoryKHR" ) );
|
|
|
22123 vkCmdCopyMemoryToAccelerationStructureKHR =
|
|
|
22124 PFN_vkCmdCopyMemoryToAccelerationStructureKHR( vkGetInstanceProcAddr( instance, "vkCmdCopyMemoryToAccelerationStructureKHR" ) );
|
|
|
22125 vkGetAccelerationStructureDeviceAddressKHR =
|
|
|
22126 PFN_vkGetAccelerationStructureDeviceAddressKHR( vkGetInstanceProcAddr( instance, "vkGetAccelerationStructureDeviceAddressKHR" ) );
|
|
|
22127 vkCmdWriteAccelerationStructuresPropertiesKHR =
|
|
|
22128 PFN_vkCmdWriteAccelerationStructuresPropertiesKHR( vkGetInstanceProcAddr( instance, "vkCmdWriteAccelerationStructuresPropertiesKHR" ) );
|
|
|
22129 vkGetDeviceAccelerationStructureCompatibilityKHR =
|
|
|
22130 PFN_vkGetDeviceAccelerationStructureCompatibilityKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceAccelerationStructureCompatibilityKHR" ) );
|
|
|
22131 vkGetAccelerationStructureBuildSizesKHR =
|
|
|
22132 PFN_vkGetAccelerationStructureBuildSizesKHR( vkGetInstanceProcAddr( instance, "vkGetAccelerationStructureBuildSizesKHR" ) );
|
|
|
22133
|
|
|
22134 //=== VK_KHR_ray_tracing_pipeline ===
|
|
|
22135 vkCmdTraceRaysKHR = PFN_vkCmdTraceRaysKHR( vkGetInstanceProcAddr( instance, "vkCmdTraceRaysKHR" ) );
|
|
|
22136 vkCreateRayTracingPipelinesKHR = PFN_vkCreateRayTracingPipelinesKHR( vkGetInstanceProcAddr( instance, "vkCreateRayTracingPipelinesKHR" ) );
|
|
|
22137 vkGetRayTracingShaderGroupHandlesKHR =
|
|
|
22138 PFN_vkGetRayTracingShaderGroupHandlesKHR( vkGetInstanceProcAddr( instance, "vkGetRayTracingShaderGroupHandlesKHR" ) );
|
|
|
22139 vkGetRayTracingCaptureReplayShaderGroupHandlesKHR =
|
|
|
22140 PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( vkGetInstanceProcAddr( instance, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR" ) );
|
|
|
22141 vkCmdTraceRaysIndirectKHR = PFN_vkCmdTraceRaysIndirectKHR( vkGetInstanceProcAddr( instance, "vkCmdTraceRaysIndirectKHR" ) );
|
|
|
22142 vkGetRayTracingShaderGroupStackSizeKHR =
|
|
|
22143 PFN_vkGetRayTracingShaderGroupStackSizeKHR( vkGetInstanceProcAddr( instance, "vkGetRayTracingShaderGroupStackSizeKHR" ) );
|
|
|
22144 vkCmdSetRayTracingPipelineStackSizeKHR =
|
|
|
22145 PFN_vkCmdSetRayTracingPipelineStackSizeKHR( vkGetInstanceProcAddr( instance, "vkCmdSetRayTracingPipelineStackSizeKHR" ) );
|
|
|
22146
|
|
|
22147 //=== VK_KHR_sampler_ycbcr_conversion ===
|
|
|
22148 vkCreateSamplerYcbcrConversionKHR = PFN_vkCreateSamplerYcbcrConversionKHR( vkGetInstanceProcAddr( instance, "vkCreateSamplerYcbcrConversionKHR" ) );
|
|
|
22149 if ( !vkCreateSamplerYcbcrConversion )
|
|
|
22150 vkCreateSamplerYcbcrConversion = vkCreateSamplerYcbcrConversionKHR;
|
|
|
22151 vkDestroySamplerYcbcrConversionKHR = PFN_vkDestroySamplerYcbcrConversionKHR( vkGetInstanceProcAddr( instance, "vkDestroySamplerYcbcrConversionKHR" ) );
|
|
|
22152 if ( !vkDestroySamplerYcbcrConversion )
|
|
|
22153 vkDestroySamplerYcbcrConversion = vkDestroySamplerYcbcrConversionKHR;
|
|
|
22154
|
|
|
22155 //=== VK_KHR_bind_memory2 ===
|
|
|
22156 vkBindBufferMemory2KHR = PFN_vkBindBufferMemory2KHR( vkGetInstanceProcAddr( instance, "vkBindBufferMemory2KHR" ) );
|
|
|
22157 if ( !vkBindBufferMemory2 )
|
|
|
22158 vkBindBufferMemory2 = vkBindBufferMemory2KHR;
|
|
|
22159 vkBindImageMemory2KHR = PFN_vkBindImageMemory2KHR( vkGetInstanceProcAddr( instance, "vkBindImageMemory2KHR" ) );
|
|
|
22160 if ( !vkBindImageMemory2 )
|
|
|
22161 vkBindImageMemory2 = vkBindImageMemory2KHR;
|
|
|
22162
|
|
|
22163 //=== VK_EXT_image_drm_format_modifier ===
|
|
|
22164 vkGetImageDrmFormatModifierPropertiesEXT =
|
|
|
22165 PFN_vkGetImageDrmFormatModifierPropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetImageDrmFormatModifierPropertiesEXT" ) );
|
|
|
22166
|
|
|
22167 //=== VK_EXT_validation_cache ===
|
|
|
22168 vkCreateValidationCacheEXT = PFN_vkCreateValidationCacheEXT( vkGetInstanceProcAddr( instance, "vkCreateValidationCacheEXT" ) );
|
|
|
22169 vkDestroyValidationCacheEXT = PFN_vkDestroyValidationCacheEXT( vkGetInstanceProcAddr( instance, "vkDestroyValidationCacheEXT" ) );
|
|
|
22170 vkMergeValidationCachesEXT = PFN_vkMergeValidationCachesEXT( vkGetInstanceProcAddr( instance, "vkMergeValidationCachesEXT" ) );
|
|
|
22171 vkGetValidationCacheDataEXT = PFN_vkGetValidationCacheDataEXT( vkGetInstanceProcAddr( instance, "vkGetValidationCacheDataEXT" ) );
|
|
|
22172
|
|
|
22173 //=== VK_NV_shading_rate_image ===
|
|
|
22174 vkCmdBindShadingRateImageNV = PFN_vkCmdBindShadingRateImageNV( vkGetInstanceProcAddr( instance, "vkCmdBindShadingRateImageNV" ) );
|
|
|
22175 vkCmdSetViewportShadingRatePaletteNV =
|
|
|
22176 PFN_vkCmdSetViewportShadingRatePaletteNV( vkGetInstanceProcAddr( instance, "vkCmdSetViewportShadingRatePaletteNV" ) );
|
|
|
22177 vkCmdSetCoarseSampleOrderNV = PFN_vkCmdSetCoarseSampleOrderNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoarseSampleOrderNV" ) );
|
|
|
22178
|
|
|
22179 //=== VK_NV_ray_tracing ===
|
|
|
22180 vkCreateAccelerationStructureNV = PFN_vkCreateAccelerationStructureNV( vkGetInstanceProcAddr( instance, "vkCreateAccelerationStructureNV" ) );
|
|
|
22181 vkDestroyAccelerationStructureNV = PFN_vkDestroyAccelerationStructureNV( vkGetInstanceProcAddr( instance, "vkDestroyAccelerationStructureNV" ) );
|
|
|
22182 vkGetAccelerationStructureMemoryRequirementsNV =
|
|
|
22183 PFN_vkGetAccelerationStructureMemoryRequirementsNV( vkGetInstanceProcAddr( instance, "vkGetAccelerationStructureMemoryRequirementsNV" ) );
|
|
|
22184 vkBindAccelerationStructureMemoryNV =
|
|
|
22185 PFN_vkBindAccelerationStructureMemoryNV( vkGetInstanceProcAddr( instance, "vkBindAccelerationStructureMemoryNV" ) );
|
|
|
22186 vkCmdBuildAccelerationStructureNV = PFN_vkCmdBuildAccelerationStructureNV( vkGetInstanceProcAddr( instance, "vkCmdBuildAccelerationStructureNV" ) );
|
|
|
22187 vkCmdCopyAccelerationStructureNV = PFN_vkCmdCopyAccelerationStructureNV( vkGetInstanceProcAddr( instance, "vkCmdCopyAccelerationStructureNV" ) );
|
|
|
22188 vkCmdTraceRaysNV = PFN_vkCmdTraceRaysNV( vkGetInstanceProcAddr( instance, "vkCmdTraceRaysNV" ) );
|
|
|
22189 vkCreateRayTracingPipelinesNV = PFN_vkCreateRayTracingPipelinesNV( vkGetInstanceProcAddr( instance, "vkCreateRayTracingPipelinesNV" ) );
|
|
|
22190 vkGetRayTracingShaderGroupHandlesNV =
|
|
|
22191 PFN_vkGetRayTracingShaderGroupHandlesNV( vkGetInstanceProcAddr( instance, "vkGetRayTracingShaderGroupHandlesNV" ) );
|
|
|
22192 if ( !vkGetRayTracingShaderGroupHandlesKHR )
|
|
|
22193 vkGetRayTracingShaderGroupHandlesKHR = vkGetRayTracingShaderGroupHandlesNV;
|
|
|
22194 vkGetAccelerationStructureHandleNV = PFN_vkGetAccelerationStructureHandleNV( vkGetInstanceProcAddr( instance, "vkGetAccelerationStructureHandleNV" ) );
|
|
|
22195 vkCmdWriteAccelerationStructuresPropertiesNV =
|
|
|
22196 PFN_vkCmdWriteAccelerationStructuresPropertiesNV( vkGetInstanceProcAddr( instance, "vkCmdWriteAccelerationStructuresPropertiesNV" ) );
|
|
|
22197 vkCompileDeferredNV = PFN_vkCompileDeferredNV( vkGetInstanceProcAddr( instance, "vkCompileDeferredNV" ) );
|
|
|
22198
|
|
|
22199 //=== VK_KHR_maintenance3 ===
|
|
|
22200 vkGetDescriptorSetLayoutSupportKHR = PFN_vkGetDescriptorSetLayoutSupportKHR( vkGetInstanceProcAddr( instance, "vkGetDescriptorSetLayoutSupportKHR" ) );
|
|
|
22201 if ( !vkGetDescriptorSetLayoutSupport )
|
|
|
22202 vkGetDescriptorSetLayoutSupport = vkGetDescriptorSetLayoutSupportKHR;
|
|
|
22203
|
|
|
22204 //=== VK_KHR_draw_indirect_count ===
|
|
|
22205 vkCmdDrawIndirectCountKHR = PFN_vkCmdDrawIndirectCountKHR( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectCountKHR" ) );
|
|
|
22206 if ( !vkCmdDrawIndirectCount )
|
|
|
22207 vkCmdDrawIndirectCount = vkCmdDrawIndirectCountKHR;
|
|
|
22208 vkCmdDrawIndexedIndirectCountKHR = PFN_vkCmdDrawIndexedIndirectCountKHR( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirectCountKHR" ) );
|
|
|
22209 if ( !vkCmdDrawIndexedIndirectCount )
|
|
|
22210 vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountKHR;
|
|
|
22211
|
|
|
22212 //=== VK_EXT_external_memory_host ===
|
|
|
22213 vkGetMemoryHostPointerPropertiesEXT =
|
|
|
22214 PFN_vkGetMemoryHostPointerPropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetMemoryHostPointerPropertiesEXT" ) );
|
|
|
22215
|
|
|
22216 //=== VK_AMD_buffer_marker ===
|
|
|
22217 vkCmdWriteBufferMarkerAMD = PFN_vkCmdWriteBufferMarkerAMD( vkGetInstanceProcAddr( instance, "vkCmdWriteBufferMarkerAMD" ) );
|
|
|
22218 vkCmdWriteBufferMarker2AMD = PFN_vkCmdWriteBufferMarker2AMD( vkGetInstanceProcAddr( instance, "vkCmdWriteBufferMarker2AMD" ) );
|
|
|
22219
|
|
|
22220 //=== VK_EXT_calibrated_timestamps ===
|
|
|
22221 vkGetPhysicalDeviceCalibrateableTimeDomainsEXT =
|
|
|
22222 PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT" ) );
|
|
|
22223 if ( !vkGetPhysicalDeviceCalibrateableTimeDomainsKHR )
|
|
|
22224 vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = vkGetPhysicalDeviceCalibrateableTimeDomainsEXT;
|
|
|
22225 vkGetCalibratedTimestampsEXT = PFN_vkGetCalibratedTimestampsEXT( vkGetInstanceProcAddr( instance, "vkGetCalibratedTimestampsEXT" ) );
|
|
|
22226 if ( !vkGetCalibratedTimestampsKHR )
|
|
|
22227 vkGetCalibratedTimestampsKHR = vkGetCalibratedTimestampsEXT;
|
|
|
22228
|
|
|
22229 //=== VK_NV_mesh_shader ===
|
|
|
22230 vkCmdDrawMeshTasksNV = PFN_vkCmdDrawMeshTasksNV( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksNV" ) );
|
|
|
22231 vkCmdDrawMeshTasksIndirectNV = PFN_vkCmdDrawMeshTasksIndirectNV( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksIndirectNV" ) );
|
|
|
22232 vkCmdDrawMeshTasksIndirectCountNV = PFN_vkCmdDrawMeshTasksIndirectCountNV( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksIndirectCountNV" ) );
|
|
|
22233
|
|
|
22234 //=== VK_NV_scissor_exclusive ===
|
|
|
22235 vkCmdSetExclusiveScissorEnableNV = PFN_vkCmdSetExclusiveScissorEnableNV( vkGetInstanceProcAddr( instance, "vkCmdSetExclusiveScissorEnableNV" ) );
|
|
|
22236 vkCmdSetExclusiveScissorNV = PFN_vkCmdSetExclusiveScissorNV( vkGetInstanceProcAddr( instance, "vkCmdSetExclusiveScissorNV" ) );
|
|
|
22237
|
|
|
22238 //=== VK_NV_device_diagnostic_checkpoints ===
|
|
|
22239 vkCmdSetCheckpointNV = PFN_vkCmdSetCheckpointNV( vkGetInstanceProcAddr( instance, "vkCmdSetCheckpointNV" ) );
|
|
|
22240 vkGetQueueCheckpointDataNV = PFN_vkGetQueueCheckpointDataNV( vkGetInstanceProcAddr( instance, "vkGetQueueCheckpointDataNV" ) );
|
|
|
22241 vkGetQueueCheckpointData2NV = PFN_vkGetQueueCheckpointData2NV( vkGetInstanceProcAddr( instance, "vkGetQueueCheckpointData2NV" ) );
|
|
|
22242
|
|
|
22243 //=== VK_KHR_timeline_semaphore ===
|
|
|
22244 vkGetSemaphoreCounterValueKHR = PFN_vkGetSemaphoreCounterValueKHR( vkGetInstanceProcAddr( instance, "vkGetSemaphoreCounterValueKHR" ) );
|
|
|
22245 if ( !vkGetSemaphoreCounterValue )
|
|
|
22246 vkGetSemaphoreCounterValue = vkGetSemaphoreCounterValueKHR;
|
|
|
22247 vkWaitSemaphoresKHR = PFN_vkWaitSemaphoresKHR( vkGetInstanceProcAddr( instance, "vkWaitSemaphoresKHR" ) );
|
|
|
22248 if ( !vkWaitSemaphores )
|
|
|
22249 vkWaitSemaphores = vkWaitSemaphoresKHR;
|
|
|
22250 vkSignalSemaphoreKHR = PFN_vkSignalSemaphoreKHR( vkGetInstanceProcAddr( instance, "vkSignalSemaphoreKHR" ) );
|
|
|
22251 if ( !vkSignalSemaphore )
|
|
|
22252 vkSignalSemaphore = vkSignalSemaphoreKHR;
|
|
|
22253
|
|
|
22254 //=== VK_INTEL_performance_query ===
|
|
|
22255 vkInitializePerformanceApiINTEL = PFN_vkInitializePerformanceApiINTEL( vkGetInstanceProcAddr( instance, "vkInitializePerformanceApiINTEL" ) );
|
|
|
22256 vkUninitializePerformanceApiINTEL = PFN_vkUninitializePerformanceApiINTEL( vkGetInstanceProcAddr( instance, "vkUninitializePerformanceApiINTEL" ) );
|
|
|
22257 vkCmdSetPerformanceMarkerINTEL = PFN_vkCmdSetPerformanceMarkerINTEL( vkGetInstanceProcAddr( instance, "vkCmdSetPerformanceMarkerINTEL" ) );
|
|
|
22258 vkCmdSetPerformanceStreamMarkerINTEL =
|
|
|
22259 PFN_vkCmdSetPerformanceStreamMarkerINTEL( vkGetInstanceProcAddr( instance, "vkCmdSetPerformanceStreamMarkerINTEL" ) );
|
|
|
22260 vkCmdSetPerformanceOverrideINTEL = PFN_vkCmdSetPerformanceOverrideINTEL( vkGetInstanceProcAddr( instance, "vkCmdSetPerformanceOverrideINTEL" ) );
|
|
|
22261 vkAcquirePerformanceConfigurationINTEL =
|
|
|
22262 PFN_vkAcquirePerformanceConfigurationINTEL( vkGetInstanceProcAddr( instance, "vkAcquirePerformanceConfigurationINTEL" ) );
|
|
|
22263 vkReleasePerformanceConfigurationINTEL =
|
|
|
22264 PFN_vkReleasePerformanceConfigurationINTEL( vkGetInstanceProcAddr( instance, "vkReleasePerformanceConfigurationINTEL" ) );
|
|
|
22265 vkQueueSetPerformanceConfigurationINTEL =
|
|
|
22266 PFN_vkQueueSetPerformanceConfigurationINTEL( vkGetInstanceProcAddr( instance, "vkQueueSetPerformanceConfigurationINTEL" ) );
|
|
|
22267 vkGetPerformanceParameterINTEL = PFN_vkGetPerformanceParameterINTEL( vkGetInstanceProcAddr( instance, "vkGetPerformanceParameterINTEL" ) );
|
|
|
22268
|
|
|
22269 //=== VK_AMD_display_native_hdr ===
|
|
|
22270 vkSetLocalDimmingAMD = PFN_vkSetLocalDimmingAMD( vkGetInstanceProcAddr( instance, "vkSetLocalDimmingAMD" ) );
|
|
|
22271
|
|
|
22272 #if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
|
22273 //=== VK_FUCHSIA_imagepipe_surface ===
|
|
|
22274 vkCreateImagePipeSurfaceFUCHSIA = PFN_vkCreateImagePipeSurfaceFUCHSIA( vkGetInstanceProcAddr( instance, "vkCreateImagePipeSurfaceFUCHSIA" ) );
|
|
|
22275 #endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
22276
|
|
|
22277 #if defined( VK_USE_PLATFORM_METAL_EXT )
|
|
|
22278 //=== VK_EXT_metal_surface ===
|
|
|
22279 vkCreateMetalSurfaceEXT = PFN_vkCreateMetalSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateMetalSurfaceEXT" ) );
|
|
|
22280 #endif /*VK_USE_PLATFORM_METAL_EXT*/
|
|
|
22281
|
|
|
22282 //=== VK_KHR_fragment_shading_rate ===
|
|
|
22283 vkGetPhysicalDeviceFragmentShadingRatesKHR =
|
|
|
22284 PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFragmentShadingRatesKHR" ) );
|
|
|
22285 vkCmdSetFragmentShadingRateKHR = PFN_vkCmdSetFragmentShadingRateKHR( vkGetInstanceProcAddr( instance, "vkCmdSetFragmentShadingRateKHR" ) );
|
|
|
22286
|
|
|
22287 //=== VK_KHR_dynamic_rendering_local_read ===
|
|
|
22288 vkCmdSetRenderingAttachmentLocationsKHR =
|
|
|
22289 PFN_vkCmdSetRenderingAttachmentLocationsKHR( vkGetInstanceProcAddr( instance, "vkCmdSetRenderingAttachmentLocationsKHR" ) );
|
|
|
22290 if ( !vkCmdSetRenderingAttachmentLocations )
|
|
|
22291 vkCmdSetRenderingAttachmentLocations = vkCmdSetRenderingAttachmentLocationsKHR;
|
|
|
22292 vkCmdSetRenderingInputAttachmentIndicesKHR =
|
|
|
22293 PFN_vkCmdSetRenderingInputAttachmentIndicesKHR( vkGetInstanceProcAddr( instance, "vkCmdSetRenderingInputAttachmentIndicesKHR" ) );
|
|
|
22294 if ( !vkCmdSetRenderingInputAttachmentIndices )
|
|
|
22295 vkCmdSetRenderingInputAttachmentIndices = vkCmdSetRenderingInputAttachmentIndicesKHR;
|
|
|
22296
|
|
|
22297 //=== VK_EXT_buffer_device_address ===
|
|
|
22298 vkGetBufferDeviceAddressEXT = PFN_vkGetBufferDeviceAddressEXT( vkGetInstanceProcAddr( instance, "vkGetBufferDeviceAddressEXT" ) );
|
|
|
22299 if ( !vkGetBufferDeviceAddress )
|
|
|
22300 vkGetBufferDeviceAddress = vkGetBufferDeviceAddressEXT;
|
|
|
22301
|
|
|
22302 //=== VK_EXT_tooling_info ===
|
|
|
22303 vkGetPhysicalDeviceToolPropertiesEXT =
|
|
|
22304 PFN_vkGetPhysicalDeviceToolPropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceToolPropertiesEXT" ) );
|
|
|
22305 if ( !vkGetPhysicalDeviceToolProperties )
|
|
|
22306 vkGetPhysicalDeviceToolProperties = vkGetPhysicalDeviceToolPropertiesEXT;
|
|
|
22307
|
|
|
22308 //=== VK_KHR_present_wait ===
|
|
|
22309 vkWaitForPresentKHR = PFN_vkWaitForPresentKHR( vkGetInstanceProcAddr( instance, "vkWaitForPresentKHR" ) );
|
|
|
22310
|
|
|
22311 //=== VK_NV_cooperative_matrix ===
|
|
|
22312 vkGetPhysicalDeviceCooperativeMatrixPropertiesNV =
|
|
|
22313 PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV" ) );
|
|
|
22314
|
|
|
22315 //=== VK_NV_coverage_reduction_mode ===
|
|
|
22316 vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
|
|
|
22317 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" ) );
|
|
|
22318
|
|
|
22319 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
22320 //=== VK_EXT_full_screen_exclusive ===
|
|
|
22321 vkGetPhysicalDeviceSurfacePresentModes2EXT =
|
|
|
22322 PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfacePresentModes2EXT" ) );
|
|
|
22323 vkAcquireFullScreenExclusiveModeEXT =
|
|
|
22324 PFN_vkAcquireFullScreenExclusiveModeEXT( vkGetInstanceProcAddr( instance, "vkAcquireFullScreenExclusiveModeEXT" ) );
|
|
|
22325 vkReleaseFullScreenExclusiveModeEXT =
|
|
|
22326 PFN_vkReleaseFullScreenExclusiveModeEXT( vkGetInstanceProcAddr( instance, "vkReleaseFullScreenExclusiveModeEXT" ) );
|
|
|
22327 vkGetDeviceGroupSurfacePresentModes2EXT =
|
|
|
22328 PFN_vkGetDeviceGroupSurfacePresentModes2EXT( vkGetInstanceProcAddr( instance, "vkGetDeviceGroupSurfacePresentModes2EXT" ) );
|
|
|
22329 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
22330
|
|
|
22331 //=== VK_EXT_headless_surface ===
|
|
|
22332 vkCreateHeadlessSurfaceEXT = PFN_vkCreateHeadlessSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateHeadlessSurfaceEXT" ) );
|
|
|
22333
|
|
|
22334 //=== VK_KHR_buffer_device_address ===
|
|
|
22335 vkGetBufferDeviceAddressKHR = PFN_vkGetBufferDeviceAddressKHR( vkGetInstanceProcAddr( instance, "vkGetBufferDeviceAddressKHR" ) );
|
|
|
22336 if ( !vkGetBufferDeviceAddress )
|
|
|
22337 vkGetBufferDeviceAddress = vkGetBufferDeviceAddressKHR;
|
|
|
22338 vkGetBufferOpaqueCaptureAddressKHR = PFN_vkGetBufferOpaqueCaptureAddressKHR( vkGetInstanceProcAddr( instance, "vkGetBufferOpaqueCaptureAddressKHR" ) );
|
|
|
22339 if ( !vkGetBufferOpaqueCaptureAddress )
|
|
|
22340 vkGetBufferOpaqueCaptureAddress = vkGetBufferOpaqueCaptureAddressKHR;
|
|
|
22341 vkGetDeviceMemoryOpaqueCaptureAddressKHR =
|
|
|
22342 PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceMemoryOpaqueCaptureAddressKHR" ) );
|
|
|
22343 if ( !vkGetDeviceMemoryOpaqueCaptureAddress )
|
|
|
22344 vkGetDeviceMemoryOpaqueCaptureAddress = vkGetDeviceMemoryOpaqueCaptureAddressKHR;
|
|
|
22345
|
|
|
22346 //=== VK_EXT_line_rasterization ===
|
|
|
22347 vkCmdSetLineStippleEXT = PFN_vkCmdSetLineStippleEXT( vkGetInstanceProcAddr( instance, "vkCmdSetLineStippleEXT" ) );
|
|
|
22348 if ( !vkCmdSetLineStipple )
|
|
|
22349 vkCmdSetLineStipple = vkCmdSetLineStippleEXT;
|
|
|
22350
|
|
|
22351 //=== VK_EXT_host_query_reset ===
|
|
|
22352 vkResetQueryPoolEXT = PFN_vkResetQueryPoolEXT( vkGetInstanceProcAddr( instance, "vkResetQueryPoolEXT" ) );
|
|
|
22353 if ( !vkResetQueryPool )
|
|
|
22354 vkResetQueryPool = vkResetQueryPoolEXT;
|
|
|
22355
|
|
|
22356 //=== VK_EXT_extended_dynamic_state ===
|
|
|
22357 vkCmdSetCullModeEXT = PFN_vkCmdSetCullModeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetCullModeEXT" ) );
|
|
|
22358 if ( !vkCmdSetCullMode )
|
|
|
22359 vkCmdSetCullMode = vkCmdSetCullModeEXT;
|
|
|
22360 vkCmdSetFrontFaceEXT = PFN_vkCmdSetFrontFaceEXT( vkGetInstanceProcAddr( instance, "vkCmdSetFrontFaceEXT" ) );
|
|
|
22361 if ( !vkCmdSetFrontFace )
|
|
|
22362 vkCmdSetFrontFace = vkCmdSetFrontFaceEXT;
|
|
|
22363 vkCmdSetPrimitiveTopologyEXT = PFN_vkCmdSetPrimitiveTopologyEXT( vkGetInstanceProcAddr( instance, "vkCmdSetPrimitiveTopologyEXT" ) );
|
|
|
22364 if ( !vkCmdSetPrimitiveTopology )
|
|
|
22365 vkCmdSetPrimitiveTopology = vkCmdSetPrimitiveTopologyEXT;
|
|
|
22366 vkCmdSetViewportWithCountEXT = PFN_vkCmdSetViewportWithCountEXT( vkGetInstanceProcAddr( instance, "vkCmdSetViewportWithCountEXT" ) );
|
|
|
22367 if ( !vkCmdSetViewportWithCount )
|
|
|
22368 vkCmdSetViewportWithCount = vkCmdSetViewportWithCountEXT;
|
|
|
22369 vkCmdSetScissorWithCountEXT = PFN_vkCmdSetScissorWithCountEXT( vkGetInstanceProcAddr( instance, "vkCmdSetScissorWithCountEXT" ) );
|
|
|
22370 if ( !vkCmdSetScissorWithCount )
|
|
|
22371 vkCmdSetScissorWithCount = vkCmdSetScissorWithCountEXT;
|
|
|
22372 vkCmdBindVertexBuffers2EXT = PFN_vkCmdBindVertexBuffers2EXT( vkGetInstanceProcAddr( instance, "vkCmdBindVertexBuffers2EXT" ) );
|
|
|
22373 if ( !vkCmdBindVertexBuffers2 )
|
|
|
22374 vkCmdBindVertexBuffers2 = vkCmdBindVertexBuffers2EXT;
|
|
|
22375 vkCmdSetDepthTestEnableEXT = PFN_vkCmdSetDepthTestEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthTestEnableEXT" ) );
|
|
|
22376 if ( !vkCmdSetDepthTestEnable )
|
|
|
22377 vkCmdSetDepthTestEnable = vkCmdSetDepthTestEnableEXT;
|
|
|
22378 vkCmdSetDepthWriteEnableEXT = PFN_vkCmdSetDepthWriteEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthWriteEnableEXT" ) );
|
|
|
22379 if ( !vkCmdSetDepthWriteEnable )
|
|
|
22380 vkCmdSetDepthWriteEnable = vkCmdSetDepthWriteEnableEXT;
|
|
|
22381 vkCmdSetDepthCompareOpEXT = PFN_vkCmdSetDepthCompareOpEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthCompareOpEXT" ) );
|
|
|
22382 if ( !vkCmdSetDepthCompareOp )
|
|
|
22383 vkCmdSetDepthCompareOp = vkCmdSetDepthCompareOpEXT;
|
|
|
22384 vkCmdSetDepthBoundsTestEnableEXT = PFN_vkCmdSetDepthBoundsTestEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBoundsTestEnableEXT" ) );
|
|
|
22385 if ( !vkCmdSetDepthBoundsTestEnable )
|
|
|
22386 vkCmdSetDepthBoundsTestEnable = vkCmdSetDepthBoundsTestEnableEXT;
|
|
|
22387 vkCmdSetStencilTestEnableEXT = PFN_vkCmdSetStencilTestEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetStencilTestEnableEXT" ) );
|
|
|
22388 if ( !vkCmdSetStencilTestEnable )
|
|
|
22389 vkCmdSetStencilTestEnable = vkCmdSetStencilTestEnableEXT;
|
|
|
22390 vkCmdSetStencilOpEXT = PFN_vkCmdSetStencilOpEXT( vkGetInstanceProcAddr( instance, "vkCmdSetStencilOpEXT" ) );
|
|
|
22391 if ( !vkCmdSetStencilOp )
|
|
|
22392 vkCmdSetStencilOp = vkCmdSetStencilOpEXT;
|
|
|
22393
|
|
|
22394 //=== VK_KHR_deferred_host_operations ===
|
|
|
22395 vkCreateDeferredOperationKHR = PFN_vkCreateDeferredOperationKHR( vkGetInstanceProcAddr( instance, "vkCreateDeferredOperationKHR" ) );
|
|
|
22396 vkDestroyDeferredOperationKHR = PFN_vkDestroyDeferredOperationKHR( vkGetInstanceProcAddr( instance, "vkDestroyDeferredOperationKHR" ) );
|
|
|
22397 vkGetDeferredOperationMaxConcurrencyKHR =
|
|
|
22398 PFN_vkGetDeferredOperationMaxConcurrencyKHR( vkGetInstanceProcAddr( instance, "vkGetDeferredOperationMaxConcurrencyKHR" ) );
|
|
|
22399 vkGetDeferredOperationResultKHR = PFN_vkGetDeferredOperationResultKHR( vkGetInstanceProcAddr( instance, "vkGetDeferredOperationResultKHR" ) );
|
|
|
22400 vkDeferredOperationJoinKHR = PFN_vkDeferredOperationJoinKHR( vkGetInstanceProcAddr( instance, "vkDeferredOperationJoinKHR" ) );
|
|
|
22401
|
|
|
22402 //=== VK_KHR_pipeline_executable_properties ===
|
|
|
22403 vkGetPipelineExecutablePropertiesKHR =
|
|
|
22404 PFN_vkGetPipelineExecutablePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPipelineExecutablePropertiesKHR" ) );
|
|
|
22405 vkGetPipelineExecutableStatisticsKHR =
|
|
|
22406 PFN_vkGetPipelineExecutableStatisticsKHR( vkGetInstanceProcAddr( instance, "vkGetPipelineExecutableStatisticsKHR" ) );
|
|
|
22407 vkGetPipelineExecutableInternalRepresentationsKHR =
|
|
|
22408 PFN_vkGetPipelineExecutableInternalRepresentationsKHR( vkGetInstanceProcAddr( instance, "vkGetPipelineExecutableInternalRepresentationsKHR" ) );
|
|
|
22409
|
|
|
22410 //=== VK_EXT_host_image_copy ===
|
|
|
22411 vkCopyMemoryToImageEXT = PFN_vkCopyMemoryToImageEXT( vkGetInstanceProcAddr( instance, "vkCopyMemoryToImageEXT" ) );
|
|
|
22412 if ( !vkCopyMemoryToImage )
|
|
|
22413 vkCopyMemoryToImage = vkCopyMemoryToImageEXT;
|
|
|
22414 vkCopyImageToMemoryEXT = PFN_vkCopyImageToMemoryEXT( vkGetInstanceProcAddr( instance, "vkCopyImageToMemoryEXT" ) );
|
|
|
22415 if ( !vkCopyImageToMemory )
|
|
|
22416 vkCopyImageToMemory = vkCopyImageToMemoryEXT;
|
|
|
22417 vkCopyImageToImageEXT = PFN_vkCopyImageToImageEXT( vkGetInstanceProcAddr( instance, "vkCopyImageToImageEXT" ) );
|
|
|
22418 if ( !vkCopyImageToImage )
|
|
|
22419 vkCopyImageToImage = vkCopyImageToImageEXT;
|
|
|
22420 vkTransitionImageLayoutEXT = PFN_vkTransitionImageLayoutEXT( vkGetInstanceProcAddr( instance, "vkTransitionImageLayoutEXT" ) );
|
|
|
22421 if ( !vkTransitionImageLayout )
|
|
|
22422 vkTransitionImageLayout = vkTransitionImageLayoutEXT;
|
|
|
22423 vkGetImageSubresourceLayout2EXT = PFN_vkGetImageSubresourceLayout2EXT( vkGetInstanceProcAddr( instance, "vkGetImageSubresourceLayout2EXT" ) );
|
|
|
22424 if ( !vkGetImageSubresourceLayout2 )
|
|
|
22425 vkGetImageSubresourceLayout2 = vkGetImageSubresourceLayout2EXT;
|
|
|
22426
|
|
|
22427 //=== VK_KHR_map_memory2 ===
|
|
|
22428 vkMapMemory2KHR = PFN_vkMapMemory2KHR( vkGetInstanceProcAddr( instance, "vkMapMemory2KHR" ) );
|
|
|
22429 if ( !vkMapMemory2 )
|
|
|
22430 vkMapMemory2 = vkMapMemory2KHR;
|
|
|
22431 vkUnmapMemory2KHR = PFN_vkUnmapMemory2KHR( vkGetInstanceProcAddr( instance, "vkUnmapMemory2KHR" ) );
|
|
|
22432 if ( !vkUnmapMemory2 )
|
|
|
22433 vkUnmapMemory2 = vkUnmapMemory2KHR;
|
|
|
22434
|
|
|
22435 //=== VK_EXT_swapchain_maintenance1 ===
|
|
|
22436 vkReleaseSwapchainImagesEXT = PFN_vkReleaseSwapchainImagesEXT( vkGetInstanceProcAddr( instance, "vkReleaseSwapchainImagesEXT" ) );
|
|
|
22437 if ( !vkReleaseSwapchainImagesKHR )
|
|
|
22438 vkReleaseSwapchainImagesKHR = vkReleaseSwapchainImagesEXT;
|
|
|
22439
|
|
|
22440 //=== VK_NV_device_generated_commands ===
|
|
|
22441 vkGetGeneratedCommandsMemoryRequirementsNV =
|
|
|
22442 PFN_vkGetGeneratedCommandsMemoryRequirementsNV( vkGetInstanceProcAddr( instance, "vkGetGeneratedCommandsMemoryRequirementsNV" ) );
|
|
|
22443 vkCmdPreprocessGeneratedCommandsNV = PFN_vkCmdPreprocessGeneratedCommandsNV( vkGetInstanceProcAddr( instance, "vkCmdPreprocessGeneratedCommandsNV" ) );
|
|
|
22444 vkCmdExecuteGeneratedCommandsNV = PFN_vkCmdExecuteGeneratedCommandsNV( vkGetInstanceProcAddr( instance, "vkCmdExecuteGeneratedCommandsNV" ) );
|
|
|
22445 vkCmdBindPipelineShaderGroupNV = PFN_vkCmdBindPipelineShaderGroupNV( vkGetInstanceProcAddr( instance, "vkCmdBindPipelineShaderGroupNV" ) );
|
|
|
22446 vkCreateIndirectCommandsLayoutNV = PFN_vkCreateIndirectCommandsLayoutNV( vkGetInstanceProcAddr( instance, "vkCreateIndirectCommandsLayoutNV" ) );
|
|
|
22447 vkDestroyIndirectCommandsLayoutNV = PFN_vkDestroyIndirectCommandsLayoutNV( vkGetInstanceProcAddr( instance, "vkDestroyIndirectCommandsLayoutNV" ) );
|
|
|
22448
|
|
|
22449 //=== VK_EXT_depth_bias_control ===
|
|
|
22450 vkCmdSetDepthBias2EXT = PFN_vkCmdSetDepthBias2EXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBias2EXT" ) );
|
|
|
22451
|
|
|
22452 //=== VK_EXT_acquire_drm_display ===
|
|
|
22453 vkAcquireDrmDisplayEXT = PFN_vkAcquireDrmDisplayEXT( vkGetInstanceProcAddr( instance, "vkAcquireDrmDisplayEXT" ) );
|
|
|
22454 vkGetDrmDisplayEXT = PFN_vkGetDrmDisplayEXT( vkGetInstanceProcAddr( instance, "vkGetDrmDisplayEXT" ) );
|
|
|
22455
|
|
|
22456 //=== VK_EXT_private_data ===
|
|
|
22457 vkCreatePrivateDataSlotEXT = PFN_vkCreatePrivateDataSlotEXT( vkGetInstanceProcAddr( instance, "vkCreatePrivateDataSlotEXT" ) );
|
|
|
22458 if ( !vkCreatePrivateDataSlot )
|
|
|
22459 vkCreatePrivateDataSlot = vkCreatePrivateDataSlotEXT;
|
|
|
22460 vkDestroyPrivateDataSlotEXT = PFN_vkDestroyPrivateDataSlotEXT( vkGetInstanceProcAddr( instance, "vkDestroyPrivateDataSlotEXT" ) );
|
|
|
22461 if ( !vkDestroyPrivateDataSlot )
|
|
|
22462 vkDestroyPrivateDataSlot = vkDestroyPrivateDataSlotEXT;
|
|
|
22463 vkSetPrivateDataEXT = PFN_vkSetPrivateDataEXT( vkGetInstanceProcAddr( instance, "vkSetPrivateDataEXT" ) );
|
|
|
22464 if ( !vkSetPrivateData )
|
|
|
22465 vkSetPrivateData = vkSetPrivateDataEXT;
|
|
|
22466 vkGetPrivateDataEXT = PFN_vkGetPrivateDataEXT( vkGetInstanceProcAddr( instance, "vkGetPrivateDataEXT" ) );
|
|
|
22467 if ( !vkGetPrivateData )
|
|
|
22468 vkGetPrivateData = vkGetPrivateDataEXT;
|
|
|
22469
|
|
|
22470 //=== VK_KHR_video_encode_queue ===
|
|
|
22471 vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(
|
|
|
22472 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR" ) );
|
|
|
22473 vkGetEncodedVideoSessionParametersKHR =
|
|
|
22474 PFN_vkGetEncodedVideoSessionParametersKHR( vkGetInstanceProcAddr( instance, "vkGetEncodedVideoSessionParametersKHR" ) );
|
|
|
22475 vkCmdEncodeVideoKHR = PFN_vkCmdEncodeVideoKHR( vkGetInstanceProcAddr( instance, "vkCmdEncodeVideoKHR" ) );
|
|
|
22476
|
|
|
22477 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
22478 //=== VK_NV_cuda_kernel_launch ===
|
|
|
22479 vkCreateCudaModuleNV = PFN_vkCreateCudaModuleNV( vkGetInstanceProcAddr( instance, "vkCreateCudaModuleNV" ) );
|
|
|
22480 vkGetCudaModuleCacheNV = PFN_vkGetCudaModuleCacheNV( vkGetInstanceProcAddr( instance, "vkGetCudaModuleCacheNV" ) );
|
|
|
22481 vkCreateCudaFunctionNV = PFN_vkCreateCudaFunctionNV( vkGetInstanceProcAddr( instance, "vkCreateCudaFunctionNV" ) );
|
|
|
22482 vkDestroyCudaModuleNV = PFN_vkDestroyCudaModuleNV( vkGetInstanceProcAddr( instance, "vkDestroyCudaModuleNV" ) );
|
|
|
22483 vkDestroyCudaFunctionNV = PFN_vkDestroyCudaFunctionNV( vkGetInstanceProcAddr( instance, "vkDestroyCudaFunctionNV" ) );
|
|
|
22484 vkCmdCudaLaunchKernelNV = PFN_vkCmdCudaLaunchKernelNV( vkGetInstanceProcAddr( instance, "vkCmdCudaLaunchKernelNV" ) );
|
|
|
22485 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
22486
|
|
|
22487 //=== VK_QCOM_tile_shading ===
|
|
|
22488 vkCmdDispatchTileQCOM = PFN_vkCmdDispatchTileQCOM( vkGetInstanceProcAddr( instance, "vkCmdDispatchTileQCOM" ) );
|
|
|
22489 vkCmdBeginPerTileExecutionQCOM = PFN_vkCmdBeginPerTileExecutionQCOM( vkGetInstanceProcAddr( instance, "vkCmdBeginPerTileExecutionQCOM" ) );
|
|
|
22490 vkCmdEndPerTileExecutionQCOM = PFN_vkCmdEndPerTileExecutionQCOM( vkGetInstanceProcAddr( instance, "vkCmdEndPerTileExecutionQCOM" ) );
|
|
|
22491
|
|
|
22492 #if defined( VK_USE_PLATFORM_METAL_EXT )
|
|
|
22493 //=== VK_EXT_metal_objects ===
|
|
|
22494 vkExportMetalObjectsEXT = PFN_vkExportMetalObjectsEXT( vkGetInstanceProcAddr( instance, "vkExportMetalObjectsEXT" ) );
|
|
|
22495 #endif /*VK_USE_PLATFORM_METAL_EXT*/
|
|
|
22496
|
|
|
22497 //=== VK_KHR_synchronization2 ===
|
|
|
22498 vkCmdSetEvent2KHR = PFN_vkCmdSetEvent2KHR( vkGetInstanceProcAddr( instance, "vkCmdSetEvent2KHR" ) );
|
|
|
22499 if ( !vkCmdSetEvent2 )
|
|
|
22500 vkCmdSetEvent2 = vkCmdSetEvent2KHR;
|
|
|
22501 vkCmdResetEvent2KHR = PFN_vkCmdResetEvent2KHR( vkGetInstanceProcAddr( instance, "vkCmdResetEvent2KHR" ) );
|
|
|
22502 if ( !vkCmdResetEvent2 )
|
|
|
22503 vkCmdResetEvent2 = vkCmdResetEvent2KHR;
|
|
|
22504 vkCmdWaitEvents2KHR = PFN_vkCmdWaitEvents2KHR( vkGetInstanceProcAddr( instance, "vkCmdWaitEvents2KHR" ) );
|
|
|
22505 if ( !vkCmdWaitEvents2 )
|
|
|
22506 vkCmdWaitEvents2 = vkCmdWaitEvents2KHR;
|
|
|
22507 vkCmdPipelineBarrier2KHR = PFN_vkCmdPipelineBarrier2KHR( vkGetInstanceProcAddr( instance, "vkCmdPipelineBarrier2KHR" ) );
|
|
|
22508 if ( !vkCmdPipelineBarrier2 )
|
|
|
22509 vkCmdPipelineBarrier2 = vkCmdPipelineBarrier2KHR;
|
|
|
22510 vkCmdWriteTimestamp2KHR = PFN_vkCmdWriteTimestamp2KHR( vkGetInstanceProcAddr( instance, "vkCmdWriteTimestamp2KHR" ) );
|
|
|
22511 if ( !vkCmdWriteTimestamp2 )
|
|
|
22512 vkCmdWriteTimestamp2 = vkCmdWriteTimestamp2KHR;
|
|
|
22513 vkQueueSubmit2KHR = PFN_vkQueueSubmit2KHR( vkGetInstanceProcAddr( instance, "vkQueueSubmit2KHR" ) );
|
|
|
22514 if ( !vkQueueSubmit2 )
|
|
|
22515 vkQueueSubmit2 = vkQueueSubmit2KHR;
|
|
|
22516
|
|
|
22517 //=== VK_EXT_descriptor_buffer ===
|
|
|
22518 vkGetDescriptorSetLayoutSizeEXT = PFN_vkGetDescriptorSetLayoutSizeEXT( vkGetInstanceProcAddr( instance, "vkGetDescriptorSetLayoutSizeEXT" ) );
|
|
|
22519 vkGetDescriptorSetLayoutBindingOffsetEXT =
|
|
|
22520 PFN_vkGetDescriptorSetLayoutBindingOffsetEXT( vkGetInstanceProcAddr( instance, "vkGetDescriptorSetLayoutBindingOffsetEXT" ) );
|
|
|
22521 vkGetDescriptorEXT = PFN_vkGetDescriptorEXT( vkGetInstanceProcAddr( instance, "vkGetDescriptorEXT" ) );
|
|
|
22522 vkCmdBindDescriptorBuffersEXT = PFN_vkCmdBindDescriptorBuffersEXT( vkGetInstanceProcAddr( instance, "vkCmdBindDescriptorBuffersEXT" ) );
|
|
|
22523 vkCmdSetDescriptorBufferOffsetsEXT = PFN_vkCmdSetDescriptorBufferOffsetsEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDescriptorBufferOffsetsEXT" ) );
|
|
|
22524 vkCmdBindDescriptorBufferEmbeddedSamplersEXT =
|
|
|
22525 PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT( vkGetInstanceProcAddr( instance, "vkCmdBindDescriptorBufferEmbeddedSamplersEXT" ) );
|
|
|
22526 vkGetBufferOpaqueCaptureDescriptorDataEXT =
|
|
|
22527 PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT( vkGetInstanceProcAddr( instance, "vkGetBufferOpaqueCaptureDescriptorDataEXT" ) );
|
|
|
22528 vkGetImageOpaqueCaptureDescriptorDataEXT =
|
|
|
22529 PFN_vkGetImageOpaqueCaptureDescriptorDataEXT( vkGetInstanceProcAddr( instance, "vkGetImageOpaqueCaptureDescriptorDataEXT" ) );
|
|
|
22530 vkGetImageViewOpaqueCaptureDescriptorDataEXT =
|
|
|
22531 PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT( vkGetInstanceProcAddr( instance, "vkGetImageViewOpaqueCaptureDescriptorDataEXT" ) );
|
|
|
22532 vkGetSamplerOpaqueCaptureDescriptorDataEXT =
|
|
|
22533 PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT( vkGetInstanceProcAddr( instance, "vkGetSamplerOpaqueCaptureDescriptorDataEXT" ) );
|
|
|
22534 vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(
|
|
|
22535 vkGetInstanceProcAddr( instance, "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT" ) );
|
|
|
22536
|
|
|
22537 //=== VK_NV_fragment_shading_rate_enums ===
|
|
|
22538 vkCmdSetFragmentShadingRateEnumNV = PFN_vkCmdSetFragmentShadingRateEnumNV( vkGetInstanceProcAddr( instance, "vkCmdSetFragmentShadingRateEnumNV" ) );
|
|
|
22539
|
|
|
22540 //=== VK_EXT_mesh_shader ===
|
|
|
22541 vkCmdDrawMeshTasksEXT = PFN_vkCmdDrawMeshTasksEXT( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksEXT" ) );
|
|
|
22542 vkCmdDrawMeshTasksIndirectEXT = PFN_vkCmdDrawMeshTasksIndirectEXT( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksIndirectEXT" ) );
|
|
|
22543 vkCmdDrawMeshTasksIndirectCountEXT = PFN_vkCmdDrawMeshTasksIndirectCountEXT( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksIndirectCountEXT" ) );
|
|
|
22544
|
|
|
22545 //=== VK_KHR_copy_commands2 ===
|
|
|
22546 vkCmdCopyBuffer2KHR = PFN_vkCmdCopyBuffer2KHR( vkGetInstanceProcAddr( instance, "vkCmdCopyBuffer2KHR" ) );
|
|
|
22547 if ( !vkCmdCopyBuffer2 )
|
|
|
22548 vkCmdCopyBuffer2 = vkCmdCopyBuffer2KHR;
|
|
|
22549 vkCmdCopyImage2KHR = PFN_vkCmdCopyImage2KHR( vkGetInstanceProcAddr( instance, "vkCmdCopyImage2KHR" ) );
|
|
|
22550 if ( !vkCmdCopyImage2 )
|
|
|
22551 vkCmdCopyImage2 = vkCmdCopyImage2KHR;
|
|
|
22552 vkCmdCopyBufferToImage2KHR = PFN_vkCmdCopyBufferToImage2KHR( vkGetInstanceProcAddr( instance, "vkCmdCopyBufferToImage2KHR" ) );
|
|
|
22553 if ( !vkCmdCopyBufferToImage2 )
|
|
|
22554 vkCmdCopyBufferToImage2 = vkCmdCopyBufferToImage2KHR;
|
|
|
22555 vkCmdCopyImageToBuffer2KHR = PFN_vkCmdCopyImageToBuffer2KHR( vkGetInstanceProcAddr( instance, "vkCmdCopyImageToBuffer2KHR" ) );
|
|
|
22556 if ( !vkCmdCopyImageToBuffer2 )
|
|
|
22557 vkCmdCopyImageToBuffer2 = vkCmdCopyImageToBuffer2KHR;
|
|
|
22558 vkCmdBlitImage2KHR = PFN_vkCmdBlitImage2KHR( vkGetInstanceProcAddr( instance, "vkCmdBlitImage2KHR" ) );
|
|
|
22559 if ( !vkCmdBlitImage2 )
|
|
|
22560 vkCmdBlitImage2 = vkCmdBlitImage2KHR;
|
|
|
22561 vkCmdResolveImage2KHR = PFN_vkCmdResolveImage2KHR( vkGetInstanceProcAddr( instance, "vkCmdResolveImage2KHR" ) );
|
|
|
22562 if ( !vkCmdResolveImage2 )
|
|
|
22563 vkCmdResolveImage2 = vkCmdResolveImage2KHR;
|
|
|
22564
|
|
|
22565 //=== VK_EXT_device_fault ===
|
|
|
22566 vkGetDeviceFaultInfoEXT = PFN_vkGetDeviceFaultInfoEXT( vkGetInstanceProcAddr( instance, "vkGetDeviceFaultInfoEXT" ) );
|
|
|
22567
|
|
|
22568 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
22569 //=== VK_NV_acquire_winrt_display ===
|
|
|
22570 vkAcquireWinrtDisplayNV = PFN_vkAcquireWinrtDisplayNV( vkGetInstanceProcAddr( instance, "vkAcquireWinrtDisplayNV" ) );
|
|
|
22571 vkGetWinrtDisplayNV = PFN_vkGetWinrtDisplayNV( vkGetInstanceProcAddr( instance, "vkGetWinrtDisplayNV" ) );
|
|
|
22572 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
22573
|
|
|
22574 #if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
|
|
|
22575 //=== VK_EXT_directfb_surface ===
|
|
|
22576 vkCreateDirectFBSurfaceEXT = PFN_vkCreateDirectFBSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateDirectFBSurfaceEXT" ) );
|
|
|
22577 vkGetPhysicalDeviceDirectFBPresentationSupportEXT =
|
|
|
22578 PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDirectFBPresentationSupportEXT" ) );
|
|
|
22579 #endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
|
|
|
22580
|
|
|
22581 //=== VK_EXT_vertex_input_dynamic_state ===
|
|
|
22582 vkCmdSetVertexInputEXT = PFN_vkCmdSetVertexInputEXT( vkGetInstanceProcAddr( instance, "vkCmdSetVertexInputEXT" ) );
|
|
|
22583
|
|
|
22584 #if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
|
22585 //=== VK_FUCHSIA_external_memory ===
|
|
|
22586 vkGetMemoryZirconHandleFUCHSIA = PFN_vkGetMemoryZirconHandleFUCHSIA( vkGetInstanceProcAddr( instance, "vkGetMemoryZirconHandleFUCHSIA" ) );
|
|
|
22587 vkGetMemoryZirconHandlePropertiesFUCHSIA =
|
|
|
22588 PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA( vkGetInstanceProcAddr( instance, "vkGetMemoryZirconHandlePropertiesFUCHSIA" ) );
|
|
|
22589 #endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
22590
|
|
|
22591 #if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
|
22592 //=== VK_FUCHSIA_external_semaphore ===
|
|
|
22593 vkImportSemaphoreZirconHandleFUCHSIA =
|
|
|
22594 PFN_vkImportSemaphoreZirconHandleFUCHSIA( vkGetInstanceProcAddr( instance, "vkImportSemaphoreZirconHandleFUCHSIA" ) );
|
|
|
22595 vkGetSemaphoreZirconHandleFUCHSIA = PFN_vkGetSemaphoreZirconHandleFUCHSIA( vkGetInstanceProcAddr( instance, "vkGetSemaphoreZirconHandleFUCHSIA" ) );
|
|
|
22596 #endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
22597
|
|
|
22598 #if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
|
22599 //=== VK_FUCHSIA_buffer_collection ===
|
|
|
22600 vkCreateBufferCollectionFUCHSIA = PFN_vkCreateBufferCollectionFUCHSIA( vkGetInstanceProcAddr( instance, "vkCreateBufferCollectionFUCHSIA" ) );
|
|
|
22601 vkSetBufferCollectionImageConstraintsFUCHSIA =
|
|
|
22602 PFN_vkSetBufferCollectionImageConstraintsFUCHSIA( vkGetInstanceProcAddr( instance, "vkSetBufferCollectionImageConstraintsFUCHSIA" ) );
|
|
|
22603 vkSetBufferCollectionBufferConstraintsFUCHSIA =
|
|
|
22604 PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA( vkGetInstanceProcAddr( instance, "vkSetBufferCollectionBufferConstraintsFUCHSIA" ) );
|
|
|
22605 vkDestroyBufferCollectionFUCHSIA = PFN_vkDestroyBufferCollectionFUCHSIA( vkGetInstanceProcAddr( instance, "vkDestroyBufferCollectionFUCHSIA" ) );
|
|
|
22606 vkGetBufferCollectionPropertiesFUCHSIA =
|
|
|
22607 PFN_vkGetBufferCollectionPropertiesFUCHSIA( vkGetInstanceProcAddr( instance, "vkGetBufferCollectionPropertiesFUCHSIA" ) );
|
|
|
22608 #endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
22609
|
|
|
22610 //=== VK_HUAWEI_subpass_shading ===
|
|
|
22611 vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI =
|
|
|
22612 PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( vkGetInstanceProcAddr( instance, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI" ) );
|
|
|
22613 vkCmdSubpassShadingHUAWEI = PFN_vkCmdSubpassShadingHUAWEI( vkGetInstanceProcAddr( instance, "vkCmdSubpassShadingHUAWEI" ) );
|
|
|
22614
|
|
|
22615 //=== VK_HUAWEI_invocation_mask ===
|
|
|
22616 vkCmdBindInvocationMaskHUAWEI = PFN_vkCmdBindInvocationMaskHUAWEI( vkGetInstanceProcAddr( instance, "vkCmdBindInvocationMaskHUAWEI" ) );
|
|
|
22617
|
|
|
22618 //=== VK_NV_external_memory_rdma ===
|
|
|
22619 vkGetMemoryRemoteAddressNV = PFN_vkGetMemoryRemoteAddressNV( vkGetInstanceProcAddr( instance, "vkGetMemoryRemoteAddressNV" ) );
|
|
|
22620
|
|
|
22621 //=== VK_EXT_pipeline_properties ===
|
|
|
22622 vkGetPipelinePropertiesEXT = PFN_vkGetPipelinePropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetPipelinePropertiesEXT" ) );
|
|
|
22623
|
|
|
22624 //=== VK_EXT_extended_dynamic_state2 ===
|
|
|
22625 vkCmdSetPatchControlPointsEXT = PFN_vkCmdSetPatchControlPointsEXT( vkGetInstanceProcAddr( instance, "vkCmdSetPatchControlPointsEXT" ) );
|
|
|
22626 vkCmdSetRasterizerDiscardEnableEXT = PFN_vkCmdSetRasterizerDiscardEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetRasterizerDiscardEnableEXT" ) );
|
|
|
22627 if ( !vkCmdSetRasterizerDiscardEnable )
|
|
|
22628 vkCmdSetRasterizerDiscardEnable = vkCmdSetRasterizerDiscardEnableEXT;
|
|
|
22629 vkCmdSetDepthBiasEnableEXT = PFN_vkCmdSetDepthBiasEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBiasEnableEXT" ) );
|
|
|
22630 if ( !vkCmdSetDepthBiasEnable )
|
|
|
22631 vkCmdSetDepthBiasEnable = vkCmdSetDepthBiasEnableEXT;
|
|
|
22632 vkCmdSetLogicOpEXT = PFN_vkCmdSetLogicOpEXT( vkGetInstanceProcAddr( instance, "vkCmdSetLogicOpEXT" ) );
|
|
|
22633 vkCmdSetPrimitiveRestartEnableEXT = PFN_vkCmdSetPrimitiveRestartEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetPrimitiveRestartEnableEXT" ) );
|
|
|
22634 if ( !vkCmdSetPrimitiveRestartEnable )
|
|
|
22635 vkCmdSetPrimitiveRestartEnable = vkCmdSetPrimitiveRestartEnableEXT;
|
|
|
22636
|
|
|
22637 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
|
|
22638 //=== VK_QNX_screen_surface ===
|
|
|
22639 vkCreateScreenSurfaceQNX = PFN_vkCreateScreenSurfaceQNX( vkGetInstanceProcAddr( instance, "vkCreateScreenSurfaceQNX" ) );
|
|
|
22640 vkGetPhysicalDeviceScreenPresentationSupportQNX =
|
|
|
22641 PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceScreenPresentationSupportQNX" ) );
|
|
|
22642 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
|
|
22643
|
|
|
22644 //=== VK_EXT_color_write_enable ===
|
|
|
22645 vkCmdSetColorWriteEnableEXT = PFN_vkCmdSetColorWriteEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetColorWriteEnableEXT" ) );
|
|
|
22646
|
|
|
22647 //=== VK_KHR_ray_tracing_maintenance1 ===
|
|
|
22648 vkCmdTraceRaysIndirect2KHR = PFN_vkCmdTraceRaysIndirect2KHR( vkGetInstanceProcAddr( instance, "vkCmdTraceRaysIndirect2KHR" ) );
|
|
|
22649
|
|
|
22650 //=== VK_EXT_multi_draw ===
|
|
|
22651 vkCmdDrawMultiEXT = PFN_vkCmdDrawMultiEXT( vkGetInstanceProcAddr( instance, "vkCmdDrawMultiEXT" ) );
|
|
|
22652 vkCmdDrawMultiIndexedEXT = PFN_vkCmdDrawMultiIndexedEXT( vkGetInstanceProcAddr( instance, "vkCmdDrawMultiIndexedEXT" ) );
|
|
|
22653
|
|
|
22654 //=== VK_EXT_opacity_micromap ===
|
|
|
22655 vkCreateMicromapEXT = PFN_vkCreateMicromapEXT( vkGetInstanceProcAddr( instance, "vkCreateMicromapEXT" ) );
|
|
|
22656 vkDestroyMicromapEXT = PFN_vkDestroyMicromapEXT( vkGetInstanceProcAddr( instance, "vkDestroyMicromapEXT" ) );
|
|
|
22657 vkCmdBuildMicromapsEXT = PFN_vkCmdBuildMicromapsEXT( vkGetInstanceProcAddr( instance, "vkCmdBuildMicromapsEXT" ) );
|
|
|
22658 vkBuildMicromapsEXT = PFN_vkBuildMicromapsEXT( vkGetInstanceProcAddr( instance, "vkBuildMicromapsEXT" ) );
|
|
|
22659 vkCopyMicromapEXT = PFN_vkCopyMicromapEXT( vkGetInstanceProcAddr( instance, "vkCopyMicromapEXT" ) );
|
|
|
22660 vkCopyMicromapToMemoryEXT = PFN_vkCopyMicromapToMemoryEXT( vkGetInstanceProcAddr( instance, "vkCopyMicromapToMemoryEXT" ) );
|
|
|
22661 vkCopyMemoryToMicromapEXT = PFN_vkCopyMemoryToMicromapEXT( vkGetInstanceProcAddr( instance, "vkCopyMemoryToMicromapEXT" ) );
|
|
|
22662 vkWriteMicromapsPropertiesEXT = PFN_vkWriteMicromapsPropertiesEXT( vkGetInstanceProcAddr( instance, "vkWriteMicromapsPropertiesEXT" ) );
|
|
|
22663 vkCmdCopyMicromapEXT = PFN_vkCmdCopyMicromapEXT( vkGetInstanceProcAddr( instance, "vkCmdCopyMicromapEXT" ) );
|
|
|
22664 vkCmdCopyMicromapToMemoryEXT = PFN_vkCmdCopyMicromapToMemoryEXT( vkGetInstanceProcAddr( instance, "vkCmdCopyMicromapToMemoryEXT" ) );
|
|
|
22665 vkCmdCopyMemoryToMicromapEXT = PFN_vkCmdCopyMemoryToMicromapEXT( vkGetInstanceProcAddr( instance, "vkCmdCopyMemoryToMicromapEXT" ) );
|
|
|
22666 vkCmdWriteMicromapsPropertiesEXT = PFN_vkCmdWriteMicromapsPropertiesEXT( vkGetInstanceProcAddr( instance, "vkCmdWriteMicromapsPropertiesEXT" ) );
|
|
|
22667 vkGetDeviceMicromapCompatibilityEXT =
|
|
|
22668 PFN_vkGetDeviceMicromapCompatibilityEXT( vkGetInstanceProcAddr( instance, "vkGetDeviceMicromapCompatibilityEXT" ) );
|
|
|
22669 vkGetMicromapBuildSizesEXT = PFN_vkGetMicromapBuildSizesEXT( vkGetInstanceProcAddr( instance, "vkGetMicromapBuildSizesEXT" ) );
|
|
|
22670
|
|
|
22671 //=== VK_HUAWEI_cluster_culling_shader ===
|
|
|
22672 vkCmdDrawClusterHUAWEI = PFN_vkCmdDrawClusterHUAWEI( vkGetInstanceProcAddr( instance, "vkCmdDrawClusterHUAWEI" ) );
|
|
|
22673 vkCmdDrawClusterIndirectHUAWEI = PFN_vkCmdDrawClusterIndirectHUAWEI( vkGetInstanceProcAddr( instance, "vkCmdDrawClusterIndirectHUAWEI" ) );
|
|
|
22674
|
|
|
22675 //=== VK_EXT_pageable_device_local_memory ===
|
|
|
22676 vkSetDeviceMemoryPriorityEXT = PFN_vkSetDeviceMemoryPriorityEXT( vkGetInstanceProcAddr( instance, "vkSetDeviceMemoryPriorityEXT" ) );
|
|
|
22677
|
|
|
22678 //=== VK_KHR_maintenance4 ===
|
|
|
22679 vkGetDeviceBufferMemoryRequirementsKHR =
|
|
|
22680 PFN_vkGetDeviceBufferMemoryRequirementsKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceBufferMemoryRequirementsKHR" ) );
|
|
|
22681 if ( !vkGetDeviceBufferMemoryRequirements )
|
|
|
22682 vkGetDeviceBufferMemoryRequirements = vkGetDeviceBufferMemoryRequirementsKHR;
|
|
|
22683 vkGetDeviceImageMemoryRequirementsKHR =
|
|
|
22684 PFN_vkGetDeviceImageMemoryRequirementsKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceImageMemoryRequirementsKHR" ) );
|
|
|
22685 if ( !vkGetDeviceImageMemoryRequirements )
|
|
|
22686 vkGetDeviceImageMemoryRequirements = vkGetDeviceImageMemoryRequirementsKHR;
|
|
|
22687 vkGetDeviceImageSparseMemoryRequirementsKHR =
|
|
|
22688 PFN_vkGetDeviceImageSparseMemoryRequirementsKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceImageSparseMemoryRequirementsKHR" ) );
|
|
|
22689 if ( !vkGetDeviceImageSparseMemoryRequirements )
|
|
|
22690 vkGetDeviceImageSparseMemoryRequirements = vkGetDeviceImageSparseMemoryRequirementsKHR;
|
|
|
22691
|
|
|
22692 //=== VK_VALVE_descriptor_set_host_mapping ===
|
|
|
22693 vkGetDescriptorSetLayoutHostMappingInfoVALVE =
|
|
|
22694 PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE( vkGetInstanceProcAddr( instance, "vkGetDescriptorSetLayoutHostMappingInfoVALVE" ) );
|
|
|
22695 vkGetDescriptorSetHostMappingVALVE = PFN_vkGetDescriptorSetHostMappingVALVE( vkGetInstanceProcAddr( instance, "vkGetDescriptorSetHostMappingVALVE" ) );
|
|
|
22696
|
|
|
22697 //=== VK_NV_copy_memory_indirect ===
|
|
|
22698 vkCmdCopyMemoryIndirectNV = PFN_vkCmdCopyMemoryIndirectNV( vkGetInstanceProcAddr( instance, "vkCmdCopyMemoryIndirectNV" ) );
|
|
|
22699 vkCmdCopyMemoryToImageIndirectNV = PFN_vkCmdCopyMemoryToImageIndirectNV( vkGetInstanceProcAddr( instance, "vkCmdCopyMemoryToImageIndirectNV" ) );
|
|
|
22700
|
|
|
22701 //=== VK_NV_memory_decompression ===
|
|
|
22702 vkCmdDecompressMemoryNV = PFN_vkCmdDecompressMemoryNV( vkGetInstanceProcAddr( instance, "vkCmdDecompressMemoryNV" ) );
|
|
|
22703 vkCmdDecompressMemoryIndirectCountNV =
|
|
|
22704 PFN_vkCmdDecompressMemoryIndirectCountNV( vkGetInstanceProcAddr( instance, "vkCmdDecompressMemoryIndirectCountNV" ) );
|
|
|
22705
|
|
|
22706 //=== VK_NV_device_generated_commands_compute ===
|
|
|
22707 vkGetPipelineIndirectMemoryRequirementsNV =
|
|
|
22708 PFN_vkGetPipelineIndirectMemoryRequirementsNV( vkGetInstanceProcAddr( instance, "vkGetPipelineIndirectMemoryRequirementsNV" ) );
|
|
|
22709 vkCmdUpdatePipelineIndirectBufferNV =
|
|
|
22710 PFN_vkCmdUpdatePipelineIndirectBufferNV( vkGetInstanceProcAddr( instance, "vkCmdUpdatePipelineIndirectBufferNV" ) );
|
|
|
22711 vkGetPipelineIndirectDeviceAddressNV =
|
|
|
22712 PFN_vkGetPipelineIndirectDeviceAddressNV( vkGetInstanceProcAddr( instance, "vkGetPipelineIndirectDeviceAddressNV" ) );
|
|
|
22713
|
|
|
22714 #if defined( VK_USE_PLATFORM_OHOS )
|
|
|
22715 //=== VK_OHOS_external_memory ===
|
|
|
22716 vkGetNativeBufferPropertiesOHOS = PFN_vkGetNativeBufferPropertiesOHOS( vkGetInstanceProcAddr( instance, "vkGetNativeBufferPropertiesOHOS" ) );
|
|
|
22717 vkGetMemoryNativeBufferOHOS = PFN_vkGetMemoryNativeBufferOHOS( vkGetInstanceProcAddr( instance, "vkGetMemoryNativeBufferOHOS" ) );
|
|
|
22718 #endif /*VK_USE_PLATFORM_OHOS*/
|
|
|
22719
|
|
|
22720 //=== VK_EXT_extended_dynamic_state3 ===
|
|
|
22721 vkCmdSetDepthClampEnableEXT = PFN_vkCmdSetDepthClampEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthClampEnableEXT" ) );
|
|
|
22722 vkCmdSetPolygonModeEXT = PFN_vkCmdSetPolygonModeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetPolygonModeEXT" ) );
|
|
|
22723 vkCmdSetRasterizationSamplesEXT = PFN_vkCmdSetRasterizationSamplesEXT( vkGetInstanceProcAddr( instance, "vkCmdSetRasterizationSamplesEXT" ) );
|
|
|
22724 vkCmdSetSampleMaskEXT = PFN_vkCmdSetSampleMaskEXT( vkGetInstanceProcAddr( instance, "vkCmdSetSampleMaskEXT" ) );
|
|
|
22725 vkCmdSetAlphaToCoverageEnableEXT = PFN_vkCmdSetAlphaToCoverageEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetAlphaToCoverageEnableEXT" ) );
|
|
|
22726 vkCmdSetAlphaToOneEnableEXT = PFN_vkCmdSetAlphaToOneEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetAlphaToOneEnableEXT" ) );
|
|
|
22727 vkCmdSetLogicOpEnableEXT = PFN_vkCmdSetLogicOpEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetLogicOpEnableEXT" ) );
|
|
|
22728 vkCmdSetColorBlendEnableEXT = PFN_vkCmdSetColorBlendEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetColorBlendEnableEXT" ) );
|
|
|
22729 vkCmdSetColorBlendEquationEXT = PFN_vkCmdSetColorBlendEquationEXT( vkGetInstanceProcAddr( instance, "vkCmdSetColorBlendEquationEXT" ) );
|
|
|
22730 vkCmdSetColorWriteMaskEXT = PFN_vkCmdSetColorWriteMaskEXT( vkGetInstanceProcAddr( instance, "vkCmdSetColorWriteMaskEXT" ) );
|
|
|
22731 vkCmdSetTessellationDomainOriginEXT =
|
|
|
22732 PFN_vkCmdSetTessellationDomainOriginEXT( vkGetInstanceProcAddr( instance, "vkCmdSetTessellationDomainOriginEXT" ) );
|
|
|
22733 vkCmdSetRasterizationStreamEXT = PFN_vkCmdSetRasterizationStreamEXT( vkGetInstanceProcAddr( instance, "vkCmdSetRasterizationStreamEXT" ) );
|
|
|
22734 vkCmdSetConservativeRasterizationModeEXT =
|
|
|
22735 PFN_vkCmdSetConservativeRasterizationModeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetConservativeRasterizationModeEXT" ) );
|
|
|
22736 vkCmdSetExtraPrimitiveOverestimationSizeEXT =
|
|
|
22737 PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetExtraPrimitiveOverestimationSizeEXT" ) );
|
|
|
22738 vkCmdSetDepthClipEnableEXT = PFN_vkCmdSetDepthClipEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthClipEnableEXT" ) );
|
|
|
22739 vkCmdSetSampleLocationsEnableEXT = PFN_vkCmdSetSampleLocationsEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetSampleLocationsEnableEXT" ) );
|
|
|
22740 vkCmdSetColorBlendAdvancedEXT = PFN_vkCmdSetColorBlendAdvancedEXT( vkGetInstanceProcAddr( instance, "vkCmdSetColorBlendAdvancedEXT" ) );
|
|
|
22741 vkCmdSetProvokingVertexModeEXT = PFN_vkCmdSetProvokingVertexModeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetProvokingVertexModeEXT" ) );
|
|
|
22742 vkCmdSetLineRasterizationModeEXT = PFN_vkCmdSetLineRasterizationModeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetLineRasterizationModeEXT" ) );
|
|
|
22743 vkCmdSetLineStippleEnableEXT = PFN_vkCmdSetLineStippleEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetLineStippleEnableEXT" ) );
|
|
|
22744 vkCmdSetDepthClipNegativeOneToOneEXT =
|
|
|
22745 PFN_vkCmdSetDepthClipNegativeOneToOneEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthClipNegativeOneToOneEXT" ) );
|
|
|
22746 vkCmdSetViewportWScalingEnableNV = PFN_vkCmdSetViewportWScalingEnableNV( vkGetInstanceProcAddr( instance, "vkCmdSetViewportWScalingEnableNV" ) );
|
|
|
22747 vkCmdSetViewportSwizzleNV = PFN_vkCmdSetViewportSwizzleNV( vkGetInstanceProcAddr( instance, "vkCmdSetViewportSwizzleNV" ) );
|
|
|
22748 vkCmdSetCoverageToColorEnableNV = PFN_vkCmdSetCoverageToColorEnableNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoverageToColorEnableNV" ) );
|
|
|
22749 vkCmdSetCoverageToColorLocationNV = PFN_vkCmdSetCoverageToColorLocationNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoverageToColorLocationNV" ) );
|
|
|
22750 vkCmdSetCoverageModulationModeNV = PFN_vkCmdSetCoverageModulationModeNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoverageModulationModeNV" ) );
|
|
|
22751 vkCmdSetCoverageModulationTableEnableNV =
|
|
|
22752 PFN_vkCmdSetCoverageModulationTableEnableNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoverageModulationTableEnableNV" ) );
|
|
|
22753 vkCmdSetCoverageModulationTableNV = PFN_vkCmdSetCoverageModulationTableNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoverageModulationTableNV" ) );
|
|
|
22754 vkCmdSetShadingRateImageEnableNV = PFN_vkCmdSetShadingRateImageEnableNV( vkGetInstanceProcAddr( instance, "vkCmdSetShadingRateImageEnableNV" ) );
|
|
|
22755 vkCmdSetRepresentativeFragmentTestEnableNV =
|
|
|
22756 PFN_vkCmdSetRepresentativeFragmentTestEnableNV( vkGetInstanceProcAddr( instance, "vkCmdSetRepresentativeFragmentTestEnableNV" ) );
|
|
|
22757 vkCmdSetCoverageReductionModeNV = PFN_vkCmdSetCoverageReductionModeNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoverageReductionModeNV" ) );
|
|
|
22758
|
|
|
22759 //=== VK_ARM_tensors ===
|
|
|
22760 vkCreateTensorARM = PFN_vkCreateTensorARM( vkGetInstanceProcAddr( instance, "vkCreateTensorARM" ) );
|
|
|
22761 vkDestroyTensorARM = PFN_vkDestroyTensorARM( vkGetInstanceProcAddr( instance, "vkDestroyTensorARM" ) );
|
|
|
22762 vkCreateTensorViewARM = PFN_vkCreateTensorViewARM( vkGetInstanceProcAddr( instance, "vkCreateTensorViewARM" ) );
|
|
|
22763 vkDestroyTensorViewARM = PFN_vkDestroyTensorViewARM( vkGetInstanceProcAddr( instance, "vkDestroyTensorViewARM" ) );
|
|
|
22764 vkGetTensorMemoryRequirementsARM = PFN_vkGetTensorMemoryRequirementsARM( vkGetInstanceProcAddr( instance, "vkGetTensorMemoryRequirementsARM" ) );
|
|
|
22765 vkBindTensorMemoryARM = PFN_vkBindTensorMemoryARM( vkGetInstanceProcAddr( instance, "vkBindTensorMemoryARM" ) );
|
|
|
22766 vkGetDeviceTensorMemoryRequirementsARM =
|
|
|
22767 PFN_vkGetDeviceTensorMemoryRequirementsARM( vkGetInstanceProcAddr( instance, "vkGetDeviceTensorMemoryRequirementsARM" ) );
|
|
|
22768 vkCmdCopyTensorARM = PFN_vkCmdCopyTensorARM( vkGetInstanceProcAddr( instance, "vkCmdCopyTensorARM" ) );
|
|
|
22769 vkGetPhysicalDeviceExternalTensorPropertiesARM =
|
|
|
22770 PFN_vkGetPhysicalDeviceExternalTensorPropertiesARM( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalTensorPropertiesARM" ) );
|
|
|
22771 vkGetTensorOpaqueCaptureDescriptorDataARM =
|
|
|
22772 PFN_vkGetTensorOpaqueCaptureDescriptorDataARM( vkGetInstanceProcAddr( instance, "vkGetTensorOpaqueCaptureDescriptorDataARM" ) );
|
|
|
22773 vkGetTensorViewOpaqueCaptureDescriptorDataARM =
|
|
|
22774 PFN_vkGetTensorViewOpaqueCaptureDescriptorDataARM( vkGetInstanceProcAddr( instance, "vkGetTensorViewOpaqueCaptureDescriptorDataARM" ) );
|
|
|
22775
|
|
|
22776 //=== VK_EXT_shader_module_identifier ===
|
|
|
22777 vkGetShaderModuleIdentifierEXT = PFN_vkGetShaderModuleIdentifierEXT( vkGetInstanceProcAddr( instance, "vkGetShaderModuleIdentifierEXT" ) );
|
|
|
22778 vkGetShaderModuleCreateInfoIdentifierEXT =
|
|
|
22779 PFN_vkGetShaderModuleCreateInfoIdentifierEXT( vkGetInstanceProcAddr( instance, "vkGetShaderModuleCreateInfoIdentifierEXT" ) );
|
|
|
22780
|
|
|
22781 //=== VK_NV_optical_flow ===
|
|
|
22782 vkGetPhysicalDeviceOpticalFlowImageFormatsNV =
|
|
|
22783 PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceOpticalFlowImageFormatsNV" ) );
|
|
|
22784 vkCreateOpticalFlowSessionNV = PFN_vkCreateOpticalFlowSessionNV( vkGetInstanceProcAddr( instance, "vkCreateOpticalFlowSessionNV" ) );
|
|
|
22785 vkDestroyOpticalFlowSessionNV = PFN_vkDestroyOpticalFlowSessionNV( vkGetInstanceProcAddr( instance, "vkDestroyOpticalFlowSessionNV" ) );
|
|
|
22786 vkBindOpticalFlowSessionImageNV = PFN_vkBindOpticalFlowSessionImageNV( vkGetInstanceProcAddr( instance, "vkBindOpticalFlowSessionImageNV" ) );
|
|
|
22787 vkCmdOpticalFlowExecuteNV = PFN_vkCmdOpticalFlowExecuteNV( vkGetInstanceProcAddr( instance, "vkCmdOpticalFlowExecuteNV" ) );
|
|
|
22788
|
|
|
22789 //=== VK_KHR_maintenance5 ===
|
|
|
22790 vkCmdBindIndexBuffer2KHR = PFN_vkCmdBindIndexBuffer2KHR( vkGetInstanceProcAddr( instance, "vkCmdBindIndexBuffer2KHR" ) );
|
|
|
22791 if ( !vkCmdBindIndexBuffer2 )
|
|
|
22792 vkCmdBindIndexBuffer2 = vkCmdBindIndexBuffer2KHR;
|
|
|
22793 vkGetRenderingAreaGranularityKHR = PFN_vkGetRenderingAreaGranularityKHR( vkGetInstanceProcAddr( instance, "vkGetRenderingAreaGranularityKHR" ) );
|
|
|
22794 if ( !vkGetRenderingAreaGranularity )
|
|
|
22795 vkGetRenderingAreaGranularity = vkGetRenderingAreaGranularityKHR;
|
|
|
22796 vkGetDeviceImageSubresourceLayoutKHR =
|
|
|
22797 PFN_vkGetDeviceImageSubresourceLayoutKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceImageSubresourceLayoutKHR" ) );
|
|
|
22798 if ( !vkGetDeviceImageSubresourceLayout )
|
|
|
22799 vkGetDeviceImageSubresourceLayout = vkGetDeviceImageSubresourceLayoutKHR;
|
|
|
22800 vkGetImageSubresourceLayout2KHR = PFN_vkGetImageSubresourceLayout2KHR( vkGetInstanceProcAddr( instance, "vkGetImageSubresourceLayout2KHR" ) );
|
|
|
22801 if ( !vkGetImageSubresourceLayout2 )
|
|
|
22802 vkGetImageSubresourceLayout2 = vkGetImageSubresourceLayout2KHR;
|
|
|
22803
|
|
|
22804 //=== VK_AMD_anti_lag ===
|
|
|
22805 vkAntiLagUpdateAMD = PFN_vkAntiLagUpdateAMD( vkGetInstanceProcAddr( instance, "vkAntiLagUpdateAMD" ) );
|
|
|
22806
|
|
|
22807 //=== VK_KHR_present_wait2 ===
|
|
|
22808 vkWaitForPresent2KHR = PFN_vkWaitForPresent2KHR( vkGetInstanceProcAddr( instance, "vkWaitForPresent2KHR" ) );
|
|
|
22809
|
|
|
22810 //=== VK_EXT_shader_object ===
|
|
|
22811 vkCreateShadersEXT = PFN_vkCreateShadersEXT( vkGetInstanceProcAddr( instance, "vkCreateShadersEXT" ) );
|
|
|
22812 vkDestroyShaderEXT = PFN_vkDestroyShaderEXT( vkGetInstanceProcAddr( instance, "vkDestroyShaderEXT" ) );
|
|
|
22813 vkGetShaderBinaryDataEXT = PFN_vkGetShaderBinaryDataEXT( vkGetInstanceProcAddr( instance, "vkGetShaderBinaryDataEXT" ) );
|
|
|
22814 vkCmdBindShadersEXT = PFN_vkCmdBindShadersEXT( vkGetInstanceProcAddr( instance, "vkCmdBindShadersEXT" ) );
|
|
|
22815 vkCmdSetDepthClampRangeEXT = PFN_vkCmdSetDepthClampRangeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthClampRangeEXT" ) );
|
|
|
22816
|
|
|
22817 //=== VK_KHR_pipeline_binary ===
|
|
|
22818 vkCreatePipelineBinariesKHR = PFN_vkCreatePipelineBinariesKHR( vkGetInstanceProcAddr( instance, "vkCreatePipelineBinariesKHR" ) );
|
|
|
22819 vkDestroyPipelineBinaryKHR = PFN_vkDestroyPipelineBinaryKHR( vkGetInstanceProcAddr( instance, "vkDestroyPipelineBinaryKHR" ) );
|
|
|
22820 vkGetPipelineKeyKHR = PFN_vkGetPipelineKeyKHR( vkGetInstanceProcAddr( instance, "vkGetPipelineKeyKHR" ) );
|
|
|
22821 vkGetPipelineBinaryDataKHR = PFN_vkGetPipelineBinaryDataKHR( vkGetInstanceProcAddr( instance, "vkGetPipelineBinaryDataKHR" ) );
|
|
|
22822 vkReleaseCapturedPipelineDataKHR = PFN_vkReleaseCapturedPipelineDataKHR( vkGetInstanceProcAddr( instance, "vkReleaseCapturedPipelineDataKHR" ) );
|
|
|
22823
|
|
|
22824 //=== VK_QCOM_tile_properties ===
|
|
|
22825 vkGetFramebufferTilePropertiesQCOM = PFN_vkGetFramebufferTilePropertiesQCOM( vkGetInstanceProcAddr( instance, "vkGetFramebufferTilePropertiesQCOM" ) );
|
|
|
22826 vkGetDynamicRenderingTilePropertiesQCOM =
|
|
|
22827 PFN_vkGetDynamicRenderingTilePropertiesQCOM( vkGetInstanceProcAddr( instance, "vkGetDynamicRenderingTilePropertiesQCOM" ) );
|
|
|
22828
|
|
|
22829 //=== VK_KHR_swapchain_maintenance1 ===
|
|
|
22830 vkReleaseSwapchainImagesKHR = PFN_vkReleaseSwapchainImagesKHR( vkGetInstanceProcAddr( instance, "vkReleaseSwapchainImagesKHR" ) );
|
|
|
22831
|
|
|
22832 //=== VK_NV_cooperative_vector ===
|
|
|
22833 vkGetPhysicalDeviceCooperativeVectorPropertiesNV =
|
|
|
22834 PFN_vkGetPhysicalDeviceCooperativeVectorPropertiesNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCooperativeVectorPropertiesNV" ) );
|
|
|
22835 vkConvertCooperativeVectorMatrixNV = PFN_vkConvertCooperativeVectorMatrixNV( vkGetInstanceProcAddr( instance, "vkConvertCooperativeVectorMatrixNV" ) );
|
|
|
22836 vkCmdConvertCooperativeVectorMatrixNV =
|
|
|
22837 PFN_vkCmdConvertCooperativeVectorMatrixNV( vkGetInstanceProcAddr( instance, "vkCmdConvertCooperativeVectorMatrixNV" ) );
|
|
|
22838
|
|
|
22839 //=== VK_NV_low_latency2 ===
|
|
|
22840 vkSetLatencySleepModeNV = PFN_vkSetLatencySleepModeNV( vkGetInstanceProcAddr( instance, "vkSetLatencySleepModeNV" ) );
|
|
|
22841 vkLatencySleepNV = PFN_vkLatencySleepNV( vkGetInstanceProcAddr( instance, "vkLatencySleepNV" ) );
|
|
|
22842 vkSetLatencyMarkerNV = PFN_vkSetLatencyMarkerNV( vkGetInstanceProcAddr( instance, "vkSetLatencyMarkerNV" ) );
|
|
|
22843 vkGetLatencyTimingsNV = PFN_vkGetLatencyTimingsNV( vkGetInstanceProcAddr( instance, "vkGetLatencyTimingsNV" ) );
|
|
|
22844 vkQueueNotifyOutOfBandNV = PFN_vkQueueNotifyOutOfBandNV( vkGetInstanceProcAddr( instance, "vkQueueNotifyOutOfBandNV" ) );
|
|
|
22845
|
|
|
22846 //=== VK_KHR_cooperative_matrix ===
|
|
|
22847 vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR =
|
|
|
22848 PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR" ) );
|
|
|
22849
|
|
|
22850 //=== VK_ARM_data_graph ===
|
|
|
22851 vkCreateDataGraphPipelinesARM = PFN_vkCreateDataGraphPipelinesARM( vkGetInstanceProcAddr( instance, "vkCreateDataGraphPipelinesARM" ) );
|
|
|
22852 vkCreateDataGraphPipelineSessionARM =
|
|
|
22853 PFN_vkCreateDataGraphPipelineSessionARM( vkGetInstanceProcAddr( instance, "vkCreateDataGraphPipelineSessionARM" ) );
|
|
|
22854 vkGetDataGraphPipelineSessionBindPointRequirementsARM = PFN_vkGetDataGraphPipelineSessionBindPointRequirementsARM(
|
|
|
22855 vkGetInstanceProcAddr( instance, "vkGetDataGraphPipelineSessionBindPointRequirementsARM" ) );
|
|
|
22856 vkGetDataGraphPipelineSessionMemoryRequirementsARM =
|
|
|
22857 PFN_vkGetDataGraphPipelineSessionMemoryRequirementsARM( vkGetInstanceProcAddr( instance, "vkGetDataGraphPipelineSessionMemoryRequirementsARM" ) );
|
|
|
22858 vkBindDataGraphPipelineSessionMemoryARM =
|
|
|
22859 PFN_vkBindDataGraphPipelineSessionMemoryARM( vkGetInstanceProcAddr( instance, "vkBindDataGraphPipelineSessionMemoryARM" ) );
|
|
|
22860 vkDestroyDataGraphPipelineSessionARM =
|
|
|
22861 PFN_vkDestroyDataGraphPipelineSessionARM( vkGetInstanceProcAddr( instance, "vkDestroyDataGraphPipelineSessionARM" ) );
|
|
|
22862 vkCmdDispatchDataGraphARM = PFN_vkCmdDispatchDataGraphARM( vkGetInstanceProcAddr( instance, "vkCmdDispatchDataGraphARM" ) );
|
|
|
22863 vkGetDataGraphPipelineAvailablePropertiesARM =
|
|
|
22864 PFN_vkGetDataGraphPipelineAvailablePropertiesARM( vkGetInstanceProcAddr( instance, "vkGetDataGraphPipelineAvailablePropertiesARM" ) );
|
|
|
22865 vkGetDataGraphPipelinePropertiesARM =
|
|
|
22866 PFN_vkGetDataGraphPipelinePropertiesARM( vkGetInstanceProcAddr( instance, "vkGetDataGraphPipelinePropertiesARM" ) );
|
|
|
22867 vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM =
|
|
|
22868 PFN_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM" ) );
|
|
|
22869 vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM = PFN_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM(
|
|
|
22870 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM" ) );
|
|
|
22871
|
|
|
22872 //=== VK_EXT_attachment_feedback_loop_dynamic_state ===
|
|
|
22873 vkCmdSetAttachmentFeedbackLoopEnableEXT =
|
|
|
22874 PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetAttachmentFeedbackLoopEnableEXT" ) );
|
|
|
22875
|
|
|
22876 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
|
|
22877 //=== VK_QNX_external_memory_screen_buffer ===
|
|
|
22878 vkGetScreenBufferPropertiesQNX = PFN_vkGetScreenBufferPropertiesQNX( vkGetInstanceProcAddr( instance, "vkGetScreenBufferPropertiesQNX" ) );
|
|
|
22879 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
|
|
22880
|
|
|
22881 //=== VK_KHR_line_rasterization ===
|
|
|
22882 vkCmdSetLineStippleKHR = PFN_vkCmdSetLineStippleKHR( vkGetInstanceProcAddr( instance, "vkCmdSetLineStippleKHR" ) );
|
|
|
22883 if ( !vkCmdSetLineStipple )
|
|
|
22884 vkCmdSetLineStipple = vkCmdSetLineStippleKHR;
|
|
|
22885
|
|
|
22886 //=== VK_KHR_calibrated_timestamps ===
|
|
|
22887 vkGetPhysicalDeviceCalibrateableTimeDomainsKHR =
|
|
|
22888 PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsKHR" ) );
|
|
|
22889 vkGetCalibratedTimestampsKHR = PFN_vkGetCalibratedTimestampsKHR( vkGetInstanceProcAddr( instance, "vkGetCalibratedTimestampsKHR" ) );
|
|
|
22890
|
|
|
22891 //=== VK_KHR_maintenance6 ===
|
|
|
22892 vkCmdBindDescriptorSets2KHR = PFN_vkCmdBindDescriptorSets2KHR( vkGetInstanceProcAddr( instance, "vkCmdBindDescriptorSets2KHR" ) );
|
|
|
22893 if ( !vkCmdBindDescriptorSets2 )
|
|
|
22894 vkCmdBindDescriptorSets2 = vkCmdBindDescriptorSets2KHR;
|
|
|
22895 vkCmdPushConstants2KHR = PFN_vkCmdPushConstants2KHR( vkGetInstanceProcAddr( instance, "vkCmdPushConstants2KHR" ) );
|
|
|
22896 if ( !vkCmdPushConstants2 )
|
|
|
22897 vkCmdPushConstants2 = vkCmdPushConstants2KHR;
|
|
|
22898 vkCmdPushDescriptorSet2KHR = PFN_vkCmdPushDescriptorSet2KHR( vkGetInstanceProcAddr( instance, "vkCmdPushDescriptorSet2KHR" ) );
|
|
|
22899 if ( !vkCmdPushDescriptorSet2 )
|
|
|
22900 vkCmdPushDescriptorSet2 = vkCmdPushDescriptorSet2KHR;
|
|
|
22901 vkCmdPushDescriptorSetWithTemplate2KHR =
|
|
|
22902 PFN_vkCmdPushDescriptorSetWithTemplate2KHR( vkGetInstanceProcAddr( instance, "vkCmdPushDescriptorSetWithTemplate2KHR" ) );
|
|
|
22903 if ( !vkCmdPushDescriptorSetWithTemplate2 )
|
|
|
22904 vkCmdPushDescriptorSetWithTemplate2 = vkCmdPushDescriptorSetWithTemplate2KHR;
|
|
|
22905 vkCmdSetDescriptorBufferOffsets2EXT =
|
|
|
22906 PFN_vkCmdSetDescriptorBufferOffsets2EXT( vkGetInstanceProcAddr( instance, "vkCmdSetDescriptorBufferOffsets2EXT" ) );
|
|
|
22907 vkCmdBindDescriptorBufferEmbeddedSamplers2EXT =
|
|
|
22908 PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( vkGetInstanceProcAddr( instance, "vkCmdBindDescriptorBufferEmbeddedSamplers2EXT" ) );
|
|
|
22909
|
|
|
22910 //=== VK_QCOM_tile_memory_heap ===
|
|
|
22911 vkCmdBindTileMemoryQCOM = PFN_vkCmdBindTileMemoryQCOM( vkGetInstanceProcAddr( instance, "vkCmdBindTileMemoryQCOM" ) );
|
|
|
22912
|
|
|
22913 //=== VK_KHR_copy_memory_indirect ===
|
|
|
22914 vkCmdCopyMemoryIndirectKHR = PFN_vkCmdCopyMemoryIndirectKHR( vkGetInstanceProcAddr( instance, "vkCmdCopyMemoryIndirectKHR" ) );
|
|
|
22915 vkCmdCopyMemoryToImageIndirectKHR = PFN_vkCmdCopyMemoryToImageIndirectKHR( vkGetInstanceProcAddr( instance, "vkCmdCopyMemoryToImageIndirectKHR" ) );
|
|
|
22916
|
|
|
22917 //=== VK_EXT_memory_decompression ===
|
|
|
22918 vkCmdDecompressMemoryEXT = PFN_vkCmdDecompressMemoryEXT( vkGetInstanceProcAddr( instance, "vkCmdDecompressMemoryEXT" ) );
|
|
|
22919 vkCmdDecompressMemoryIndirectCountEXT =
|
|
|
22920 PFN_vkCmdDecompressMemoryIndirectCountEXT( vkGetInstanceProcAddr( instance, "vkCmdDecompressMemoryIndirectCountEXT" ) );
|
|
|
22921
|
|
|
22922 //=== VK_NV_external_compute_queue ===
|
|
|
22923 vkCreateExternalComputeQueueNV = PFN_vkCreateExternalComputeQueueNV( vkGetInstanceProcAddr( instance, "vkCreateExternalComputeQueueNV" ) );
|
|
|
22924 vkDestroyExternalComputeQueueNV = PFN_vkDestroyExternalComputeQueueNV( vkGetInstanceProcAddr( instance, "vkDestroyExternalComputeQueueNV" ) );
|
|
|
22925 vkGetExternalComputeQueueDataNV = PFN_vkGetExternalComputeQueueDataNV( vkGetInstanceProcAddr( instance, "vkGetExternalComputeQueueDataNV" ) );
|
|
|
22926
|
|
|
22927 //=== VK_NV_cluster_acceleration_structure ===
|
|
|
22928 vkGetClusterAccelerationStructureBuildSizesNV =
|
|
|
22929 PFN_vkGetClusterAccelerationStructureBuildSizesNV( vkGetInstanceProcAddr( instance, "vkGetClusterAccelerationStructureBuildSizesNV" ) );
|
|
|
22930 vkCmdBuildClusterAccelerationStructureIndirectNV =
|
|
|
22931 PFN_vkCmdBuildClusterAccelerationStructureIndirectNV( vkGetInstanceProcAddr( instance, "vkCmdBuildClusterAccelerationStructureIndirectNV" ) );
|
|
|
22932
|
|
|
22933 //=== VK_NV_partitioned_acceleration_structure ===
|
|
|
22934 vkGetPartitionedAccelerationStructuresBuildSizesNV =
|
|
|
22935 PFN_vkGetPartitionedAccelerationStructuresBuildSizesNV( vkGetInstanceProcAddr( instance, "vkGetPartitionedAccelerationStructuresBuildSizesNV" ) );
|
|
|
22936 vkCmdBuildPartitionedAccelerationStructuresNV =
|
|
|
22937 PFN_vkCmdBuildPartitionedAccelerationStructuresNV( vkGetInstanceProcAddr( instance, "vkCmdBuildPartitionedAccelerationStructuresNV" ) );
|
|
|
22938
|
|
|
22939 //=== VK_EXT_device_generated_commands ===
|
|
|
22940 vkGetGeneratedCommandsMemoryRequirementsEXT =
|
|
|
22941 PFN_vkGetGeneratedCommandsMemoryRequirementsEXT( vkGetInstanceProcAddr( instance, "vkGetGeneratedCommandsMemoryRequirementsEXT" ) );
|
|
|
22942 vkCmdPreprocessGeneratedCommandsEXT =
|
|
|
22943 PFN_vkCmdPreprocessGeneratedCommandsEXT( vkGetInstanceProcAddr( instance, "vkCmdPreprocessGeneratedCommandsEXT" ) );
|
|
|
22944 vkCmdExecuteGeneratedCommandsEXT = PFN_vkCmdExecuteGeneratedCommandsEXT( vkGetInstanceProcAddr( instance, "vkCmdExecuteGeneratedCommandsEXT" ) );
|
|
|
22945 vkCreateIndirectCommandsLayoutEXT = PFN_vkCreateIndirectCommandsLayoutEXT( vkGetInstanceProcAddr( instance, "vkCreateIndirectCommandsLayoutEXT" ) );
|
|
|
22946 vkDestroyIndirectCommandsLayoutEXT = PFN_vkDestroyIndirectCommandsLayoutEXT( vkGetInstanceProcAddr( instance, "vkDestroyIndirectCommandsLayoutEXT" ) );
|
|
|
22947 vkCreateIndirectExecutionSetEXT = PFN_vkCreateIndirectExecutionSetEXT( vkGetInstanceProcAddr( instance, "vkCreateIndirectExecutionSetEXT" ) );
|
|
|
22948 vkDestroyIndirectExecutionSetEXT = PFN_vkDestroyIndirectExecutionSetEXT( vkGetInstanceProcAddr( instance, "vkDestroyIndirectExecutionSetEXT" ) );
|
|
|
22949 vkUpdateIndirectExecutionSetPipelineEXT =
|
|
|
22950 PFN_vkUpdateIndirectExecutionSetPipelineEXT( vkGetInstanceProcAddr( instance, "vkUpdateIndirectExecutionSetPipelineEXT" ) );
|
|
|
22951 vkUpdateIndirectExecutionSetShaderEXT =
|
|
|
22952 PFN_vkUpdateIndirectExecutionSetShaderEXT( vkGetInstanceProcAddr( instance, "vkUpdateIndirectExecutionSetShaderEXT" ) );
|
|
|
22953
|
|
|
22954 #if defined( VK_USE_PLATFORM_OHOS )
|
|
|
22955 //=== VK_OHOS_surface ===
|
|
|
22956 vkCreateSurfaceOHOS = PFN_vkCreateSurfaceOHOS( vkGetInstanceProcAddr( instance, "vkCreateSurfaceOHOS" ) );
|
|
|
22957 #endif /*VK_USE_PLATFORM_OHOS*/
|
|
|
22958
|
|
|
22959 #if defined( VK_USE_PLATFORM_OHOS )
|
|
|
22960 //=== VK_OHOS_native_buffer ===
|
|
|
22961 vkGetSwapchainGrallocUsageOHOS = PFN_vkGetSwapchainGrallocUsageOHOS( vkGetInstanceProcAddr( instance, "vkGetSwapchainGrallocUsageOHOS" ) );
|
|
|
22962 vkAcquireImageOHOS = PFN_vkAcquireImageOHOS( vkGetInstanceProcAddr( instance, "vkAcquireImageOHOS" ) );
|
|
|
22963 vkQueueSignalReleaseImageOHOS = PFN_vkQueueSignalReleaseImageOHOS( vkGetInstanceProcAddr( instance, "vkQueueSignalReleaseImageOHOS" ) );
|
|
|
22964 #endif /*VK_USE_PLATFORM_OHOS*/
|
|
|
22965
|
|
|
22966 //=== VK_NV_cooperative_matrix2 ===
|
|
|
22967 vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV = PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(
|
|
|
22968 vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV" ) );
|
|
|
22969
|
|
|
22970 #if defined( VK_USE_PLATFORM_METAL_EXT )
|
|
|
22971 //=== VK_EXT_external_memory_metal ===
|
|
|
22972 vkGetMemoryMetalHandleEXT = PFN_vkGetMemoryMetalHandleEXT( vkGetInstanceProcAddr( instance, "vkGetMemoryMetalHandleEXT" ) );
|
|
|
22973 vkGetMemoryMetalHandlePropertiesEXT =
|
|
|
22974 PFN_vkGetMemoryMetalHandlePropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetMemoryMetalHandlePropertiesEXT" ) );
|
|
|
22975 #endif /*VK_USE_PLATFORM_METAL_EXT*/
|
|
|
22976
|
|
|
22977 //=== VK_ARM_performance_counters_by_region ===
|
|
|
22978 vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM = PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM(
|
|
|
22979 vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM" ) );
|
|
|
22980
|
|
|
22981 //=== VK_EXT_fragment_density_map_offset ===
|
|
|
22982 vkCmdEndRendering2EXT = PFN_vkCmdEndRendering2EXT( vkGetInstanceProcAddr( instance, "vkCmdEndRendering2EXT" ) );
|
|
|
22983 if ( !vkCmdEndRendering2KHR )
|
|
|
22984 vkCmdEndRendering2KHR = vkCmdEndRendering2EXT;
|
|
|
22985
|
|
|
22986 //=== VK_EXT_custom_resolve ===
|
|
|
22987 vkCmdBeginCustomResolveEXT = PFN_vkCmdBeginCustomResolveEXT( vkGetInstanceProcAddr( instance, "vkCmdBeginCustomResolveEXT" ) );
|
|
|
22988
|
|
|
22989 //=== VK_KHR_maintenance10 ===
|
|
|
22990 vkCmdEndRendering2KHR = PFN_vkCmdEndRendering2KHR( vkGetInstanceProcAddr( instance, "vkCmdEndRendering2KHR" ) );
|
|
|
22991 }
|
|
|
22992
|
|
|
22993 void init( Device deviceCpp ) VULKAN_HPP_NOEXCEPT
|
|
|
22994 {
|
|
|
22995 VkDevice device = static_cast<VkDevice>( deviceCpp );
|
|
|
22996
|
|
|
22997 //=== VK_VERSION_1_0 ===
|
|
|
22998 vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr( vkGetDeviceProcAddr( device, "vkGetDeviceProcAddr" ) );
|
|
|
22999 vkDestroyDevice = PFN_vkDestroyDevice( vkGetDeviceProcAddr( device, "vkDestroyDevice" ) );
|
|
|
23000 vkGetDeviceQueue = PFN_vkGetDeviceQueue( vkGetDeviceProcAddr( device, "vkGetDeviceQueue" ) );
|
|
|
23001 vkQueueSubmit = PFN_vkQueueSubmit( vkGetDeviceProcAddr( device, "vkQueueSubmit" ) );
|
|
|
23002 vkQueueWaitIdle = PFN_vkQueueWaitIdle( vkGetDeviceProcAddr( device, "vkQueueWaitIdle" ) );
|
|
|
23003 vkDeviceWaitIdle = PFN_vkDeviceWaitIdle( vkGetDeviceProcAddr( device, "vkDeviceWaitIdle" ) );
|
|
|
23004 vkAllocateMemory = PFN_vkAllocateMemory( vkGetDeviceProcAddr( device, "vkAllocateMemory" ) );
|
|
|
23005 vkFreeMemory = PFN_vkFreeMemory( vkGetDeviceProcAddr( device, "vkFreeMemory" ) );
|
|
|
23006 vkMapMemory = PFN_vkMapMemory( vkGetDeviceProcAddr( device, "vkMapMemory" ) );
|
|
|
23007 vkUnmapMemory = PFN_vkUnmapMemory( vkGetDeviceProcAddr( device, "vkUnmapMemory" ) );
|
|
|
23008 vkFlushMappedMemoryRanges = PFN_vkFlushMappedMemoryRanges( vkGetDeviceProcAddr( device, "vkFlushMappedMemoryRanges" ) );
|
|
|
23009 vkInvalidateMappedMemoryRanges = PFN_vkInvalidateMappedMemoryRanges( vkGetDeviceProcAddr( device, "vkInvalidateMappedMemoryRanges" ) );
|
|
|
23010 vkGetDeviceMemoryCommitment = PFN_vkGetDeviceMemoryCommitment( vkGetDeviceProcAddr( device, "vkGetDeviceMemoryCommitment" ) );
|
|
|
23011 vkBindBufferMemory = PFN_vkBindBufferMemory( vkGetDeviceProcAddr( device, "vkBindBufferMemory" ) );
|
|
|
23012 vkBindImageMemory = PFN_vkBindImageMemory( vkGetDeviceProcAddr( device, "vkBindImageMemory" ) );
|
|
|
23013 vkGetBufferMemoryRequirements = PFN_vkGetBufferMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements" ) );
|
|
|
23014 vkGetImageMemoryRequirements = PFN_vkGetImageMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements" ) );
|
|
|
23015 vkGetImageSparseMemoryRequirements = PFN_vkGetImageSparseMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements" ) );
|
|
|
23016 vkQueueBindSparse = PFN_vkQueueBindSparse( vkGetDeviceProcAddr( device, "vkQueueBindSparse" ) );
|
|
|
23017 vkCreateFence = PFN_vkCreateFence( vkGetDeviceProcAddr( device, "vkCreateFence" ) );
|
|
|
23018 vkDestroyFence = PFN_vkDestroyFence( vkGetDeviceProcAddr( device, "vkDestroyFence" ) );
|
|
|
23019 vkResetFences = PFN_vkResetFences( vkGetDeviceProcAddr( device, "vkResetFences" ) );
|
|
|
23020 vkGetFenceStatus = PFN_vkGetFenceStatus( vkGetDeviceProcAddr( device, "vkGetFenceStatus" ) );
|
|
|
23021 vkWaitForFences = PFN_vkWaitForFences( vkGetDeviceProcAddr( device, "vkWaitForFences" ) );
|
|
|
23022 vkCreateSemaphore = PFN_vkCreateSemaphore( vkGetDeviceProcAddr( device, "vkCreateSemaphore" ) );
|
|
|
23023 vkDestroySemaphore = PFN_vkDestroySemaphore( vkGetDeviceProcAddr( device, "vkDestroySemaphore" ) );
|
|
|
23024 vkCreateQueryPool = PFN_vkCreateQueryPool( vkGetDeviceProcAddr( device, "vkCreateQueryPool" ) );
|
|
|
23025 vkDestroyQueryPool = PFN_vkDestroyQueryPool( vkGetDeviceProcAddr( device, "vkDestroyQueryPool" ) );
|
|
|
23026 vkGetQueryPoolResults = PFN_vkGetQueryPoolResults( vkGetDeviceProcAddr( device, "vkGetQueryPoolResults" ) );
|
|
|
23027 vkCreateBuffer = PFN_vkCreateBuffer( vkGetDeviceProcAddr( device, "vkCreateBuffer" ) );
|
|
|
23028 vkDestroyBuffer = PFN_vkDestroyBuffer( vkGetDeviceProcAddr( device, "vkDestroyBuffer" ) );
|
|
|
23029 vkCreateImage = PFN_vkCreateImage( vkGetDeviceProcAddr( device, "vkCreateImage" ) );
|
|
|
23030 vkDestroyImage = PFN_vkDestroyImage( vkGetDeviceProcAddr( device, "vkDestroyImage" ) );
|
|
|
23031 vkGetImageSubresourceLayout = PFN_vkGetImageSubresourceLayout( vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout" ) );
|
|
|
23032 vkCreateImageView = PFN_vkCreateImageView( vkGetDeviceProcAddr( device, "vkCreateImageView" ) );
|
|
|
23033 vkDestroyImageView = PFN_vkDestroyImageView( vkGetDeviceProcAddr( device, "vkDestroyImageView" ) );
|
|
|
23034 vkCreateCommandPool = PFN_vkCreateCommandPool( vkGetDeviceProcAddr( device, "vkCreateCommandPool" ) );
|
|
|
23035 vkDestroyCommandPool = PFN_vkDestroyCommandPool( vkGetDeviceProcAddr( device, "vkDestroyCommandPool" ) );
|
|
|
23036 vkResetCommandPool = PFN_vkResetCommandPool( vkGetDeviceProcAddr( device, "vkResetCommandPool" ) );
|
|
|
23037 vkAllocateCommandBuffers = PFN_vkAllocateCommandBuffers( vkGetDeviceProcAddr( device, "vkAllocateCommandBuffers" ) );
|
|
|
23038 vkFreeCommandBuffers = PFN_vkFreeCommandBuffers( vkGetDeviceProcAddr( device, "vkFreeCommandBuffers" ) );
|
|
|
23039 vkBeginCommandBuffer = PFN_vkBeginCommandBuffer( vkGetDeviceProcAddr( device, "vkBeginCommandBuffer" ) );
|
|
|
23040 vkEndCommandBuffer = PFN_vkEndCommandBuffer( vkGetDeviceProcAddr( device, "vkEndCommandBuffer" ) );
|
|
|
23041 vkResetCommandBuffer = PFN_vkResetCommandBuffer( vkGetDeviceProcAddr( device, "vkResetCommandBuffer" ) );
|
|
|
23042 vkCmdCopyBuffer = PFN_vkCmdCopyBuffer( vkGetDeviceProcAddr( device, "vkCmdCopyBuffer" ) );
|
|
|
23043 vkCmdCopyImage = PFN_vkCmdCopyImage( vkGetDeviceProcAddr( device, "vkCmdCopyImage" ) );
|
|
|
23044 vkCmdCopyBufferToImage = PFN_vkCmdCopyBufferToImage( vkGetDeviceProcAddr( device, "vkCmdCopyBufferToImage" ) );
|
|
|
23045 vkCmdCopyImageToBuffer = PFN_vkCmdCopyImageToBuffer( vkGetDeviceProcAddr( device, "vkCmdCopyImageToBuffer" ) );
|
|
|
23046 vkCmdUpdateBuffer = PFN_vkCmdUpdateBuffer( vkGetDeviceProcAddr( device, "vkCmdUpdateBuffer" ) );
|
|
|
23047 vkCmdFillBuffer = PFN_vkCmdFillBuffer( vkGetDeviceProcAddr( device, "vkCmdFillBuffer" ) );
|
|
|
23048 vkCmdPipelineBarrier = PFN_vkCmdPipelineBarrier( vkGetDeviceProcAddr( device, "vkCmdPipelineBarrier" ) );
|
|
|
23049 vkCmdBeginQuery = PFN_vkCmdBeginQuery( vkGetDeviceProcAddr( device, "vkCmdBeginQuery" ) );
|
|
|
23050 vkCmdEndQuery = PFN_vkCmdEndQuery( vkGetDeviceProcAddr( device, "vkCmdEndQuery" ) );
|
|
|
23051 vkCmdResetQueryPool = PFN_vkCmdResetQueryPool( vkGetDeviceProcAddr( device, "vkCmdResetQueryPool" ) );
|
|
|
23052 vkCmdWriteTimestamp = PFN_vkCmdWriteTimestamp( vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp" ) );
|
|
|
23053 vkCmdCopyQueryPoolResults = PFN_vkCmdCopyQueryPoolResults( vkGetDeviceProcAddr( device, "vkCmdCopyQueryPoolResults" ) );
|
|
|
23054 vkCmdExecuteCommands = PFN_vkCmdExecuteCommands( vkGetDeviceProcAddr( device, "vkCmdExecuteCommands" ) );
|
|
|
23055 vkCreateEvent = PFN_vkCreateEvent( vkGetDeviceProcAddr( device, "vkCreateEvent" ) );
|
|
|
23056 vkDestroyEvent = PFN_vkDestroyEvent( vkGetDeviceProcAddr( device, "vkDestroyEvent" ) );
|
|
|
23057 vkGetEventStatus = PFN_vkGetEventStatus( vkGetDeviceProcAddr( device, "vkGetEventStatus" ) );
|
|
|
23058 vkSetEvent = PFN_vkSetEvent( vkGetDeviceProcAddr( device, "vkSetEvent" ) );
|
|
|
23059 vkResetEvent = PFN_vkResetEvent( vkGetDeviceProcAddr( device, "vkResetEvent" ) );
|
|
|
23060 vkCreateBufferView = PFN_vkCreateBufferView( vkGetDeviceProcAddr( device, "vkCreateBufferView" ) );
|
|
|
23061 vkDestroyBufferView = PFN_vkDestroyBufferView( vkGetDeviceProcAddr( device, "vkDestroyBufferView" ) );
|
|
|
23062 vkCreateShaderModule = PFN_vkCreateShaderModule( vkGetDeviceProcAddr( device, "vkCreateShaderModule" ) );
|
|
|
23063 vkDestroyShaderModule = PFN_vkDestroyShaderModule( vkGetDeviceProcAddr( device, "vkDestroyShaderModule" ) );
|
|
|
23064 vkCreatePipelineCache = PFN_vkCreatePipelineCache( vkGetDeviceProcAddr( device, "vkCreatePipelineCache" ) );
|
|
|
23065 vkDestroyPipelineCache = PFN_vkDestroyPipelineCache( vkGetDeviceProcAddr( device, "vkDestroyPipelineCache" ) );
|
|
|
23066 vkGetPipelineCacheData = PFN_vkGetPipelineCacheData( vkGetDeviceProcAddr( device, "vkGetPipelineCacheData" ) );
|
|
|
23067 vkMergePipelineCaches = PFN_vkMergePipelineCaches( vkGetDeviceProcAddr( device, "vkMergePipelineCaches" ) );
|
|
|
23068 vkCreateComputePipelines = PFN_vkCreateComputePipelines( vkGetDeviceProcAddr( device, "vkCreateComputePipelines" ) );
|
|
|
23069 vkDestroyPipeline = PFN_vkDestroyPipeline( vkGetDeviceProcAddr( device, "vkDestroyPipeline" ) );
|
|
|
23070 vkCreatePipelineLayout = PFN_vkCreatePipelineLayout( vkGetDeviceProcAddr( device, "vkCreatePipelineLayout" ) );
|
|
|
23071 vkDestroyPipelineLayout = PFN_vkDestroyPipelineLayout( vkGetDeviceProcAddr( device, "vkDestroyPipelineLayout" ) );
|
|
|
23072 vkCreateSampler = PFN_vkCreateSampler( vkGetDeviceProcAddr( device, "vkCreateSampler" ) );
|
|
|
23073 vkDestroySampler = PFN_vkDestroySampler( vkGetDeviceProcAddr( device, "vkDestroySampler" ) );
|
|
|
23074 vkCreateDescriptorSetLayout = PFN_vkCreateDescriptorSetLayout( vkGetDeviceProcAddr( device, "vkCreateDescriptorSetLayout" ) );
|
|
|
23075 vkDestroyDescriptorSetLayout = PFN_vkDestroyDescriptorSetLayout( vkGetDeviceProcAddr( device, "vkDestroyDescriptorSetLayout" ) );
|
|
|
23076 vkCreateDescriptorPool = PFN_vkCreateDescriptorPool( vkGetDeviceProcAddr( device, "vkCreateDescriptorPool" ) );
|
|
|
23077 vkDestroyDescriptorPool = PFN_vkDestroyDescriptorPool( vkGetDeviceProcAddr( device, "vkDestroyDescriptorPool" ) );
|
|
|
23078 vkResetDescriptorPool = PFN_vkResetDescriptorPool( vkGetDeviceProcAddr( device, "vkResetDescriptorPool" ) );
|
|
|
23079 vkAllocateDescriptorSets = PFN_vkAllocateDescriptorSets( vkGetDeviceProcAddr( device, "vkAllocateDescriptorSets" ) );
|
|
|
23080 vkFreeDescriptorSets = PFN_vkFreeDescriptorSets( vkGetDeviceProcAddr( device, "vkFreeDescriptorSets" ) );
|
|
|
23081 vkUpdateDescriptorSets = PFN_vkUpdateDescriptorSets( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSets" ) );
|
|
|
23082 vkCmdBindPipeline = PFN_vkCmdBindPipeline( vkGetDeviceProcAddr( device, "vkCmdBindPipeline" ) );
|
|
|
23083 vkCmdBindDescriptorSets = PFN_vkCmdBindDescriptorSets( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorSets" ) );
|
|
|
23084 vkCmdClearColorImage = PFN_vkCmdClearColorImage( vkGetDeviceProcAddr( device, "vkCmdClearColorImage" ) );
|
|
|
23085 vkCmdDispatch = PFN_vkCmdDispatch( vkGetDeviceProcAddr( device, "vkCmdDispatch" ) );
|
|
|
23086 vkCmdDispatchIndirect = PFN_vkCmdDispatchIndirect( vkGetDeviceProcAddr( device, "vkCmdDispatchIndirect" ) );
|
|
|
23087 vkCmdSetEvent = PFN_vkCmdSetEvent( vkGetDeviceProcAddr( device, "vkCmdSetEvent" ) );
|
|
|
23088 vkCmdResetEvent = PFN_vkCmdResetEvent( vkGetDeviceProcAddr( device, "vkCmdResetEvent" ) );
|
|
|
23089 vkCmdWaitEvents = PFN_vkCmdWaitEvents( vkGetDeviceProcAddr( device, "vkCmdWaitEvents" ) );
|
|
|
23090 vkCmdPushConstants = PFN_vkCmdPushConstants( vkGetDeviceProcAddr( device, "vkCmdPushConstants" ) );
|
|
|
23091 vkCreateGraphicsPipelines = PFN_vkCreateGraphicsPipelines( vkGetDeviceProcAddr( device, "vkCreateGraphicsPipelines" ) );
|
|
|
23092 vkCreateFramebuffer = PFN_vkCreateFramebuffer( vkGetDeviceProcAddr( device, "vkCreateFramebuffer" ) );
|
|
|
23093 vkDestroyFramebuffer = PFN_vkDestroyFramebuffer( vkGetDeviceProcAddr( device, "vkDestroyFramebuffer" ) );
|
|
|
23094 vkCreateRenderPass = PFN_vkCreateRenderPass( vkGetDeviceProcAddr( device, "vkCreateRenderPass" ) );
|
|
|
23095 vkDestroyRenderPass = PFN_vkDestroyRenderPass( vkGetDeviceProcAddr( device, "vkDestroyRenderPass" ) );
|
|
|
23096 vkGetRenderAreaGranularity = PFN_vkGetRenderAreaGranularity( vkGetDeviceProcAddr( device, "vkGetRenderAreaGranularity" ) );
|
|
|
23097 vkCmdSetViewport = PFN_vkCmdSetViewport( vkGetDeviceProcAddr( device, "vkCmdSetViewport" ) );
|
|
|
23098 vkCmdSetScissor = PFN_vkCmdSetScissor( vkGetDeviceProcAddr( device, "vkCmdSetScissor" ) );
|
|
|
23099 vkCmdSetLineWidth = PFN_vkCmdSetLineWidth( vkGetDeviceProcAddr( device, "vkCmdSetLineWidth" ) );
|
|
|
23100 vkCmdSetDepthBias = PFN_vkCmdSetDepthBias( vkGetDeviceProcAddr( device, "vkCmdSetDepthBias" ) );
|
|
|
23101 vkCmdSetBlendConstants = PFN_vkCmdSetBlendConstants( vkGetDeviceProcAddr( device, "vkCmdSetBlendConstants" ) );
|
|
|
23102 vkCmdSetDepthBounds = PFN_vkCmdSetDepthBounds( vkGetDeviceProcAddr( device, "vkCmdSetDepthBounds" ) );
|
|
|
23103 vkCmdSetStencilCompareMask = PFN_vkCmdSetStencilCompareMask( vkGetDeviceProcAddr( device, "vkCmdSetStencilCompareMask" ) );
|
|
|
23104 vkCmdSetStencilWriteMask = PFN_vkCmdSetStencilWriteMask( vkGetDeviceProcAddr( device, "vkCmdSetStencilWriteMask" ) );
|
|
|
23105 vkCmdSetStencilReference = PFN_vkCmdSetStencilReference( vkGetDeviceProcAddr( device, "vkCmdSetStencilReference" ) );
|
|
|
23106 vkCmdBindIndexBuffer = PFN_vkCmdBindIndexBuffer( vkGetDeviceProcAddr( device, "vkCmdBindIndexBuffer" ) );
|
|
|
23107 vkCmdBindVertexBuffers = PFN_vkCmdBindVertexBuffers( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers" ) );
|
|
|
23108 vkCmdDraw = PFN_vkCmdDraw( vkGetDeviceProcAddr( device, "vkCmdDraw" ) );
|
|
|
23109 vkCmdDrawIndexed = PFN_vkCmdDrawIndexed( vkGetDeviceProcAddr( device, "vkCmdDrawIndexed" ) );
|
|
|
23110 vkCmdDrawIndirect = PFN_vkCmdDrawIndirect( vkGetDeviceProcAddr( device, "vkCmdDrawIndirect" ) );
|
|
|
23111 vkCmdDrawIndexedIndirect = PFN_vkCmdDrawIndexedIndirect( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirect" ) );
|
|
|
23112 vkCmdBlitImage = PFN_vkCmdBlitImage( vkGetDeviceProcAddr( device, "vkCmdBlitImage" ) );
|
|
|
23113 vkCmdClearDepthStencilImage = PFN_vkCmdClearDepthStencilImage( vkGetDeviceProcAddr( device, "vkCmdClearDepthStencilImage" ) );
|
|
|
23114 vkCmdClearAttachments = PFN_vkCmdClearAttachments( vkGetDeviceProcAddr( device, "vkCmdClearAttachments" ) );
|
|
|
23115 vkCmdResolveImage = PFN_vkCmdResolveImage( vkGetDeviceProcAddr( device, "vkCmdResolveImage" ) );
|
|
|
23116 vkCmdBeginRenderPass = PFN_vkCmdBeginRenderPass( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass" ) );
|
|
|
23117 vkCmdNextSubpass = PFN_vkCmdNextSubpass( vkGetDeviceProcAddr( device, "vkCmdNextSubpass" ) );
|
|
|
23118 vkCmdEndRenderPass = PFN_vkCmdEndRenderPass( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass" ) );
|
|
|
23119
|
|
|
23120 //=== VK_VERSION_1_1 ===
|
|
|
23121 vkBindBufferMemory2 = PFN_vkBindBufferMemory2( vkGetDeviceProcAddr( device, "vkBindBufferMemory2" ) );
|
|
|
23122 vkBindImageMemory2 = PFN_vkBindImageMemory2( vkGetDeviceProcAddr( device, "vkBindImageMemory2" ) );
|
|
|
23123 vkGetDeviceGroupPeerMemoryFeatures = PFN_vkGetDeviceGroupPeerMemoryFeatures( vkGetDeviceProcAddr( device, "vkGetDeviceGroupPeerMemoryFeatures" ) );
|
|
|
23124 vkCmdSetDeviceMask = PFN_vkCmdSetDeviceMask( vkGetDeviceProcAddr( device, "vkCmdSetDeviceMask" ) );
|
|
|
23125 vkGetImageMemoryRequirements2 = PFN_vkGetImageMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements2" ) );
|
|
|
23126 vkGetBufferMemoryRequirements2 = PFN_vkGetBufferMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements2" ) );
|
|
|
23127 vkGetImageSparseMemoryRequirements2 = PFN_vkGetImageSparseMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements2" ) );
|
|
|
23128 vkTrimCommandPool = PFN_vkTrimCommandPool( vkGetDeviceProcAddr( device, "vkTrimCommandPool" ) );
|
|
|
23129 vkGetDeviceQueue2 = PFN_vkGetDeviceQueue2( vkGetDeviceProcAddr( device, "vkGetDeviceQueue2" ) );
|
|
|
23130 vkCmdDispatchBase = PFN_vkCmdDispatchBase( vkGetDeviceProcAddr( device, "vkCmdDispatchBase" ) );
|
|
|
23131 vkCreateDescriptorUpdateTemplate = PFN_vkCreateDescriptorUpdateTemplate( vkGetDeviceProcAddr( device, "vkCreateDescriptorUpdateTemplate" ) );
|
|
|
23132 vkDestroyDescriptorUpdateTemplate = PFN_vkDestroyDescriptorUpdateTemplate( vkGetDeviceProcAddr( device, "vkDestroyDescriptorUpdateTemplate" ) );
|
|
|
23133 vkUpdateDescriptorSetWithTemplate = PFN_vkUpdateDescriptorSetWithTemplate( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSetWithTemplate" ) );
|
|
|
23134 vkGetDescriptorSetLayoutSupport = PFN_vkGetDescriptorSetLayoutSupport( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSupport" ) );
|
|
|
23135 vkCreateSamplerYcbcrConversion = PFN_vkCreateSamplerYcbcrConversion( vkGetDeviceProcAddr( device, "vkCreateSamplerYcbcrConversion" ) );
|
|
|
23136 vkDestroySamplerYcbcrConversion = PFN_vkDestroySamplerYcbcrConversion( vkGetDeviceProcAddr( device, "vkDestroySamplerYcbcrConversion" ) );
|
|
|
23137
|
|
|
23138 //=== VK_VERSION_1_2 ===
|
|
|
23139 vkResetQueryPool = PFN_vkResetQueryPool( vkGetDeviceProcAddr( device, "vkResetQueryPool" ) );
|
|
|
23140 vkGetSemaphoreCounterValue = PFN_vkGetSemaphoreCounterValue( vkGetDeviceProcAddr( device, "vkGetSemaphoreCounterValue" ) );
|
|
|
23141 vkWaitSemaphores = PFN_vkWaitSemaphores( vkGetDeviceProcAddr( device, "vkWaitSemaphores" ) );
|
|
|
23142 vkSignalSemaphore = PFN_vkSignalSemaphore( vkGetDeviceProcAddr( device, "vkSignalSemaphore" ) );
|
|
|
23143 vkGetBufferDeviceAddress = PFN_vkGetBufferDeviceAddress( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddress" ) );
|
|
|
23144 vkGetBufferOpaqueCaptureAddress = PFN_vkGetBufferOpaqueCaptureAddress( vkGetDeviceProcAddr( device, "vkGetBufferOpaqueCaptureAddress" ) );
|
|
|
23145 vkGetDeviceMemoryOpaqueCaptureAddress =
|
|
|
23146 PFN_vkGetDeviceMemoryOpaqueCaptureAddress( vkGetDeviceProcAddr( device, "vkGetDeviceMemoryOpaqueCaptureAddress" ) );
|
|
|
23147 vkCmdDrawIndirectCount = PFN_vkCmdDrawIndirectCount( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCount" ) );
|
|
|
23148 vkCmdDrawIndexedIndirectCount = PFN_vkCmdDrawIndexedIndirectCount( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCount" ) );
|
|
|
23149 vkCreateRenderPass2 = PFN_vkCreateRenderPass2( vkGetDeviceProcAddr( device, "vkCreateRenderPass2" ) );
|
|
|
23150 vkCmdBeginRenderPass2 = PFN_vkCmdBeginRenderPass2( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass2" ) );
|
|
|
23151 vkCmdNextSubpass2 = PFN_vkCmdNextSubpass2( vkGetDeviceProcAddr( device, "vkCmdNextSubpass2" ) );
|
|
|
23152 vkCmdEndRenderPass2 = PFN_vkCmdEndRenderPass2( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass2" ) );
|
|
|
23153
|
|
|
23154 //=== VK_VERSION_1_3 ===
|
|
|
23155 vkCreatePrivateDataSlot = PFN_vkCreatePrivateDataSlot( vkGetDeviceProcAddr( device, "vkCreatePrivateDataSlot" ) );
|
|
|
23156 vkDestroyPrivateDataSlot = PFN_vkDestroyPrivateDataSlot( vkGetDeviceProcAddr( device, "vkDestroyPrivateDataSlot" ) );
|
|
|
23157 vkSetPrivateData = PFN_vkSetPrivateData( vkGetDeviceProcAddr( device, "vkSetPrivateData" ) );
|
|
|
23158 vkGetPrivateData = PFN_vkGetPrivateData( vkGetDeviceProcAddr( device, "vkGetPrivateData" ) );
|
|
|
23159 vkCmdPipelineBarrier2 = PFN_vkCmdPipelineBarrier2( vkGetDeviceProcAddr( device, "vkCmdPipelineBarrier2" ) );
|
|
|
23160 vkCmdWriteTimestamp2 = PFN_vkCmdWriteTimestamp2( vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp2" ) );
|
|
|
23161 vkQueueSubmit2 = PFN_vkQueueSubmit2( vkGetDeviceProcAddr( device, "vkQueueSubmit2" ) );
|
|
|
23162 vkCmdCopyBuffer2 = PFN_vkCmdCopyBuffer2( vkGetDeviceProcAddr( device, "vkCmdCopyBuffer2" ) );
|
|
|
23163 vkCmdCopyImage2 = PFN_vkCmdCopyImage2( vkGetDeviceProcAddr( device, "vkCmdCopyImage2" ) );
|
|
|
23164 vkCmdCopyBufferToImage2 = PFN_vkCmdCopyBufferToImage2( vkGetDeviceProcAddr( device, "vkCmdCopyBufferToImage2" ) );
|
|
|
23165 vkCmdCopyImageToBuffer2 = PFN_vkCmdCopyImageToBuffer2( vkGetDeviceProcAddr( device, "vkCmdCopyImageToBuffer2" ) );
|
|
|
23166 vkGetDeviceBufferMemoryRequirements = PFN_vkGetDeviceBufferMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetDeviceBufferMemoryRequirements" ) );
|
|
|
23167 vkGetDeviceImageMemoryRequirements = PFN_vkGetDeviceImageMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetDeviceImageMemoryRequirements" ) );
|
|
|
23168 vkGetDeviceImageSparseMemoryRequirements =
|
|
|
23169 PFN_vkGetDeviceImageSparseMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetDeviceImageSparseMemoryRequirements" ) );
|
|
|
23170 vkCmdSetEvent2 = PFN_vkCmdSetEvent2( vkGetDeviceProcAddr( device, "vkCmdSetEvent2" ) );
|
|
|
23171 vkCmdResetEvent2 = PFN_vkCmdResetEvent2( vkGetDeviceProcAddr( device, "vkCmdResetEvent2" ) );
|
|
|
23172 vkCmdWaitEvents2 = PFN_vkCmdWaitEvents2( vkGetDeviceProcAddr( device, "vkCmdWaitEvents2" ) );
|
|
|
23173 vkCmdBlitImage2 = PFN_vkCmdBlitImage2( vkGetDeviceProcAddr( device, "vkCmdBlitImage2" ) );
|
|
|
23174 vkCmdResolveImage2 = PFN_vkCmdResolveImage2( vkGetDeviceProcAddr( device, "vkCmdResolveImage2" ) );
|
|
|
23175 vkCmdBeginRendering = PFN_vkCmdBeginRendering( vkGetDeviceProcAddr( device, "vkCmdBeginRendering" ) );
|
|
|
23176 vkCmdEndRendering = PFN_vkCmdEndRendering( vkGetDeviceProcAddr( device, "vkCmdEndRendering" ) );
|
|
|
23177 vkCmdSetCullMode = PFN_vkCmdSetCullMode( vkGetDeviceProcAddr( device, "vkCmdSetCullMode" ) );
|
|
|
23178 vkCmdSetFrontFace = PFN_vkCmdSetFrontFace( vkGetDeviceProcAddr( device, "vkCmdSetFrontFace" ) );
|
|
|
23179 vkCmdSetPrimitiveTopology = PFN_vkCmdSetPrimitiveTopology( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveTopology" ) );
|
|
|
23180 vkCmdSetViewportWithCount = PFN_vkCmdSetViewportWithCount( vkGetDeviceProcAddr( device, "vkCmdSetViewportWithCount" ) );
|
|
|
23181 vkCmdSetScissorWithCount = PFN_vkCmdSetScissorWithCount( vkGetDeviceProcAddr( device, "vkCmdSetScissorWithCount" ) );
|
|
|
23182 vkCmdBindVertexBuffers2 = PFN_vkCmdBindVertexBuffers2( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers2" ) );
|
|
|
23183 vkCmdSetDepthTestEnable = PFN_vkCmdSetDepthTestEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthTestEnable" ) );
|
|
|
23184 vkCmdSetDepthWriteEnable = PFN_vkCmdSetDepthWriteEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthWriteEnable" ) );
|
|
|
23185 vkCmdSetDepthCompareOp = PFN_vkCmdSetDepthCompareOp( vkGetDeviceProcAddr( device, "vkCmdSetDepthCompareOp" ) );
|
|
|
23186 vkCmdSetDepthBoundsTestEnable = PFN_vkCmdSetDepthBoundsTestEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthBoundsTestEnable" ) );
|
|
|
23187 vkCmdSetStencilTestEnable = PFN_vkCmdSetStencilTestEnable( vkGetDeviceProcAddr( device, "vkCmdSetStencilTestEnable" ) );
|
|
|
23188 vkCmdSetStencilOp = PFN_vkCmdSetStencilOp( vkGetDeviceProcAddr( device, "vkCmdSetStencilOp" ) );
|
|
|
23189 vkCmdSetRasterizerDiscardEnable = PFN_vkCmdSetRasterizerDiscardEnable( vkGetDeviceProcAddr( device, "vkCmdSetRasterizerDiscardEnable" ) );
|
|
|
23190 vkCmdSetDepthBiasEnable = PFN_vkCmdSetDepthBiasEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthBiasEnable" ) );
|
|
|
23191 vkCmdSetPrimitiveRestartEnable = PFN_vkCmdSetPrimitiveRestartEnable( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveRestartEnable" ) );
|
|
|
23192
|
|
|
23193 //=== VK_VERSION_1_4 ===
|
|
|
23194 vkMapMemory2 = PFN_vkMapMemory2( vkGetDeviceProcAddr( device, "vkMapMemory2" ) );
|
|
|
23195 vkUnmapMemory2 = PFN_vkUnmapMemory2( vkGetDeviceProcAddr( device, "vkUnmapMemory2" ) );
|
|
|
23196 vkGetDeviceImageSubresourceLayout = PFN_vkGetDeviceImageSubresourceLayout( vkGetDeviceProcAddr( device, "vkGetDeviceImageSubresourceLayout" ) );
|
|
|
23197 vkGetImageSubresourceLayout2 = PFN_vkGetImageSubresourceLayout2( vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout2" ) );
|
|
|
23198 vkCopyMemoryToImage = PFN_vkCopyMemoryToImage( vkGetDeviceProcAddr( device, "vkCopyMemoryToImage" ) );
|
|
|
23199 vkCopyImageToMemory = PFN_vkCopyImageToMemory( vkGetDeviceProcAddr( device, "vkCopyImageToMemory" ) );
|
|
|
23200 vkCopyImageToImage = PFN_vkCopyImageToImage( vkGetDeviceProcAddr( device, "vkCopyImageToImage" ) );
|
|
|
23201 vkTransitionImageLayout = PFN_vkTransitionImageLayout( vkGetDeviceProcAddr( device, "vkTransitionImageLayout" ) );
|
|
|
23202 vkCmdPushDescriptorSet = PFN_vkCmdPushDescriptorSet( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSet" ) );
|
|
|
23203 vkCmdPushDescriptorSetWithTemplate = PFN_vkCmdPushDescriptorSetWithTemplate( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetWithTemplate" ) );
|
|
|
23204 vkCmdBindDescriptorSets2 = PFN_vkCmdBindDescriptorSets2( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorSets2" ) );
|
|
|
23205 vkCmdPushConstants2 = PFN_vkCmdPushConstants2( vkGetDeviceProcAddr( device, "vkCmdPushConstants2" ) );
|
|
|
23206 vkCmdPushDescriptorSet2 = PFN_vkCmdPushDescriptorSet2( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSet2" ) );
|
|
|
23207 vkCmdPushDescriptorSetWithTemplate2 = PFN_vkCmdPushDescriptorSetWithTemplate2( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetWithTemplate2" ) );
|
|
|
23208 vkCmdSetLineStipple = PFN_vkCmdSetLineStipple( vkGetDeviceProcAddr( device, "vkCmdSetLineStipple" ) );
|
|
|
23209 vkCmdBindIndexBuffer2 = PFN_vkCmdBindIndexBuffer2( vkGetDeviceProcAddr( device, "vkCmdBindIndexBuffer2" ) );
|
|
|
23210 vkGetRenderingAreaGranularity = PFN_vkGetRenderingAreaGranularity( vkGetDeviceProcAddr( device, "vkGetRenderingAreaGranularity" ) );
|
|
|
23211 vkCmdSetRenderingAttachmentLocations =
|
|
|
23212 PFN_vkCmdSetRenderingAttachmentLocations( vkGetDeviceProcAddr( device, "vkCmdSetRenderingAttachmentLocations" ) );
|
|
|
23213 vkCmdSetRenderingInputAttachmentIndices =
|
|
|
23214 PFN_vkCmdSetRenderingInputAttachmentIndices( vkGetDeviceProcAddr( device, "vkCmdSetRenderingInputAttachmentIndices" ) );
|
|
|
23215
|
|
|
23216 //=== VK_KHR_swapchain ===
|
|
|
23217 vkCreateSwapchainKHR = PFN_vkCreateSwapchainKHR( vkGetDeviceProcAddr( device, "vkCreateSwapchainKHR" ) );
|
|
|
23218 vkDestroySwapchainKHR = PFN_vkDestroySwapchainKHR( vkGetDeviceProcAddr( device, "vkDestroySwapchainKHR" ) );
|
|
|
23219 vkGetSwapchainImagesKHR = PFN_vkGetSwapchainImagesKHR( vkGetDeviceProcAddr( device, "vkGetSwapchainImagesKHR" ) );
|
|
|
23220 vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR( vkGetDeviceProcAddr( device, "vkAcquireNextImageKHR" ) );
|
|
|
23221 vkQueuePresentKHR = PFN_vkQueuePresentKHR( vkGetDeviceProcAddr( device, "vkQueuePresentKHR" ) );
|
|
|
23222 vkGetDeviceGroupPresentCapabilitiesKHR =
|
|
|
23223 PFN_vkGetDeviceGroupPresentCapabilitiesKHR( vkGetDeviceProcAddr( device, "vkGetDeviceGroupPresentCapabilitiesKHR" ) );
|
|
|
23224 vkGetDeviceGroupSurfacePresentModesKHR =
|
|
|
23225 PFN_vkGetDeviceGroupSurfacePresentModesKHR( vkGetDeviceProcAddr( device, "vkGetDeviceGroupSurfacePresentModesKHR" ) );
|
|
|
23226 vkAcquireNextImage2KHR = PFN_vkAcquireNextImage2KHR( vkGetDeviceProcAddr( device, "vkAcquireNextImage2KHR" ) );
|
|
|
23227
|
|
|
23228 //=== VK_KHR_display_swapchain ===
|
|
|
23229 vkCreateSharedSwapchainsKHR = PFN_vkCreateSharedSwapchainsKHR( vkGetDeviceProcAddr( device, "vkCreateSharedSwapchainsKHR" ) );
|
|
|
23230
|
|
|
23231 //=== VK_EXT_debug_marker ===
|
|
|
23232 vkDebugMarkerSetObjectTagEXT = PFN_vkDebugMarkerSetObjectTagEXT( vkGetDeviceProcAddr( device, "vkDebugMarkerSetObjectTagEXT" ) );
|
|
|
23233 vkDebugMarkerSetObjectNameEXT = PFN_vkDebugMarkerSetObjectNameEXT( vkGetDeviceProcAddr( device, "vkDebugMarkerSetObjectNameEXT" ) );
|
|
|
23234 vkCmdDebugMarkerBeginEXT = PFN_vkCmdDebugMarkerBeginEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerBeginEXT" ) );
|
|
|
23235 vkCmdDebugMarkerEndEXT = PFN_vkCmdDebugMarkerEndEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerEndEXT" ) );
|
|
|
23236 vkCmdDebugMarkerInsertEXT = PFN_vkCmdDebugMarkerInsertEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerInsertEXT" ) );
|
|
|
23237
|
|
|
23238 //=== VK_KHR_video_queue ===
|
|
|
23239 vkCreateVideoSessionKHR = PFN_vkCreateVideoSessionKHR( vkGetDeviceProcAddr( device, "vkCreateVideoSessionKHR" ) );
|
|
|
23240 vkDestroyVideoSessionKHR = PFN_vkDestroyVideoSessionKHR( vkGetDeviceProcAddr( device, "vkDestroyVideoSessionKHR" ) );
|
|
|
23241 vkGetVideoSessionMemoryRequirementsKHR =
|
|
|
23242 PFN_vkGetVideoSessionMemoryRequirementsKHR( vkGetDeviceProcAddr( device, "vkGetVideoSessionMemoryRequirementsKHR" ) );
|
|
|
23243 vkBindVideoSessionMemoryKHR = PFN_vkBindVideoSessionMemoryKHR( vkGetDeviceProcAddr( device, "vkBindVideoSessionMemoryKHR" ) );
|
|
|
23244 vkCreateVideoSessionParametersKHR = PFN_vkCreateVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkCreateVideoSessionParametersKHR" ) );
|
|
|
23245 vkUpdateVideoSessionParametersKHR = PFN_vkUpdateVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkUpdateVideoSessionParametersKHR" ) );
|
|
|
23246 vkDestroyVideoSessionParametersKHR = PFN_vkDestroyVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkDestroyVideoSessionParametersKHR" ) );
|
|
|
23247 vkCmdBeginVideoCodingKHR = PFN_vkCmdBeginVideoCodingKHR( vkGetDeviceProcAddr( device, "vkCmdBeginVideoCodingKHR" ) );
|
|
|
23248 vkCmdEndVideoCodingKHR = PFN_vkCmdEndVideoCodingKHR( vkGetDeviceProcAddr( device, "vkCmdEndVideoCodingKHR" ) );
|
|
|
23249 vkCmdControlVideoCodingKHR = PFN_vkCmdControlVideoCodingKHR( vkGetDeviceProcAddr( device, "vkCmdControlVideoCodingKHR" ) );
|
|
|
23250
|
|
|
23251 //=== VK_KHR_video_decode_queue ===
|
|
|
23252 vkCmdDecodeVideoKHR = PFN_vkCmdDecodeVideoKHR( vkGetDeviceProcAddr( device, "vkCmdDecodeVideoKHR" ) );
|
|
|
23253
|
|
|
23254 //=== VK_EXT_transform_feedback ===
|
|
|
23255 vkCmdBindTransformFeedbackBuffersEXT =
|
|
|
23256 PFN_vkCmdBindTransformFeedbackBuffersEXT( vkGetDeviceProcAddr( device, "vkCmdBindTransformFeedbackBuffersEXT" ) );
|
|
|
23257 vkCmdBeginTransformFeedbackEXT = PFN_vkCmdBeginTransformFeedbackEXT( vkGetDeviceProcAddr( device, "vkCmdBeginTransformFeedbackEXT" ) );
|
|
|
23258 vkCmdEndTransformFeedbackEXT = PFN_vkCmdEndTransformFeedbackEXT( vkGetDeviceProcAddr( device, "vkCmdEndTransformFeedbackEXT" ) );
|
|
|
23259 vkCmdBeginQueryIndexedEXT = PFN_vkCmdBeginQueryIndexedEXT( vkGetDeviceProcAddr( device, "vkCmdBeginQueryIndexedEXT" ) );
|
|
|
23260 vkCmdEndQueryIndexedEXT = PFN_vkCmdEndQueryIndexedEXT( vkGetDeviceProcAddr( device, "vkCmdEndQueryIndexedEXT" ) );
|
|
|
23261 vkCmdDrawIndirectByteCountEXT = PFN_vkCmdDrawIndirectByteCountEXT( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectByteCountEXT" ) );
|
|
|
23262
|
|
|
23263 //=== VK_NVX_binary_import ===
|
|
|
23264 vkCreateCuModuleNVX = PFN_vkCreateCuModuleNVX( vkGetDeviceProcAddr( device, "vkCreateCuModuleNVX" ) );
|
|
|
23265 vkCreateCuFunctionNVX = PFN_vkCreateCuFunctionNVX( vkGetDeviceProcAddr( device, "vkCreateCuFunctionNVX" ) );
|
|
|
23266 vkDestroyCuModuleNVX = PFN_vkDestroyCuModuleNVX( vkGetDeviceProcAddr( device, "vkDestroyCuModuleNVX" ) );
|
|
|
23267 vkDestroyCuFunctionNVX = PFN_vkDestroyCuFunctionNVX( vkGetDeviceProcAddr( device, "vkDestroyCuFunctionNVX" ) );
|
|
|
23268 vkCmdCuLaunchKernelNVX = PFN_vkCmdCuLaunchKernelNVX( vkGetDeviceProcAddr( device, "vkCmdCuLaunchKernelNVX" ) );
|
|
|
23269
|
|
|
23270 //=== VK_NVX_image_view_handle ===
|
|
|
23271 vkGetImageViewHandleNVX = PFN_vkGetImageViewHandleNVX( vkGetDeviceProcAddr( device, "vkGetImageViewHandleNVX" ) );
|
|
|
23272 vkGetImageViewHandle64NVX = PFN_vkGetImageViewHandle64NVX( vkGetDeviceProcAddr( device, "vkGetImageViewHandle64NVX" ) );
|
|
|
23273 vkGetImageViewAddressNVX = PFN_vkGetImageViewAddressNVX( vkGetDeviceProcAddr( device, "vkGetImageViewAddressNVX" ) );
|
|
|
23274
|
|
|
23275 //=== VK_AMD_draw_indirect_count ===
|
|
|
23276 vkCmdDrawIndirectCountAMD = PFN_vkCmdDrawIndirectCountAMD( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCountAMD" ) );
|
|
|
23277 if ( !vkCmdDrawIndirectCount )
|
|
|
23278 vkCmdDrawIndirectCount = vkCmdDrawIndirectCountAMD;
|
|
|
23279 vkCmdDrawIndexedIndirectCountAMD = PFN_vkCmdDrawIndexedIndirectCountAMD( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCountAMD" ) );
|
|
|
23280 if ( !vkCmdDrawIndexedIndirectCount )
|
|
|
23281 vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountAMD;
|
|
|
23282
|
|
|
23283 //=== VK_AMD_shader_info ===
|
|
|
23284 vkGetShaderInfoAMD = PFN_vkGetShaderInfoAMD( vkGetDeviceProcAddr( device, "vkGetShaderInfoAMD" ) );
|
|
|
23285
|
|
|
23286 //=== VK_KHR_dynamic_rendering ===
|
|
|
23287 vkCmdBeginRenderingKHR = PFN_vkCmdBeginRenderingKHR( vkGetDeviceProcAddr( device, "vkCmdBeginRenderingKHR" ) );
|
|
|
23288 if ( !vkCmdBeginRendering )
|
|
|
23289 vkCmdBeginRendering = vkCmdBeginRenderingKHR;
|
|
|
23290 vkCmdEndRenderingKHR = PFN_vkCmdEndRenderingKHR( vkGetDeviceProcAddr( device, "vkCmdEndRenderingKHR" ) );
|
|
|
23291 if ( !vkCmdEndRendering )
|
|
|
23292 vkCmdEndRendering = vkCmdEndRenderingKHR;
|
|
|
23293
|
|
|
23294 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
23295 //=== VK_NV_external_memory_win32 ===
|
|
|
23296 vkGetMemoryWin32HandleNV = PFN_vkGetMemoryWin32HandleNV( vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleNV" ) );
|
|
|
23297 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
23298
|
|
|
23299 //=== VK_KHR_device_group ===
|
|
|
23300 vkGetDeviceGroupPeerMemoryFeaturesKHR =
|
|
|
23301 PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR( vkGetDeviceProcAddr( device, "vkGetDeviceGroupPeerMemoryFeaturesKHR" ) );
|
|
|
23302 if ( !vkGetDeviceGroupPeerMemoryFeatures )
|
|
|
23303 vkGetDeviceGroupPeerMemoryFeatures = vkGetDeviceGroupPeerMemoryFeaturesKHR;
|
|
|
23304 vkCmdSetDeviceMaskKHR = PFN_vkCmdSetDeviceMaskKHR( vkGetDeviceProcAddr( device, "vkCmdSetDeviceMaskKHR" ) );
|
|
|
23305 if ( !vkCmdSetDeviceMask )
|
|
|
23306 vkCmdSetDeviceMask = vkCmdSetDeviceMaskKHR;
|
|
|
23307 vkCmdDispatchBaseKHR = PFN_vkCmdDispatchBaseKHR( vkGetDeviceProcAddr( device, "vkCmdDispatchBaseKHR" ) );
|
|
|
23308 if ( !vkCmdDispatchBase )
|
|
|
23309 vkCmdDispatchBase = vkCmdDispatchBaseKHR;
|
|
|
23310
|
|
|
23311 //=== VK_KHR_maintenance1 ===
|
|
|
23312 vkTrimCommandPoolKHR = PFN_vkTrimCommandPoolKHR( vkGetDeviceProcAddr( device, "vkTrimCommandPoolKHR" ) );
|
|
|
23313 if ( !vkTrimCommandPool )
|
|
|
23314 vkTrimCommandPool = vkTrimCommandPoolKHR;
|
|
|
23315
|
|
|
23316 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
23317 //=== VK_KHR_external_memory_win32 ===
|
|
|
23318 vkGetMemoryWin32HandleKHR = PFN_vkGetMemoryWin32HandleKHR( vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleKHR" ) );
|
|
|
23319 vkGetMemoryWin32HandlePropertiesKHR = PFN_vkGetMemoryWin32HandlePropertiesKHR( vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandlePropertiesKHR" ) );
|
|
|
23320 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
23321
|
|
|
23322 //=== VK_KHR_external_memory_fd ===
|
|
|
23323 vkGetMemoryFdKHR = PFN_vkGetMemoryFdKHR( vkGetDeviceProcAddr( device, "vkGetMemoryFdKHR" ) );
|
|
|
23324 vkGetMemoryFdPropertiesKHR = PFN_vkGetMemoryFdPropertiesKHR( vkGetDeviceProcAddr( device, "vkGetMemoryFdPropertiesKHR" ) );
|
|
|
23325
|
|
|
23326 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
23327 //=== VK_KHR_external_semaphore_win32 ===
|
|
|
23328 vkImportSemaphoreWin32HandleKHR = PFN_vkImportSemaphoreWin32HandleKHR( vkGetDeviceProcAddr( device, "vkImportSemaphoreWin32HandleKHR" ) );
|
|
|
23329 vkGetSemaphoreWin32HandleKHR = PFN_vkGetSemaphoreWin32HandleKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreWin32HandleKHR" ) );
|
|
|
23330 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
23331
|
|
|
23332 //=== VK_KHR_external_semaphore_fd ===
|
|
|
23333 vkImportSemaphoreFdKHR = PFN_vkImportSemaphoreFdKHR( vkGetDeviceProcAddr( device, "vkImportSemaphoreFdKHR" ) );
|
|
|
23334 vkGetSemaphoreFdKHR = PFN_vkGetSemaphoreFdKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreFdKHR" ) );
|
|
|
23335
|
|
|
23336 //=== VK_KHR_push_descriptor ===
|
|
|
23337 vkCmdPushDescriptorSetKHR = PFN_vkCmdPushDescriptorSetKHR( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetKHR" ) );
|
|
|
23338 if ( !vkCmdPushDescriptorSet )
|
|
|
23339 vkCmdPushDescriptorSet = vkCmdPushDescriptorSetKHR;
|
|
|
23340 vkCmdPushDescriptorSetWithTemplateKHR =
|
|
|
23341 PFN_vkCmdPushDescriptorSetWithTemplateKHR( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetWithTemplateKHR" ) );
|
|
|
23342 if ( !vkCmdPushDescriptorSetWithTemplate )
|
|
|
23343 vkCmdPushDescriptorSetWithTemplate = vkCmdPushDescriptorSetWithTemplateKHR;
|
|
|
23344
|
|
|
23345 //=== VK_EXT_conditional_rendering ===
|
|
|
23346 vkCmdBeginConditionalRenderingEXT = PFN_vkCmdBeginConditionalRenderingEXT( vkGetDeviceProcAddr( device, "vkCmdBeginConditionalRenderingEXT" ) );
|
|
|
23347 vkCmdEndConditionalRenderingEXT = PFN_vkCmdEndConditionalRenderingEXT( vkGetDeviceProcAddr( device, "vkCmdEndConditionalRenderingEXT" ) );
|
|
|
23348
|
|
|
23349 //=== VK_KHR_descriptor_update_template ===
|
|
|
23350 vkCreateDescriptorUpdateTemplateKHR = PFN_vkCreateDescriptorUpdateTemplateKHR( vkGetDeviceProcAddr( device, "vkCreateDescriptorUpdateTemplateKHR" ) );
|
|
|
23351 if ( !vkCreateDescriptorUpdateTemplate )
|
|
|
23352 vkCreateDescriptorUpdateTemplate = vkCreateDescriptorUpdateTemplateKHR;
|
|
|
23353 vkDestroyDescriptorUpdateTemplateKHR =
|
|
|
23354 PFN_vkDestroyDescriptorUpdateTemplateKHR( vkGetDeviceProcAddr( device, "vkDestroyDescriptorUpdateTemplateKHR" ) );
|
|
|
23355 if ( !vkDestroyDescriptorUpdateTemplate )
|
|
|
23356 vkDestroyDescriptorUpdateTemplate = vkDestroyDescriptorUpdateTemplateKHR;
|
|
|
23357 vkUpdateDescriptorSetWithTemplateKHR =
|
|
|
23358 PFN_vkUpdateDescriptorSetWithTemplateKHR( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSetWithTemplateKHR" ) );
|
|
|
23359 if ( !vkUpdateDescriptorSetWithTemplate )
|
|
|
23360 vkUpdateDescriptorSetWithTemplate = vkUpdateDescriptorSetWithTemplateKHR;
|
|
|
23361
|
|
|
23362 //=== VK_NV_clip_space_w_scaling ===
|
|
|
23363 vkCmdSetViewportWScalingNV = PFN_vkCmdSetViewportWScalingNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportWScalingNV" ) );
|
|
|
23364
|
|
|
23365 //=== VK_EXT_display_control ===
|
|
|
23366 vkDisplayPowerControlEXT = PFN_vkDisplayPowerControlEXT( vkGetDeviceProcAddr( device, "vkDisplayPowerControlEXT" ) );
|
|
|
23367 vkRegisterDeviceEventEXT = PFN_vkRegisterDeviceEventEXT( vkGetDeviceProcAddr( device, "vkRegisterDeviceEventEXT" ) );
|
|
|
23368 vkRegisterDisplayEventEXT = PFN_vkRegisterDisplayEventEXT( vkGetDeviceProcAddr( device, "vkRegisterDisplayEventEXT" ) );
|
|
|
23369 vkGetSwapchainCounterEXT = PFN_vkGetSwapchainCounterEXT( vkGetDeviceProcAddr( device, "vkGetSwapchainCounterEXT" ) );
|
|
|
23370
|
|
|
23371 //=== VK_GOOGLE_display_timing ===
|
|
|
23372 vkGetRefreshCycleDurationGOOGLE = PFN_vkGetRefreshCycleDurationGOOGLE( vkGetDeviceProcAddr( device, "vkGetRefreshCycleDurationGOOGLE" ) );
|
|
|
23373 vkGetPastPresentationTimingGOOGLE = PFN_vkGetPastPresentationTimingGOOGLE( vkGetDeviceProcAddr( device, "vkGetPastPresentationTimingGOOGLE" ) );
|
|
|
23374
|
|
|
23375 //=== VK_EXT_discard_rectangles ===
|
|
|
23376 vkCmdSetDiscardRectangleEXT = PFN_vkCmdSetDiscardRectangleEXT( vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleEXT" ) );
|
|
|
23377 vkCmdSetDiscardRectangleEnableEXT = PFN_vkCmdSetDiscardRectangleEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleEnableEXT" ) );
|
|
|
23378 vkCmdSetDiscardRectangleModeEXT = PFN_vkCmdSetDiscardRectangleModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleModeEXT" ) );
|
|
|
23379
|
|
|
23380 //=== VK_EXT_hdr_metadata ===
|
|
|
23381 vkSetHdrMetadataEXT = PFN_vkSetHdrMetadataEXT( vkGetDeviceProcAddr( device, "vkSetHdrMetadataEXT" ) );
|
|
|
23382
|
|
|
23383 //=== VK_KHR_create_renderpass2 ===
|
|
|
23384 vkCreateRenderPass2KHR = PFN_vkCreateRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCreateRenderPass2KHR" ) );
|
|
|
23385 if ( !vkCreateRenderPass2 )
|
|
|
23386 vkCreateRenderPass2 = vkCreateRenderPass2KHR;
|
|
|
23387 vkCmdBeginRenderPass2KHR = PFN_vkCmdBeginRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass2KHR" ) );
|
|
|
23388 if ( !vkCmdBeginRenderPass2 )
|
|
|
23389 vkCmdBeginRenderPass2 = vkCmdBeginRenderPass2KHR;
|
|
|
23390 vkCmdNextSubpass2KHR = PFN_vkCmdNextSubpass2KHR( vkGetDeviceProcAddr( device, "vkCmdNextSubpass2KHR" ) );
|
|
|
23391 if ( !vkCmdNextSubpass2 )
|
|
|
23392 vkCmdNextSubpass2 = vkCmdNextSubpass2KHR;
|
|
|
23393 vkCmdEndRenderPass2KHR = PFN_vkCmdEndRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass2KHR" ) );
|
|
|
23394 if ( !vkCmdEndRenderPass2 )
|
|
|
23395 vkCmdEndRenderPass2 = vkCmdEndRenderPass2KHR;
|
|
|
23396
|
|
|
23397 //=== VK_KHR_shared_presentable_image ===
|
|
|
23398 vkGetSwapchainStatusKHR = PFN_vkGetSwapchainStatusKHR( vkGetDeviceProcAddr( device, "vkGetSwapchainStatusKHR" ) );
|
|
|
23399
|
|
|
23400 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
23401 //=== VK_KHR_external_fence_win32 ===
|
|
|
23402 vkImportFenceWin32HandleKHR = PFN_vkImportFenceWin32HandleKHR( vkGetDeviceProcAddr( device, "vkImportFenceWin32HandleKHR" ) );
|
|
|
23403 vkGetFenceWin32HandleKHR = PFN_vkGetFenceWin32HandleKHR( vkGetDeviceProcAddr( device, "vkGetFenceWin32HandleKHR" ) );
|
|
|
23404 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
23405
|
|
|
23406 //=== VK_KHR_external_fence_fd ===
|
|
|
23407 vkImportFenceFdKHR = PFN_vkImportFenceFdKHR( vkGetDeviceProcAddr( device, "vkImportFenceFdKHR" ) );
|
|
|
23408 vkGetFenceFdKHR = PFN_vkGetFenceFdKHR( vkGetDeviceProcAddr( device, "vkGetFenceFdKHR" ) );
|
|
|
23409
|
|
|
23410 //=== VK_KHR_performance_query ===
|
|
|
23411 vkAcquireProfilingLockKHR = PFN_vkAcquireProfilingLockKHR( vkGetDeviceProcAddr( device, "vkAcquireProfilingLockKHR" ) );
|
|
|
23412 vkReleaseProfilingLockKHR = PFN_vkReleaseProfilingLockKHR( vkGetDeviceProcAddr( device, "vkReleaseProfilingLockKHR" ) );
|
|
|
23413
|
|
|
23414 //=== VK_EXT_debug_utils ===
|
|
|
23415 vkSetDebugUtilsObjectNameEXT = PFN_vkSetDebugUtilsObjectNameEXT( vkGetDeviceProcAddr( device, "vkSetDebugUtilsObjectNameEXT" ) );
|
|
|
23416 vkSetDebugUtilsObjectTagEXT = PFN_vkSetDebugUtilsObjectTagEXT( vkGetDeviceProcAddr( device, "vkSetDebugUtilsObjectTagEXT" ) );
|
|
|
23417 vkQueueBeginDebugUtilsLabelEXT = PFN_vkQueueBeginDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueBeginDebugUtilsLabelEXT" ) );
|
|
|
23418 vkQueueEndDebugUtilsLabelEXT = PFN_vkQueueEndDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueEndDebugUtilsLabelEXT" ) );
|
|
|
23419 vkQueueInsertDebugUtilsLabelEXT = PFN_vkQueueInsertDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueInsertDebugUtilsLabelEXT" ) );
|
|
|
23420 vkCmdBeginDebugUtilsLabelEXT = PFN_vkCmdBeginDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdBeginDebugUtilsLabelEXT" ) );
|
|
|
23421 vkCmdEndDebugUtilsLabelEXT = PFN_vkCmdEndDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdEndDebugUtilsLabelEXT" ) );
|
|
|
23422 vkCmdInsertDebugUtilsLabelEXT = PFN_vkCmdInsertDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdInsertDebugUtilsLabelEXT" ) );
|
|
|
23423
|
|
|
23424 #if defined( VK_USE_PLATFORM_ANDROID_KHR )
|
|
|
23425 //=== VK_ANDROID_external_memory_android_hardware_buffer ===
|
|
|
23426 vkGetAndroidHardwareBufferPropertiesANDROID =
|
|
|
23427 PFN_vkGetAndroidHardwareBufferPropertiesANDROID( vkGetDeviceProcAddr( device, "vkGetAndroidHardwareBufferPropertiesANDROID" ) );
|
|
|
23428 vkGetMemoryAndroidHardwareBufferANDROID =
|
|
|
23429 PFN_vkGetMemoryAndroidHardwareBufferANDROID( vkGetDeviceProcAddr( device, "vkGetMemoryAndroidHardwareBufferANDROID" ) );
|
|
|
23430 #endif /*VK_USE_PLATFORM_ANDROID_KHR*/
|
|
|
23431
|
|
|
23432 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
23433 //=== VK_AMDX_shader_enqueue ===
|
|
|
23434 vkCreateExecutionGraphPipelinesAMDX = PFN_vkCreateExecutionGraphPipelinesAMDX( vkGetDeviceProcAddr( device, "vkCreateExecutionGraphPipelinesAMDX" ) );
|
|
|
23435 vkGetExecutionGraphPipelineScratchSizeAMDX =
|
|
|
23436 PFN_vkGetExecutionGraphPipelineScratchSizeAMDX( vkGetDeviceProcAddr( device, "vkGetExecutionGraphPipelineScratchSizeAMDX" ) );
|
|
|
23437 vkGetExecutionGraphPipelineNodeIndexAMDX =
|
|
|
23438 PFN_vkGetExecutionGraphPipelineNodeIndexAMDX( vkGetDeviceProcAddr( device, "vkGetExecutionGraphPipelineNodeIndexAMDX" ) );
|
|
|
23439 vkCmdInitializeGraphScratchMemoryAMDX =
|
|
|
23440 PFN_vkCmdInitializeGraphScratchMemoryAMDX( vkGetDeviceProcAddr( device, "vkCmdInitializeGraphScratchMemoryAMDX" ) );
|
|
|
23441 vkCmdDispatchGraphAMDX = PFN_vkCmdDispatchGraphAMDX( vkGetDeviceProcAddr( device, "vkCmdDispatchGraphAMDX" ) );
|
|
|
23442 vkCmdDispatchGraphIndirectAMDX = PFN_vkCmdDispatchGraphIndirectAMDX( vkGetDeviceProcAddr( device, "vkCmdDispatchGraphIndirectAMDX" ) );
|
|
|
23443 vkCmdDispatchGraphIndirectCountAMDX = PFN_vkCmdDispatchGraphIndirectCountAMDX( vkGetDeviceProcAddr( device, "vkCmdDispatchGraphIndirectCountAMDX" ) );
|
|
|
23444 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
23445
|
|
|
23446 //=== VK_EXT_sample_locations ===
|
|
|
23447 vkCmdSetSampleLocationsEXT = PFN_vkCmdSetSampleLocationsEXT( vkGetDeviceProcAddr( device, "vkCmdSetSampleLocationsEXT" ) );
|
|
|
23448
|
|
|
23449 //=== VK_KHR_get_memory_requirements2 ===
|
|
|
23450 vkGetImageMemoryRequirements2KHR = PFN_vkGetImageMemoryRequirements2KHR( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements2KHR" ) );
|
|
|
23451 if ( !vkGetImageMemoryRequirements2 )
|
|
|
23452 vkGetImageMemoryRequirements2 = vkGetImageMemoryRequirements2KHR;
|
|
|
23453 vkGetBufferMemoryRequirements2KHR = PFN_vkGetBufferMemoryRequirements2KHR( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements2KHR" ) );
|
|
|
23454 if ( !vkGetBufferMemoryRequirements2 )
|
|
|
23455 vkGetBufferMemoryRequirements2 = vkGetBufferMemoryRequirements2KHR;
|
|
|
23456 vkGetImageSparseMemoryRequirements2KHR =
|
|
|
23457 PFN_vkGetImageSparseMemoryRequirements2KHR( vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements2KHR" ) );
|
|
|
23458 if ( !vkGetImageSparseMemoryRequirements2 )
|
|
|
23459 vkGetImageSparseMemoryRequirements2 = vkGetImageSparseMemoryRequirements2KHR;
|
|
|
23460
|
|
|
23461 //=== VK_KHR_acceleration_structure ===
|
|
|
23462 vkCreateAccelerationStructureKHR = PFN_vkCreateAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCreateAccelerationStructureKHR" ) );
|
|
|
23463 vkDestroyAccelerationStructureKHR = PFN_vkDestroyAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkDestroyAccelerationStructureKHR" ) );
|
|
|
23464 vkCmdBuildAccelerationStructuresKHR = PFN_vkCmdBuildAccelerationStructuresKHR( vkGetDeviceProcAddr( device, "vkCmdBuildAccelerationStructuresKHR" ) );
|
|
|
23465 vkCmdBuildAccelerationStructuresIndirectKHR =
|
|
|
23466 PFN_vkCmdBuildAccelerationStructuresIndirectKHR( vkGetDeviceProcAddr( device, "vkCmdBuildAccelerationStructuresIndirectKHR" ) );
|
|
|
23467 vkBuildAccelerationStructuresKHR = PFN_vkBuildAccelerationStructuresKHR( vkGetDeviceProcAddr( device, "vkBuildAccelerationStructuresKHR" ) );
|
|
|
23468 vkCopyAccelerationStructureKHR = PFN_vkCopyAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCopyAccelerationStructureKHR" ) );
|
|
|
23469 vkCopyAccelerationStructureToMemoryKHR =
|
|
|
23470 PFN_vkCopyAccelerationStructureToMemoryKHR( vkGetDeviceProcAddr( device, "vkCopyAccelerationStructureToMemoryKHR" ) );
|
|
|
23471 vkCopyMemoryToAccelerationStructureKHR =
|
|
|
23472 PFN_vkCopyMemoryToAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCopyMemoryToAccelerationStructureKHR" ) );
|
|
|
23473 vkWriteAccelerationStructuresPropertiesKHR =
|
|
|
23474 PFN_vkWriteAccelerationStructuresPropertiesKHR( vkGetDeviceProcAddr( device, "vkWriteAccelerationStructuresPropertiesKHR" ) );
|
|
|
23475 vkCmdCopyAccelerationStructureKHR = PFN_vkCmdCopyAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCmdCopyAccelerationStructureKHR" ) );
|
|
|
23476 vkCmdCopyAccelerationStructureToMemoryKHR =
|
|
|
23477 PFN_vkCmdCopyAccelerationStructureToMemoryKHR( vkGetDeviceProcAddr( device, "vkCmdCopyAccelerationStructureToMemoryKHR" ) );
|
|
|
23478 vkCmdCopyMemoryToAccelerationStructureKHR =
|
|
|
23479 PFN_vkCmdCopyMemoryToAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToAccelerationStructureKHR" ) );
|
|
|
23480 vkGetAccelerationStructureDeviceAddressKHR =
|
|
|
23481 PFN_vkGetAccelerationStructureDeviceAddressKHR( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureDeviceAddressKHR" ) );
|
|
|
23482 vkCmdWriteAccelerationStructuresPropertiesKHR =
|
|
|
23483 PFN_vkCmdWriteAccelerationStructuresPropertiesKHR( vkGetDeviceProcAddr( device, "vkCmdWriteAccelerationStructuresPropertiesKHR" ) );
|
|
|
23484 vkGetDeviceAccelerationStructureCompatibilityKHR =
|
|
|
23485 PFN_vkGetDeviceAccelerationStructureCompatibilityKHR( vkGetDeviceProcAddr( device, "vkGetDeviceAccelerationStructureCompatibilityKHR" ) );
|
|
|
23486 vkGetAccelerationStructureBuildSizesKHR =
|
|
|
23487 PFN_vkGetAccelerationStructureBuildSizesKHR( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureBuildSizesKHR" ) );
|
|
|
23488
|
|
|
23489 //=== VK_KHR_ray_tracing_pipeline ===
|
|
|
23490 vkCmdTraceRaysKHR = PFN_vkCmdTraceRaysKHR( vkGetDeviceProcAddr( device, "vkCmdTraceRaysKHR" ) );
|
|
|
23491 vkCreateRayTracingPipelinesKHR = PFN_vkCreateRayTracingPipelinesKHR( vkGetDeviceProcAddr( device, "vkCreateRayTracingPipelinesKHR" ) );
|
|
|
23492 vkGetRayTracingShaderGroupHandlesKHR =
|
|
|
23493 PFN_vkGetRayTracingShaderGroupHandlesKHR( vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupHandlesKHR" ) );
|
|
|
23494 vkGetRayTracingCaptureReplayShaderGroupHandlesKHR =
|
|
|
23495 PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( vkGetDeviceProcAddr( device, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR" ) );
|
|
|
23496 vkCmdTraceRaysIndirectKHR = PFN_vkCmdTraceRaysIndirectKHR( vkGetDeviceProcAddr( device, "vkCmdTraceRaysIndirectKHR" ) );
|
|
|
23497 vkGetRayTracingShaderGroupStackSizeKHR =
|
|
|
23498 PFN_vkGetRayTracingShaderGroupStackSizeKHR( vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupStackSizeKHR" ) );
|
|
|
23499 vkCmdSetRayTracingPipelineStackSizeKHR =
|
|
|
23500 PFN_vkCmdSetRayTracingPipelineStackSizeKHR( vkGetDeviceProcAddr( device, "vkCmdSetRayTracingPipelineStackSizeKHR" ) );
|
|
|
23501
|
|
|
23502 //=== VK_KHR_sampler_ycbcr_conversion ===
|
|
|
23503 vkCreateSamplerYcbcrConversionKHR = PFN_vkCreateSamplerYcbcrConversionKHR( vkGetDeviceProcAddr( device, "vkCreateSamplerYcbcrConversionKHR" ) );
|
|
|
23504 if ( !vkCreateSamplerYcbcrConversion )
|
|
|
23505 vkCreateSamplerYcbcrConversion = vkCreateSamplerYcbcrConversionKHR;
|
|
|
23506 vkDestroySamplerYcbcrConversionKHR = PFN_vkDestroySamplerYcbcrConversionKHR( vkGetDeviceProcAddr( device, "vkDestroySamplerYcbcrConversionKHR" ) );
|
|
|
23507 if ( !vkDestroySamplerYcbcrConversion )
|
|
|
23508 vkDestroySamplerYcbcrConversion = vkDestroySamplerYcbcrConversionKHR;
|
|
|
23509
|
|
|
23510 //=== VK_KHR_bind_memory2 ===
|
|
|
23511 vkBindBufferMemory2KHR = PFN_vkBindBufferMemory2KHR( vkGetDeviceProcAddr( device, "vkBindBufferMemory2KHR" ) );
|
|
|
23512 if ( !vkBindBufferMemory2 )
|
|
|
23513 vkBindBufferMemory2 = vkBindBufferMemory2KHR;
|
|
|
23514 vkBindImageMemory2KHR = PFN_vkBindImageMemory2KHR( vkGetDeviceProcAddr( device, "vkBindImageMemory2KHR" ) );
|
|
|
23515 if ( !vkBindImageMemory2 )
|
|
|
23516 vkBindImageMemory2 = vkBindImageMemory2KHR;
|
|
|
23517
|
|
|
23518 //=== VK_EXT_image_drm_format_modifier ===
|
|
|
23519 vkGetImageDrmFormatModifierPropertiesEXT =
|
|
|
23520 PFN_vkGetImageDrmFormatModifierPropertiesEXT( vkGetDeviceProcAddr( device, "vkGetImageDrmFormatModifierPropertiesEXT" ) );
|
|
|
23521
|
|
|
23522 //=== VK_EXT_validation_cache ===
|
|
|
23523 vkCreateValidationCacheEXT = PFN_vkCreateValidationCacheEXT( vkGetDeviceProcAddr( device, "vkCreateValidationCacheEXT" ) );
|
|
|
23524 vkDestroyValidationCacheEXT = PFN_vkDestroyValidationCacheEXT( vkGetDeviceProcAddr( device, "vkDestroyValidationCacheEXT" ) );
|
|
|
23525 vkMergeValidationCachesEXT = PFN_vkMergeValidationCachesEXT( vkGetDeviceProcAddr( device, "vkMergeValidationCachesEXT" ) );
|
|
|
23526 vkGetValidationCacheDataEXT = PFN_vkGetValidationCacheDataEXT( vkGetDeviceProcAddr( device, "vkGetValidationCacheDataEXT" ) );
|
|
|
23527
|
|
|
23528 //=== VK_NV_shading_rate_image ===
|
|
|
23529 vkCmdBindShadingRateImageNV = PFN_vkCmdBindShadingRateImageNV( vkGetDeviceProcAddr( device, "vkCmdBindShadingRateImageNV" ) );
|
|
|
23530 vkCmdSetViewportShadingRatePaletteNV =
|
|
|
23531 PFN_vkCmdSetViewportShadingRatePaletteNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportShadingRatePaletteNV" ) );
|
|
|
23532 vkCmdSetCoarseSampleOrderNV = PFN_vkCmdSetCoarseSampleOrderNV( vkGetDeviceProcAddr( device, "vkCmdSetCoarseSampleOrderNV" ) );
|
|
|
23533
|
|
|
23534 //=== VK_NV_ray_tracing ===
|
|
|
23535 vkCreateAccelerationStructureNV = PFN_vkCreateAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkCreateAccelerationStructureNV" ) );
|
|
|
23536 vkDestroyAccelerationStructureNV = PFN_vkDestroyAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkDestroyAccelerationStructureNV" ) );
|
|
|
23537 vkGetAccelerationStructureMemoryRequirementsNV =
|
|
|
23538 PFN_vkGetAccelerationStructureMemoryRequirementsNV( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureMemoryRequirementsNV" ) );
|
|
|
23539 vkBindAccelerationStructureMemoryNV = PFN_vkBindAccelerationStructureMemoryNV( vkGetDeviceProcAddr( device, "vkBindAccelerationStructureMemoryNV" ) );
|
|
|
23540 vkCmdBuildAccelerationStructureNV = PFN_vkCmdBuildAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkCmdBuildAccelerationStructureNV" ) );
|
|
|
23541 vkCmdCopyAccelerationStructureNV = PFN_vkCmdCopyAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkCmdCopyAccelerationStructureNV" ) );
|
|
|
23542 vkCmdTraceRaysNV = PFN_vkCmdTraceRaysNV( vkGetDeviceProcAddr( device, "vkCmdTraceRaysNV" ) );
|
|
|
23543 vkCreateRayTracingPipelinesNV = PFN_vkCreateRayTracingPipelinesNV( vkGetDeviceProcAddr( device, "vkCreateRayTracingPipelinesNV" ) );
|
|
|
23544 vkGetRayTracingShaderGroupHandlesNV = PFN_vkGetRayTracingShaderGroupHandlesNV( vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupHandlesNV" ) );
|
|
|
23545 if ( !vkGetRayTracingShaderGroupHandlesKHR )
|
|
|
23546 vkGetRayTracingShaderGroupHandlesKHR = vkGetRayTracingShaderGroupHandlesNV;
|
|
|
23547 vkGetAccelerationStructureHandleNV = PFN_vkGetAccelerationStructureHandleNV( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureHandleNV" ) );
|
|
|
23548 vkCmdWriteAccelerationStructuresPropertiesNV =
|
|
|
23549 PFN_vkCmdWriteAccelerationStructuresPropertiesNV( vkGetDeviceProcAddr( device, "vkCmdWriteAccelerationStructuresPropertiesNV" ) );
|
|
|
23550 vkCompileDeferredNV = PFN_vkCompileDeferredNV( vkGetDeviceProcAddr( device, "vkCompileDeferredNV" ) );
|
|
|
23551
|
|
|
23552 //=== VK_KHR_maintenance3 ===
|
|
|
23553 vkGetDescriptorSetLayoutSupportKHR = PFN_vkGetDescriptorSetLayoutSupportKHR( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSupportKHR" ) );
|
|
|
23554 if ( !vkGetDescriptorSetLayoutSupport )
|
|
|
23555 vkGetDescriptorSetLayoutSupport = vkGetDescriptorSetLayoutSupportKHR;
|
|
|
23556
|
|
|
23557 //=== VK_KHR_draw_indirect_count ===
|
|
|
23558 vkCmdDrawIndirectCountKHR = PFN_vkCmdDrawIndirectCountKHR( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCountKHR" ) );
|
|
|
23559 if ( !vkCmdDrawIndirectCount )
|
|
|
23560 vkCmdDrawIndirectCount = vkCmdDrawIndirectCountKHR;
|
|
|
23561 vkCmdDrawIndexedIndirectCountKHR = PFN_vkCmdDrawIndexedIndirectCountKHR( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCountKHR" ) );
|
|
|
23562 if ( !vkCmdDrawIndexedIndirectCount )
|
|
|
23563 vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountKHR;
|
|
|
23564
|
|
|
23565 //=== VK_EXT_external_memory_host ===
|
|
|
23566 vkGetMemoryHostPointerPropertiesEXT = PFN_vkGetMemoryHostPointerPropertiesEXT( vkGetDeviceProcAddr( device, "vkGetMemoryHostPointerPropertiesEXT" ) );
|
|
|
23567
|
|
|
23568 //=== VK_AMD_buffer_marker ===
|
|
|
23569 vkCmdWriteBufferMarkerAMD = PFN_vkCmdWriteBufferMarkerAMD( vkGetDeviceProcAddr( device, "vkCmdWriteBufferMarkerAMD" ) );
|
|
|
23570 vkCmdWriteBufferMarker2AMD = PFN_vkCmdWriteBufferMarker2AMD( vkGetDeviceProcAddr( device, "vkCmdWriteBufferMarker2AMD" ) );
|
|
|
23571
|
|
|
23572 //=== VK_EXT_calibrated_timestamps ===
|
|
|
23573 vkGetCalibratedTimestampsEXT = PFN_vkGetCalibratedTimestampsEXT( vkGetDeviceProcAddr( device, "vkGetCalibratedTimestampsEXT" ) );
|
|
|
23574 if ( !vkGetCalibratedTimestampsKHR )
|
|
|
23575 vkGetCalibratedTimestampsKHR = vkGetCalibratedTimestampsEXT;
|
|
|
23576
|
|
|
23577 //=== VK_NV_mesh_shader ===
|
|
|
23578 vkCmdDrawMeshTasksNV = PFN_vkCmdDrawMeshTasksNV( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksNV" ) );
|
|
|
23579 vkCmdDrawMeshTasksIndirectNV = PFN_vkCmdDrawMeshTasksIndirectNV( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectNV" ) );
|
|
|
23580 vkCmdDrawMeshTasksIndirectCountNV = PFN_vkCmdDrawMeshTasksIndirectCountNV( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectCountNV" ) );
|
|
|
23581
|
|
|
23582 //=== VK_NV_scissor_exclusive ===
|
|
|
23583 vkCmdSetExclusiveScissorEnableNV = PFN_vkCmdSetExclusiveScissorEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetExclusiveScissorEnableNV" ) );
|
|
|
23584 vkCmdSetExclusiveScissorNV = PFN_vkCmdSetExclusiveScissorNV( vkGetDeviceProcAddr( device, "vkCmdSetExclusiveScissorNV" ) );
|
|
|
23585
|
|
|
23586 //=== VK_NV_device_diagnostic_checkpoints ===
|
|
|
23587 vkCmdSetCheckpointNV = PFN_vkCmdSetCheckpointNV( vkGetDeviceProcAddr( device, "vkCmdSetCheckpointNV" ) );
|
|
|
23588 vkGetQueueCheckpointDataNV = PFN_vkGetQueueCheckpointDataNV( vkGetDeviceProcAddr( device, "vkGetQueueCheckpointDataNV" ) );
|
|
|
23589 vkGetQueueCheckpointData2NV = PFN_vkGetQueueCheckpointData2NV( vkGetDeviceProcAddr( device, "vkGetQueueCheckpointData2NV" ) );
|
|
|
23590
|
|
|
23591 //=== VK_KHR_timeline_semaphore ===
|
|
|
23592 vkGetSemaphoreCounterValueKHR = PFN_vkGetSemaphoreCounterValueKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreCounterValueKHR" ) );
|
|
|
23593 if ( !vkGetSemaphoreCounterValue )
|
|
|
23594 vkGetSemaphoreCounterValue = vkGetSemaphoreCounterValueKHR;
|
|
|
23595 vkWaitSemaphoresKHR = PFN_vkWaitSemaphoresKHR( vkGetDeviceProcAddr( device, "vkWaitSemaphoresKHR" ) );
|
|
|
23596 if ( !vkWaitSemaphores )
|
|
|
23597 vkWaitSemaphores = vkWaitSemaphoresKHR;
|
|
|
23598 vkSignalSemaphoreKHR = PFN_vkSignalSemaphoreKHR( vkGetDeviceProcAddr( device, "vkSignalSemaphoreKHR" ) );
|
|
|
23599 if ( !vkSignalSemaphore )
|
|
|
23600 vkSignalSemaphore = vkSignalSemaphoreKHR;
|
|
|
23601
|
|
|
23602 //=== VK_INTEL_performance_query ===
|
|
|
23603 vkInitializePerformanceApiINTEL = PFN_vkInitializePerformanceApiINTEL( vkGetDeviceProcAddr( device, "vkInitializePerformanceApiINTEL" ) );
|
|
|
23604 vkUninitializePerformanceApiINTEL = PFN_vkUninitializePerformanceApiINTEL( vkGetDeviceProcAddr( device, "vkUninitializePerformanceApiINTEL" ) );
|
|
|
23605 vkCmdSetPerformanceMarkerINTEL = PFN_vkCmdSetPerformanceMarkerINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceMarkerINTEL" ) );
|
|
|
23606 vkCmdSetPerformanceStreamMarkerINTEL =
|
|
|
23607 PFN_vkCmdSetPerformanceStreamMarkerINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceStreamMarkerINTEL" ) );
|
|
|
23608 vkCmdSetPerformanceOverrideINTEL = PFN_vkCmdSetPerformanceOverrideINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceOverrideINTEL" ) );
|
|
|
23609 vkAcquirePerformanceConfigurationINTEL =
|
|
|
23610 PFN_vkAcquirePerformanceConfigurationINTEL( vkGetDeviceProcAddr( device, "vkAcquirePerformanceConfigurationINTEL" ) );
|
|
|
23611 vkReleasePerformanceConfigurationINTEL =
|
|
|
23612 PFN_vkReleasePerformanceConfigurationINTEL( vkGetDeviceProcAddr( device, "vkReleasePerformanceConfigurationINTEL" ) );
|
|
|
23613 vkQueueSetPerformanceConfigurationINTEL =
|
|
|
23614 PFN_vkQueueSetPerformanceConfigurationINTEL( vkGetDeviceProcAddr( device, "vkQueueSetPerformanceConfigurationINTEL" ) );
|
|
|
23615 vkGetPerformanceParameterINTEL = PFN_vkGetPerformanceParameterINTEL( vkGetDeviceProcAddr( device, "vkGetPerformanceParameterINTEL" ) );
|
|
|
23616
|
|
|
23617 //=== VK_AMD_display_native_hdr ===
|
|
|
23618 vkSetLocalDimmingAMD = PFN_vkSetLocalDimmingAMD( vkGetDeviceProcAddr( device, "vkSetLocalDimmingAMD" ) );
|
|
|
23619
|
|
|
23620 //=== VK_KHR_fragment_shading_rate ===
|
|
|
23621 vkCmdSetFragmentShadingRateKHR = PFN_vkCmdSetFragmentShadingRateKHR( vkGetDeviceProcAddr( device, "vkCmdSetFragmentShadingRateKHR" ) );
|
|
|
23622
|
|
|
23623 //=== VK_KHR_dynamic_rendering_local_read ===
|
|
|
23624 vkCmdSetRenderingAttachmentLocationsKHR =
|
|
|
23625 PFN_vkCmdSetRenderingAttachmentLocationsKHR( vkGetDeviceProcAddr( device, "vkCmdSetRenderingAttachmentLocationsKHR" ) );
|
|
|
23626 if ( !vkCmdSetRenderingAttachmentLocations )
|
|
|
23627 vkCmdSetRenderingAttachmentLocations = vkCmdSetRenderingAttachmentLocationsKHR;
|
|
|
23628 vkCmdSetRenderingInputAttachmentIndicesKHR =
|
|
|
23629 PFN_vkCmdSetRenderingInputAttachmentIndicesKHR( vkGetDeviceProcAddr( device, "vkCmdSetRenderingInputAttachmentIndicesKHR" ) );
|
|
|
23630 if ( !vkCmdSetRenderingInputAttachmentIndices )
|
|
|
23631 vkCmdSetRenderingInputAttachmentIndices = vkCmdSetRenderingInputAttachmentIndicesKHR;
|
|
|
23632
|
|
|
23633 //=== VK_EXT_buffer_device_address ===
|
|
|
23634 vkGetBufferDeviceAddressEXT = PFN_vkGetBufferDeviceAddressEXT( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddressEXT" ) );
|
|
|
23635 if ( !vkGetBufferDeviceAddress )
|
|
|
23636 vkGetBufferDeviceAddress = vkGetBufferDeviceAddressEXT;
|
|
|
23637
|
|
|
23638 //=== VK_KHR_present_wait ===
|
|
|
23639 vkWaitForPresentKHR = PFN_vkWaitForPresentKHR( vkGetDeviceProcAddr( device, "vkWaitForPresentKHR" ) );
|
|
|
23640
|
|
|
23641 #if defined( VK_USE_PLATFORM_WIN32_KHR )
|
|
|
23642 //=== VK_EXT_full_screen_exclusive ===
|
|
|
23643 vkAcquireFullScreenExclusiveModeEXT = PFN_vkAcquireFullScreenExclusiveModeEXT( vkGetDeviceProcAddr( device, "vkAcquireFullScreenExclusiveModeEXT" ) );
|
|
|
23644 vkReleaseFullScreenExclusiveModeEXT = PFN_vkReleaseFullScreenExclusiveModeEXT( vkGetDeviceProcAddr( device, "vkReleaseFullScreenExclusiveModeEXT" ) );
|
|
|
23645 vkGetDeviceGroupSurfacePresentModes2EXT =
|
|
|
23646 PFN_vkGetDeviceGroupSurfacePresentModes2EXT( vkGetDeviceProcAddr( device, "vkGetDeviceGroupSurfacePresentModes2EXT" ) );
|
|
|
23647 #endif /*VK_USE_PLATFORM_WIN32_KHR*/
|
|
|
23648
|
|
|
23649 //=== VK_KHR_buffer_device_address ===
|
|
|
23650 vkGetBufferDeviceAddressKHR = PFN_vkGetBufferDeviceAddressKHR( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddressKHR" ) );
|
|
|
23651 if ( !vkGetBufferDeviceAddress )
|
|
|
23652 vkGetBufferDeviceAddress = vkGetBufferDeviceAddressKHR;
|
|
|
23653 vkGetBufferOpaqueCaptureAddressKHR = PFN_vkGetBufferOpaqueCaptureAddressKHR( vkGetDeviceProcAddr( device, "vkGetBufferOpaqueCaptureAddressKHR" ) );
|
|
|
23654 if ( !vkGetBufferOpaqueCaptureAddress )
|
|
|
23655 vkGetBufferOpaqueCaptureAddress = vkGetBufferOpaqueCaptureAddressKHR;
|
|
|
23656 vkGetDeviceMemoryOpaqueCaptureAddressKHR =
|
|
|
23657 PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR( vkGetDeviceProcAddr( device, "vkGetDeviceMemoryOpaqueCaptureAddressKHR" ) );
|
|
|
23658 if ( !vkGetDeviceMemoryOpaqueCaptureAddress )
|
|
|
23659 vkGetDeviceMemoryOpaqueCaptureAddress = vkGetDeviceMemoryOpaqueCaptureAddressKHR;
|
|
|
23660
|
|
|
23661 //=== VK_EXT_line_rasterization ===
|
|
|
23662 vkCmdSetLineStippleEXT = PFN_vkCmdSetLineStippleEXT( vkGetDeviceProcAddr( device, "vkCmdSetLineStippleEXT" ) );
|
|
|
23663 if ( !vkCmdSetLineStipple )
|
|
|
23664 vkCmdSetLineStipple = vkCmdSetLineStippleEXT;
|
|
|
23665
|
|
|
23666 //=== VK_EXT_host_query_reset ===
|
|
|
23667 vkResetQueryPoolEXT = PFN_vkResetQueryPoolEXT( vkGetDeviceProcAddr( device, "vkResetQueryPoolEXT" ) );
|
|
|
23668 if ( !vkResetQueryPool )
|
|
|
23669 vkResetQueryPool = vkResetQueryPoolEXT;
|
|
|
23670
|
|
|
23671 //=== VK_EXT_extended_dynamic_state ===
|
|
|
23672 vkCmdSetCullModeEXT = PFN_vkCmdSetCullModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetCullModeEXT" ) );
|
|
|
23673 if ( !vkCmdSetCullMode )
|
|
|
23674 vkCmdSetCullMode = vkCmdSetCullModeEXT;
|
|
|
23675 vkCmdSetFrontFaceEXT = PFN_vkCmdSetFrontFaceEXT( vkGetDeviceProcAddr( device, "vkCmdSetFrontFaceEXT" ) );
|
|
|
23676 if ( !vkCmdSetFrontFace )
|
|
|
23677 vkCmdSetFrontFace = vkCmdSetFrontFaceEXT;
|
|
|
23678 vkCmdSetPrimitiveTopologyEXT = PFN_vkCmdSetPrimitiveTopologyEXT( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveTopologyEXT" ) );
|
|
|
23679 if ( !vkCmdSetPrimitiveTopology )
|
|
|
23680 vkCmdSetPrimitiveTopology = vkCmdSetPrimitiveTopologyEXT;
|
|
|
23681 vkCmdSetViewportWithCountEXT = PFN_vkCmdSetViewportWithCountEXT( vkGetDeviceProcAddr( device, "vkCmdSetViewportWithCountEXT" ) );
|
|
|
23682 if ( !vkCmdSetViewportWithCount )
|
|
|
23683 vkCmdSetViewportWithCount = vkCmdSetViewportWithCountEXT;
|
|
|
23684 vkCmdSetScissorWithCountEXT = PFN_vkCmdSetScissorWithCountEXT( vkGetDeviceProcAddr( device, "vkCmdSetScissorWithCountEXT" ) );
|
|
|
23685 if ( !vkCmdSetScissorWithCount )
|
|
|
23686 vkCmdSetScissorWithCount = vkCmdSetScissorWithCountEXT;
|
|
|
23687 vkCmdBindVertexBuffers2EXT = PFN_vkCmdBindVertexBuffers2EXT( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers2EXT" ) );
|
|
|
23688 if ( !vkCmdBindVertexBuffers2 )
|
|
|
23689 vkCmdBindVertexBuffers2 = vkCmdBindVertexBuffers2EXT;
|
|
|
23690 vkCmdSetDepthTestEnableEXT = PFN_vkCmdSetDepthTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthTestEnableEXT" ) );
|
|
|
23691 if ( !vkCmdSetDepthTestEnable )
|
|
|
23692 vkCmdSetDepthTestEnable = vkCmdSetDepthTestEnableEXT;
|
|
|
23693 vkCmdSetDepthWriteEnableEXT = PFN_vkCmdSetDepthWriteEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthWriteEnableEXT" ) );
|
|
|
23694 if ( !vkCmdSetDepthWriteEnable )
|
|
|
23695 vkCmdSetDepthWriteEnable = vkCmdSetDepthWriteEnableEXT;
|
|
|
23696 vkCmdSetDepthCompareOpEXT = PFN_vkCmdSetDepthCompareOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthCompareOpEXT" ) );
|
|
|
23697 if ( !vkCmdSetDepthCompareOp )
|
|
|
23698 vkCmdSetDepthCompareOp = vkCmdSetDepthCompareOpEXT;
|
|
|
23699 vkCmdSetDepthBoundsTestEnableEXT = PFN_vkCmdSetDepthBoundsTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthBoundsTestEnableEXT" ) );
|
|
|
23700 if ( !vkCmdSetDepthBoundsTestEnable )
|
|
|
23701 vkCmdSetDepthBoundsTestEnable = vkCmdSetDepthBoundsTestEnableEXT;
|
|
|
23702 vkCmdSetStencilTestEnableEXT = PFN_vkCmdSetStencilTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetStencilTestEnableEXT" ) );
|
|
|
23703 if ( !vkCmdSetStencilTestEnable )
|
|
|
23704 vkCmdSetStencilTestEnable = vkCmdSetStencilTestEnableEXT;
|
|
|
23705 vkCmdSetStencilOpEXT = PFN_vkCmdSetStencilOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetStencilOpEXT" ) );
|
|
|
23706 if ( !vkCmdSetStencilOp )
|
|
|
23707 vkCmdSetStencilOp = vkCmdSetStencilOpEXT;
|
|
|
23708
|
|
|
23709 //=== VK_KHR_deferred_host_operations ===
|
|
|
23710 vkCreateDeferredOperationKHR = PFN_vkCreateDeferredOperationKHR( vkGetDeviceProcAddr( device, "vkCreateDeferredOperationKHR" ) );
|
|
|
23711 vkDestroyDeferredOperationKHR = PFN_vkDestroyDeferredOperationKHR( vkGetDeviceProcAddr( device, "vkDestroyDeferredOperationKHR" ) );
|
|
|
23712 vkGetDeferredOperationMaxConcurrencyKHR =
|
|
|
23713 PFN_vkGetDeferredOperationMaxConcurrencyKHR( vkGetDeviceProcAddr( device, "vkGetDeferredOperationMaxConcurrencyKHR" ) );
|
|
|
23714 vkGetDeferredOperationResultKHR = PFN_vkGetDeferredOperationResultKHR( vkGetDeviceProcAddr( device, "vkGetDeferredOperationResultKHR" ) );
|
|
|
23715 vkDeferredOperationJoinKHR = PFN_vkDeferredOperationJoinKHR( vkGetDeviceProcAddr( device, "vkDeferredOperationJoinKHR" ) );
|
|
|
23716
|
|
|
23717 //=== VK_KHR_pipeline_executable_properties ===
|
|
|
23718 vkGetPipelineExecutablePropertiesKHR =
|
|
|
23719 PFN_vkGetPipelineExecutablePropertiesKHR( vkGetDeviceProcAddr( device, "vkGetPipelineExecutablePropertiesKHR" ) );
|
|
|
23720 vkGetPipelineExecutableStatisticsKHR =
|
|
|
23721 PFN_vkGetPipelineExecutableStatisticsKHR( vkGetDeviceProcAddr( device, "vkGetPipelineExecutableStatisticsKHR" ) );
|
|
|
23722 vkGetPipelineExecutableInternalRepresentationsKHR =
|
|
|
23723 PFN_vkGetPipelineExecutableInternalRepresentationsKHR( vkGetDeviceProcAddr( device, "vkGetPipelineExecutableInternalRepresentationsKHR" ) );
|
|
|
23724
|
|
|
23725 //=== VK_EXT_host_image_copy ===
|
|
|
23726 vkCopyMemoryToImageEXT = PFN_vkCopyMemoryToImageEXT( vkGetDeviceProcAddr( device, "vkCopyMemoryToImageEXT" ) );
|
|
|
23727 if ( !vkCopyMemoryToImage )
|
|
|
23728 vkCopyMemoryToImage = vkCopyMemoryToImageEXT;
|
|
|
23729 vkCopyImageToMemoryEXT = PFN_vkCopyImageToMemoryEXT( vkGetDeviceProcAddr( device, "vkCopyImageToMemoryEXT" ) );
|
|
|
23730 if ( !vkCopyImageToMemory )
|
|
|
23731 vkCopyImageToMemory = vkCopyImageToMemoryEXT;
|
|
|
23732 vkCopyImageToImageEXT = PFN_vkCopyImageToImageEXT( vkGetDeviceProcAddr( device, "vkCopyImageToImageEXT" ) );
|
|
|
23733 if ( !vkCopyImageToImage )
|
|
|
23734 vkCopyImageToImage = vkCopyImageToImageEXT;
|
|
|
23735 vkTransitionImageLayoutEXT = PFN_vkTransitionImageLayoutEXT( vkGetDeviceProcAddr( device, "vkTransitionImageLayoutEXT" ) );
|
|
|
23736 if ( !vkTransitionImageLayout )
|
|
|
23737 vkTransitionImageLayout = vkTransitionImageLayoutEXT;
|
|
|
23738 vkGetImageSubresourceLayout2EXT = PFN_vkGetImageSubresourceLayout2EXT( vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout2EXT" ) );
|
|
|
23739 if ( !vkGetImageSubresourceLayout2 )
|
|
|
23740 vkGetImageSubresourceLayout2 = vkGetImageSubresourceLayout2EXT;
|
|
|
23741
|
|
|
23742 //=== VK_KHR_map_memory2 ===
|
|
|
23743 vkMapMemory2KHR = PFN_vkMapMemory2KHR( vkGetDeviceProcAddr( device, "vkMapMemory2KHR" ) );
|
|
|
23744 if ( !vkMapMemory2 )
|
|
|
23745 vkMapMemory2 = vkMapMemory2KHR;
|
|
|
23746 vkUnmapMemory2KHR = PFN_vkUnmapMemory2KHR( vkGetDeviceProcAddr( device, "vkUnmapMemory2KHR" ) );
|
|
|
23747 if ( !vkUnmapMemory2 )
|
|
|
23748 vkUnmapMemory2 = vkUnmapMemory2KHR;
|
|
|
23749
|
|
|
23750 //=== VK_EXT_swapchain_maintenance1 ===
|
|
|
23751 vkReleaseSwapchainImagesEXT = PFN_vkReleaseSwapchainImagesEXT( vkGetDeviceProcAddr( device, "vkReleaseSwapchainImagesEXT" ) );
|
|
|
23752 if ( !vkReleaseSwapchainImagesKHR )
|
|
|
23753 vkReleaseSwapchainImagesKHR = vkReleaseSwapchainImagesEXT;
|
|
|
23754
|
|
|
23755 //=== VK_NV_device_generated_commands ===
|
|
|
23756 vkGetGeneratedCommandsMemoryRequirementsNV =
|
|
|
23757 PFN_vkGetGeneratedCommandsMemoryRequirementsNV( vkGetDeviceProcAddr( device, "vkGetGeneratedCommandsMemoryRequirementsNV" ) );
|
|
|
23758 vkCmdPreprocessGeneratedCommandsNV = PFN_vkCmdPreprocessGeneratedCommandsNV( vkGetDeviceProcAddr( device, "vkCmdPreprocessGeneratedCommandsNV" ) );
|
|
|
23759 vkCmdExecuteGeneratedCommandsNV = PFN_vkCmdExecuteGeneratedCommandsNV( vkGetDeviceProcAddr( device, "vkCmdExecuteGeneratedCommandsNV" ) );
|
|
|
23760 vkCmdBindPipelineShaderGroupNV = PFN_vkCmdBindPipelineShaderGroupNV( vkGetDeviceProcAddr( device, "vkCmdBindPipelineShaderGroupNV" ) );
|
|
|
23761 vkCreateIndirectCommandsLayoutNV = PFN_vkCreateIndirectCommandsLayoutNV( vkGetDeviceProcAddr( device, "vkCreateIndirectCommandsLayoutNV" ) );
|
|
|
23762 vkDestroyIndirectCommandsLayoutNV = PFN_vkDestroyIndirectCommandsLayoutNV( vkGetDeviceProcAddr( device, "vkDestroyIndirectCommandsLayoutNV" ) );
|
|
|
23763
|
|
|
23764 //=== VK_EXT_depth_bias_control ===
|
|
|
23765 vkCmdSetDepthBias2EXT = PFN_vkCmdSetDepthBias2EXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthBias2EXT" ) );
|
|
|
23766
|
|
|
23767 //=== VK_EXT_private_data ===
|
|
|
23768 vkCreatePrivateDataSlotEXT = PFN_vkCreatePrivateDataSlotEXT( vkGetDeviceProcAddr( device, "vkCreatePrivateDataSlotEXT" ) );
|
|
|
23769 if ( !vkCreatePrivateDataSlot )
|
|
|
23770 vkCreatePrivateDataSlot = vkCreatePrivateDataSlotEXT;
|
|
|
23771 vkDestroyPrivateDataSlotEXT = PFN_vkDestroyPrivateDataSlotEXT( vkGetDeviceProcAddr( device, "vkDestroyPrivateDataSlotEXT" ) );
|
|
|
23772 if ( !vkDestroyPrivateDataSlot )
|
|
|
23773 vkDestroyPrivateDataSlot = vkDestroyPrivateDataSlotEXT;
|
|
|
23774 vkSetPrivateDataEXT = PFN_vkSetPrivateDataEXT( vkGetDeviceProcAddr( device, "vkSetPrivateDataEXT" ) );
|
|
|
23775 if ( !vkSetPrivateData )
|
|
|
23776 vkSetPrivateData = vkSetPrivateDataEXT;
|
|
|
23777 vkGetPrivateDataEXT = PFN_vkGetPrivateDataEXT( vkGetDeviceProcAddr( device, "vkGetPrivateDataEXT" ) );
|
|
|
23778 if ( !vkGetPrivateData )
|
|
|
23779 vkGetPrivateData = vkGetPrivateDataEXT;
|
|
|
23780
|
|
|
23781 //=== VK_KHR_video_encode_queue ===
|
|
|
23782 vkGetEncodedVideoSessionParametersKHR =
|
|
|
23783 PFN_vkGetEncodedVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkGetEncodedVideoSessionParametersKHR" ) );
|
|
|
23784 vkCmdEncodeVideoKHR = PFN_vkCmdEncodeVideoKHR( vkGetDeviceProcAddr( device, "vkCmdEncodeVideoKHR" ) );
|
|
|
23785
|
|
|
23786 #if defined( VK_ENABLE_BETA_EXTENSIONS )
|
|
|
23787 //=== VK_NV_cuda_kernel_launch ===
|
|
|
23788 vkCreateCudaModuleNV = PFN_vkCreateCudaModuleNV( vkGetDeviceProcAddr( device, "vkCreateCudaModuleNV" ) );
|
|
|
23789 vkGetCudaModuleCacheNV = PFN_vkGetCudaModuleCacheNV( vkGetDeviceProcAddr( device, "vkGetCudaModuleCacheNV" ) );
|
|
|
23790 vkCreateCudaFunctionNV = PFN_vkCreateCudaFunctionNV( vkGetDeviceProcAddr( device, "vkCreateCudaFunctionNV" ) );
|
|
|
23791 vkDestroyCudaModuleNV = PFN_vkDestroyCudaModuleNV( vkGetDeviceProcAddr( device, "vkDestroyCudaModuleNV" ) );
|
|
|
23792 vkDestroyCudaFunctionNV = PFN_vkDestroyCudaFunctionNV( vkGetDeviceProcAddr( device, "vkDestroyCudaFunctionNV" ) );
|
|
|
23793 vkCmdCudaLaunchKernelNV = PFN_vkCmdCudaLaunchKernelNV( vkGetDeviceProcAddr( device, "vkCmdCudaLaunchKernelNV" ) );
|
|
|
23794 #endif /*VK_ENABLE_BETA_EXTENSIONS*/
|
|
|
23795
|
|
|
23796 //=== VK_QCOM_tile_shading ===
|
|
|
23797 vkCmdDispatchTileQCOM = PFN_vkCmdDispatchTileQCOM( vkGetDeviceProcAddr( device, "vkCmdDispatchTileQCOM" ) );
|
|
|
23798 vkCmdBeginPerTileExecutionQCOM = PFN_vkCmdBeginPerTileExecutionQCOM( vkGetDeviceProcAddr( device, "vkCmdBeginPerTileExecutionQCOM" ) );
|
|
|
23799 vkCmdEndPerTileExecutionQCOM = PFN_vkCmdEndPerTileExecutionQCOM( vkGetDeviceProcAddr( device, "vkCmdEndPerTileExecutionQCOM" ) );
|
|
|
23800
|
|
|
23801 #if defined( VK_USE_PLATFORM_METAL_EXT )
|
|
|
23802 //=== VK_EXT_metal_objects ===
|
|
|
23803 vkExportMetalObjectsEXT = PFN_vkExportMetalObjectsEXT( vkGetDeviceProcAddr( device, "vkExportMetalObjectsEXT" ) );
|
|
|
23804 #endif /*VK_USE_PLATFORM_METAL_EXT*/
|
|
|
23805
|
|
|
23806 //=== VK_KHR_synchronization2 ===
|
|
|
23807 vkCmdSetEvent2KHR = PFN_vkCmdSetEvent2KHR( vkGetDeviceProcAddr( device, "vkCmdSetEvent2KHR" ) );
|
|
|
23808 if ( !vkCmdSetEvent2 )
|
|
|
23809 vkCmdSetEvent2 = vkCmdSetEvent2KHR;
|
|
|
23810 vkCmdResetEvent2KHR = PFN_vkCmdResetEvent2KHR( vkGetDeviceProcAddr( device, "vkCmdResetEvent2KHR" ) );
|
|
|
23811 if ( !vkCmdResetEvent2 )
|
|
|
23812 vkCmdResetEvent2 = vkCmdResetEvent2KHR;
|
|
|
23813 vkCmdWaitEvents2KHR = PFN_vkCmdWaitEvents2KHR( vkGetDeviceProcAddr( device, "vkCmdWaitEvents2KHR" ) );
|
|
|
23814 if ( !vkCmdWaitEvents2 )
|
|
|
23815 vkCmdWaitEvents2 = vkCmdWaitEvents2KHR;
|
|
|
23816 vkCmdPipelineBarrier2KHR = PFN_vkCmdPipelineBarrier2KHR( vkGetDeviceProcAddr( device, "vkCmdPipelineBarrier2KHR" ) );
|
|
|
23817 if ( !vkCmdPipelineBarrier2 )
|
|
|
23818 vkCmdPipelineBarrier2 = vkCmdPipelineBarrier2KHR;
|
|
|
23819 vkCmdWriteTimestamp2KHR = PFN_vkCmdWriteTimestamp2KHR( vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp2KHR" ) );
|
|
|
23820 if ( !vkCmdWriteTimestamp2 )
|
|
|
23821 vkCmdWriteTimestamp2 = vkCmdWriteTimestamp2KHR;
|
|
|
23822 vkQueueSubmit2KHR = PFN_vkQueueSubmit2KHR( vkGetDeviceProcAddr( device, "vkQueueSubmit2KHR" ) );
|
|
|
23823 if ( !vkQueueSubmit2 )
|
|
|
23824 vkQueueSubmit2 = vkQueueSubmit2KHR;
|
|
|
23825
|
|
|
23826 //=== VK_EXT_descriptor_buffer ===
|
|
|
23827 vkGetDescriptorSetLayoutSizeEXT = PFN_vkGetDescriptorSetLayoutSizeEXT( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSizeEXT" ) );
|
|
|
23828 vkGetDescriptorSetLayoutBindingOffsetEXT =
|
|
|
23829 PFN_vkGetDescriptorSetLayoutBindingOffsetEXT( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutBindingOffsetEXT" ) );
|
|
|
23830 vkGetDescriptorEXT = PFN_vkGetDescriptorEXT( vkGetDeviceProcAddr( device, "vkGetDescriptorEXT" ) );
|
|
|
23831 vkCmdBindDescriptorBuffersEXT = PFN_vkCmdBindDescriptorBuffersEXT( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorBuffersEXT" ) );
|
|
|
23832 vkCmdSetDescriptorBufferOffsetsEXT = PFN_vkCmdSetDescriptorBufferOffsetsEXT( vkGetDeviceProcAddr( device, "vkCmdSetDescriptorBufferOffsetsEXT" ) );
|
|
|
23833 vkCmdBindDescriptorBufferEmbeddedSamplersEXT =
|
|
|
23834 PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorBufferEmbeddedSamplersEXT" ) );
|
|
|
23835 vkGetBufferOpaqueCaptureDescriptorDataEXT =
|
|
|
23836 PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetBufferOpaqueCaptureDescriptorDataEXT" ) );
|
|
|
23837 vkGetImageOpaqueCaptureDescriptorDataEXT =
|
|
|
23838 PFN_vkGetImageOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetImageOpaqueCaptureDescriptorDataEXT" ) );
|
|
|
23839 vkGetImageViewOpaqueCaptureDescriptorDataEXT =
|
|
|
23840 PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetImageViewOpaqueCaptureDescriptorDataEXT" ) );
|
|
|
23841 vkGetSamplerOpaqueCaptureDescriptorDataEXT =
|
|
|
23842 PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetSamplerOpaqueCaptureDescriptorDataEXT" ) );
|
|
|
23843 vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(
|
|
|
23844 vkGetDeviceProcAddr( device, "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT" ) );
|
|
|
23845
|
|
|
23846 //=== VK_NV_fragment_shading_rate_enums ===
|
|
|
23847 vkCmdSetFragmentShadingRateEnumNV = PFN_vkCmdSetFragmentShadingRateEnumNV( vkGetDeviceProcAddr( device, "vkCmdSetFragmentShadingRateEnumNV" ) );
|
|
|
23848
|
|
|
23849 //=== VK_EXT_mesh_shader ===
|
|
|
23850 vkCmdDrawMeshTasksEXT = PFN_vkCmdDrawMeshTasksEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksEXT" ) );
|
|
|
23851 vkCmdDrawMeshTasksIndirectEXT = PFN_vkCmdDrawMeshTasksIndirectEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectEXT" ) );
|
|
|
23852 vkCmdDrawMeshTasksIndirectCountEXT = PFN_vkCmdDrawMeshTasksIndirectCountEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectCountEXT" ) );
|
|
|
23853
|
|
|
23854 //=== VK_KHR_copy_commands2 ===
|
|
|
23855 vkCmdCopyBuffer2KHR = PFN_vkCmdCopyBuffer2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyBuffer2KHR" ) );
|
|
|
23856 if ( !vkCmdCopyBuffer2 )
|
|
|
23857 vkCmdCopyBuffer2 = vkCmdCopyBuffer2KHR;
|
|
|
23858 vkCmdCopyImage2KHR = PFN_vkCmdCopyImage2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyImage2KHR" ) );
|
|
|
23859 if ( !vkCmdCopyImage2 )
|
|
|
23860 vkCmdCopyImage2 = vkCmdCopyImage2KHR;
|
|
|
23861 vkCmdCopyBufferToImage2KHR = PFN_vkCmdCopyBufferToImage2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyBufferToImage2KHR" ) );
|
|
|
23862 if ( !vkCmdCopyBufferToImage2 )
|
|
|
23863 vkCmdCopyBufferToImage2 = vkCmdCopyBufferToImage2KHR;
|
|
|
23864 vkCmdCopyImageToBuffer2KHR = PFN_vkCmdCopyImageToBuffer2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyImageToBuffer2KHR" ) );
|
|
|
23865 if ( !vkCmdCopyImageToBuffer2 )
|
|
|
23866 vkCmdCopyImageToBuffer2 = vkCmdCopyImageToBuffer2KHR;
|
|
|
23867 vkCmdBlitImage2KHR = PFN_vkCmdBlitImage2KHR( vkGetDeviceProcAddr( device, "vkCmdBlitImage2KHR" ) );
|
|
|
23868 if ( !vkCmdBlitImage2 )
|
|
|
23869 vkCmdBlitImage2 = vkCmdBlitImage2KHR;
|
|
|
23870 vkCmdResolveImage2KHR = PFN_vkCmdResolveImage2KHR( vkGetDeviceProcAddr( device, "vkCmdResolveImage2KHR" ) );
|
|
|
23871 if ( !vkCmdResolveImage2 )
|
|
|
23872 vkCmdResolveImage2 = vkCmdResolveImage2KHR;
|
|
|
23873
|
|
|
23874 //=== VK_EXT_device_fault ===
|
|
|
23875 vkGetDeviceFaultInfoEXT = PFN_vkGetDeviceFaultInfoEXT( vkGetDeviceProcAddr( device, "vkGetDeviceFaultInfoEXT" ) );
|
|
|
23876
|
|
|
23877 //=== VK_EXT_vertex_input_dynamic_state ===
|
|
|
23878 vkCmdSetVertexInputEXT = PFN_vkCmdSetVertexInputEXT( vkGetDeviceProcAddr( device, "vkCmdSetVertexInputEXT" ) );
|
|
|
23879
|
|
|
23880 #if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
|
23881 //=== VK_FUCHSIA_external_memory ===
|
|
|
23882 vkGetMemoryZirconHandleFUCHSIA = PFN_vkGetMemoryZirconHandleFUCHSIA( vkGetDeviceProcAddr( device, "vkGetMemoryZirconHandleFUCHSIA" ) );
|
|
|
23883 vkGetMemoryZirconHandlePropertiesFUCHSIA =
|
|
|
23884 PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA( vkGetDeviceProcAddr( device, "vkGetMemoryZirconHandlePropertiesFUCHSIA" ) );
|
|
|
23885 #endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
23886
|
|
|
23887 #if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
|
23888 //=== VK_FUCHSIA_external_semaphore ===
|
|
|
23889 vkImportSemaphoreZirconHandleFUCHSIA =
|
|
|
23890 PFN_vkImportSemaphoreZirconHandleFUCHSIA( vkGetDeviceProcAddr( device, "vkImportSemaphoreZirconHandleFUCHSIA" ) );
|
|
|
23891 vkGetSemaphoreZirconHandleFUCHSIA = PFN_vkGetSemaphoreZirconHandleFUCHSIA( vkGetDeviceProcAddr( device, "vkGetSemaphoreZirconHandleFUCHSIA" ) );
|
|
|
23892 #endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
23893
|
|
|
23894 #if defined( VK_USE_PLATFORM_FUCHSIA )
|
|
|
23895 //=== VK_FUCHSIA_buffer_collection ===
|
|
|
23896 vkCreateBufferCollectionFUCHSIA = PFN_vkCreateBufferCollectionFUCHSIA( vkGetDeviceProcAddr( device, "vkCreateBufferCollectionFUCHSIA" ) );
|
|
|
23897 vkSetBufferCollectionImageConstraintsFUCHSIA =
|
|
|
23898 PFN_vkSetBufferCollectionImageConstraintsFUCHSIA( vkGetDeviceProcAddr( device, "vkSetBufferCollectionImageConstraintsFUCHSIA" ) );
|
|
|
23899 vkSetBufferCollectionBufferConstraintsFUCHSIA =
|
|
|
23900 PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA( vkGetDeviceProcAddr( device, "vkSetBufferCollectionBufferConstraintsFUCHSIA" ) );
|
|
|
23901 vkDestroyBufferCollectionFUCHSIA = PFN_vkDestroyBufferCollectionFUCHSIA( vkGetDeviceProcAddr( device, "vkDestroyBufferCollectionFUCHSIA" ) );
|
|
|
23902 vkGetBufferCollectionPropertiesFUCHSIA =
|
|
|
23903 PFN_vkGetBufferCollectionPropertiesFUCHSIA( vkGetDeviceProcAddr( device, "vkGetBufferCollectionPropertiesFUCHSIA" ) );
|
|
|
23904 #endif /*VK_USE_PLATFORM_FUCHSIA*/
|
|
|
23905
|
|
|
23906 //=== VK_HUAWEI_subpass_shading ===
|
|
|
23907 vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI =
|
|
|
23908 PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( vkGetDeviceProcAddr( device, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI" ) );
|
|
|
23909 vkCmdSubpassShadingHUAWEI = PFN_vkCmdSubpassShadingHUAWEI( vkGetDeviceProcAddr( device, "vkCmdSubpassShadingHUAWEI" ) );
|
|
|
23910
|
|
|
23911 //=== VK_HUAWEI_invocation_mask ===
|
|
|
23912 vkCmdBindInvocationMaskHUAWEI = PFN_vkCmdBindInvocationMaskHUAWEI( vkGetDeviceProcAddr( device, "vkCmdBindInvocationMaskHUAWEI" ) );
|
|
|
23913
|
|
|
23914 //=== VK_NV_external_memory_rdma ===
|
|
|
23915 vkGetMemoryRemoteAddressNV = PFN_vkGetMemoryRemoteAddressNV( vkGetDeviceProcAddr( device, "vkGetMemoryRemoteAddressNV" ) );
|
|
|
23916
|
|
|
23917 //=== VK_EXT_pipeline_properties ===
|
|
|
23918 vkGetPipelinePropertiesEXT = PFN_vkGetPipelinePropertiesEXT( vkGetDeviceProcAddr( device, "vkGetPipelinePropertiesEXT" ) );
|
|
|
23919
|
|
|
23920 //=== VK_EXT_extended_dynamic_state2 ===
|
|
|
23921 vkCmdSetPatchControlPointsEXT = PFN_vkCmdSetPatchControlPointsEXT( vkGetDeviceProcAddr( device, "vkCmdSetPatchControlPointsEXT" ) );
|
|
|
23922 vkCmdSetRasterizerDiscardEnableEXT = PFN_vkCmdSetRasterizerDiscardEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetRasterizerDiscardEnableEXT" ) );
|
|
|
23923 if ( !vkCmdSetRasterizerDiscardEnable )
|
|
|
23924 vkCmdSetRasterizerDiscardEnable = vkCmdSetRasterizerDiscardEnableEXT;
|
|
|
23925 vkCmdSetDepthBiasEnableEXT = PFN_vkCmdSetDepthBiasEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthBiasEnableEXT" ) );
|
|
|
23926 if ( !vkCmdSetDepthBiasEnable )
|
|
|
23927 vkCmdSetDepthBiasEnable = vkCmdSetDepthBiasEnableEXT;
|
|
|
23928 vkCmdSetLogicOpEXT = PFN_vkCmdSetLogicOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetLogicOpEXT" ) );
|
|
|
23929 vkCmdSetPrimitiveRestartEnableEXT = PFN_vkCmdSetPrimitiveRestartEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveRestartEnableEXT" ) );
|
|
|
23930 if ( !vkCmdSetPrimitiveRestartEnable )
|
|
|
23931 vkCmdSetPrimitiveRestartEnable = vkCmdSetPrimitiveRestartEnableEXT;
|
|
|
23932
|
|
|
23933 //=== VK_EXT_color_write_enable ===
|
|
|
23934 vkCmdSetColorWriteEnableEXT = PFN_vkCmdSetColorWriteEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorWriteEnableEXT" ) );
|
|
|
23935
|
|
|
23936 //=== VK_KHR_ray_tracing_maintenance1 ===
|
|
|
23937 vkCmdTraceRaysIndirect2KHR = PFN_vkCmdTraceRaysIndirect2KHR( vkGetDeviceProcAddr( device, "vkCmdTraceRaysIndirect2KHR" ) );
|
|
|
23938
|
|
|
23939 //=== VK_EXT_multi_draw ===
|
|
|
23940 vkCmdDrawMultiEXT = PFN_vkCmdDrawMultiEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMultiEXT" ) );
|
|
|
23941 vkCmdDrawMultiIndexedEXT = PFN_vkCmdDrawMultiIndexedEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMultiIndexedEXT" ) );
|
|
|
23942
|
|
|
23943 //=== VK_EXT_opacity_micromap ===
|
|
|
23944 vkCreateMicromapEXT = PFN_vkCreateMicromapEXT( vkGetDeviceProcAddr( device, "vkCreateMicromapEXT" ) );
|
|
|
23945 vkDestroyMicromapEXT = PFN_vkDestroyMicromapEXT( vkGetDeviceProcAddr( device, "vkDestroyMicromapEXT" ) );
|
|
|
23946 vkCmdBuildMicromapsEXT = PFN_vkCmdBuildMicromapsEXT( vkGetDeviceProcAddr( device, "vkCmdBuildMicromapsEXT" ) );
|
|
|
23947 vkBuildMicromapsEXT = PFN_vkBuildMicromapsEXT( vkGetDeviceProcAddr( device, "vkBuildMicromapsEXT" ) );
|
|
|
23948 vkCopyMicromapEXT = PFN_vkCopyMicromapEXT( vkGetDeviceProcAddr( device, "vkCopyMicromapEXT" ) );
|
|
|
23949 vkCopyMicromapToMemoryEXT = PFN_vkCopyMicromapToMemoryEXT( vkGetDeviceProcAddr( device, "vkCopyMicromapToMemoryEXT" ) );
|
|
|
23950 vkCopyMemoryToMicromapEXT = PFN_vkCopyMemoryToMicromapEXT( vkGetDeviceProcAddr( device, "vkCopyMemoryToMicromapEXT" ) );
|
|
|
23951 vkWriteMicromapsPropertiesEXT = PFN_vkWriteMicromapsPropertiesEXT( vkGetDeviceProcAddr( device, "vkWriteMicromapsPropertiesEXT" ) );
|
|
|
23952 vkCmdCopyMicromapEXT = PFN_vkCmdCopyMicromapEXT( vkGetDeviceProcAddr( device, "vkCmdCopyMicromapEXT" ) );
|
|
|
23953 vkCmdCopyMicromapToMemoryEXT = PFN_vkCmdCopyMicromapToMemoryEXT( vkGetDeviceProcAddr( device, "vkCmdCopyMicromapToMemoryEXT" ) );
|
|
|
23954 vkCmdCopyMemoryToMicromapEXT = PFN_vkCmdCopyMemoryToMicromapEXT( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToMicromapEXT" ) );
|
|
|
23955 vkCmdWriteMicromapsPropertiesEXT = PFN_vkCmdWriteMicromapsPropertiesEXT( vkGetDeviceProcAddr( device, "vkCmdWriteMicromapsPropertiesEXT" ) );
|
|
|
23956 vkGetDeviceMicromapCompatibilityEXT = PFN_vkGetDeviceMicromapCompatibilityEXT( vkGetDeviceProcAddr( device, "vkGetDeviceMicromapCompatibilityEXT" ) );
|
|
|
23957 vkGetMicromapBuildSizesEXT = PFN_vkGetMicromapBuildSizesEXT( vkGetDeviceProcAddr( device, "vkGetMicromapBuildSizesEXT" ) );
|
|
|
23958
|
|
|
23959 //=== VK_HUAWEI_cluster_culling_shader ===
|
|
|
23960 vkCmdDrawClusterHUAWEI = PFN_vkCmdDrawClusterHUAWEI( vkGetDeviceProcAddr( device, "vkCmdDrawClusterHUAWEI" ) );
|
|
|
23961 vkCmdDrawClusterIndirectHUAWEI = PFN_vkCmdDrawClusterIndirectHUAWEI( vkGetDeviceProcAddr( device, "vkCmdDrawClusterIndirectHUAWEI" ) );
|
|
|
23962
|
|
|
23963 //=== VK_EXT_pageable_device_local_memory ===
|
|
|
23964 vkSetDeviceMemoryPriorityEXT = PFN_vkSetDeviceMemoryPriorityEXT( vkGetDeviceProcAddr( device, "vkSetDeviceMemoryPriorityEXT" ) );
|
|
|
23965
|
|
|
23966 //=== VK_KHR_maintenance4 ===
|
|
|
23967 vkGetDeviceBufferMemoryRequirementsKHR =
|
|
|
23968 PFN_vkGetDeviceBufferMemoryRequirementsKHR( vkGetDeviceProcAddr( device, "vkGetDeviceBufferMemoryRequirementsKHR" ) );
|
|
|
23969 if ( !vkGetDeviceBufferMemoryRequirements )
|
|
|
23970 vkGetDeviceBufferMemoryRequirements = vkGetDeviceBufferMemoryRequirementsKHR;
|
|
|
23971 vkGetDeviceImageMemoryRequirementsKHR =
|
|
|
23972 PFN_vkGetDeviceImageMemoryRequirementsKHR( vkGetDeviceProcAddr( device, "vkGetDeviceImageMemoryRequirementsKHR" ) );
|
|
|
23973 if ( !vkGetDeviceImageMemoryRequirements )
|
|
|
23974 vkGetDeviceImageMemoryRequirements = vkGetDeviceImageMemoryRequirementsKHR;
|
|
|
23975 vkGetDeviceImageSparseMemoryRequirementsKHR =
|
|
|
23976 PFN_vkGetDeviceImageSparseMemoryRequirementsKHR( vkGetDeviceProcAddr( device, "vkGetDeviceImageSparseMemoryRequirementsKHR" ) );
|
|
|
23977 if ( !vkGetDeviceImageSparseMemoryRequirements )
|
|
|
23978 vkGetDeviceImageSparseMemoryRequirements = vkGetDeviceImageSparseMemoryRequirementsKHR;
|
|
|
23979
|
|
|
23980 //=== VK_VALVE_descriptor_set_host_mapping ===
|
|
|
23981 vkGetDescriptorSetLayoutHostMappingInfoVALVE =
|
|
|
23982 PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutHostMappingInfoVALVE" ) );
|
|
|
23983 vkGetDescriptorSetHostMappingVALVE = PFN_vkGetDescriptorSetHostMappingVALVE( vkGetDeviceProcAddr( device, "vkGetDescriptorSetHostMappingVALVE" ) );
|
|
|
23984
|
|
|
23985 //=== VK_NV_copy_memory_indirect ===
|
|
|
23986 vkCmdCopyMemoryIndirectNV = PFN_vkCmdCopyMemoryIndirectNV( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryIndirectNV" ) );
|
|
|
23987 vkCmdCopyMemoryToImageIndirectNV = PFN_vkCmdCopyMemoryToImageIndirectNV( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToImageIndirectNV" ) );
|
|
|
23988
|
|
|
23989 //=== VK_NV_memory_decompression ===
|
|
|
23990 vkCmdDecompressMemoryNV = PFN_vkCmdDecompressMemoryNV( vkGetDeviceProcAddr( device, "vkCmdDecompressMemoryNV" ) );
|
|
|
23991 vkCmdDecompressMemoryIndirectCountNV =
|
|
|
23992 PFN_vkCmdDecompressMemoryIndirectCountNV( vkGetDeviceProcAddr( device, "vkCmdDecompressMemoryIndirectCountNV" ) );
|
|
|
23993
|
|
|
23994 //=== VK_NV_device_generated_commands_compute ===
|
|
|
23995 vkGetPipelineIndirectMemoryRequirementsNV =
|
|
|
23996 PFN_vkGetPipelineIndirectMemoryRequirementsNV( vkGetDeviceProcAddr( device, "vkGetPipelineIndirectMemoryRequirementsNV" ) );
|
|
|
23997 vkCmdUpdatePipelineIndirectBufferNV = PFN_vkCmdUpdatePipelineIndirectBufferNV( vkGetDeviceProcAddr( device, "vkCmdUpdatePipelineIndirectBufferNV" ) );
|
|
|
23998 vkGetPipelineIndirectDeviceAddressNV =
|
|
|
23999 PFN_vkGetPipelineIndirectDeviceAddressNV( vkGetDeviceProcAddr( device, "vkGetPipelineIndirectDeviceAddressNV" ) );
|
|
|
24000
|
|
|
24001 #if defined( VK_USE_PLATFORM_OHOS )
|
|
|
24002 //=== VK_OHOS_external_memory ===
|
|
|
24003 vkGetNativeBufferPropertiesOHOS = PFN_vkGetNativeBufferPropertiesOHOS( vkGetDeviceProcAddr( device, "vkGetNativeBufferPropertiesOHOS" ) );
|
|
|
24004 vkGetMemoryNativeBufferOHOS = PFN_vkGetMemoryNativeBufferOHOS( vkGetDeviceProcAddr( device, "vkGetMemoryNativeBufferOHOS" ) );
|
|
|
24005 #endif /*VK_USE_PLATFORM_OHOS*/
|
|
|
24006
|
|
|
24007 //=== VK_EXT_extended_dynamic_state3 ===
|
|
|
24008 vkCmdSetDepthClampEnableEXT = PFN_vkCmdSetDepthClampEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthClampEnableEXT" ) );
|
|
|
24009 vkCmdSetPolygonModeEXT = PFN_vkCmdSetPolygonModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetPolygonModeEXT" ) );
|
|
|
24010 vkCmdSetRasterizationSamplesEXT = PFN_vkCmdSetRasterizationSamplesEXT( vkGetDeviceProcAddr( device, "vkCmdSetRasterizationSamplesEXT" ) );
|
|
|
24011 vkCmdSetSampleMaskEXT = PFN_vkCmdSetSampleMaskEXT( vkGetDeviceProcAddr( device, "vkCmdSetSampleMaskEXT" ) );
|
|
|
24012 vkCmdSetAlphaToCoverageEnableEXT = PFN_vkCmdSetAlphaToCoverageEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetAlphaToCoverageEnableEXT" ) );
|
|
|
24013 vkCmdSetAlphaToOneEnableEXT = PFN_vkCmdSetAlphaToOneEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetAlphaToOneEnableEXT" ) );
|
|
|
24014 vkCmdSetLogicOpEnableEXT = PFN_vkCmdSetLogicOpEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetLogicOpEnableEXT" ) );
|
|
|
24015 vkCmdSetColorBlendEnableEXT = PFN_vkCmdSetColorBlendEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorBlendEnableEXT" ) );
|
|
|
24016 vkCmdSetColorBlendEquationEXT = PFN_vkCmdSetColorBlendEquationEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorBlendEquationEXT" ) );
|
|
|
24017 vkCmdSetColorWriteMaskEXT = PFN_vkCmdSetColorWriteMaskEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorWriteMaskEXT" ) );
|
|
|
24018 vkCmdSetTessellationDomainOriginEXT = PFN_vkCmdSetTessellationDomainOriginEXT( vkGetDeviceProcAddr( device, "vkCmdSetTessellationDomainOriginEXT" ) );
|
|
|
24019 vkCmdSetRasterizationStreamEXT = PFN_vkCmdSetRasterizationStreamEXT( vkGetDeviceProcAddr( device, "vkCmdSetRasterizationStreamEXT" ) );
|
|
|
24020 vkCmdSetConservativeRasterizationModeEXT =
|
|
|
24021 PFN_vkCmdSetConservativeRasterizationModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetConservativeRasterizationModeEXT" ) );
|
|
|
24022 vkCmdSetExtraPrimitiveOverestimationSizeEXT =
|
|
|
24023 PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT( vkGetDeviceProcAddr( device, "vkCmdSetExtraPrimitiveOverestimationSizeEXT" ) );
|
|
|
24024 vkCmdSetDepthClipEnableEXT = PFN_vkCmdSetDepthClipEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthClipEnableEXT" ) );
|
|
|
24025 vkCmdSetSampleLocationsEnableEXT = PFN_vkCmdSetSampleLocationsEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetSampleLocationsEnableEXT" ) );
|
|
|
24026 vkCmdSetColorBlendAdvancedEXT = PFN_vkCmdSetColorBlendAdvancedEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorBlendAdvancedEXT" ) );
|
|
|
24027 vkCmdSetProvokingVertexModeEXT = PFN_vkCmdSetProvokingVertexModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetProvokingVertexModeEXT" ) );
|
|
|
24028 vkCmdSetLineRasterizationModeEXT = PFN_vkCmdSetLineRasterizationModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetLineRasterizationModeEXT" ) );
|
|
|
24029 vkCmdSetLineStippleEnableEXT = PFN_vkCmdSetLineStippleEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetLineStippleEnableEXT" ) );
|
|
|
24030 vkCmdSetDepthClipNegativeOneToOneEXT =
|
|
|
24031 PFN_vkCmdSetDepthClipNegativeOneToOneEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthClipNegativeOneToOneEXT" ) );
|
|
|
24032 vkCmdSetViewportWScalingEnableNV = PFN_vkCmdSetViewportWScalingEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportWScalingEnableNV" ) );
|
|
|
24033 vkCmdSetViewportSwizzleNV = PFN_vkCmdSetViewportSwizzleNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportSwizzleNV" ) );
|
|
|
24034 vkCmdSetCoverageToColorEnableNV = PFN_vkCmdSetCoverageToColorEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageToColorEnableNV" ) );
|
|
|
24035 vkCmdSetCoverageToColorLocationNV = PFN_vkCmdSetCoverageToColorLocationNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageToColorLocationNV" ) );
|
|
|
24036 vkCmdSetCoverageModulationModeNV = PFN_vkCmdSetCoverageModulationModeNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageModulationModeNV" ) );
|
|
|
24037 vkCmdSetCoverageModulationTableEnableNV =
|
|
|
24038 PFN_vkCmdSetCoverageModulationTableEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageModulationTableEnableNV" ) );
|
|
|
24039 vkCmdSetCoverageModulationTableNV = PFN_vkCmdSetCoverageModulationTableNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageModulationTableNV" ) );
|
|
|
24040 vkCmdSetShadingRateImageEnableNV = PFN_vkCmdSetShadingRateImageEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetShadingRateImageEnableNV" ) );
|
|
|
24041 vkCmdSetRepresentativeFragmentTestEnableNV =
|
|
|
24042 PFN_vkCmdSetRepresentativeFragmentTestEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetRepresentativeFragmentTestEnableNV" ) );
|
|
|
24043 vkCmdSetCoverageReductionModeNV = PFN_vkCmdSetCoverageReductionModeNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageReductionModeNV" ) );
|
|
|
24044
|
|
|
24045 //=== VK_ARM_tensors ===
|
|
|
24046 vkCreateTensorARM = PFN_vkCreateTensorARM( vkGetDeviceProcAddr( device, "vkCreateTensorARM" ) );
|
|
|
24047 vkDestroyTensorARM = PFN_vkDestroyTensorARM( vkGetDeviceProcAddr( device, "vkDestroyTensorARM" ) );
|
|
|
24048 vkCreateTensorViewARM = PFN_vkCreateTensorViewARM( vkGetDeviceProcAddr( device, "vkCreateTensorViewARM" ) );
|
|
|
24049 vkDestroyTensorViewARM = PFN_vkDestroyTensorViewARM( vkGetDeviceProcAddr( device, "vkDestroyTensorViewARM" ) );
|
|
|
24050 vkGetTensorMemoryRequirementsARM = PFN_vkGetTensorMemoryRequirementsARM( vkGetDeviceProcAddr( device, "vkGetTensorMemoryRequirementsARM" ) );
|
|
|
24051 vkBindTensorMemoryARM = PFN_vkBindTensorMemoryARM( vkGetDeviceProcAddr( device, "vkBindTensorMemoryARM" ) );
|
|
|
24052 vkGetDeviceTensorMemoryRequirementsARM =
|
|
|
24053 PFN_vkGetDeviceTensorMemoryRequirementsARM( vkGetDeviceProcAddr( device, "vkGetDeviceTensorMemoryRequirementsARM" ) );
|
|
|
24054 vkCmdCopyTensorARM = PFN_vkCmdCopyTensorARM( vkGetDeviceProcAddr( device, "vkCmdCopyTensorARM" ) );
|
|
|
24055 vkGetTensorOpaqueCaptureDescriptorDataARM =
|
|
|
24056 PFN_vkGetTensorOpaqueCaptureDescriptorDataARM( vkGetDeviceProcAddr( device, "vkGetTensorOpaqueCaptureDescriptorDataARM" ) );
|
|
|
24057 vkGetTensorViewOpaqueCaptureDescriptorDataARM =
|
|
|
24058 PFN_vkGetTensorViewOpaqueCaptureDescriptorDataARM( vkGetDeviceProcAddr( device, "vkGetTensorViewOpaqueCaptureDescriptorDataARM" ) );
|
|
|
24059
|
|
|
24060 //=== VK_EXT_shader_module_identifier ===
|
|
|
24061 vkGetShaderModuleIdentifierEXT = PFN_vkGetShaderModuleIdentifierEXT( vkGetDeviceProcAddr( device, "vkGetShaderModuleIdentifierEXT" ) );
|
|
|
24062 vkGetShaderModuleCreateInfoIdentifierEXT =
|
|
|
24063 PFN_vkGetShaderModuleCreateInfoIdentifierEXT( vkGetDeviceProcAddr( device, "vkGetShaderModuleCreateInfoIdentifierEXT" ) );
|
|
|
24064
|
|
|
24065 //=== VK_NV_optical_flow ===
|
|
|
24066 vkCreateOpticalFlowSessionNV = PFN_vkCreateOpticalFlowSessionNV( vkGetDeviceProcAddr( device, "vkCreateOpticalFlowSessionNV" ) );
|
|
|
24067 vkDestroyOpticalFlowSessionNV = PFN_vkDestroyOpticalFlowSessionNV( vkGetDeviceProcAddr( device, "vkDestroyOpticalFlowSessionNV" ) );
|
|
|
24068 vkBindOpticalFlowSessionImageNV = PFN_vkBindOpticalFlowSessionImageNV( vkGetDeviceProcAddr( device, "vkBindOpticalFlowSessionImageNV" ) );
|
|
|
24069 vkCmdOpticalFlowExecuteNV = PFN_vkCmdOpticalFlowExecuteNV( vkGetDeviceProcAddr( device, "vkCmdOpticalFlowExecuteNV" ) );
|
|
|
24070
|
|
|
24071 //=== VK_KHR_maintenance5 ===
|
|
|
24072 vkCmdBindIndexBuffer2KHR = PFN_vkCmdBindIndexBuffer2KHR( vkGetDeviceProcAddr( device, "vkCmdBindIndexBuffer2KHR" ) );
|
|
|
24073 if ( !vkCmdBindIndexBuffer2 )
|
|
|
24074 vkCmdBindIndexBuffer2 = vkCmdBindIndexBuffer2KHR;
|
|
|
24075 vkGetRenderingAreaGranularityKHR = PFN_vkGetRenderingAreaGranularityKHR( vkGetDeviceProcAddr( device, "vkGetRenderingAreaGranularityKHR" ) );
|
|
|
24076 if ( !vkGetRenderingAreaGranularity )
|
|
|
24077 vkGetRenderingAreaGranularity = vkGetRenderingAreaGranularityKHR;
|
|
|
24078 vkGetDeviceImageSubresourceLayoutKHR =
|
|
|
24079 PFN_vkGetDeviceImageSubresourceLayoutKHR( vkGetDeviceProcAddr( device, "vkGetDeviceImageSubresourceLayoutKHR" ) );
|
|
|
24080 if ( !vkGetDeviceImageSubresourceLayout )
|
|
|
24081 vkGetDeviceImageSubresourceLayout = vkGetDeviceImageSubresourceLayoutKHR;
|
|
|
24082 vkGetImageSubresourceLayout2KHR = PFN_vkGetImageSubresourceLayout2KHR( vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout2KHR" ) );
|
|
|
24083 if ( !vkGetImageSubresourceLayout2 )
|
|
|
24084 vkGetImageSubresourceLayout2 = vkGetImageSubresourceLayout2KHR;
|
|
|
24085
|
|
|
24086 //=== VK_AMD_anti_lag ===
|
|
|
24087 vkAntiLagUpdateAMD = PFN_vkAntiLagUpdateAMD( vkGetDeviceProcAddr( device, "vkAntiLagUpdateAMD" ) );
|
|
|
24088
|
|
|
24089 //=== VK_KHR_present_wait2 ===
|
|
|
24090 vkWaitForPresent2KHR = PFN_vkWaitForPresent2KHR( vkGetDeviceProcAddr( device, "vkWaitForPresent2KHR" ) );
|
|
|
24091
|
|
|
24092 //=== VK_EXT_shader_object ===
|
|
|
24093 vkCreateShadersEXT = PFN_vkCreateShadersEXT( vkGetDeviceProcAddr( device, "vkCreateShadersEXT" ) );
|
|
|
24094 vkDestroyShaderEXT = PFN_vkDestroyShaderEXT( vkGetDeviceProcAddr( device, "vkDestroyShaderEXT" ) );
|
|
|
24095 vkGetShaderBinaryDataEXT = PFN_vkGetShaderBinaryDataEXT( vkGetDeviceProcAddr( device, "vkGetShaderBinaryDataEXT" ) );
|
|
|
24096 vkCmdBindShadersEXT = PFN_vkCmdBindShadersEXT( vkGetDeviceProcAddr( device, "vkCmdBindShadersEXT" ) );
|
|
|
24097 vkCmdSetDepthClampRangeEXT = PFN_vkCmdSetDepthClampRangeEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthClampRangeEXT" ) );
|
|
|
24098
|
|
|
24099 //=== VK_KHR_pipeline_binary ===
|
|
|
24100 vkCreatePipelineBinariesKHR = PFN_vkCreatePipelineBinariesKHR( vkGetDeviceProcAddr( device, "vkCreatePipelineBinariesKHR" ) );
|
|
|
24101 vkDestroyPipelineBinaryKHR = PFN_vkDestroyPipelineBinaryKHR( vkGetDeviceProcAddr( device, "vkDestroyPipelineBinaryKHR" ) );
|
|
|
24102 vkGetPipelineKeyKHR = PFN_vkGetPipelineKeyKHR( vkGetDeviceProcAddr( device, "vkGetPipelineKeyKHR" ) );
|
|
|
24103 vkGetPipelineBinaryDataKHR = PFN_vkGetPipelineBinaryDataKHR( vkGetDeviceProcAddr( device, "vkGetPipelineBinaryDataKHR" ) );
|
|
|
24104 vkReleaseCapturedPipelineDataKHR = PFN_vkReleaseCapturedPipelineDataKHR( vkGetDeviceProcAddr( device, "vkReleaseCapturedPipelineDataKHR" ) );
|
|
|
24105
|
|
|
24106 //=== VK_QCOM_tile_properties ===
|
|
|
24107 vkGetFramebufferTilePropertiesQCOM = PFN_vkGetFramebufferTilePropertiesQCOM( vkGetDeviceProcAddr( device, "vkGetFramebufferTilePropertiesQCOM" ) );
|
|
|
24108 vkGetDynamicRenderingTilePropertiesQCOM =
|
|
|
24109 PFN_vkGetDynamicRenderingTilePropertiesQCOM( vkGetDeviceProcAddr( device, "vkGetDynamicRenderingTilePropertiesQCOM" ) );
|
|
|
24110
|
|
|
24111 //=== VK_KHR_swapchain_maintenance1 ===
|
|
|
24112 vkReleaseSwapchainImagesKHR = PFN_vkReleaseSwapchainImagesKHR( vkGetDeviceProcAddr( device, "vkReleaseSwapchainImagesKHR" ) );
|
|
|
24113
|
|
|
24114 //=== VK_NV_cooperative_vector ===
|
|
|
24115 vkConvertCooperativeVectorMatrixNV = PFN_vkConvertCooperativeVectorMatrixNV( vkGetDeviceProcAddr( device, "vkConvertCooperativeVectorMatrixNV" ) );
|
|
|
24116 vkCmdConvertCooperativeVectorMatrixNV =
|
|
|
24117 PFN_vkCmdConvertCooperativeVectorMatrixNV( vkGetDeviceProcAddr( device, "vkCmdConvertCooperativeVectorMatrixNV" ) );
|
|
|
24118
|
|
|
24119 //=== VK_NV_low_latency2 ===
|
|
|
24120 vkSetLatencySleepModeNV = PFN_vkSetLatencySleepModeNV( vkGetDeviceProcAddr( device, "vkSetLatencySleepModeNV" ) );
|
|
|
24121 vkLatencySleepNV = PFN_vkLatencySleepNV( vkGetDeviceProcAddr( device, "vkLatencySleepNV" ) );
|
|
|
24122 vkSetLatencyMarkerNV = PFN_vkSetLatencyMarkerNV( vkGetDeviceProcAddr( device, "vkSetLatencyMarkerNV" ) );
|
|
|
24123 vkGetLatencyTimingsNV = PFN_vkGetLatencyTimingsNV( vkGetDeviceProcAddr( device, "vkGetLatencyTimingsNV" ) );
|
|
|
24124 vkQueueNotifyOutOfBandNV = PFN_vkQueueNotifyOutOfBandNV( vkGetDeviceProcAddr( device, "vkQueueNotifyOutOfBandNV" ) );
|
|
|
24125
|
|
|
24126 //=== VK_ARM_data_graph ===
|
|
|
24127 vkCreateDataGraphPipelinesARM = PFN_vkCreateDataGraphPipelinesARM( vkGetDeviceProcAddr( device, "vkCreateDataGraphPipelinesARM" ) );
|
|
|
24128 vkCreateDataGraphPipelineSessionARM = PFN_vkCreateDataGraphPipelineSessionARM( vkGetDeviceProcAddr( device, "vkCreateDataGraphPipelineSessionARM" ) );
|
|
|
24129 vkGetDataGraphPipelineSessionBindPointRequirementsARM =
|
|
|
24130 PFN_vkGetDataGraphPipelineSessionBindPointRequirementsARM( vkGetDeviceProcAddr( device, "vkGetDataGraphPipelineSessionBindPointRequirementsARM" ) );
|
|
|
24131 vkGetDataGraphPipelineSessionMemoryRequirementsARM =
|
|
|
24132 PFN_vkGetDataGraphPipelineSessionMemoryRequirementsARM( vkGetDeviceProcAddr( device, "vkGetDataGraphPipelineSessionMemoryRequirementsARM" ) );
|
|
|
24133 vkBindDataGraphPipelineSessionMemoryARM =
|
|
|
24134 PFN_vkBindDataGraphPipelineSessionMemoryARM( vkGetDeviceProcAddr( device, "vkBindDataGraphPipelineSessionMemoryARM" ) );
|
|
|
24135 vkDestroyDataGraphPipelineSessionARM =
|
|
|
24136 PFN_vkDestroyDataGraphPipelineSessionARM( vkGetDeviceProcAddr( device, "vkDestroyDataGraphPipelineSessionARM" ) );
|
|
|
24137 vkCmdDispatchDataGraphARM = PFN_vkCmdDispatchDataGraphARM( vkGetDeviceProcAddr( device, "vkCmdDispatchDataGraphARM" ) );
|
|
|
24138 vkGetDataGraphPipelineAvailablePropertiesARM =
|
|
|
24139 PFN_vkGetDataGraphPipelineAvailablePropertiesARM( vkGetDeviceProcAddr( device, "vkGetDataGraphPipelineAvailablePropertiesARM" ) );
|
|
|
24140 vkGetDataGraphPipelinePropertiesARM = PFN_vkGetDataGraphPipelinePropertiesARM( vkGetDeviceProcAddr( device, "vkGetDataGraphPipelinePropertiesARM" ) );
|
|
|
24141
|
|
|
24142 //=== VK_EXT_attachment_feedback_loop_dynamic_state ===
|
|
|
24143 vkCmdSetAttachmentFeedbackLoopEnableEXT =
|
|
|
24144 PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetAttachmentFeedbackLoopEnableEXT" ) );
|
|
|
24145
|
|
|
24146 #if defined( VK_USE_PLATFORM_SCREEN_QNX )
|
|
|
24147 //=== VK_QNX_external_memory_screen_buffer ===
|
|
|
24148 vkGetScreenBufferPropertiesQNX = PFN_vkGetScreenBufferPropertiesQNX( vkGetDeviceProcAddr( device, "vkGetScreenBufferPropertiesQNX" ) );
|
|
|
24149 #endif /*VK_USE_PLATFORM_SCREEN_QNX*/
|
|
|
24150
|
|
|
24151 //=== VK_KHR_line_rasterization ===
|
|
|
24152 vkCmdSetLineStippleKHR = PFN_vkCmdSetLineStippleKHR( vkGetDeviceProcAddr( device, "vkCmdSetLineStippleKHR" ) );
|
|
|
24153 if ( !vkCmdSetLineStipple )
|
|
|
24154 vkCmdSetLineStipple = vkCmdSetLineStippleKHR;
|
|
|
24155
|
|
|
24156 //=== VK_KHR_calibrated_timestamps ===
|
|
|
24157 vkGetCalibratedTimestampsKHR = PFN_vkGetCalibratedTimestampsKHR( vkGetDeviceProcAddr( device, "vkGetCalibratedTimestampsKHR" ) );
|
|
|
24158
|
|
|
24159 //=== VK_KHR_maintenance6 ===
|
|
|
24160 vkCmdBindDescriptorSets2KHR = PFN_vkCmdBindDescriptorSets2KHR( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorSets2KHR" ) );
|
|
|
24161 if ( !vkCmdBindDescriptorSets2 )
|
|
|
24162 vkCmdBindDescriptorSets2 = vkCmdBindDescriptorSets2KHR;
|
|
|
24163 vkCmdPushConstants2KHR = PFN_vkCmdPushConstants2KHR( vkGetDeviceProcAddr( device, "vkCmdPushConstants2KHR" ) );
|
|
|
24164 if ( !vkCmdPushConstants2 )
|
|
|
24165 vkCmdPushConstants2 = vkCmdPushConstants2KHR;
|
|
|
24166 vkCmdPushDescriptorSet2KHR = PFN_vkCmdPushDescriptorSet2KHR( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSet2KHR" ) );
|
|
|
24167 if ( !vkCmdPushDescriptorSet2 )
|
|
|
24168 vkCmdPushDescriptorSet2 = vkCmdPushDescriptorSet2KHR;
|
|
|
24169 vkCmdPushDescriptorSetWithTemplate2KHR =
|
|
|
24170 PFN_vkCmdPushDescriptorSetWithTemplate2KHR( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetWithTemplate2KHR" ) );
|
|
|
24171 if ( !vkCmdPushDescriptorSetWithTemplate2 )
|
|
|
24172 vkCmdPushDescriptorSetWithTemplate2 = vkCmdPushDescriptorSetWithTemplate2KHR;
|
|
|
24173 vkCmdSetDescriptorBufferOffsets2EXT = PFN_vkCmdSetDescriptorBufferOffsets2EXT( vkGetDeviceProcAddr( device, "vkCmdSetDescriptorBufferOffsets2EXT" ) );
|
|
|
24174 vkCmdBindDescriptorBufferEmbeddedSamplers2EXT =
|
|
|
24175 PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorBufferEmbeddedSamplers2EXT" ) );
|
|
|
24176
|
|
|
24177 //=== VK_QCOM_tile_memory_heap ===
|
|
|
24178 vkCmdBindTileMemoryQCOM = PFN_vkCmdBindTileMemoryQCOM( vkGetDeviceProcAddr( device, "vkCmdBindTileMemoryQCOM" ) );
|
|
|
24179
|
|
|
24180 //=== VK_KHR_copy_memory_indirect ===
|
|
|
24181 vkCmdCopyMemoryIndirectKHR = PFN_vkCmdCopyMemoryIndirectKHR( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryIndirectKHR" ) );
|
|
|
24182 vkCmdCopyMemoryToImageIndirectKHR = PFN_vkCmdCopyMemoryToImageIndirectKHR( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToImageIndirectKHR" ) );
|
|
|
24183
|
|
|
24184 //=== VK_EXT_memory_decompression ===
|
|
|
24185 vkCmdDecompressMemoryEXT = PFN_vkCmdDecompressMemoryEXT( vkGetDeviceProcAddr( device, "vkCmdDecompressMemoryEXT" ) );
|
|
|
24186 vkCmdDecompressMemoryIndirectCountEXT =
|
|
|
24187 PFN_vkCmdDecompressMemoryIndirectCountEXT( vkGetDeviceProcAddr( device, "vkCmdDecompressMemoryIndirectCountEXT" ) );
|
|
|
24188
|
|
|
24189 //=== VK_NV_external_compute_queue ===
|
|
|
24190 vkCreateExternalComputeQueueNV = PFN_vkCreateExternalComputeQueueNV( vkGetDeviceProcAddr( device, "vkCreateExternalComputeQueueNV" ) );
|
|
|
24191 vkDestroyExternalComputeQueueNV = PFN_vkDestroyExternalComputeQueueNV( vkGetDeviceProcAddr( device, "vkDestroyExternalComputeQueueNV" ) );
|
|
|
24192 vkGetExternalComputeQueueDataNV = PFN_vkGetExternalComputeQueueDataNV( vkGetDeviceProcAddr( device, "vkGetExternalComputeQueueDataNV" ) );
|
|
|
24193
|
|
|
24194 //=== VK_NV_cluster_acceleration_structure ===
|
|
|
24195 vkGetClusterAccelerationStructureBuildSizesNV =
|
|
|
24196 PFN_vkGetClusterAccelerationStructureBuildSizesNV( vkGetDeviceProcAddr( device, "vkGetClusterAccelerationStructureBuildSizesNV" ) );
|
|
|
24197 vkCmdBuildClusterAccelerationStructureIndirectNV =
|
|
|
24198 PFN_vkCmdBuildClusterAccelerationStructureIndirectNV( vkGetDeviceProcAddr( device, "vkCmdBuildClusterAccelerationStructureIndirectNV" ) );
|
|
|
24199
|
|
|
24200 //=== VK_NV_partitioned_acceleration_structure ===
|
|
|
24201 vkGetPartitionedAccelerationStructuresBuildSizesNV =
|
|
|
24202 PFN_vkGetPartitionedAccelerationStructuresBuildSizesNV( vkGetDeviceProcAddr( device, "vkGetPartitionedAccelerationStructuresBuildSizesNV" ) );
|
|
|
24203 vkCmdBuildPartitionedAccelerationStructuresNV =
|
|
|
24204 PFN_vkCmdBuildPartitionedAccelerationStructuresNV( vkGetDeviceProcAddr( device, "vkCmdBuildPartitionedAccelerationStructuresNV" ) );
|
|
|
24205
|
|
|
24206 //=== VK_EXT_device_generated_commands ===
|
|
|
24207 vkGetGeneratedCommandsMemoryRequirementsEXT =
|
|
|
24208 PFN_vkGetGeneratedCommandsMemoryRequirementsEXT( vkGetDeviceProcAddr( device, "vkGetGeneratedCommandsMemoryRequirementsEXT" ) );
|
|
|
24209 vkCmdPreprocessGeneratedCommandsEXT = PFN_vkCmdPreprocessGeneratedCommandsEXT( vkGetDeviceProcAddr( device, "vkCmdPreprocessGeneratedCommandsEXT" ) );
|
|
|
24210 vkCmdExecuteGeneratedCommandsEXT = PFN_vkCmdExecuteGeneratedCommandsEXT( vkGetDeviceProcAddr( device, "vkCmdExecuteGeneratedCommandsEXT" ) );
|
|
|
24211 vkCreateIndirectCommandsLayoutEXT = PFN_vkCreateIndirectCommandsLayoutEXT( vkGetDeviceProcAddr( device, "vkCreateIndirectCommandsLayoutEXT" ) );
|
|
|
24212 vkDestroyIndirectCommandsLayoutEXT = PFN_vkDestroyIndirectCommandsLayoutEXT( vkGetDeviceProcAddr( device, "vkDestroyIndirectCommandsLayoutEXT" ) );
|
|
|
24213 vkCreateIndirectExecutionSetEXT = PFN_vkCreateIndirectExecutionSetEXT( vkGetDeviceProcAddr( device, "vkCreateIndirectExecutionSetEXT" ) );
|
|
|
24214 vkDestroyIndirectExecutionSetEXT = PFN_vkDestroyIndirectExecutionSetEXT( vkGetDeviceProcAddr( device, "vkDestroyIndirectExecutionSetEXT" ) );
|
|
|
24215 vkUpdateIndirectExecutionSetPipelineEXT =
|
|
|
24216 PFN_vkUpdateIndirectExecutionSetPipelineEXT( vkGetDeviceProcAddr( device, "vkUpdateIndirectExecutionSetPipelineEXT" ) );
|
|
|
24217 vkUpdateIndirectExecutionSetShaderEXT =
|
|
|
24218 PFN_vkUpdateIndirectExecutionSetShaderEXT( vkGetDeviceProcAddr( device, "vkUpdateIndirectExecutionSetShaderEXT" ) );
|
|
|
24219
|
|
|
24220 #if defined( VK_USE_PLATFORM_OHOS )
|
|
|
24221 //=== VK_OHOS_native_buffer ===
|
|
|
24222 vkGetSwapchainGrallocUsageOHOS = PFN_vkGetSwapchainGrallocUsageOHOS( vkGetDeviceProcAddr( device, "vkGetSwapchainGrallocUsageOHOS" ) );
|
|
|
24223 vkAcquireImageOHOS = PFN_vkAcquireImageOHOS( vkGetDeviceProcAddr( device, "vkAcquireImageOHOS" ) );
|
|
|
24224 vkQueueSignalReleaseImageOHOS = PFN_vkQueueSignalReleaseImageOHOS( vkGetDeviceProcAddr( device, "vkQueueSignalReleaseImageOHOS" ) );
|
|
|
24225 #endif /*VK_USE_PLATFORM_OHOS*/
|
|
|
24226
|
|
|
24227 #if defined( VK_USE_PLATFORM_METAL_EXT )
|
|
|
24228 //=== VK_EXT_external_memory_metal ===
|
|
|
24229 vkGetMemoryMetalHandleEXT = PFN_vkGetMemoryMetalHandleEXT( vkGetDeviceProcAddr( device, "vkGetMemoryMetalHandleEXT" ) );
|
|
|
24230 vkGetMemoryMetalHandlePropertiesEXT = PFN_vkGetMemoryMetalHandlePropertiesEXT( vkGetDeviceProcAddr( device, "vkGetMemoryMetalHandlePropertiesEXT" ) );
|
|
|
24231 #endif /*VK_USE_PLATFORM_METAL_EXT*/
|
|
|
24232
|
|
|
24233 //=== VK_EXT_fragment_density_map_offset ===
|
|
|
24234 vkCmdEndRendering2EXT = PFN_vkCmdEndRendering2EXT( vkGetDeviceProcAddr( device, "vkCmdEndRendering2EXT" ) );
|
|
|
24235 if ( !vkCmdEndRendering2KHR )
|
|
|
24236 vkCmdEndRendering2KHR = vkCmdEndRendering2EXT;
|
|
|
24237
|
|
|
24238 //=== VK_EXT_custom_resolve ===
|
|
|
24239 vkCmdBeginCustomResolveEXT = PFN_vkCmdBeginCustomResolveEXT( vkGetDeviceProcAddr( device, "vkCmdBeginCustomResolveEXT" ) );
|
|
|
24240
|
|
|
24241 //=== VK_KHR_maintenance10 ===
|
|
|
24242 vkCmdEndRendering2KHR = PFN_vkCmdEndRendering2KHR( vkGetDeviceProcAddr( device, "vkCmdEndRendering2KHR" ) );
|
|
|
24243 }
|
|
|
24244
|
|
|
24245 template <typename DynamicLoader>
|
|
|
24246 void init( Instance const & instance, Device const & device, DynamicLoader const & dl ) VULKAN_HPP_NOEXCEPT
|
|
|
24247 {
|
|
|
24248 PFN_vkGetInstanceProcAddr getInstanceProcAddr = dl.template getProcAddress<PFN_vkGetInstanceProcAddr>( "vkGetInstanceProcAddr" );
|
|
|
24249 PFN_vkGetDeviceProcAddr getDeviceProcAddr = dl.template getProcAddress<PFN_vkGetDeviceProcAddr>( "vkGetDeviceProcAddr" );
|
|
|
24250 init( static_cast<VkInstance>( instance ), getInstanceProcAddr, static_cast<VkDevice>( device ), device ? getDeviceProcAddr : nullptr );
|
|
|
24251 }
|
|
|
24252
|
|
|
24253 template <typename DynamicLoader
|
|
|
24254 #if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
|
|
|
24255 = VULKAN_HPP_NAMESPACE::detail::DynamicLoader
|
|
|
24256 #endif
|
|
|
24257 >
|
|
|
24258 void init( Instance const & instance, Device const & device ) VULKAN_HPP_NOEXCEPT
|
|
|
24259 {
|
|
|
24260 static DynamicLoader dl;
|
|
|
24261 init( instance, device, dl );
|
|
|
24262 }
|
|
|
24263 };
|
|
|
24264
|
|
|
24265 template <>
|
|
|
24266 struct isDispatchLoader<DispatchLoaderDynamic>
|
|
|
24267 {
|
|
|
24268 static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true;
|
|
|
24269 };
|
|
|
24270
|
|
|
24271 } // namespace detail
|
|
|
24272 } // namespace VULKAN_HPP_NAMESPACE
|
|
|
24273 #endif
|