SDL 2.0
vulkan.hpp
Go to the documentation of this file.
1// Copyright (c) 2015-2018 The Khronos Group Inc.
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14//
15// ---- Exceptions to the Apache 2.0 License: ----
16//
17// As an exception, if you use this Software to generate code and portions of
18// this Software are embedded into the generated code as a result, you may
19// redistribute such product without providing attribution as would otherwise
20// be required by Sections 4(a), 4(b) and 4(d) of the License.
21//
22// In addition, if you combine or link code generated by this Software with
23// software that is licensed under the GPLv2 or the LGPL v2.0 or 2.1
24// ("`Combined Software`") and if a court of competent jurisdiction determines
25// that the patent provision (Section 3), the indemnity provision (Section 9)
26// or other Section of the License conflicts with the conditions of the
27// applicable GPL or LGPL license, you may retroactively and prospectively
28// choose to deem waived or otherwise exclude such Section(s) of the License,
29// but only in their entirety and only with respect to the Combined Software.
30//
31
32// This header is generated from the Khronos Vulkan XML API Registry.
33
34#ifndef VULKAN_HPP
35#define VULKAN_HPP
36
37#include <algorithm>
38#include <array>
39#include <cstddef>
40#include <cstdint>
41#include <cstring>
42#include <initializer_list>
43#include <string>
44#include <system_error>
45#include <tuple>
46#include <type_traits>
47#include <vulkan/vulkan.h>
48#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
49# include <memory>
50# include <vector>
51#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
52#if !defined(VULKAN_HPP_ASSERT)
53# include <cassert>
54# define VULKAN_HPP_ASSERT assert
55#endif
56
57// <tuple> includes <sys/sysmacros.h> through some other header
58// this results in major(x) being resolved to gnu_dev_major(x)
59// which is an expression in a constructor initializer list.
60#if defined(major)
61 #undef major
62#endif
63#if defined(minor)
64 #undef minor
65#endif
66
67// Windows defines MemoryBarrier which is deprecated and collides
68// with the vk::MemoryBarrier struct.
69#ifdef MemoryBarrier
70 #undef MemoryBarrier
71#endif
72
73static_assert( VK_HEADER_VERSION == 91 , "Wrong VK_HEADER_VERSION!" );
74
75// 32-bit vulkan is not typesafe for handles, so don't allow copy constructors on this platform by default.
76// To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION
77#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
78# if !defined( VULKAN_HPP_TYPESAFE_CONVERSION )
79# define VULKAN_HPP_TYPESAFE_CONVERSION
80# endif
81#endif
82
83#if !defined(VULKAN_HPP_HAS_UNRESTRICTED_UNIONS)
84# if defined(__clang__)
85# if __has_feature(cxx_unrestricted_unions)
86# define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
87# endif
88# elif defined(__GNUC__)
89# define GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
90# if 40600 <= GCC_VERSION
91# define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
92# endif
93# elif defined(_MSC_VER)
94# if 1900 <= _MSC_VER
95# define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
96# endif
97# endif
98#endif
99
100#if !defined(VULKAN_HPP_INLINE)
101# if defined(__clang___)
102# if __has_attribute(always_inline)
103# define VULKAN_HPP_INLINE __attribute__((always_inline)) __inline__
104# else
105# define VULKAN_HPP_INLINE inline
106# endif
107# elif defined(__GNUC__)
108# define VULKAN_HPP_INLINE __attribute__((always_inline)) __inline__
109# elif defined(_MSC_VER)
110# define VULKAN_HPP_INLINE inline
111# else
112# define VULKAN_HPP_INLINE inline
113# endif
114#endif
115
116#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
117# define VULKAN_HPP_TYPESAFE_EXPLICIT
118#else
119# define VULKAN_HPP_TYPESAFE_EXPLICIT explicit
120#endif
121
122#if defined(_MSC_VER) && (_MSC_VER <= 1800)
123# define VULKAN_HPP_CONSTEXPR
124#else
125# define VULKAN_HPP_CONSTEXPR constexpr
126#endif
127
128
129#if !defined(VULKAN_HPP_NAMESPACE)
130#define VULKAN_HPP_NAMESPACE vk
131#endif
132
133#define VULKAN_HPP_STRINGIFY2(text) #text
134#define VULKAN_HPP_STRINGIFY(text) VULKAN_HPP_STRINGIFY2(text)
135#define VULKAN_HPP_NAMESPACE_STRING VULKAN_HPP_STRINGIFY(VULKAN_HPP_NAMESPACE)
136
138{
139
140 template <typename FlagBitsType> struct FlagTraits
141 {
142 enum { allFlags = 0 };
143 };
144
145 template <typename BitType, typename MaskType = VkFlags>
146 class Flags
147 {
148 public:
150 : m_mask(0)
151 {
152 }
153
154 Flags(BitType bit)
155 : m_mask(static_cast<MaskType>(bit))
156 {
157 }
158
160 : m_mask(rhs.m_mask)
161 {
162 }
163
164 explicit Flags(MaskType flags)
165 : m_mask(flags)
166 {
167 }
168
170 {
171 m_mask = rhs.m_mask;
172 return *this;
173 }
174
176 {
177 m_mask |= rhs.m_mask;
178 return *this;
179 }
180
182 {
183 m_mask &= rhs.m_mask;
184 return *this;
185 }
186
188 {
189 m_mask ^= rhs.m_mask;
190 return *this;
191 }
192
194 {
195 Flags<BitType> result(*this);
196 result |= rhs;
197 return result;
198 }
199
201 {
202 Flags<BitType> result(*this);
203 result &= rhs;
204 return result;
205 }
206
208 {
209 Flags<BitType> result(*this);
210 result ^= rhs;
211 return result;
212 }
213
214 bool operator!() const
215 {
216 return !m_mask;
217 }
218
220 {
221 Flags<BitType> result(*this);
223 return result;
224 }
225
226 bool operator==(Flags<BitType> const& rhs) const
227 {
228 return m_mask == rhs.m_mask;
229 }
230
231 bool operator!=(Flags<BitType> const& rhs) const
232 {
233 return m_mask != rhs.m_mask;
234 }
235
236 explicit operator bool() const
237 {
238 return !!m_mask;
239 }
240
241 explicit operator MaskType() const
242 {
243 return m_mask;
244 }
245
246 private:
247 MaskType m_mask;
248 };
249
250 template <typename BitType>
252 {
253 return flags | bit;
254 }
255
256 template <typename BitType>
258 {
259 return flags & bit;
260 }
261
262 template <typename BitType>
264 {
265 return flags ^ bit;
266 }
267
268
269 template <typename RefType>
271 {
272 public:
274 Optional(RefType * ptr) { m_ptr = ptr; }
275 Optional(std::nullptr_t) { m_ptr = nullptr; }
276
277 operator RefType*() const { return m_ptr; }
278 RefType const* operator->() const { return m_ptr; }
279 explicit operator bool() const { return !!m_ptr; }
280
281 private:
282 RefType *m_ptr;
283 };
284
285#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
286 template <typename T>
288 {
289 public:
291 : m_count(0)
292 , m_ptr(nullptr)
293 {}
294
296 : m_count(1)
297 , m_ptr(&ptr)
298 {}
299
301 : m_count(count)
302 , m_ptr(ptr)
303 {}
304
305 template <size_t N>
307 : m_count(N)
308 , m_ptr(data.data())
309 {}
310
311 template <size_t N>
313 : m_count(N)
314 , m_ptr(data.data())
315 {}
316
318 ArrayProxy(std::vector<typename std::remove_const<T>::type, Allocator> & data)
319 : m_count(static_cast<uint32_t>(data.size()))
320 , m_ptr(data.data())
321 {}
322
324 ArrayProxy(std::vector<typename std::remove_const<T>::type, Allocator> const& data)
325 : m_count(static_cast<uint32_t>(data.size()))
326 , m_ptr(data.data())
327 {}
328
329 ArrayProxy(std::initializer_list<T> const& data)
330 : m_count(static_cast<uint32_t>(data.end() - data.begin()))
331 , m_ptr(data.begin())
332 {}
333
334 const T * begin() const
335 {
336 return m_ptr;
337 }
338
339 const T * end() const
340 {
341 return m_ptr + m_count;
342 }
343
344 const T & front() const
345 {
347 return *m_ptr;
348 }
349
350 const T & back() const
351 {
353 return *(m_ptr + m_count - 1);
354 }
355
356 bool empty() const
357 {
358 return (m_count == 0);
359 }
360
362 {
363 return m_count;
364 }
365
366 T * data() const
367 {
368 return m_ptr;
369 }
370
371 private:
374 };
375#endif
376
377#ifndef VULKAN_HPP_NO_SMART_HANDLE
378
379 template <typename Type, typename Dispatch> class UniqueHandleTraits;
380
381 template <typename Type, typename Dispatch>
382 class UniqueHandle : public UniqueHandleTraits<Type,Dispatch>::deleter
383 {
384 private:
386 public:
387 explicit UniqueHandle( Type const& value = Type(), Deleter const& deleter = Deleter() )
388 : Deleter( deleter)
389 , m_value( value )
390 {}
391
392 UniqueHandle( UniqueHandle const& ) = delete;
393
395 : Deleter( std::move( static_cast<Deleter&>( other ) ) )
396 , m_value( other.release() )
397 {}
398
400 {
401 if ( m_value ) this->destroy( m_value );
402 }
403
404 UniqueHandle & operator=( UniqueHandle const& ) = delete;
405
407 {
408 reset( other.release() );
409 *static_cast<Deleter*>(this) = std::move( static_cast<Deleter&>(other) );
410 return *this;
411 }
412
413 explicit operator bool() const
414 {
415 return m_value.operator bool();
416 }
417
418 Type const* operator->() const
419 {
420 return &m_value;
421 }
422
424 {
425 return &m_value;
426 }
427
428 Type const& operator*() const
429 {
430 return m_value;
431 }
432
434 {
435 return m_value;
436 }
437
438 const Type & get() const
439 {
440 return m_value;
441 }
442
444 {
445 return m_value;
446 }
447
448 void reset( Type const& value = Type() )
449 {
450 if ( m_value != value )
451 {
452 if ( m_value ) this->destroy( m_value );
453 m_value = value;
454 }
455 }
456
458 {
460 m_value = nullptr;
461 return value;
462 }
463
465 {
467 std::swap(static_cast<Deleter&>(*this), static_cast<Deleter&>(rhs));
468 }
469
470 private:
472 };
473
474 template <typename Type, typename Dispatch>
476 {
477 lhs.swap( rhs );
478 }
479#endif
480
481
482
483 template <typename X, typename Y> struct isStructureChainValid { enum { value = false }; };
484
485 template <typename P, typename T>
486 struct TypeList
487 {
488 using list = P;
489 using last = T;
490 };
491
492 template <typename List, typename X>
494 {
496 };
497
498 template <typename T, typename X>
500 {
502 };
503
504 template <typename X>
506 {
507 static const bool valid = true;
508 };
509
510 template <class Element>
512 {
513 public:
514 explicit operator Element&() { return value; }
515 explicit operator const Element&() const { return value; }
516 private:
517 Element value;
518 };
519
520 template<typename ...StructureElements>
521 class StructureChain : private StructureChainElement<StructureElements>...
522 {
523 public:
525 {
526 link<void, StructureElements...>();
527 }
528
530 {
531 linkAndCopy<void, StructureElements...>(rhs);
532 }
533
534 StructureChain(StructureElements const &... elems)
535 {
536 linkAndCopyElements<void, StructureElements...>(elems...);
537 }
538
540 {
541 linkAndCopy<void, StructureElements...>(rhs);
542 return *this;
543 }
544
545 template<typename ClassType> ClassType& get() { return static_cast<ClassType&>(*this);}
546
547 private:
548 template<typename List, typename X>
549 void link()
550 {
551 static_assert(extendCheck<List, X>::valid, "The structure chain is not valid!");
552 }
553
554 template<typename List, typename X, typename Y, typename ...Z>
555 void link()
556 {
557 static_assert(extendCheck<List,X>::valid, "The structure chain is not valid!");
558 X& x = static_cast<X&>(*this);
559 Y& y = static_cast<Y&>(*this);
560 x.pNext = &y;
561 link<TypeList<List, X>, Y, Z...>();
562 }
563
564 template<typename List, typename X>
566 {
567 static_assert(extendCheck<List, X>::valid, "The structure chain is not valid!");
568 static_cast<X&>(*this) = static_cast<X const &>(rhs);
569 }
570
571 template<typename List, typename X, typename Y, typename ...Z>
573 {
574 static_assert(extendCheck<List, X>::valid, "The structure chain is not valid!");
575 X& x = static_cast<X&>(*this);
576 Y& y = static_cast<Y&>(*this);
577 x = static_cast<X const &>(rhs);
578 x.pNext = &y;
579 linkAndCopy<TypeList<List, X>, Y, Z...>(rhs);
580 }
581
582 template<typename List, typename X>
583 void linkAndCopyElements(X const &xelem)
584 {
585 static_assert(extendCheck<List, X>::valid, "The structure chain is not valid!");
586 static_cast<X&>(*this) = xelem;
587 }
588
589 template<typename List, typename X, typename Y, typename ...Z>
590 void linkAndCopyElements(X const &xelem, Y const &yelem, Z const &... zelem)
591 {
592 static_assert(extendCheck<List, X>::valid, "The structure chain is not valid!");
593 X& x = static_cast<X&>(*this);
594 Y& y = static_cast<Y&>(*this);
595 x = xelem;
596 x.pNext = &y;
597 linkAndCopyElements<TypeList<List, X>, Y, Z...>(yelem, zelem...);
598 }
599 };
600
601 enum class Result
602 {
635 };
636
638 {
639 switch (value)
640 {
641 case Result::eSuccess: return "Success";
642 case Result::eNotReady: return "NotReady";
643 case Result::eTimeout: return "Timeout";
644 case Result::eEventSet: return "EventSet";
645 case Result::eEventReset: return "EventReset";
646 case Result::eIncomplete: return "Incomplete";
647 case Result::eErrorOutOfHostMemory: return "ErrorOutOfHostMemory";
648 case Result::eErrorOutOfDeviceMemory: return "ErrorOutOfDeviceMemory";
649 case Result::eErrorInitializationFailed: return "ErrorInitializationFailed";
650 case Result::eErrorDeviceLost: return "ErrorDeviceLost";
651 case Result::eErrorMemoryMapFailed: return "ErrorMemoryMapFailed";
652 case Result::eErrorLayerNotPresent: return "ErrorLayerNotPresent";
653 case Result::eErrorExtensionNotPresent: return "ErrorExtensionNotPresent";
654 case Result::eErrorFeatureNotPresent: return "ErrorFeatureNotPresent";
655 case Result::eErrorIncompatibleDriver: return "ErrorIncompatibleDriver";
656 case Result::eErrorTooManyObjects: return "ErrorTooManyObjects";
657 case Result::eErrorFormatNotSupported: return "ErrorFormatNotSupported";
658 case Result::eErrorFragmentedPool: return "ErrorFragmentedPool";
659 case Result::eErrorOutOfPoolMemory: return "ErrorOutOfPoolMemory";
660 case Result::eErrorInvalidExternalHandle: return "ErrorInvalidExternalHandle";
661 case Result::eErrorSurfaceLostKHR: return "ErrorSurfaceLostKHR";
662 case Result::eErrorNativeWindowInUseKHR: return "ErrorNativeWindowInUseKHR";
663 case Result::eSuboptimalKHR: return "SuboptimalKHR";
664 case Result::eErrorOutOfDateKHR: return "ErrorOutOfDateKHR";
665 case Result::eErrorIncompatibleDisplayKHR: return "ErrorIncompatibleDisplayKHR";
666 case Result::eErrorValidationFailedEXT: return "ErrorValidationFailedEXT";
667 case Result::eErrorInvalidShaderNV: return "ErrorInvalidShaderNV";
668 case Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT: return "ErrorInvalidDrmFormatModifierPlaneLayoutEXT";
669 case Result::eErrorFragmentationEXT: return "ErrorFragmentationEXT";
670 case Result::eErrorNotPermittedEXT: return "ErrorNotPermittedEXT";
671 default: return "invalid";
672 }
673 }
674
675#ifndef VULKAN_HPP_NO_EXCEPTIONS
676#if defined(_MSC_VER) && (_MSC_VER == 1800)
677# define noexcept _NOEXCEPT
678#endif
679
680 class ErrorCategoryImpl : public std::error_category
681 {
682 public:
683 virtual const char* name() const noexcept override { return VULKAN_HPP_NAMESPACE_STRING"::Result"; }
684 virtual std::string message(int ev) const override { return to_string(static_cast<Result>(ev)); }
685 };
686
687#if defined(_MSC_VER) && (_MSC_VER == 1800)
688# undef noexcept
689#endif
690
691 VULKAN_HPP_INLINE const std::error_category& errorCategory()
692 {
693 static ErrorCategoryImpl instance;
694 return instance;
695 }
696
698 {
699 return std::error_code(static_cast<int>(e), errorCategory());
700 }
701
703 {
704 return std::error_condition(static_cast<int>(e), errorCategory());
705 }
706
707#if defined(_MSC_VER) && (_MSC_VER == 1800)
708# define noexcept _NOEXCEPT
709#endif
710
711 class Error
712 {
713 public:
714 virtual ~Error() = default;
715
716 virtual const char* what() const noexcept = 0;
717 };
718
719 class LogicError : public Error, public std::logic_error
720 {
721 public:
722 explicit LogicError( const std::string& what )
723 : Error(), std::logic_error(what) {}
724 explicit LogicError( char const * what )
725 : Error(), std::logic_error(what) {}
726 virtual ~LogicError() = default;
727
728 virtual const char* what() const noexcept { return std::logic_error::what(); }
729 };
730
731 class SystemError : public Error, public std::system_error
732 {
733 public:
734 SystemError( std::error_code ec )
735 : Error(), std::system_error(ec) {}
736 SystemError( std::error_code ec, std::string const& what )
737 : Error(), std::system_error(ec, what) {}
738 SystemError( std::error_code ec, char const * what )
739 : Error(), std::system_error(ec, what) {}
740 SystemError( int ev, std::error_category const& ecat )
741 : Error(), std::system_error(ev, ecat) {}
742 SystemError( int ev, std::error_category const& ecat, std::string const& what)
743 : Error(), std::system_error(ev, ecat, what) {}
744 SystemError( int ev, std::error_category const& ecat, char const * what)
745 : Error(), std::system_error(ev, ecat, what) {}
746 virtual ~SystemError() = default;
747
748 virtual const char* what() const noexcept { return std::system_error::what(); }
749 };
750
751#if defined(_MSC_VER) && (_MSC_VER == 1800)
752# undef noexcept
753#endif
754
756 {
757 public:
762 };
764 {
765 public:
770 };
772 {
773 public:
778 };
780 {
781 public:
784 DeviceLostError( char const * message )
786 };
788 {
789 public:
794 };
796 {
797 public:
802 };
804 {
805 public:
810 };
812 {
813 public:
818 };
820 {
821 public:
826 };
828 {
829 public:
834 };
836 {
837 public:
842 };
844 {
845 public:
850 };
852 {
853 public:
858 };
860 {
861 public:
866 };
868 {
869 public:
874 };
876 {
877 public:
882 };
884 {
885 public:
890 };
892 {
893 public:
898 };
900 {
901 public:
906 };
908 {
909 public:
914 };
916 {
917 public:
922 };
924 {
925 public:
930 };
932 {
933 public:
938 };
939
941 {
942 switch ( result )
943 {
967 default: throw SystemError( make_error_code( result ) );
968 }
969 }
970#endif
971} // namespace VULKAN_HPP_NAMESPACE
972
973namespace std
974{
975 template <>
976 struct is_error_code_enum<VULKAN_HPP_NAMESPACE::Result> : public true_type
977 {};
978}
979
980namespace VULKAN_HPP_NAMESPACE
981{
982
983 template <typename T>
985 {
987 : result( r )
988 , value( v )
989 {}
990
992 : result( r )
993 , value( std::move( v ) )
994 {}
995
998
999 operator std::tuple<Result&, T&>() { return std::tuple<Result&, T&>(result, value); }
1000 };
1001
1002 template <typename T>
1004 {
1005#ifdef VULKAN_HPP_NO_EXCEPTIONS
1006 typedef ResultValue<T> type;
1007#else
1008 typedef T type;
1009#endif
1010 };
1011
1012 template <>
1014 {
1015#ifdef VULKAN_HPP_NO_EXCEPTIONS
1016 typedef Result type;
1017#else
1018 typedef void type;
1019#endif
1020 };
1021
1023 {
1024#ifdef VULKAN_HPP_NO_EXCEPTIONS
1026 return result;
1027#else
1028 if ( result != Result::eSuccess )
1029 {
1031 }
1032#endif
1033 }
1034
1035 template <typename T>
1037 {
1038#ifdef VULKAN_HPP_NO_EXCEPTIONS
1040 return ResultValue<T>( result, data );
1041#else
1042 if ( result != Result::eSuccess )
1043 {
1045 }
1046 return std::move( data );
1047#endif
1048 }
1049
1050 VULKAN_HPP_INLINE Result createResultValue( Result result, char const * message, std::initializer_list<Result> successCodes )
1051 {
1052#ifdef VULKAN_HPP_NO_EXCEPTIONS
1053 VULKAN_HPP_ASSERT( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() );
1054#else
1055 if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() )
1056 {
1058 }
1059#endif
1060 return result;
1061 }
1062
1063 template <typename T>
1064 VULKAN_HPP_INLINE ResultValue<T> createResultValue( Result result, T & data, char const * message, std::initializer_list<Result> successCodes )
1065 {
1066#ifdef VULKAN_HPP_NO_EXCEPTIONS
1067 VULKAN_HPP_ASSERT( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() );
1068#else
1069 if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() )
1070 {
1072 }
1073#endif
1074 return ResultValue<T>( result, data );
1075 }
1076
1077#ifndef VULKAN_HPP_NO_SMART_HANDLE
1078 template <typename T, typename D>
1080 {
1081#ifdef VULKAN_HPP_NO_EXCEPTIONS
1084#else
1085 if ( result != Result::eSuccess )
1086 {
1088 }
1089 return UniqueHandle<T,D>(data, deleter);
1090#endif
1091 }
1092#endif
1093
1095{
1096public:
1097 VkResult vkAcquireNextImage2KHR( VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex ) const
1098 {
1099 return ::vkAcquireNextImage2KHR( device, pAcquireInfo, pImageIndex);
1100 }
1101 VkResult vkAcquireNextImageKHR( VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex ) const
1102 {
1103 return ::vkAcquireNextImageKHR( device, swapchain, timeout, semaphore, fence, pImageIndex);
1104 }
1105#ifdef VK_USE_PLATFORM_XLIB_XRANDR_NV
1106 VkResult vkAcquireXlibDisplayEXT( VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display ) const
1107 {
1108 return ::vkAcquireXlibDisplayEXT( physicalDevice, dpy, display);
1109 }
1110#endif /*VK_USE_PLATFORM_XLIB_XRANDR_NV*/
1111 VkResult vkAllocateCommandBuffers( VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers ) const
1112 {
1113 return ::vkAllocateCommandBuffers( device, pAllocateInfo, pCommandBuffers);
1114 }
1115 VkResult vkAllocateDescriptorSets( VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets ) const
1116 {
1117 return ::vkAllocateDescriptorSets( device, pAllocateInfo, pDescriptorSets);
1118 }
1119 VkResult vkAllocateMemory( VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory ) const
1120 {
1121 return ::vkAllocateMemory( device, pAllocateInfo, pAllocator, pMemory);
1122 }
1123 VkResult vkBeginCommandBuffer( VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo ) const
1124 {
1125 return ::vkBeginCommandBuffer( commandBuffer, pBeginInfo);
1126 }
1128 {
1129 return ::vkBindAccelerationStructureMemoryNV( device, bindInfoCount, pBindInfos);
1130 }
1131 VkResult vkBindBufferMemory( VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset ) const
1132 {
1134 }
1135 VkResult vkBindBufferMemory2( VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos ) const
1136 {
1137 return ::vkBindBufferMemory2( device, bindInfoCount, pBindInfos);
1138 }
1139 VkResult vkBindBufferMemory2KHR( VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos ) const
1140 {
1141 return ::vkBindBufferMemory2KHR( device, bindInfoCount, pBindInfos);
1142 }
1143 VkResult vkBindImageMemory( VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset ) const
1144 {
1146 }
1147 VkResult vkBindImageMemory2( VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos ) const
1148 {
1149 return ::vkBindImageMemory2( device, bindInfoCount, pBindInfos);
1150 }
1151 VkResult vkBindImageMemory2KHR( VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos ) const
1152 {
1153 return ::vkBindImageMemory2KHR( device, bindInfoCount, pBindInfos);
1154 }
1155 void vkCmdBeginConditionalRenderingEXT( VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin ) const
1156 {
1157 return ::vkCmdBeginConditionalRenderingEXT( commandBuffer, pConditionalRenderingBegin);
1158 }
1159 void vkCmdBeginDebugUtilsLabelEXT( VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo ) const
1160 {
1161 return ::vkCmdBeginDebugUtilsLabelEXT( commandBuffer, pLabelInfo);
1162 }
1163 void vkCmdBeginQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags ) const
1164 {
1165 return ::vkCmdBeginQuery( commandBuffer, queryPool, query, flags);
1166 }
1167 void vkCmdBeginQueryIndexedEXT( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index ) const
1168 {
1169 return ::vkCmdBeginQueryIndexedEXT( commandBuffer, queryPool, query, flags, index);
1170 }
1171 void vkCmdBeginRenderPass( VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents ) const
1172 {
1173 return ::vkCmdBeginRenderPass( commandBuffer, pRenderPassBegin, contents);
1174 }
1175 void vkCmdBeginRenderPass2KHR( VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfoKHR* pSubpassBeginInfo ) const
1176 {
1177 return ::vkCmdBeginRenderPass2KHR( commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
1178 }
1179 void vkCmdBeginTransformFeedbackEXT( VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets ) const
1180 {
1181 return ::vkCmdBeginTransformFeedbackEXT( commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
1182 }
1183 void vkCmdBindDescriptorSets( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets ) const
1184 {
1185 return ::vkCmdBindDescriptorSets( commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
1186 }
1187 void vkCmdBindIndexBuffer( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType ) const
1188 {
1189 return ::vkCmdBindIndexBuffer( commandBuffer, buffer, offset, indexType);
1190 }
1191 void vkCmdBindPipeline( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline ) const
1192 {
1193 return ::vkCmdBindPipeline( commandBuffer, pipelineBindPoint, pipeline);
1194 }
1195 void vkCmdBindShadingRateImageNV( VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout ) const
1196 {
1197 return ::vkCmdBindShadingRateImageNV( commandBuffer, imageView, imageLayout);
1198 }
1199 void vkCmdBindTransformFeedbackBuffersEXT( VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes ) const
1200 {
1201 return ::vkCmdBindTransformFeedbackBuffersEXT( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes);
1202 }
1203 void vkCmdBindVertexBuffers( VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets ) const
1204 {
1205 return ::vkCmdBindVertexBuffers( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
1206 }
1207 void vkCmdBlitImage( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter ) const
1208 {
1209 return ::vkCmdBlitImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
1210 }
1211 void vkCmdBuildAccelerationStructureNV( VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset ) const
1212 {
1213 return ::vkCmdBuildAccelerationStructureNV( commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset);
1214 }
1215 void vkCmdClearAttachments( VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects ) const
1216 {
1217 return ::vkCmdClearAttachments( commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
1218 }
1219 void vkCmdClearColorImage( VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges ) const
1220 {
1221 return ::vkCmdClearColorImage( commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
1222 }
1223 void vkCmdClearDepthStencilImage( VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges ) const
1224 {
1225 return ::vkCmdClearDepthStencilImage( commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
1226 }
1227 void vkCmdCopyAccelerationStructureNV( VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeNV mode ) const
1228 {
1230 }
1231 void vkCmdCopyBuffer( VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions ) const
1232 {
1233 return ::vkCmdCopyBuffer( commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
1234 }
1235 void vkCmdCopyBufferToImage( VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions ) const
1236 {
1237 return ::vkCmdCopyBufferToImage( commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
1238 }
1239 void vkCmdCopyImage( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions ) const
1240 {
1241 return ::vkCmdCopyImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
1242 }
1243 void vkCmdCopyImageToBuffer( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions ) const
1244 {
1245 return ::vkCmdCopyImageToBuffer( commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
1246 }
1247 void vkCmdCopyQueryPoolResults( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags ) const
1248 {
1249 return ::vkCmdCopyQueryPoolResults( commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
1250 }
1251 void vkCmdDebugMarkerBeginEXT( VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo ) const
1252 {
1253 return ::vkCmdDebugMarkerBeginEXT( commandBuffer, pMarkerInfo);
1254 }
1255 void vkCmdDebugMarkerEndEXT( VkCommandBuffer commandBuffer ) const
1256 {
1257 return ::vkCmdDebugMarkerEndEXT( commandBuffer);
1258 }
1259 void vkCmdDebugMarkerInsertEXT( VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo ) const
1260 {
1261 return ::vkCmdDebugMarkerInsertEXT( commandBuffer, pMarkerInfo);
1262 }
1263 void vkCmdDispatch( VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const
1264 {
1265 return ::vkCmdDispatch( commandBuffer, groupCountX, groupCountY, groupCountZ);
1266 }
1267 void vkCmdDispatchBase( VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const
1268 {
1269 return ::vkCmdDispatchBase( commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
1270 }
1271 void vkCmdDispatchBaseKHR( VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const
1272 {
1273 return ::vkCmdDispatchBaseKHR( commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
1274 }
1275 void vkCmdDispatchIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset ) const
1276 {
1278 }
1279 void vkCmdDraw( VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance ) const
1280 {
1281 return ::vkCmdDraw( commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
1282 }
1283 void vkCmdDrawIndexed( VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance ) const
1284 {
1285 return ::vkCmdDrawIndexed( commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
1286 }
1287 void vkCmdDrawIndexedIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const
1288 {
1290 }
1291 void vkCmdDrawIndexedIndirectCountAMD( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const
1292 {
1293 return ::vkCmdDrawIndexedIndirectCountAMD( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
1294 }
1295 void vkCmdDrawIndexedIndirectCountKHR( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const
1296 {
1297 return ::vkCmdDrawIndexedIndirectCountKHR( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
1298 }
1299 void vkCmdDrawIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const
1300 {
1302 }
1303 void vkCmdDrawIndirectByteCountEXT( VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride ) const
1304 {
1305 return ::vkCmdDrawIndirectByteCountEXT( commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride);
1306 }
1307 void vkCmdDrawIndirectCountAMD( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const
1308 {
1309 return ::vkCmdDrawIndirectCountAMD( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
1310 }
1311 void vkCmdDrawIndirectCountKHR( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const
1312 {
1313 return ::vkCmdDrawIndirectCountKHR( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
1314 }
1315 void vkCmdDrawMeshTasksIndirectCountNV( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const
1316 {
1317 return ::vkCmdDrawMeshTasksIndirectCountNV( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
1318 }
1319 void vkCmdDrawMeshTasksIndirectNV( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const
1320 {
1322 }
1323 void vkCmdDrawMeshTasksNV( VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask ) const
1324 {
1325 return ::vkCmdDrawMeshTasksNV( commandBuffer, taskCount, firstTask);
1326 }
1327 void vkCmdEndConditionalRenderingEXT( VkCommandBuffer commandBuffer ) const
1328 {
1330 }
1331 void vkCmdEndDebugUtilsLabelEXT( VkCommandBuffer commandBuffer ) const
1332 {
1334 }
1335 void vkCmdEndQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query ) const
1336 {
1337 return ::vkCmdEndQuery( commandBuffer, queryPool, query);
1338 }
1339 void vkCmdEndQueryIndexedEXT( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index ) const
1340 {
1341 return ::vkCmdEndQueryIndexedEXT( commandBuffer, queryPool, query, index);
1342 }
1343 void vkCmdEndRenderPass( VkCommandBuffer commandBuffer ) const
1344 {
1345 return ::vkCmdEndRenderPass( commandBuffer);
1346 }
1347 void vkCmdEndRenderPass2KHR( VkCommandBuffer commandBuffer, const VkSubpassEndInfoKHR* pSubpassEndInfo ) const
1348 {
1349 return ::vkCmdEndRenderPass2KHR( commandBuffer, pSubpassEndInfo);
1350 }
1351 void vkCmdEndTransformFeedbackEXT( VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets ) const
1352 {
1353 return ::vkCmdEndTransformFeedbackEXT( commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
1354 }
1355 void vkCmdExecuteCommands( VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers ) const
1356 {
1357 return ::vkCmdExecuteCommands( commandBuffer, commandBufferCount, pCommandBuffers);
1358 }
1359 void vkCmdFillBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data ) const
1360 {
1361 return ::vkCmdFillBuffer( commandBuffer, dstBuffer, dstOffset, size, data);
1362 }
1363 void vkCmdInsertDebugUtilsLabelEXT( VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo ) const
1364 {
1365 return ::vkCmdInsertDebugUtilsLabelEXT( commandBuffer, pLabelInfo);
1366 }
1367 void vkCmdNextSubpass( VkCommandBuffer commandBuffer, VkSubpassContents contents ) const
1368 {
1369 return ::vkCmdNextSubpass( commandBuffer, contents);
1370 }
1371 void vkCmdNextSubpass2KHR( VkCommandBuffer commandBuffer, const VkSubpassBeginInfoKHR* pSubpassBeginInfo, const VkSubpassEndInfoKHR* pSubpassEndInfo ) const
1372 {
1373 return ::vkCmdNextSubpass2KHR( commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
1374 }
1375 void vkCmdPipelineBarrier( VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers ) const
1376 {
1377 return ::vkCmdPipelineBarrier( commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
1378 }
1379 void vkCmdProcessCommandsNVX( VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo ) const
1380 {
1381 return ::vkCmdProcessCommandsNVX( commandBuffer, pProcessCommandsInfo);
1382 }
1383 void vkCmdPushConstants( VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues ) const
1384 {
1385 return ::vkCmdPushConstants( commandBuffer, layout, stageFlags, offset, size, pValues);
1386 }
1387 void vkCmdPushDescriptorSetKHR( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites ) const
1388 {
1389 return ::vkCmdPushDescriptorSetKHR( commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites);
1390 }
1391 void vkCmdPushDescriptorSetWithTemplateKHR( VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData ) const
1392 {
1393 return ::vkCmdPushDescriptorSetWithTemplateKHR( commandBuffer, descriptorUpdateTemplate, layout, set, pData);
1394 }
1395 void vkCmdReserveSpaceForCommandsNVX( VkCommandBuffer commandBuffer, const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo ) const
1396 {
1397 return ::vkCmdReserveSpaceForCommandsNVX( commandBuffer, pReserveSpaceInfo);
1398 }
1399 void vkCmdResetEvent( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask ) const
1400 {
1401 return ::vkCmdResetEvent( commandBuffer, event, stageMask);
1402 }
1403 void vkCmdResetQueryPool( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const
1404 {
1405 return ::vkCmdResetQueryPool( commandBuffer, queryPool, firstQuery, queryCount);
1406 }
1407 void vkCmdResolveImage( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions ) const
1408 {
1409 return ::vkCmdResolveImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
1410 }
1411 void vkCmdSetBlendConstants( VkCommandBuffer commandBuffer, const float blendConstants[4] ) const
1412 {
1413 return ::vkCmdSetBlendConstants( commandBuffer, blendConstants);
1414 }
1415 void vkCmdSetCheckpointNV( VkCommandBuffer commandBuffer, const void* pCheckpointMarker ) const
1416 {
1417 return ::vkCmdSetCheckpointNV( commandBuffer, pCheckpointMarker);
1418 }
1419 void vkCmdSetCoarseSampleOrderNV( VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders ) const
1420 {
1421 return ::vkCmdSetCoarseSampleOrderNV( commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders);
1422 }
1423 void vkCmdSetDepthBias( VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor ) const
1424 {
1425 return ::vkCmdSetDepthBias( commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
1426 }
1427 void vkCmdSetDepthBounds( VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds ) const
1428 {
1429 return ::vkCmdSetDepthBounds( commandBuffer, minDepthBounds, maxDepthBounds);
1430 }
1431 void vkCmdSetDeviceMask( VkCommandBuffer commandBuffer, uint32_t deviceMask ) const
1432 {
1433 return ::vkCmdSetDeviceMask( commandBuffer, deviceMask);
1434 }
1435 void vkCmdSetDeviceMaskKHR( VkCommandBuffer commandBuffer, uint32_t deviceMask ) const
1436 {
1437 return ::vkCmdSetDeviceMaskKHR( commandBuffer, deviceMask);
1438 }
1439 void vkCmdSetDiscardRectangleEXT( VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles ) const
1440 {
1441 return ::vkCmdSetDiscardRectangleEXT( commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles);
1442 }
1443 void vkCmdSetEvent( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask ) const
1444 {
1445 return ::vkCmdSetEvent( commandBuffer, event, stageMask);
1446 }
1447 void vkCmdSetExclusiveScissorNV( VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors ) const
1448 {
1449 return ::vkCmdSetExclusiveScissorNV( commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors);
1450 }
1451 void vkCmdSetLineWidth( VkCommandBuffer commandBuffer, float lineWidth ) const
1452 {
1453 return ::vkCmdSetLineWidth( commandBuffer, lineWidth);
1454 }
1455 void vkCmdSetSampleLocationsEXT( VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo ) const
1456 {
1457 return ::vkCmdSetSampleLocationsEXT( commandBuffer, pSampleLocationsInfo);
1458 }
1459 void vkCmdSetScissor( VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors ) const
1460 {
1461 return ::vkCmdSetScissor( commandBuffer, firstScissor, scissorCount, pScissors);
1462 }
1463 void vkCmdSetStencilCompareMask( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask ) const
1464 {
1465 return ::vkCmdSetStencilCompareMask( commandBuffer, faceMask, compareMask);
1466 }
1467 void vkCmdSetStencilReference( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference ) const
1468 {
1469 return ::vkCmdSetStencilReference( commandBuffer, faceMask, reference);
1470 }
1471 void vkCmdSetStencilWriteMask( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask ) const
1472 {
1473 return ::vkCmdSetStencilWriteMask( commandBuffer, faceMask, writeMask);
1474 }
1475 void vkCmdSetViewport( VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports ) const
1476 {
1477 return ::vkCmdSetViewport( commandBuffer, firstViewport, viewportCount, pViewports);
1478 }
1479 void vkCmdSetViewportShadingRatePaletteNV( VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes ) const
1480 {
1481 return ::vkCmdSetViewportShadingRatePaletteNV( commandBuffer, firstViewport, viewportCount, pShadingRatePalettes);
1482 }
1483 void vkCmdSetViewportWScalingNV( VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings ) const
1484 {
1485 return ::vkCmdSetViewportWScalingNV( commandBuffer, firstViewport, viewportCount, pViewportWScalings);
1486 }
1487 void vkCmdTraceRaysNV( VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth ) const
1488 {
1489 return ::vkCmdTraceRaysNV( commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth);
1490 }
1491 void vkCmdUpdateBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData ) const
1492 {
1493 return ::vkCmdUpdateBuffer( commandBuffer, dstBuffer, dstOffset, dataSize, pData);
1494 }
1495 void vkCmdWaitEvents( VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers ) const
1496 {
1497 return ::vkCmdWaitEvents( commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
1498 }
1499 void vkCmdWriteAccelerationStructuresPropertiesNV( VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery ) const
1500 {
1501 return ::vkCmdWriteAccelerationStructuresPropertiesNV( commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery);
1502 }
1503 void vkCmdWriteBufferMarkerAMD( VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker ) const
1504 {
1505 return ::vkCmdWriteBufferMarkerAMD( commandBuffer, pipelineStage, dstBuffer, dstOffset, marker);
1506 }
1507 void vkCmdWriteTimestamp( VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query ) const
1508 {
1509 return ::vkCmdWriteTimestamp( commandBuffer, pipelineStage, queryPool, query);
1510 }
1511 VkResult vkCompileDeferredNV( VkDevice device, VkPipeline pipeline, uint32_t shader ) const
1512 {
1514 }
1515 VkResult vkCreateAccelerationStructureNV( VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure ) const
1516 {
1517 return ::vkCreateAccelerationStructureNV( device, pCreateInfo, pAllocator, pAccelerationStructure);
1518 }
1519#ifdef VK_USE_PLATFORM_ANDROID_KHR
1520 VkResult vkCreateAndroidSurfaceKHR( VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const
1521 {
1522 return ::vkCreateAndroidSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface);
1523 }
1524#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
1525 VkResult vkCreateBuffer( VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer ) const
1526 {
1527 return ::vkCreateBuffer( device, pCreateInfo, pAllocator, pBuffer);
1528 }
1529 VkResult vkCreateBufferView( VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView ) const
1530 {
1531 return ::vkCreateBufferView( device, pCreateInfo, pAllocator, pView);
1532 }
1533 VkResult vkCreateCommandPool( VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool ) const
1534 {
1535 return ::vkCreateCommandPool( device, pCreateInfo, pAllocator, pCommandPool);
1536 }
1537 VkResult vkCreateComputePipelines( VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines ) const
1538 {
1539 return ::vkCreateComputePipelines( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
1540 }
1541 VkResult vkCreateDebugReportCallbackEXT( VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback ) const
1542 {
1543 return ::vkCreateDebugReportCallbackEXT( instance, pCreateInfo, pAllocator, pCallback);
1544 }
1545 VkResult vkCreateDebugUtilsMessengerEXT( VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger ) const
1546 {
1547 return ::vkCreateDebugUtilsMessengerEXT( instance, pCreateInfo, pAllocator, pMessenger);
1548 }
1549 VkResult vkCreateDescriptorPool( VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool ) const
1550 {
1551 return ::vkCreateDescriptorPool( device, pCreateInfo, pAllocator, pDescriptorPool);
1552 }
1553 VkResult vkCreateDescriptorSetLayout( VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout ) const
1554 {
1555 return ::vkCreateDescriptorSetLayout( device, pCreateInfo, pAllocator, pSetLayout);
1556 }
1557 VkResult vkCreateDescriptorUpdateTemplate( VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate ) const
1558 {
1559 return ::vkCreateDescriptorUpdateTemplate( device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
1560 }
1561 VkResult vkCreateDescriptorUpdateTemplateKHR( VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate ) const
1562 {
1563 return ::vkCreateDescriptorUpdateTemplateKHR( device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
1564 }
1565 VkResult vkCreateDevice( VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice ) const
1566 {
1567 return ::vkCreateDevice( physicalDevice, pCreateInfo, pAllocator, pDevice);
1568 }
1569 VkResult vkCreateDisplayModeKHR( VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode ) const
1570 {
1571 return ::vkCreateDisplayModeKHR( physicalDevice, display, pCreateInfo, pAllocator, pMode);
1572 }
1573 VkResult vkCreateDisplayPlaneSurfaceKHR( VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const
1574 {
1575 return ::vkCreateDisplayPlaneSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface);
1576 }
1577 VkResult vkCreateEvent( VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent ) const
1578 {
1579 return ::vkCreateEvent( device, pCreateInfo, pAllocator, pEvent);
1580 }
1581 VkResult vkCreateFence( VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence ) const
1582 {
1583 return ::vkCreateFence( device, pCreateInfo, pAllocator, pFence);
1584 }
1585 VkResult vkCreateFramebuffer( VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer ) const
1586 {
1587 return ::vkCreateFramebuffer( device, pCreateInfo, pAllocator, pFramebuffer);
1588 }
1589 VkResult vkCreateGraphicsPipelines( VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines ) const
1590 {
1591 return ::vkCreateGraphicsPipelines( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
1592 }
1593#ifdef VK_USE_PLATFORM_IOS_MVK
1594 VkResult vkCreateIOSSurfaceMVK( VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const
1595 {
1596 return ::vkCreateIOSSurfaceMVK( instance, pCreateInfo, pAllocator, pSurface);
1597 }
1598#endif /*VK_USE_PLATFORM_IOS_MVK*/
1599 VkResult vkCreateImage( VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage ) const
1600 {
1601 return ::vkCreateImage( device, pCreateInfo, pAllocator, pImage);
1602 }
1603#ifdef VK_USE_PLATFORM_FUCHSIA_FUCHSIA
1604 VkResult vkCreateImagePipeSurfaceFUCHSIA( VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const
1605 {
1606 return ::vkCreateImagePipeSurfaceFUCHSIA( instance, pCreateInfo, pAllocator, pSurface);
1607 }
1608#endif /*VK_USE_PLATFORM_FUCHSIA_FUCHSIA*/
1609 VkResult vkCreateImageView( VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView ) const
1610 {
1611 return ::vkCreateImageView( device, pCreateInfo, pAllocator, pView);
1612 }
1613 VkResult vkCreateIndirectCommandsLayoutNVX( VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout ) const
1614 {
1615 return ::vkCreateIndirectCommandsLayoutNVX( device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
1616 }
1617 VkResult vkCreateInstance( const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance ) const
1618 {
1619 return ::vkCreateInstance( pCreateInfo, pAllocator, pInstance);
1620 }
1621#ifdef VK_USE_PLATFORM_MACOS_MVK
1622 VkResult vkCreateMacOSSurfaceMVK( VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const
1623 {
1624 return ::vkCreateMacOSSurfaceMVK( instance, pCreateInfo, pAllocator, pSurface);
1625 }
1626#endif /*VK_USE_PLATFORM_MACOS_MVK*/
1627 VkResult vkCreateObjectTableNVX( VkDevice device, const VkObjectTableCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkObjectTableNVX* pObjectTable ) const
1628 {
1629 return ::vkCreateObjectTableNVX( device, pCreateInfo, pAllocator, pObjectTable);
1630 }
1631 VkResult vkCreatePipelineCache( VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache ) const
1632 {
1633 return ::vkCreatePipelineCache( device, pCreateInfo, pAllocator, pPipelineCache);
1634 }
1635 VkResult vkCreatePipelineLayout( VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout ) const
1636 {
1637 return ::vkCreatePipelineLayout( device, pCreateInfo, pAllocator, pPipelineLayout);
1638 }
1639 VkResult vkCreateQueryPool( VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool ) const
1640 {
1641 return ::vkCreateQueryPool( device, pCreateInfo, pAllocator, pQueryPool);
1642 }
1643 VkResult vkCreateRayTracingPipelinesNV( VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines ) const
1644 {
1645 return ::vkCreateRayTracingPipelinesNV( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
1646 }
1647 VkResult vkCreateRenderPass( VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass ) const
1648 {
1649 return ::vkCreateRenderPass( device, pCreateInfo, pAllocator, pRenderPass);
1650 }
1651 VkResult vkCreateRenderPass2KHR( VkDevice device, const VkRenderPassCreateInfo2KHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass ) const
1652 {
1653 return ::vkCreateRenderPass2KHR( device, pCreateInfo, pAllocator, pRenderPass);
1654 }
1655 VkResult vkCreateSampler( VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler ) const
1656 {
1657 return ::vkCreateSampler( device, pCreateInfo, pAllocator, pSampler);
1658 }
1659 VkResult vkCreateSamplerYcbcrConversion( VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion ) const
1660 {
1661 return ::vkCreateSamplerYcbcrConversion( device, pCreateInfo, pAllocator, pYcbcrConversion);
1662 }
1663 VkResult vkCreateSamplerYcbcrConversionKHR( VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion ) const
1664 {
1665 return ::vkCreateSamplerYcbcrConversionKHR( device, pCreateInfo, pAllocator, pYcbcrConversion);
1666 }
1667 VkResult vkCreateSemaphore( VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore ) const
1668 {
1669 return ::vkCreateSemaphore( device, pCreateInfo, pAllocator, pSemaphore);
1670 }
1671 VkResult vkCreateShaderModule( VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule ) const
1672 {
1673 return ::vkCreateShaderModule( device, pCreateInfo, pAllocator, pShaderModule);
1674 }
1675 VkResult vkCreateSharedSwapchainsKHR( VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains ) const
1676 {
1677 return ::vkCreateSharedSwapchainsKHR( device, swapchainCount, pCreateInfos, pAllocator, pSwapchains);
1678 }
1679 VkResult vkCreateSwapchainKHR( VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain ) const
1680 {
1681 return ::vkCreateSwapchainKHR( device, pCreateInfo, pAllocator, pSwapchain);
1682 }
1683 VkResult vkCreateValidationCacheEXT( VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache ) const
1684 {
1685 return ::vkCreateValidationCacheEXT( device, pCreateInfo, pAllocator, pValidationCache);
1686 }
1687#ifdef VK_USE_PLATFORM_VI_NN
1688 VkResult vkCreateViSurfaceNN( VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const
1689 {
1690 return ::vkCreateViSurfaceNN( instance, pCreateInfo, pAllocator, pSurface);
1691 }
1692#endif /*VK_USE_PLATFORM_VI_NN*/
1693#ifdef VK_USE_PLATFORM_WAYLAND_KHR
1694 VkResult vkCreateWaylandSurfaceKHR( VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const
1695 {
1696 return ::vkCreateWaylandSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface);
1697 }
1698#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
1699#ifdef VK_USE_PLATFORM_WIN32_KHR
1700 VkResult vkCreateWin32SurfaceKHR( VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const
1701 {
1702 return ::vkCreateWin32SurfaceKHR( instance, pCreateInfo, pAllocator, pSurface);
1703 }
1704#endif /*VK_USE_PLATFORM_WIN32_KHR*/
1705#ifdef VK_USE_PLATFORM_XCB_KHR
1706 VkResult vkCreateXcbSurfaceKHR( VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const
1707 {
1708 return ::vkCreateXcbSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface);
1709 }
1710#endif /*VK_USE_PLATFORM_XCB_KHR*/
1711#ifdef VK_USE_PLATFORM_XLIB_KHR
1712 VkResult vkCreateXlibSurfaceKHR( VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface ) const
1713 {
1714 return ::vkCreateXlibSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface);
1715 }
1716#endif /*VK_USE_PLATFORM_XLIB_KHR*/
1718 {
1720 }
1722 {
1724 }
1725 void vkDebugReportMessageEXT( VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage ) const
1726 {
1727 return ::vkDebugReportMessageEXT( instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage);
1728 }
1729 void vkDestroyAccelerationStructureNV( VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator ) const
1730 {
1731 return ::vkDestroyAccelerationStructureNV( device, accelerationStructure, pAllocator);
1732 }
1733 void vkDestroyBuffer( VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator ) const
1734 {
1735 return ::vkDestroyBuffer( device, buffer, pAllocator);
1736 }
1737 void vkDestroyBufferView( VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator ) const
1738 {
1739 return ::vkDestroyBufferView( device, bufferView, pAllocator);
1740 }
1741 void vkDestroyCommandPool( VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator ) const
1742 {
1743 return ::vkDestroyCommandPool( device, commandPool, pAllocator);
1744 }
1745 void vkDestroyDebugReportCallbackEXT( VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator ) const
1746 {
1747 return ::vkDestroyDebugReportCallbackEXT( instance, callback, pAllocator);
1748 }
1749 void vkDestroyDebugUtilsMessengerEXT( VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator ) const
1750 {
1751 return ::vkDestroyDebugUtilsMessengerEXT( instance, messenger, pAllocator);
1752 }
1753 void vkDestroyDescriptorPool( VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator ) const
1754 {
1755 return ::vkDestroyDescriptorPool( device, descriptorPool, pAllocator);
1756 }
1757 void vkDestroyDescriptorSetLayout( VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator ) const
1758 {
1759 return ::vkDestroyDescriptorSetLayout( device, descriptorSetLayout, pAllocator);
1760 }
1761 void vkDestroyDescriptorUpdateTemplate( VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator ) const
1762 {
1763 return ::vkDestroyDescriptorUpdateTemplate( device, descriptorUpdateTemplate, pAllocator);
1764 }
1765 void vkDestroyDescriptorUpdateTemplateKHR( VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator ) const
1766 {
1767 return ::vkDestroyDescriptorUpdateTemplateKHR( device, descriptorUpdateTemplate, pAllocator);
1768 }
1769 void vkDestroyDevice( VkDevice device, const VkAllocationCallbacks* pAllocator ) const
1770 {
1771 return ::vkDestroyDevice( device, pAllocator);
1772 }
1773 void vkDestroyEvent( VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator ) const
1774 {
1775 return ::vkDestroyEvent( device, event, pAllocator);
1776 }
1777 void vkDestroyFence( VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator ) const
1778 {
1779 return ::vkDestroyFence( device, fence, pAllocator);
1780 }
1781 void vkDestroyFramebuffer( VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator ) const
1782 {
1784 }
1785 void vkDestroyImage( VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator ) const
1786 {
1787 return ::vkDestroyImage( device, image, pAllocator);
1788 }
1789 void vkDestroyImageView( VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator ) const
1790 {
1791 return ::vkDestroyImageView( device, imageView, pAllocator);
1792 }
1793 void vkDestroyIndirectCommandsLayoutNVX( VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout, const VkAllocationCallbacks* pAllocator ) const
1794 {
1795 return ::vkDestroyIndirectCommandsLayoutNVX( device, indirectCommandsLayout, pAllocator);
1796 }
1797 void vkDestroyInstance( VkInstance instance, const VkAllocationCallbacks* pAllocator ) const
1798 {
1799 return ::vkDestroyInstance( instance, pAllocator);
1800 }
1801 void vkDestroyObjectTableNVX( VkDevice device, VkObjectTableNVX objectTable, const VkAllocationCallbacks* pAllocator ) const
1802 {
1803 return ::vkDestroyObjectTableNVX( device, objectTable, pAllocator);
1804 }
1805 void vkDestroyPipeline( VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator ) const
1806 {
1807 return ::vkDestroyPipeline( device, pipeline, pAllocator);
1808 }
1809 void vkDestroyPipelineCache( VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator ) const
1810 {
1811 return ::vkDestroyPipelineCache( device, pipelineCache, pAllocator);
1812 }
1813 void vkDestroyPipelineLayout( VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator ) const
1814 {
1815 return ::vkDestroyPipelineLayout( device, pipelineLayout, pAllocator);
1816 }
1817 void vkDestroyQueryPool( VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator ) const
1818 {
1819 return ::vkDestroyQueryPool( device, queryPool, pAllocator);
1820 }
1821 void vkDestroyRenderPass( VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator ) const
1822 {
1823 return ::vkDestroyRenderPass( device, renderPass, pAllocator);
1824 }
1825 void vkDestroySampler( VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator ) const
1826 {
1828 }
1829 void vkDestroySamplerYcbcrConversion( VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator ) const
1830 {
1831 return ::vkDestroySamplerYcbcrConversion( device, ycbcrConversion, pAllocator);
1832 }
1833 void vkDestroySamplerYcbcrConversionKHR( VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator ) const
1834 {
1835 return ::vkDestroySamplerYcbcrConversionKHR( device, ycbcrConversion, pAllocator);
1836 }
1837 void vkDestroySemaphore( VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator ) const
1838 {
1839 return ::vkDestroySemaphore( device, semaphore, pAllocator);
1840 }
1841 void vkDestroyShaderModule( VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator ) const
1842 {
1843 return ::vkDestroyShaderModule( device, shaderModule, pAllocator);
1844 }
1845 void vkDestroySurfaceKHR( VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator ) const
1846 {
1847 return ::vkDestroySurfaceKHR( instance, surface, pAllocator);
1848 }
1849 void vkDestroySwapchainKHR( VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator ) const
1850 {
1851 return ::vkDestroySwapchainKHR( device, swapchain, pAllocator);
1852 }
1853 void vkDestroyValidationCacheEXT( VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator ) const
1854 {
1855 return ::vkDestroyValidationCacheEXT( device, validationCache, pAllocator);
1856 }
1858 {
1860 }
1861 VkResult vkDisplayPowerControlEXT( VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo ) const
1862 {
1863 return ::vkDisplayPowerControlEXT( device, display, pDisplayPowerInfo);
1864 }
1865 VkResult vkEndCommandBuffer( VkCommandBuffer commandBuffer ) const
1866 {
1867 return ::vkEndCommandBuffer( commandBuffer);
1868 }
1869 VkResult vkEnumerateDeviceExtensionProperties( VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties ) const
1870 {
1871 return ::vkEnumerateDeviceExtensionProperties( physicalDevice, pLayerName, pPropertyCount, pProperties);
1872 }
1873 VkResult vkEnumerateDeviceLayerProperties( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties ) const
1874 {
1875 return ::vkEnumerateDeviceLayerProperties( physicalDevice, pPropertyCount, pProperties);
1876 }
1877 VkResult vkEnumerateInstanceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties ) const
1878 {
1879 return ::vkEnumerateInstanceExtensionProperties( pLayerName, pPropertyCount, pProperties);
1880 }
1882 {
1883 return ::vkEnumerateInstanceLayerProperties( pPropertyCount, pProperties);
1884 }
1886 {
1888 }
1889 VkResult vkEnumeratePhysicalDeviceGroups( VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties ) const
1890 {
1891 return ::vkEnumeratePhysicalDeviceGroups( instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
1892 }
1893 VkResult vkEnumeratePhysicalDeviceGroupsKHR( VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties ) const
1894 {
1895 return ::vkEnumeratePhysicalDeviceGroupsKHR( instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
1896 }
1897 VkResult vkEnumeratePhysicalDevices( VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices ) const
1898 {
1899 return ::vkEnumeratePhysicalDevices( instance, pPhysicalDeviceCount, pPhysicalDevices);
1900 }
1901 VkResult vkFlushMappedMemoryRanges( VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges ) const
1902 {
1903 return ::vkFlushMappedMemoryRanges( device, memoryRangeCount, pMemoryRanges);
1904 }
1905 void vkFreeCommandBuffers( VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers ) const
1906 {
1907 return ::vkFreeCommandBuffers( device, commandPool, commandBufferCount, pCommandBuffers);
1908 }
1909 VkResult vkFreeDescriptorSets( VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets ) const
1910 {
1911 return ::vkFreeDescriptorSets( device, descriptorPool, descriptorSetCount, pDescriptorSets);
1912 }
1913 void vkFreeMemory( VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator ) const
1914 {
1915 return ::vkFreeMemory( device, memory, pAllocator);
1916 }
1917 VkResult vkGetAccelerationStructureHandleNV( VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData ) const
1918 {
1919 return ::vkGetAccelerationStructureHandleNV( device, accelerationStructure, dataSize, pData);
1920 }
1922 {
1924 }
1925#ifdef VK_USE_PLATFORM_ANDROID_ANDROID
1926 VkResult vkGetAndroidHardwareBufferPropertiesANDROID( VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties ) const
1927 {
1929 }
1930#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/
1931 void vkGetBufferMemoryRequirements( VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements ) const
1932 {
1934 }
1935 void vkGetBufferMemoryRequirements2( VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements ) const
1936 {
1937 return ::vkGetBufferMemoryRequirements2( device, pInfo, pMemoryRequirements);
1938 }
1940 {
1941 return ::vkGetBufferMemoryRequirements2KHR( device, pInfo, pMemoryRequirements);
1942 }
1943 VkResult vkGetCalibratedTimestampsEXT( VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation ) const
1944 {
1945 return ::vkGetCalibratedTimestampsEXT( device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation);
1946 }
1948 {
1949 return ::vkGetDescriptorSetLayoutSupport( device, pCreateInfo, pSupport);
1950 }
1952 {
1953 return ::vkGetDescriptorSetLayoutSupportKHR( device, pCreateInfo, pSupport);
1954 }
1955 void vkGetDeviceGroupPeerMemoryFeatures( VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures ) const
1956 {
1957 return ::vkGetDeviceGroupPeerMemoryFeatures( device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
1958 }
1959 void vkGetDeviceGroupPeerMemoryFeaturesKHR( VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures ) const
1960 {
1961 return ::vkGetDeviceGroupPeerMemoryFeaturesKHR( device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
1962 }
1964 {
1965 return ::vkGetDeviceGroupPresentCapabilitiesKHR( device, pDeviceGroupPresentCapabilities);
1966 }
1968 {
1970 }
1971 void vkGetDeviceMemoryCommitment( VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes ) const
1972 {
1973 return ::vkGetDeviceMemoryCommitment( device, memory, pCommittedMemoryInBytes);
1974 }
1975 PFN_vkVoidFunction vkGetDeviceProcAddr( VkDevice device, const char* pName ) const
1976 {
1978 }
1979 void vkGetDeviceQueue( VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue ) const
1980 {
1981 return ::vkGetDeviceQueue( device, queueFamilyIndex, queueIndex, pQueue);
1982 }
1983 void vkGetDeviceQueue2( VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue ) const
1984 {
1985 return ::vkGetDeviceQueue2( device, pQueueInfo, pQueue);
1986 }
1987 VkResult vkGetDisplayModeProperties2KHR( VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties ) const
1988 {
1989 return ::vkGetDisplayModeProperties2KHR( physicalDevice, display, pPropertyCount, pProperties);
1990 }
1991 VkResult vkGetDisplayModePropertiesKHR( VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties ) const
1992 {
1993 return ::vkGetDisplayModePropertiesKHR( physicalDevice, display, pPropertyCount, pProperties);
1994 }
1995 VkResult vkGetDisplayPlaneCapabilities2KHR( VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities ) const
1996 {
1997 return ::vkGetDisplayPlaneCapabilities2KHR( physicalDevice, pDisplayPlaneInfo, pCapabilities);
1998 }
1999 VkResult vkGetDisplayPlaneCapabilitiesKHR( VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities ) const
2000 {
2001 return ::vkGetDisplayPlaneCapabilitiesKHR( physicalDevice, mode, planeIndex, pCapabilities);
2002 }
2003 VkResult vkGetDisplayPlaneSupportedDisplaysKHR( VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays ) const
2004 {
2005 return ::vkGetDisplayPlaneSupportedDisplaysKHR( physicalDevice, planeIndex, pDisplayCount, pDisplays);
2006 }
2007 VkResult vkGetEventStatus( VkDevice device, VkEvent event ) const
2008 {
2010 }
2011 VkResult vkGetFenceFdKHR( VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd ) const
2012 {
2013 return ::vkGetFenceFdKHR( device, pGetFdInfo, pFd);
2014 }
2015 VkResult vkGetFenceStatus( VkDevice device, VkFence fence ) const
2016 {
2018 }
2019#ifdef VK_USE_PLATFORM_WIN32_KHR
2020 VkResult vkGetFenceWin32HandleKHR( VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle ) const
2021 {
2022 return ::vkGetFenceWin32HandleKHR( device, pGetWin32HandleInfo, pHandle);
2023 }
2024#endif /*VK_USE_PLATFORM_WIN32_KHR*/
2026 {
2028 }
2029 void vkGetImageMemoryRequirements( VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements ) const
2030 {
2031 return ::vkGetImageMemoryRequirements( device, image, pMemoryRequirements);
2032 }
2033 void vkGetImageMemoryRequirements2( VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements ) const
2034 {
2035 return ::vkGetImageMemoryRequirements2( device, pInfo, pMemoryRequirements);
2036 }
2037 void vkGetImageMemoryRequirements2KHR( VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements ) const
2038 {
2039 return ::vkGetImageMemoryRequirements2KHR( device, pInfo, pMemoryRequirements);
2040 }
2041 void vkGetImageSparseMemoryRequirements( VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements ) const
2042 {
2043 return ::vkGetImageSparseMemoryRequirements( device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
2044 }
2045 void vkGetImageSparseMemoryRequirements2( VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements ) const
2046 {
2047 return ::vkGetImageSparseMemoryRequirements2( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
2048 }
2049 void vkGetImageSparseMemoryRequirements2KHR( VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements ) const
2050 {
2051 return ::vkGetImageSparseMemoryRequirements2KHR( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
2052 }
2053 void vkGetImageSubresourceLayout( VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout ) const
2054 {
2055 return ::vkGetImageSubresourceLayout( device, image, pSubresource, pLayout);
2056 }
2057 PFN_vkVoidFunction vkGetInstanceProcAddr( VkInstance instance, const char* pName ) const
2058 {
2059 return ::vkGetInstanceProcAddr( instance, pName);
2060 }
2061#ifdef VK_USE_PLATFORM_ANDROID_ANDROID
2062 VkResult vkGetMemoryAndroidHardwareBufferANDROID( VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer ) const
2063 {
2065 }
2066#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/
2067 VkResult vkGetMemoryFdKHR( VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd ) const
2068 {
2069 return ::vkGetMemoryFdKHR( device, pGetFdInfo, pFd);
2070 }
2072 {
2074 }
2076 {
2077 return ::vkGetMemoryHostPointerPropertiesEXT( device, handleType, pHostPointer, pMemoryHostPointerProperties);
2078 }
2079#ifdef VK_USE_PLATFORM_WIN32_KHR
2080 VkResult vkGetMemoryWin32HandleKHR( VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle ) const
2081 {
2082 return ::vkGetMemoryWin32HandleKHR( device, pGetWin32HandleInfo, pHandle);
2083 }
2084#endif /*VK_USE_PLATFORM_WIN32_KHR*/
2085#ifdef VK_USE_PLATFORM_WIN32_NV
2086 VkResult vkGetMemoryWin32HandleNV( VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle ) const
2087 {
2089 }
2090#endif /*VK_USE_PLATFORM_WIN32_NV*/
2091#ifdef VK_USE_PLATFORM_WIN32_KHR
2093 {
2094 return ::vkGetMemoryWin32HandlePropertiesKHR( device, handleType, handle, pMemoryWin32HandleProperties);
2095 }
2096#endif /*VK_USE_PLATFORM_WIN32_KHR*/
2097 VkResult vkGetPastPresentationTimingGOOGLE( VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings ) const
2098 {
2099 return ::vkGetPastPresentationTimingGOOGLE( device, swapchain, pPresentationTimingCount, pPresentationTimings);
2100 }
2101 VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains ) const
2102 {
2103 return ::vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( physicalDevice, pTimeDomainCount, pTimeDomains);
2104 }
2105 VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties ) const
2106 {
2107 return ::vkGetPhysicalDeviceDisplayPlaneProperties2KHR( physicalDevice, pPropertyCount, pProperties);
2108 }
2109 VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties ) const
2110 {
2111 return ::vkGetPhysicalDeviceDisplayPlanePropertiesKHR( physicalDevice, pPropertyCount, pProperties);
2112 }
2113 VkResult vkGetPhysicalDeviceDisplayProperties2KHR( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties ) const
2114 {
2115 return ::vkGetPhysicalDeviceDisplayProperties2KHR( physicalDevice, pPropertyCount, pProperties);
2116 }
2117 VkResult vkGetPhysicalDeviceDisplayPropertiesKHR( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties ) const
2118 {
2119 return ::vkGetPhysicalDeviceDisplayPropertiesKHR( physicalDevice, pPropertyCount, pProperties);
2120 }
2121 void vkGetPhysicalDeviceExternalBufferProperties( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties ) const
2122 {
2123 return ::vkGetPhysicalDeviceExternalBufferProperties( physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
2124 }
2125 void vkGetPhysicalDeviceExternalBufferPropertiesKHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties ) const
2126 {
2127 return ::vkGetPhysicalDeviceExternalBufferPropertiesKHR( physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
2128 }
2129 void vkGetPhysicalDeviceExternalFenceProperties( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties ) const
2130 {
2131 return ::vkGetPhysicalDeviceExternalFenceProperties( physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
2132 }
2133 void vkGetPhysicalDeviceExternalFencePropertiesKHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties ) const
2134 {
2135 return ::vkGetPhysicalDeviceExternalFencePropertiesKHR( physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
2136 }
2138 {
2139 return ::vkGetPhysicalDeviceExternalImageFormatPropertiesNV( physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties);
2140 }
2141 void vkGetPhysicalDeviceExternalSemaphoreProperties( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties ) const
2142 {
2143 return ::vkGetPhysicalDeviceExternalSemaphoreProperties( physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
2144 }
2145 void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties ) const
2146 {
2147 return ::vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
2148 }
2149 void vkGetPhysicalDeviceFeatures( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures ) const
2150 {
2151 return ::vkGetPhysicalDeviceFeatures( physicalDevice, pFeatures);
2152 }
2153 void vkGetPhysicalDeviceFeatures2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures ) const
2154 {
2155 return ::vkGetPhysicalDeviceFeatures2( physicalDevice, pFeatures);
2156 }
2157 void vkGetPhysicalDeviceFeatures2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures ) const
2158 {
2159 return ::vkGetPhysicalDeviceFeatures2KHR( physicalDevice, pFeatures);
2160 }
2161 void vkGetPhysicalDeviceFormatProperties( VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties ) const
2162 {
2163 return ::vkGetPhysicalDeviceFormatProperties( physicalDevice, format, pFormatProperties);
2164 }
2165 void vkGetPhysicalDeviceFormatProperties2( VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties ) const
2166 {
2167 return ::vkGetPhysicalDeviceFormatProperties2( physicalDevice, format, pFormatProperties);
2168 }
2169 void vkGetPhysicalDeviceFormatProperties2KHR( VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties ) const
2170 {
2171 return ::vkGetPhysicalDeviceFormatProperties2KHR( physicalDevice, format, pFormatProperties);
2172 }
2174 {
2175 return ::vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( physicalDevice, pFeatures, pLimits);
2176 }
2178 {
2179 return ::vkGetPhysicalDeviceImageFormatProperties( physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
2180 }
2181 VkResult vkGetPhysicalDeviceImageFormatProperties2( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties ) const
2182 {
2183 return ::vkGetPhysicalDeviceImageFormatProperties2( physicalDevice, pImageFormatInfo, pImageFormatProperties);
2184 }
2185 VkResult vkGetPhysicalDeviceImageFormatProperties2KHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties ) const
2186 {
2187 return ::vkGetPhysicalDeviceImageFormatProperties2KHR( physicalDevice, pImageFormatInfo, pImageFormatProperties);
2188 }
2189 void vkGetPhysicalDeviceMemoryProperties( VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties ) const
2190 {
2191 return ::vkGetPhysicalDeviceMemoryProperties( physicalDevice, pMemoryProperties);
2192 }
2193 void vkGetPhysicalDeviceMemoryProperties2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties ) const
2194 {
2195 return ::vkGetPhysicalDeviceMemoryProperties2( physicalDevice, pMemoryProperties);
2196 }
2197 void vkGetPhysicalDeviceMemoryProperties2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties ) const
2198 {
2199 return ::vkGetPhysicalDeviceMemoryProperties2KHR( physicalDevice, pMemoryProperties);
2200 }
2201 void vkGetPhysicalDeviceMultisamplePropertiesEXT( VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties ) const
2202 {
2203 return ::vkGetPhysicalDeviceMultisamplePropertiesEXT( physicalDevice, samples, pMultisampleProperties);
2204 }
2205 VkResult vkGetPhysicalDevicePresentRectanglesKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects ) const
2206 {
2207 return ::vkGetPhysicalDevicePresentRectanglesKHR( physicalDevice, surface, pRectCount, pRects);
2208 }
2209 void vkGetPhysicalDeviceProperties( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties ) const
2210 {
2211 return ::vkGetPhysicalDeviceProperties( physicalDevice, pProperties);
2212 }
2213 void vkGetPhysicalDeviceProperties2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties ) const
2214 {
2215 return ::vkGetPhysicalDeviceProperties2( physicalDevice, pProperties);
2216 }
2217 void vkGetPhysicalDeviceProperties2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties ) const
2218 {
2219 return ::vkGetPhysicalDeviceProperties2KHR( physicalDevice, pProperties);
2220 }
2221 void vkGetPhysicalDeviceQueueFamilyProperties( VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties ) const
2222 {
2223 return ::vkGetPhysicalDeviceQueueFamilyProperties( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
2224 }
2225 void vkGetPhysicalDeviceQueueFamilyProperties2( VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties ) const
2226 {
2227 return ::vkGetPhysicalDeviceQueueFamilyProperties2( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
2228 }
2229 void vkGetPhysicalDeviceQueueFamilyProperties2KHR( VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties ) const
2230 {
2231 return ::vkGetPhysicalDeviceQueueFamilyProperties2KHR( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
2232 }
2234 {
2235 return ::vkGetPhysicalDeviceSparseImageFormatProperties( physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
2236 }
2237 void vkGetPhysicalDeviceSparseImageFormatProperties2( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties ) const
2238 {
2239 return ::vkGetPhysicalDeviceSparseImageFormatProperties2( physicalDevice, pFormatInfo, pPropertyCount, pProperties);
2240 }
2241 void vkGetPhysicalDeviceSparseImageFormatProperties2KHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties ) const
2242 {
2243 return ::vkGetPhysicalDeviceSparseImageFormatProperties2KHR( physicalDevice, pFormatInfo, pPropertyCount, pProperties);
2244 }
2245 VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities ) const
2246 {
2247 return ::vkGetPhysicalDeviceSurfaceCapabilities2EXT( physicalDevice, surface, pSurfaceCapabilities);
2248 }
2249 VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities ) const
2250 {
2251 return ::vkGetPhysicalDeviceSurfaceCapabilities2KHR( physicalDevice, pSurfaceInfo, pSurfaceCapabilities);
2252 }
2253 VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities ) const
2254 {
2255 return ::vkGetPhysicalDeviceSurfaceCapabilitiesKHR( physicalDevice, surface, pSurfaceCapabilities);
2256 }
2257 VkResult vkGetPhysicalDeviceSurfaceFormats2KHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats ) const
2258 {
2259 return ::vkGetPhysicalDeviceSurfaceFormats2KHR( physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats);
2260 }
2261 VkResult vkGetPhysicalDeviceSurfaceFormatsKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats ) const
2262 {
2263 return ::vkGetPhysicalDeviceSurfaceFormatsKHR( physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
2264 }
2265 VkResult vkGetPhysicalDeviceSurfacePresentModesKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes ) const
2266 {
2267 return ::vkGetPhysicalDeviceSurfacePresentModesKHR( physicalDevice, surface, pPresentModeCount, pPresentModes);
2268 }
2269 VkResult vkGetPhysicalDeviceSurfaceSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported ) const
2270 {
2271 return ::vkGetPhysicalDeviceSurfaceSupportKHR( physicalDevice, queueFamilyIndex, surface, pSupported);
2272 }
2273#ifdef VK_USE_PLATFORM_WAYLAND_KHR
2274 VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display ) const
2275 {
2276 return ::vkGetPhysicalDeviceWaylandPresentationSupportKHR( physicalDevice, queueFamilyIndex, display);
2277 }
2278#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
2279#ifdef VK_USE_PLATFORM_WIN32_KHR
2280 VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex ) const
2281 {
2282 return ::vkGetPhysicalDeviceWin32PresentationSupportKHR( physicalDevice, queueFamilyIndex);
2283 }
2284#endif /*VK_USE_PLATFORM_WIN32_KHR*/
2285#ifdef VK_USE_PLATFORM_XCB_KHR
2286 VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id ) const
2287 {
2288 return ::vkGetPhysicalDeviceXcbPresentationSupportKHR( physicalDevice, queueFamilyIndex, connection, visual_id);
2289 }
2290#endif /*VK_USE_PLATFORM_XCB_KHR*/
2291#ifdef VK_USE_PLATFORM_XLIB_KHR
2292 VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID ) const
2293 {
2294 return ::vkGetPhysicalDeviceXlibPresentationSupportKHR( physicalDevice, queueFamilyIndex, dpy, visualID);
2295 }
2296#endif /*VK_USE_PLATFORM_XLIB_KHR*/
2297 VkResult vkGetPipelineCacheData( VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData ) const
2298 {
2299 return ::vkGetPipelineCacheData( device, pipelineCache, pDataSize, pData);
2300 }
2301 VkResult vkGetQueryPoolResults( VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags ) const
2302 {
2303 return ::vkGetQueryPoolResults( device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
2304 }
2305 void vkGetQueueCheckpointDataNV( VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData ) const
2306 {
2307 return ::vkGetQueueCheckpointDataNV( queue, pCheckpointDataCount, pCheckpointData);
2308 }
2309#ifdef VK_USE_PLATFORM_XLIB_XRANDR_NV
2310 VkResult vkGetRandROutputDisplayEXT( VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay ) const
2311 {
2312 return ::vkGetRandROutputDisplayEXT( physicalDevice, dpy, rrOutput, pDisplay);
2313 }
2314#endif /*VK_USE_PLATFORM_XLIB_XRANDR_NV*/
2315 VkResult vkGetRayTracingShaderGroupHandlesNV( VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData ) const
2316 {
2317 return ::vkGetRayTracingShaderGroupHandlesNV( device, pipeline, firstGroup, groupCount, dataSize, pData);
2318 }
2319 VkResult vkGetRefreshCycleDurationGOOGLE( VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties ) const
2320 {
2321 return ::vkGetRefreshCycleDurationGOOGLE( device, swapchain, pDisplayTimingProperties);
2322 }
2323 void vkGetRenderAreaGranularity( VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity ) const
2324 {
2325 return ::vkGetRenderAreaGranularity( device, renderPass, pGranularity);
2326 }
2327 VkResult vkGetSemaphoreFdKHR( VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd ) const
2328 {
2329 return ::vkGetSemaphoreFdKHR( device, pGetFdInfo, pFd);
2330 }
2331#ifdef VK_USE_PLATFORM_WIN32_KHR
2332 VkResult vkGetSemaphoreWin32HandleKHR( VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle ) const
2333 {
2334 return ::vkGetSemaphoreWin32HandleKHR( device, pGetWin32HandleInfo, pHandle);
2335 }
2336#endif /*VK_USE_PLATFORM_WIN32_KHR*/
2337 VkResult vkGetShaderInfoAMD( VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo ) const
2338 {
2339 return ::vkGetShaderInfoAMD( device, pipeline, shaderStage, infoType, pInfoSize, pInfo);
2340 }
2341 VkResult vkGetSwapchainCounterEXT( VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue ) const
2342 {
2343 return ::vkGetSwapchainCounterEXT( device, swapchain, counter, pCounterValue);
2344 }
2345 VkResult vkGetSwapchainImagesKHR( VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages ) const
2346 {
2347 return ::vkGetSwapchainImagesKHR( device, swapchain, pSwapchainImageCount, pSwapchainImages);
2348 }
2349 VkResult vkGetSwapchainStatusKHR( VkDevice device, VkSwapchainKHR swapchain ) const
2350 {
2352 }
2353 VkResult vkGetValidationCacheDataEXT( VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData ) const
2354 {
2355 return ::vkGetValidationCacheDataEXT( device, validationCache, pDataSize, pData);
2356 }
2357 VkResult vkImportFenceFdKHR( VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo ) const
2358 {
2359 return ::vkImportFenceFdKHR( device, pImportFenceFdInfo);
2360 }
2361#ifdef VK_USE_PLATFORM_WIN32_KHR
2362 VkResult vkImportFenceWin32HandleKHR( VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo ) const
2363 {
2364 return ::vkImportFenceWin32HandleKHR( device, pImportFenceWin32HandleInfo);
2365 }
2366#endif /*VK_USE_PLATFORM_WIN32_KHR*/
2367 VkResult vkImportSemaphoreFdKHR( VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo ) const
2368 {
2369 return ::vkImportSemaphoreFdKHR( device, pImportSemaphoreFdInfo);
2370 }
2371#ifdef VK_USE_PLATFORM_WIN32_KHR
2372 VkResult vkImportSemaphoreWin32HandleKHR( VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo ) const
2373 {
2374 return ::vkImportSemaphoreWin32HandleKHR( device, pImportSemaphoreWin32HandleInfo);
2375 }
2376#endif /*VK_USE_PLATFORM_WIN32_KHR*/
2377 VkResult vkInvalidateMappedMemoryRanges( VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges ) const
2378 {
2379 return ::vkInvalidateMappedMemoryRanges( device, memoryRangeCount, pMemoryRanges);
2380 }
2381 VkResult vkMapMemory( VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData ) const
2382 {
2384 }
2385 VkResult vkMergePipelineCaches( VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches ) const
2386 {
2387 return ::vkMergePipelineCaches( device, dstCache, srcCacheCount, pSrcCaches);
2388 }
2389 VkResult vkMergeValidationCachesEXT( VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches ) const
2390 {
2391 return ::vkMergeValidationCachesEXT( device, dstCache, srcCacheCount, pSrcCaches);
2392 }
2393 void vkQueueBeginDebugUtilsLabelEXT( VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo ) const
2394 {
2395 return ::vkQueueBeginDebugUtilsLabelEXT( queue, pLabelInfo);
2396 }
2397 VkResult vkQueueBindSparse( VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence ) const
2398 {
2399 return ::vkQueueBindSparse( queue, bindInfoCount, pBindInfo, fence);
2400 }
2401 void vkQueueEndDebugUtilsLabelEXT( VkQueue queue ) const
2402 {
2404 }
2405 void vkQueueInsertDebugUtilsLabelEXT( VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo ) const
2406 {
2407 return ::vkQueueInsertDebugUtilsLabelEXT( queue, pLabelInfo);
2408 }
2409 VkResult vkQueuePresentKHR( VkQueue queue, const VkPresentInfoKHR* pPresentInfo ) const
2410 {
2411 return ::vkQueuePresentKHR( queue, pPresentInfo);
2412 }
2413 VkResult vkQueueSubmit( VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence ) const
2414 {
2415 return ::vkQueueSubmit( queue, submitCount, pSubmits, fence);
2416 }
2417 VkResult vkQueueWaitIdle( VkQueue queue ) const
2418 {
2420 }
2421 VkResult vkRegisterDeviceEventEXT( VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence ) const
2422 {
2423 return ::vkRegisterDeviceEventEXT( device, pDeviceEventInfo, pAllocator, pFence);
2424 }
2425 VkResult vkRegisterDisplayEventEXT( VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence ) const
2426 {
2427 return ::vkRegisterDisplayEventEXT( device, display, pDisplayEventInfo, pAllocator, pFence);
2428 }
2429 VkResult vkRegisterObjectsNVX( VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectTableEntryNVX* const* ppObjectTableEntries, const uint32_t* pObjectIndices ) const
2430 {
2431 return ::vkRegisterObjectsNVX( device, objectTable, objectCount, ppObjectTableEntries, pObjectIndices);
2432 }
2433 VkResult vkReleaseDisplayEXT( VkPhysicalDevice physicalDevice, VkDisplayKHR display ) const
2434 {
2435 return ::vkReleaseDisplayEXT( physicalDevice, display);
2436 }
2437 VkResult vkResetCommandBuffer( VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags ) const
2438 {
2439 return ::vkResetCommandBuffer( commandBuffer, flags);
2440 }
2441 VkResult vkResetCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags ) const
2442 {
2444 }
2445 VkResult vkResetDescriptorPool( VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags ) const
2446 {
2447 return ::vkResetDescriptorPool( device, descriptorPool, flags);
2448 }
2449 VkResult vkResetEvent( VkDevice device, VkEvent event ) const
2450 {
2452 }
2453 VkResult vkResetFences( VkDevice device, uint32_t fenceCount, const VkFence* pFences ) const
2454 {
2455 return ::vkResetFences( device, fenceCount, pFences);
2456 }
2458 {
2460 }
2462 {
2464 }
2465 VkResult vkSetEvent( VkDevice device, VkEvent event ) const
2466 {
2468 }
2469 void vkSetHdrMetadataEXT( VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata ) const
2470 {
2471 return ::vkSetHdrMetadataEXT( device, swapchainCount, pSwapchains, pMetadata);
2472 }
2474 {
2475 return ::vkSubmitDebugUtilsMessageEXT( instance, messageSeverity, messageTypes, pCallbackData);
2476 }
2477 void vkTrimCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags ) const
2478 {
2479 return ::vkTrimCommandPool( device, commandPool, flags);
2480 }
2481 void vkTrimCommandPoolKHR( VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags ) const
2482 {
2484 }
2485 void vkUnmapMemory( VkDevice device, VkDeviceMemory memory ) const
2486 {
2488 }
2489 VkResult vkUnregisterObjectsNVX( VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices ) const
2490 {
2491 return ::vkUnregisterObjectsNVX( device, objectTable, objectCount, pObjectEntryTypes, pObjectIndices);
2492 }
2493 void vkUpdateDescriptorSetWithTemplate( VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData ) const
2494 {
2495 return ::vkUpdateDescriptorSetWithTemplate( device, descriptorSet, descriptorUpdateTemplate, pData);
2496 }
2497 void vkUpdateDescriptorSetWithTemplateKHR( VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData ) const
2498 {
2499 return ::vkUpdateDescriptorSetWithTemplateKHR( device, descriptorSet, descriptorUpdateTemplate, pData);
2500 }
2501 void vkUpdateDescriptorSets( VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies ) const
2502 {
2503 return ::vkUpdateDescriptorSets( device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
2504 }
2505 VkResult vkWaitForFences( VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout ) const
2506 {
2507 return ::vkWaitForFences( device, fenceCount, pFences, waitAll, timeout);
2508 }
2509};
2510
2511 struct AllocationCallbacks;
2512
2513 template <typename OwnerType, typename Dispatch>
2515 {
2516 public:
2517 ObjectDestroy( OwnerType owner = OwnerType(), Optional<const AllocationCallbacks> allocationCallbacks = nullptr, Dispatch const &dispatch = Dispatch() )
2518 : m_owner( owner )
2519 , m_allocationCallbacks( allocationCallbacks )
2520 , m_dispatch( &dispatch )
2521 {}
2522
2523 OwnerType getOwner() const { return m_owner; }
2525
2526 protected:
2527 template <typename T>
2529 {
2531 }
2532
2533 private:
2534 OwnerType m_owner;
2536 Dispatch const* m_dispatch;
2537 };
2538
2539 class NoParent;
2540
2541 template <typename Dispatch>
2542 class ObjectDestroy<NoParent,Dispatch>
2543 {
2544 public:
2545 ObjectDestroy( Optional<const AllocationCallbacks> allocationCallbacks = nullptr, Dispatch const &dispatch = Dispatch() )
2546 : m_allocationCallbacks( allocationCallbacks )
2547 , m_dispatch( &dispatch )
2548 {}
2549
2551
2552 protected:
2553 template <typename T>
2555 {
2556 t.destroy( m_allocationCallbacks, *m_dispatch );
2557 }
2558
2559 private:
2561 Dispatch const* m_dispatch;
2562 };
2563
2564 template <typename OwnerType, typename Dispatch>
2566 {
2567 public:
2568 ObjectFree( OwnerType owner = OwnerType(), Optional<const AllocationCallbacks> allocationCallbacks = nullptr, Dispatch const &dispatch = Dispatch() )
2569 : m_owner( owner )
2570 , m_allocationCallbacks( allocationCallbacks )
2571 , m_dispatch( &dispatch )
2572 {}
2573
2574 OwnerType getOwner() const { return m_owner; }
2576
2577 protected:
2578 template <typename T>
2580 {
2582 }
2583
2584 private:
2585 OwnerType m_owner;
2587 Dispatch const* m_dispatch;
2588 };
2589
2590 template <typename OwnerType, typename PoolType, typename Dispatch>
2592 {
2593 public:
2594 PoolFree( OwnerType owner = OwnerType(), PoolType pool = PoolType(), Dispatch const &dispatch = Dispatch() )
2595 : m_owner( owner )
2596 , m_pool( pool )
2597 , m_dispatch( &dispatch )
2598 {}
2599
2600 OwnerType getOwner() const { return m_owner; }
2601 PoolType getPool() const { return m_pool; }
2602
2603 protected:
2604 template <typename T>
2606 {
2607 m_owner.free( m_pool, t, *m_dispatch );
2608 }
2609
2610 private:
2611 OwnerType m_owner;
2612 PoolType m_pool;
2613 Dispatch const* m_dispatch;
2614 };
2615
2617
2619
2621
2623 {
2624 };
2625
2627
2629 {
2630 };
2631
2633
2635 {
2636 };
2637
2639
2641 {
2642 };
2643
2645
2647 {
2648 };
2649
2651
2653 {
2654 };
2655
2657
2659 {
2660 };
2661
2663
2665 {
2666 };
2667
2669
2671 {
2672 };
2673
2675
2677 {
2678 };
2679
2681
2683 {
2684 };
2685
2687
2689 {
2690 };
2691
2693
2695 {
2696 };
2697
2699
2701 {
2702 };
2703
2705
2707 {
2708 };
2709
2711
2713 {
2714 };
2715
2717
2719 {
2720 };
2721
2723
2725 {
2726 };
2727
2729
2731 {
2732 };
2733
2735
2737 {
2738 };
2739
2741
2743 {
2744 };
2745
2747
2749 {
2750 };
2751
2753
2755 {
2756 };
2757
2759
2761 {
2762 };
2763
2765
2767 {
2768 };
2769
2771
2773 {
2774 };
2775
2777
2779
2781 {
2782 };
2783
2785
2787 {
2788 };
2789
2791
2792#ifdef VK_USE_PLATFORM_ANDROID_KHR
2793 enum class AndroidSurfaceCreateFlagBitsKHR
2794 {
2795 };
2796#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
2797
2798#ifdef VK_USE_PLATFORM_ANDROID_KHR
2799 using AndroidSurfaceCreateFlagsKHR = Flags<AndroidSurfaceCreateFlagBitsKHR, VkAndroidSurfaceCreateFlagsKHR>;
2800#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
2801
2802#ifdef VK_USE_PLATFORM_VI_NN
2803 enum class ViSurfaceCreateFlagBitsNN
2804 {
2805 };
2806#endif /*VK_USE_PLATFORM_VI_NN*/
2807
2808#ifdef VK_USE_PLATFORM_VI_NN
2809 using ViSurfaceCreateFlagsNN = Flags<ViSurfaceCreateFlagBitsNN, VkViSurfaceCreateFlagsNN>;
2810#endif /*VK_USE_PLATFORM_VI_NN*/
2811
2812#ifdef VK_USE_PLATFORM_WAYLAND_KHR
2813 enum class WaylandSurfaceCreateFlagBitsKHR
2814 {
2815 };
2816#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
2817
2818#ifdef VK_USE_PLATFORM_WAYLAND_KHR
2819 using WaylandSurfaceCreateFlagsKHR = Flags<WaylandSurfaceCreateFlagBitsKHR, VkWaylandSurfaceCreateFlagsKHR>;
2820#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
2821
2822#ifdef VK_USE_PLATFORM_WIN32_KHR
2823 enum class Win32SurfaceCreateFlagBitsKHR
2824 {
2825 };
2826#endif /*VK_USE_PLATFORM_WIN32_KHR*/
2827
2828#ifdef VK_USE_PLATFORM_WIN32_KHR
2829 using Win32SurfaceCreateFlagsKHR = Flags<Win32SurfaceCreateFlagBitsKHR, VkWin32SurfaceCreateFlagsKHR>;
2830#endif /*VK_USE_PLATFORM_WIN32_KHR*/
2831
2832#ifdef VK_USE_PLATFORM_XLIB_KHR
2833 enum class XlibSurfaceCreateFlagBitsKHR
2834 {
2835 };
2836#endif /*VK_USE_PLATFORM_XLIB_KHR*/
2837
2838#ifdef VK_USE_PLATFORM_XLIB_KHR
2839 using XlibSurfaceCreateFlagsKHR = Flags<XlibSurfaceCreateFlagBitsKHR, VkXlibSurfaceCreateFlagsKHR>;
2840#endif /*VK_USE_PLATFORM_XLIB_KHR*/
2841
2842#ifdef VK_USE_PLATFORM_XCB_KHR
2843 enum class XcbSurfaceCreateFlagBitsKHR
2844 {
2845 };
2846#endif /*VK_USE_PLATFORM_XCB_KHR*/
2847
2848#ifdef VK_USE_PLATFORM_XCB_KHR
2849 using XcbSurfaceCreateFlagsKHR = Flags<XcbSurfaceCreateFlagBitsKHR, VkXcbSurfaceCreateFlagsKHR>;
2850#endif /*VK_USE_PLATFORM_XCB_KHR*/
2851
2852#ifdef VK_USE_PLATFORM_IOS_MVK
2853 enum class IOSSurfaceCreateFlagBitsMVK
2854 {
2855 };
2856#endif /*VK_USE_PLATFORM_IOS_MVK*/
2857
2858#ifdef VK_USE_PLATFORM_IOS_MVK
2859 using IOSSurfaceCreateFlagsMVK = Flags<IOSSurfaceCreateFlagBitsMVK, VkIOSSurfaceCreateFlagsMVK>;
2860#endif /*VK_USE_PLATFORM_IOS_MVK*/
2861
2862#ifdef VK_USE_PLATFORM_MACOS_MVK
2863 enum class MacOSSurfaceCreateFlagBitsMVK
2864 {
2865 };
2866#endif /*VK_USE_PLATFORM_MACOS_MVK*/
2867
2868#ifdef VK_USE_PLATFORM_MACOS_MVK
2869 using MacOSSurfaceCreateFlagsMVK = Flags<MacOSSurfaceCreateFlagBitsMVK, VkMacOSSurfaceCreateFlagsMVK>;
2870#endif /*VK_USE_PLATFORM_MACOS_MVK*/
2871
2872#ifdef VK_USE_PLATFORM_FUCHSIA_FUCHSIA
2873 enum class ImagePipeSurfaceCreateFlagBitsFUCHSIA
2874 {
2875 };
2876#endif /*VK_USE_PLATFORM_FUCHSIA_FUCHSIA*/
2877
2878#ifdef VK_USE_PLATFORM_FUCHSIA_FUCHSIA
2879 using ImagePipeSurfaceCreateFlagsFUCHSIA = Flags<ImagePipeSurfaceCreateFlagBitsFUCHSIA, VkImagePipeSurfaceCreateFlagsFUCHSIA>;
2880#endif /*VK_USE_PLATFORM_FUCHSIA_FUCHSIA*/
2881
2883 {
2884 };
2885
2887
2889
2891 {
2892 };
2893
2895
2897 {
2898 };
2899
2901
2903 {
2904 };
2905
2907
2909 {
2910 };
2911
2913
2915 {
2916 };
2917
2919
2921 {
2922 };
2923
2925
2927 {
2928 };
2929
2931
2933 {
2934 };
2935
2937
2939 {
2940 };
2941
2943
2945 {
2946 public:
2949 {}
2950
2953 {}
2954
2955 VULKAN_HPP_TYPESAFE_EXPLICIT DeviceMemory( VkDeviceMemory deviceMemory )
2956 : m_deviceMemory( deviceMemory )
2957 {}
2958
2959#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
2960 DeviceMemory & operator=(VkDeviceMemory deviceMemory)
2961 {
2962 m_deviceMemory = deviceMemory;
2963 return *this;
2964 }
2965#endif
2966
2967 DeviceMemory & operator=( std::nullptr_t )
2968 {
2970 return *this;
2971 }
2972
2973 bool operator==( DeviceMemory const & rhs ) const
2974 {
2975 return m_deviceMemory == rhs.m_deviceMemory;
2976 }
2977
2978 bool operator!=(DeviceMemory const & rhs ) const
2979 {
2980 return m_deviceMemory != rhs.m_deviceMemory;
2981 }
2982
2983 bool operator<(DeviceMemory const & rhs ) const
2984 {
2985 return m_deviceMemory < rhs.m_deviceMemory;
2986 }
2987
2988
2989
2990 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeviceMemory() const
2991 {
2992 return m_deviceMemory;
2993 }
2994
2995 explicit operator bool() const
2996 {
2998 }
2999
3000 bool operator!() const
3001 {
3003 }
3004
3005 private:
3006 VkDeviceMemory m_deviceMemory;
3007 };
3008
3009 static_assert( sizeof( DeviceMemory ) == sizeof( VkDeviceMemory ), "handle and wrapper have different size!" );
3010
3012 {
3013 public:
3016 {}
3017
3020 {}
3021
3022 VULKAN_HPP_TYPESAFE_EXPLICIT CommandPool( VkCommandPool commandPool )
3023 : m_commandPool( commandPool )
3024 {}
3025
3026#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
3027 CommandPool & operator=(VkCommandPool commandPool)
3028 {
3029 m_commandPool = commandPool;
3030 return *this;
3031 }
3032#endif
3033
3034 CommandPool & operator=( std::nullptr_t )
3035 {
3037 return *this;
3038 }
3039
3040 bool operator==( CommandPool const & rhs ) const
3041 {
3042 return m_commandPool == rhs.m_commandPool;
3043 }
3044
3045 bool operator!=(CommandPool const & rhs ) const
3046 {
3047 return m_commandPool != rhs.m_commandPool;
3048 }
3049
3050 bool operator<(CommandPool const & rhs ) const
3051 {
3052 return m_commandPool < rhs.m_commandPool;
3053 }
3054
3055
3056
3057 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandPool() const
3058 {
3059 return m_commandPool;
3060 }
3061
3062 explicit operator bool() const
3063 {
3064 return m_commandPool != VK_NULL_HANDLE;
3065 }
3066
3067 bool operator!() const
3068 {
3069 return m_commandPool == VK_NULL_HANDLE;
3070 }
3071
3072 private:
3073 VkCommandPool m_commandPool;
3074 };
3075
3076 static_assert( sizeof( CommandPool ) == sizeof( VkCommandPool ), "handle and wrapper have different size!" );
3077
3079 {
3080 public:
3083 {}
3084
3087 {}
3088
3090 : m_buffer( buffer )
3091 {}
3092
3093#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
3094 Buffer & operator=(VkBuffer buffer)
3095 {
3096 m_buffer = buffer;
3097 return *this;
3098 }
3099#endif
3100
3101 Buffer & operator=( std::nullptr_t )
3102 {
3104 return *this;
3105 }
3106
3107 bool operator==( Buffer const & rhs ) const
3108 {
3109 return m_buffer == rhs.m_buffer;
3110 }
3111
3112 bool operator!=(Buffer const & rhs ) const
3113 {
3114 return m_buffer != rhs.m_buffer;
3115 }
3116
3117 bool operator<(Buffer const & rhs ) const
3118 {
3119 return m_buffer < rhs.m_buffer;
3120 }
3121
3122
3123
3124 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBuffer() const
3125 {
3126 return m_buffer;
3127 }
3128
3129 explicit operator bool() const
3130 {
3131 return m_buffer != VK_NULL_HANDLE;
3132 }
3133
3134 bool operator!() const
3135 {
3136 return m_buffer == VK_NULL_HANDLE;
3137 }
3138
3139 private:
3140 VkBuffer m_buffer;
3141 };
3142
3143 static_assert( sizeof( Buffer ) == sizeof( VkBuffer ), "handle and wrapper have different size!" );
3144
3146 {
3147 public:
3150 {}
3151
3154 {}
3155
3156 VULKAN_HPP_TYPESAFE_EXPLICIT BufferView( VkBufferView bufferView )
3157 : m_bufferView( bufferView )
3158 {}
3159
3160#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
3161 BufferView & operator=(VkBufferView bufferView)
3162 {
3163 m_bufferView = bufferView;
3164 return *this;
3165 }
3166#endif
3167
3168 BufferView & operator=( std::nullptr_t )
3169 {
3171 return *this;
3172 }
3173
3174 bool operator==( BufferView const & rhs ) const
3175 {
3176 return m_bufferView == rhs.m_bufferView;
3177 }
3178
3179 bool operator!=(BufferView const & rhs ) const
3180 {
3181 return m_bufferView != rhs.m_bufferView;
3182 }
3183
3184 bool operator<(BufferView const & rhs ) const
3185 {
3186 return m_bufferView < rhs.m_bufferView;
3187 }
3188
3189
3190
3191 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferView() const
3192 {
3193 return m_bufferView;
3194 }
3195
3196 explicit operator bool() const
3197 {
3198 return m_bufferView != VK_NULL_HANDLE;
3199 }
3200
3201 bool operator!() const
3202 {
3203 return m_bufferView == VK_NULL_HANDLE;
3204 }
3205
3206 private:
3207 VkBufferView m_bufferView;
3208 };
3209
3210 static_assert( sizeof( BufferView ) == sizeof( VkBufferView ), "handle and wrapper have different size!" );
3211
3212 class Image
3213 {
3214 public:
3217 {}
3218
3219 VULKAN_HPP_CONSTEXPR Image( std::nullptr_t )
3221 {}
3222
3224 : m_image( image )
3225 {}
3226
3227#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
3228 Image & operator=(VkImage image)
3229 {
3230 m_image = image;
3231 return *this;
3232 }
3233#endif
3234
3235 Image & operator=( std::nullptr_t )
3236 {
3238 return *this;
3239 }
3240
3241 bool operator==( Image const & rhs ) const
3242 {
3243 return m_image == rhs.m_image;
3244 }
3245
3246 bool operator!=(Image const & rhs ) const
3247 {
3248 return m_image != rhs.m_image;
3249 }
3250
3251 bool operator<(Image const & rhs ) const
3252 {
3253 return m_image < rhs.m_image;
3254 }
3255
3256
3257
3258 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImage() const
3259 {
3260 return m_image;
3261 }
3262
3263 explicit operator bool() const
3264 {
3265 return m_image != VK_NULL_HANDLE;
3266 }
3267
3268 bool operator!() const
3269 {
3270 return m_image == VK_NULL_HANDLE;
3271 }
3272
3273 private:
3274 VkImage m_image;
3275 };
3276
3277 static_assert( sizeof( Image ) == sizeof( VkImage ), "handle and wrapper have different size!" );
3278
3280 {
3281 public:
3284 {}
3285
3288 {}
3289
3291 : m_imageView( imageView )
3292 {}
3293
3294#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
3295 ImageView & operator=(VkImageView imageView)
3296 {
3297 m_imageView = imageView;
3298 return *this;
3299 }
3300#endif
3301
3302 ImageView & operator=( std::nullptr_t )
3303 {
3305 return *this;
3306 }
3307
3308 bool operator==( ImageView const & rhs ) const
3309 {
3310 return m_imageView == rhs.m_imageView;
3311 }
3312
3313 bool operator!=(ImageView const & rhs ) const
3314 {
3315 return m_imageView != rhs.m_imageView;
3316 }
3317
3318 bool operator<(ImageView const & rhs ) const
3319 {
3320 return m_imageView < rhs.m_imageView;
3321 }
3322
3323
3324
3325 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImageView() const
3326 {
3327 return m_imageView;
3328 }
3329
3330 explicit operator bool() const
3331 {
3332 return m_imageView != VK_NULL_HANDLE;
3333 }
3334
3335 bool operator!() const
3336 {
3337 return m_imageView == VK_NULL_HANDLE;
3338 }
3339
3340 private:
3341 VkImageView m_imageView;
3342 };
3343
3344 static_assert( sizeof( ImageView ) == sizeof( VkImageView ), "handle and wrapper have different size!" );
3345
3347 {
3348 public:
3351 {}
3352
3355 {}
3356
3357 VULKAN_HPP_TYPESAFE_EXPLICIT ShaderModule( VkShaderModule shaderModule )
3358 : m_shaderModule( shaderModule )
3359 {}
3360
3361#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
3362 ShaderModule & operator=(VkShaderModule shaderModule)
3363 {
3364 m_shaderModule = shaderModule;
3365 return *this;
3366 }
3367#endif
3368
3369 ShaderModule & operator=( std::nullptr_t )
3370 {
3372 return *this;
3373 }
3374
3375 bool operator==( ShaderModule const & rhs ) const
3376 {
3377 return m_shaderModule == rhs.m_shaderModule;
3378 }
3379
3380 bool operator!=(ShaderModule const & rhs ) const
3381 {
3382 return m_shaderModule != rhs.m_shaderModule;
3383 }
3384
3385 bool operator<(ShaderModule const & rhs ) const
3386 {
3387 return m_shaderModule < rhs.m_shaderModule;
3388 }
3389
3390
3391
3392 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkShaderModule() const
3393 {
3394 return m_shaderModule;
3395 }
3396
3397 explicit operator bool() const
3398 {
3400 }
3401
3402 bool operator!() const
3403 {
3405 }
3406
3407 private:
3408 VkShaderModule m_shaderModule;
3409 };
3410
3411 static_assert( sizeof( ShaderModule ) == sizeof( VkShaderModule ), "handle and wrapper have different size!" );
3412
3414 {
3415 public:
3418 {}
3419
3422 {}
3423
3425 : m_pipeline( pipeline )
3426 {}
3427
3428#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
3429 Pipeline & operator=(VkPipeline pipeline)
3430 {
3431 m_pipeline = pipeline;
3432 return *this;
3433 }
3434#endif
3435
3436 Pipeline & operator=( std::nullptr_t )
3437 {
3439 return *this;
3440 }
3441
3442 bool operator==( Pipeline const & rhs ) const
3443 {
3444 return m_pipeline == rhs.m_pipeline;
3445 }
3446
3447 bool operator!=(Pipeline const & rhs ) const
3448 {
3449 return m_pipeline != rhs.m_pipeline;
3450 }
3451
3452 bool operator<(Pipeline const & rhs ) const
3453 {
3454 return m_pipeline < rhs.m_pipeline;
3455 }
3456
3457
3458
3459 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipeline() const
3460 {
3461 return m_pipeline;
3462 }
3463
3464 explicit operator bool() const
3465 {
3466 return m_pipeline != VK_NULL_HANDLE;
3467 }
3468
3469 bool operator!() const
3470 {
3471 return m_pipeline == VK_NULL_HANDLE;
3472 }
3473
3474 private:
3475 VkPipeline m_pipeline;
3476 };
3477
3478 static_assert( sizeof( Pipeline ) == sizeof( VkPipeline ), "handle and wrapper have different size!" );
3479
3481 {
3482 public:
3485 {}
3486
3489 {}
3490
3491 VULKAN_HPP_TYPESAFE_EXPLICIT PipelineLayout( VkPipelineLayout pipelineLayout )
3492 : m_pipelineLayout( pipelineLayout )
3493 {}
3494
3495#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
3496 PipelineLayout & operator=(VkPipelineLayout pipelineLayout)
3497 {
3498 m_pipelineLayout = pipelineLayout;
3499 return *this;
3500 }
3501#endif
3502
3503 PipelineLayout & operator=( std::nullptr_t )
3504 {
3506 return *this;
3507 }
3508
3509 bool operator==( PipelineLayout const & rhs ) const
3510 {
3511 return m_pipelineLayout == rhs.m_pipelineLayout;
3512 }
3513
3514 bool operator!=(PipelineLayout const & rhs ) const
3515 {
3516 return m_pipelineLayout != rhs.m_pipelineLayout;
3517 }
3518
3519 bool operator<(PipelineLayout const & rhs ) const
3520 {
3522 }
3523
3524
3525
3526 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineLayout() const
3527 {
3528 return m_pipelineLayout;
3529 }
3530
3531 explicit operator bool() const
3532 {
3534 }
3535
3536 bool operator!() const
3537 {
3539 }
3540
3541 private:
3542 VkPipelineLayout m_pipelineLayout;
3543 };
3544
3545 static_assert( sizeof( PipelineLayout ) == sizeof( VkPipelineLayout ), "handle and wrapper have different size!" );
3546
3548 {
3549 public:
3552 {}
3553
3556 {}
3557
3559 : m_sampler( sampler )
3560 {}
3561
3562#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
3563 Sampler & operator=(VkSampler sampler)
3564 {
3566 return *this;
3567 }
3568#endif
3569
3570 Sampler & operator=( std::nullptr_t )
3571 {
3573 return *this;
3574 }
3575
3576 bool operator==( Sampler const & rhs ) const
3577 {
3578 return m_sampler == rhs.m_sampler;
3579 }
3580
3581 bool operator!=(Sampler const & rhs ) const
3582 {
3583 return m_sampler != rhs.m_sampler;
3584 }
3585
3586 bool operator<(Sampler const & rhs ) const
3587 {
3588 return m_sampler < rhs.m_sampler;
3589 }
3590
3591
3592
3593 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSampler() const
3594 {
3595 return m_sampler;
3596 }
3597
3598 explicit operator bool() const
3599 {
3600 return m_sampler != VK_NULL_HANDLE;
3601 }
3602
3603 bool operator!() const
3604 {
3605 return m_sampler == VK_NULL_HANDLE;
3606 }
3607
3608 private:
3609 VkSampler m_sampler;
3610 };
3611
3612 static_assert( sizeof( Sampler ) == sizeof( VkSampler ), "handle and wrapper have different size!" );
3613
3615 {
3616 public:
3619 {}
3620
3623 {}
3624
3625 VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSet( VkDescriptorSet descriptorSet )
3626 : m_descriptorSet( descriptorSet )
3627 {}
3628
3629#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
3630 DescriptorSet & operator=(VkDescriptorSet descriptorSet)
3631 {
3632 m_descriptorSet = descriptorSet;
3633 return *this;
3634 }
3635#endif
3636
3637 DescriptorSet & operator=( std::nullptr_t )
3638 {
3640 return *this;
3641 }
3642
3643 bool operator==( DescriptorSet const & rhs ) const
3644 {
3645 return m_descriptorSet == rhs.m_descriptorSet;
3646 }
3647
3648 bool operator!=(DescriptorSet const & rhs ) const
3649 {
3650 return m_descriptorSet != rhs.m_descriptorSet;
3651 }
3652
3653 bool operator<(DescriptorSet const & rhs ) const
3654 {
3655 return m_descriptorSet < rhs.m_descriptorSet;
3656 }
3657
3658
3659
3660 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSet() const
3661 {
3662 return m_descriptorSet;
3663 }
3664
3665 explicit operator bool() const
3666 {
3668 }
3669
3670 bool operator!() const
3671 {
3673 }
3674
3675 private:
3676 VkDescriptorSet m_descriptorSet;
3677 };
3678
3679 static_assert( sizeof( DescriptorSet ) == sizeof( VkDescriptorSet ), "handle and wrapper have different size!" );
3680
3682 {
3683 public:
3686 {}
3687
3690 {}
3691
3692 VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSetLayout( VkDescriptorSetLayout descriptorSetLayout )
3693 : m_descriptorSetLayout( descriptorSetLayout )
3694 {}
3695
3696#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
3697 DescriptorSetLayout & operator=(VkDescriptorSetLayout descriptorSetLayout)
3698 {
3699 m_descriptorSetLayout = descriptorSetLayout;
3700 return *this;
3701 }
3702#endif
3703
3704 DescriptorSetLayout & operator=( std::nullptr_t )
3705 {
3707 return *this;
3708 }
3709
3710 bool operator==( DescriptorSetLayout const & rhs ) const
3711 {
3713 }
3714
3715 bool operator!=(DescriptorSetLayout const & rhs ) const
3716 {
3718 }
3719
3720 bool operator<(DescriptorSetLayout const & rhs ) const
3721 {
3723 }
3724
3725
3726
3727 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSetLayout() const
3728 {
3729 return m_descriptorSetLayout;
3730 }
3731
3732 explicit operator bool() const
3733 {
3735 }
3736
3737 bool operator!() const
3738 {
3740 }
3741
3742 private:
3743 VkDescriptorSetLayout m_descriptorSetLayout;
3744 };
3745
3746 static_assert( sizeof( DescriptorSetLayout ) == sizeof( VkDescriptorSetLayout ), "handle and wrapper have different size!" );
3747
3749 {
3750 public:
3753 {}
3754
3757 {}
3758
3759 VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorPool( VkDescriptorPool descriptorPool )
3760 : m_descriptorPool( descriptorPool )
3761 {}
3762
3763#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
3764 DescriptorPool & operator=(VkDescriptorPool descriptorPool)
3765 {
3766 m_descriptorPool = descriptorPool;
3767 return *this;
3768 }
3769#endif
3770
3771 DescriptorPool & operator=( std::nullptr_t )
3772 {
3774 return *this;
3775 }
3776
3777 bool operator==( DescriptorPool const & rhs ) const
3778 {
3779 return m_descriptorPool == rhs.m_descriptorPool;
3780 }
3781
3782 bool operator!=(DescriptorPool const & rhs ) const
3783 {
3784 return m_descriptorPool != rhs.m_descriptorPool;
3785 }
3786
3787 bool operator<(DescriptorPool const & rhs ) const
3788 {
3790 }
3791
3792
3793
3794 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorPool() const
3795 {
3796 return m_descriptorPool;
3797 }
3798
3799 explicit operator bool() const
3800 {
3802 }
3803
3804 bool operator!() const
3805 {
3807 }
3808
3809 private:
3810 VkDescriptorPool m_descriptorPool;
3811 };
3812
3813 static_assert( sizeof( DescriptorPool ) == sizeof( VkDescriptorPool ), "handle and wrapper have different size!" );
3814
3815 class Fence
3816 {
3817 public:
3820 {}
3821
3822 VULKAN_HPP_CONSTEXPR Fence( std::nullptr_t )
3824 {}
3825
3827 : m_fence( fence )
3828 {}
3829
3830#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
3831 Fence & operator=(VkFence fence)
3832 {
3833 m_fence = fence;
3834 return *this;
3835 }
3836#endif
3837
3838 Fence & operator=( std::nullptr_t )
3839 {
3841 return *this;
3842 }
3843
3844 bool operator==( Fence const & rhs ) const
3845 {
3846 return m_fence == rhs.m_fence;
3847 }
3848
3849 bool operator!=(Fence const & rhs ) const
3850 {
3851 return m_fence != rhs.m_fence;
3852 }
3853
3854 bool operator<(Fence const & rhs ) const
3855 {
3856 return m_fence < rhs.m_fence;
3857 }
3858
3859
3860
3861 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFence() const
3862 {
3863 return m_fence;
3864 }
3865
3866 explicit operator bool() const
3867 {
3868 return m_fence != VK_NULL_HANDLE;
3869 }
3870
3871 bool operator!() const
3872 {
3873 return m_fence == VK_NULL_HANDLE;
3874 }
3875
3876 private:
3877 VkFence m_fence;
3878 };
3879
3880 static_assert( sizeof( Fence ) == sizeof( VkFence ), "handle and wrapper have different size!" );
3881
3883 {
3884 public:
3887 {}
3888
3891 {}
3892
3894 : m_semaphore( semaphore )
3895 {}
3896
3897#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
3898 Semaphore & operator=(VkSemaphore semaphore)
3899 {
3900 m_semaphore = semaphore;
3901 return *this;
3902 }
3903#endif
3904
3905 Semaphore & operator=( std::nullptr_t )
3906 {
3908 return *this;
3909 }
3910
3911 bool operator==( Semaphore const & rhs ) const
3912 {
3913 return m_semaphore == rhs.m_semaphore;
3914 }
3915
3916 bool operator!=(Semaphore const & rhs ) const
3917 {
3918 return m_semaphore != rhs.m_semaphore;
3919 }
3920
3921 bool operator<(Semaphore const & rhs ) const
3922 {
3923 return m_semaphore < rhs.m_semaphore;
3924 }
3925
3926
3927
3928 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSemaphore() const
3929 {
3930 return m_semaphore;
3931 }
3932
3933 explicit operator bool() const
3934 {
3935 return m_semaphore != VK_NULL_HANDLE;
3936 }
3937
3938 bool operator!() const
3939 {
3940 return m_semaphore == VK_NULL_HANDLE;
3941 }
3942
3943 private:
3944 VkSemaphore m_semaphore;
3945 };
3946
3947 static_assert( sizeof( Semaphore ) == sizeof( VkSemaphore ), "handle and wrapper have different size!" );
3948
3949 class Event
3950 {
3951 public:
3954 {}
3955
3956 VULKAN_HPP_CONSTEXPR Event( std::nullptr_t )
3958 {}
3959
3961 : m_event( event )
3962 {}
3963
3964#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
3965 Event & operator=(VkEvent event)
3966 {
3967 m_event = event;
3968 return *this;
3969 }
3970#endif
3971
3972 Event & operator=( std::nullptr_t )
3973 {
3975 return *this;
3976 }
3977
3978 bool operator==( Event const & rhs ) const
3979 {
3980 return m_event == rhs.m_event;
3981 }
3982
3983 bool operator!=(Event const & rhs ) const
3984 {
3985 return m_event != rhs.m_event;
3986 }
3987
3988 bool operator<(Event const & rhs ) const
3989 {
3990 return m_event < rhs.m_event;
3991 }
3992
3993
3994
3995 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkEvent() const
3996 {
3997 return m_event;
3998 }
3999
4000 explicit operator bool() const
4001 {
4002 return m_event != VK_NULL_HANDLE;
4003 }
4004
4005 bool operator!() const
4006 {
4007 return m_event == VK_NULL_HANDLE;
4008 }
4009
4010 private:
4011 VkEvent m_event;
4012 };
4013
4014 static_assert( sizeof( Event ) == sizeof( VkEvent ), "handle and wrapper have different size!" );
4015
4017 {
4018 public:
4021 {}
4022
4025 {}
4026
4028 : m_queryPool( queryPool )
4029 {}
4030
4031#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
4032 QueryPool & operator=(VkQueryPool queryPool)
4033 {
4034 m_queryPool = queryPool;
4035 return *this;
4036 }
4037#endif
4038
4039 QueryPool & operator=( std::nullptr_t )
4040 {
4042 return *this;
4043 }
4044
4045 bool operator==( QueryPool const & rhs ) const
4046 {
4047 return m_queryPool == rhs.m_queryPool;
4048 }
4049
4050 bool operator!=(QueryPool const & rhs ) const
4051 {
4052 return m_queryPool != rhs.m_queryPool;
4053 }
4054
4055 bool operator<(QueryPool const & rhs ) const
4056 {
4057 return m_queryPool < rhs.m_queryPool;
4058 }
4059
4060
4061
4062 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueryPool() const
4063 {
4064 return m_queryPool;
4065 }
4066
4067 explicit operator bool() const
4068 {
4069 return m_queryPool != VK_NULL_HANDLE;
4070 }
4071
4072 bool operator!() const
4073 {
4074 return m_queryPool == VK_NULL_HANDLE;
4075 }
4076
4077 private:
4078 VkQueryPool m_queryPool;
4079 };
4080
4081 static_assert( sizeof( QueryPool ) == sizeof( VkQueryPool ), "handle and wrapper have different size!" );
4082
4084 {
4085 public:
4088 {}
4089
4092 {}
4093
4096 {}
4097
4098#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
4099 Framebuffer & operator=(VkFramebuffer framebuffer)
4100 {
4102 return *this;
4103 }
4104#endif
4105
4106 Framebuffer & operator=( std::nullptr_t )
4107 {
4109 return *this;
4110 }
4111
4112 bool operator==( Framebuffer const & rhs ) const
4113 {
4114 return m_framebuffer == rhs.m_framebuffer;
4115 }
4116
4117 bool operator!=(Framebuffer const & rhs ) const
4118 {
4119 return m_framebuffer != rhs.m_framebuffer;
4120 }
4121
4122 bool operator<(Framebuffer const & rhs ) const
4123 {
4124 return m_framebuffer < rhs.m_framebuffer;
4125 }
4126
4127
4128
4129 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFramebuffer() const
4130 {
4131 return m_framebuffer;
4132 }
4133
4134 explicit operator bool() const
4135 {
4136 return m_framebuffer != VK_NULL_HANDLE;
4137 }
4138
4139 bool operator!() const
4140 {
4141 return m_framebuffer == VK_NULL_HANDLE;
4142 }
4143
4144 private:
4145 VkFramebuffer m_framebuffer;
4146 };
4147
4148 static_assert( sizeof( Framebuffer ) == sizeof( VkFramebuffer ), "handle and wrapper have different size!" );
4149
4151 {
4152 public:
4155 {}
4156
4159 {}
4160
4161 VULKAN_HPP_TYPESAFE_EXPLICIT RenderPass( VkRenderPass renderPass )
4162 : m_renderPass( renderPass )
4163 {}
4164
4165#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
4166 RenderPass & operator=(VkRenderPass renderPass)
4167 {
4168 m_renderPass = renderPass;
4169 return *this;
4170 }
4171#endif
4172
4173 RenderPass & operator=( std::nullptr_t )
4174 {
4176 return *this;
4177 }
4178
4179 bool operator==( RenderPass const & rhs ) const
4180 {
4181 return m_renderPass == rhs.m_renderPass;
4182 }
4183
4184 bool operator!=(RenderPass const & rhs ) const
4185 {
4186 return m_renderPass != rhs.m_renderPass;
4187 }
4188
4189 bool operator<(RenderPass const & rhs ) const
4190 {
4191 return m_renderPass < rhs.m_renderPass;
4192 }
4193
4194
4195
4196 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkRenderPass() const
4197 {
4198 return m_renderPass;
4199 }
4200
4201 explicit operator bool() const
4202 {
4203 return m_renderPass != VK_NULL_HANDLE;
4204 }
4205
4206 bool operator!() const
4207 {
4208 return m_renderPass == VK_NULL_HANDLE;
4209 }
4210
4211 private:
4212 VkRenderPass m_renderPass;
4213 };
4214
4215 static_assert( sizeof( RenderPass ) == sizeof( VkRenderPass ), "handle and wrapper have different size!" );
4216
4218 {
4219 public:
4222 {}
4223
4226 {}
4227
4228 VULKAN_HPP_TYPESAFE_EXPLICIT PipelineCache( VkPipelineCache pipelineCache )
4229 : m_pipelineCache( pipelineCache )
4230 {}
4231
4232#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
4233 PipelineCache & operator=(VkPipelineCache pipelineCache)
4234 {
4235 m_pipelineCache = pipelineCache;
4236 return *this;
4237 }
4238#endif
4239
4240 PipelineCache & operator=( std::nullptr_t )
4241 {
4243 return *this;
4244 }
4245
4246 bool operator==( PipelineCache const & rhs ) const
4247 {
4248 return m_pipelineCache == rhs.m_pipelineCache;
4249 }
4250
4251 bool operator!=(PipelineCache const & rhs ) const
4252 {
4253 return m_pipelineCache != rhs.m_pipelineCache;
4254 }
4255
4256 bool operator<(PipelineCache const & rhs ) const
4257 {
4258 return m_pipelineCache < rhs.m_pipelineCache;
4259 }
4260
4261
4262
4263 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineCache() const
4264 {
4265 return m_pipelineCache;
4266 }
4267
4268 explicit operator bool() const
4269 {
4271 }
4272
4273 bool operator!() const
4274 {
4276 }
4277
4278 private:
4279 VkPipelineCache m_pipelineCache;
4280 };
4281
4282 static_assert( sizeof( PipelineCache ) == sizeof( VkPipelineCache ), "handle and wrapper have different size!" );
4283
4285 {
4286 public:
4289 {}
4290
4293 {}
4294
4295 VULKAN_HPP_TYPESAFE_EXPLICIT ObjectTableNVX( VkObjectTableNVX objectTableNVX )
4296 : m_objectTableNVX( objectTableNVX )
4297 {}
4298
4299#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
4300 ObjectTableNVX & operator=(VkObjectTableNVX objectTableNVX)
4301 {
4302 m_objectTableNVX = objectTableNVX;
4303 return *this;
4304 }
4305#endif
4306
4307 ObjectTableNVX & operator=( std::nullptr_t )
4308 {
4310 return *this;
4311 }
4312
4313 bool operator==( ObjectTableNVX const & rhs ) const
4314 {
4315 return m_objectTableNVX == rhs.m_objectTableNVX;
4316 }
4317
4318 bool operator!=(ObjectTableNVX const & rhs ) const
4319 {
4320 return m_objectTableNVX != rhs.m_objectTableNVX;
4321 }
4322
4323 bool operator<(ObjectTableNVX const & rhs ) const
4324 {
4326 }
4327
4328
4329
4330 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkObjectTableNVX() const
4331 {
4332 return m_objectTableNVX;
4333 }
4334
4335 explicit operator bool() const
4336 {
4338 }
4339
4340 bool operator!() const
4341 {
4343 }
4344
4345 private:
4346 VkObjectTableNVX m_objectTableNVX;
4347 };
4348
4349 static_assert( sizeof( ObjectTableNVX ) == sizeof( VkObjectTableNVX ), "handle and wrapper have different size!" );
4350
4352 {
4353 public:
4356 {}
4357
4360 {}
4361
4362 VULKAN_HPP_TYPESAFE_EXPLICIT IndirectCommandsLayoutNVX( VkIndirectCommandsLayoutNVX indirectCommandsLayoutNVX )
4363 : m_indirectCommandsLayoutNVX( indirectCommandsLayoutNVX )
4364 {}
4365
4366#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
4367 IndirectCommandsLayoutNVX & operator=(VkIndirectCommandsLayoutNVX indirectCommandsLayoutNVX)
4368 {
4369 m_indirectCommandsLayoutNVX = indirectCommandsLayoutNVX;
4370 return *this;
4371 }
4372#endif
4373
4375 {
4377 return *this;
4378 }
4379
4380 bool operator==( IndirectCommandsLayoutNVX const & rhs ) const
4381 {
4383 }
4384
4385 bool operator!=(IndirectCommandsLayoutNVX const & rhs ) const
4386 {
4388 }
4389
4390 bool operator<(IndirectCommandsLayoutNVX const & rhs ) const
4391 {
4393 }
4394
4395
4396
4397 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkIndirectCommandsLayoutNVX() const
4398 {
4400 }
4401
4402 explicit operator bool() const
4403 {
4405 }
4406
4407 bool operator!() const
4408 {
4410 }
4411
4412 private:
4413 VkIndirectCommandsLayoutNVX m_indirectCommandsLayoutNVX;
4414 };
4415
4416 static_assert( sizeof( IndirectCommandsLayoutNVX ) == sizeof( VkIndirectCommandsLayoutNVX ), "handle and wrapper have different size!" );
4417
4419 {
4420 public:
4423 {}
4424
4427 {}
4428
4429 VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorUpdateTemplate( VkDescriptorUpdateTemplate descriptorUpdateTemplate )
4430 : m_descriptorUpdateTemplate( descriptorUpdateTemplate )
4431 {}
4432
4433#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
4434 DescriptorUpdateTemplate & operator=(VkDescriptorUpdateTemplate descriptorUpdateTemplate)
4435 {
4436 m_descriptorUpdateTemplate = descriptorUpdateTemplate;
4437 return *this;
4438 }
4439#endif
4440
4442 {
4444 return *this;
4445 }
4446
4447 bool operator==( DescriptorUpdateTemplate const & rhs ) const
4448 {
4450 }
4451
4452 bool operator!=(DescriptorUpdateTemplate const & rhs ) const
4453 {
4455 }
4456
4457 bool operator<(DescriptorUpdateTemplate const & rhs ) const
4458 {
4460 }
4461
4462
4463
4464 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorUpdateTemplate() const
4465 {
4467 }
4468
4469 explicit operator bool() const
4470 {
4472 }
4473
4474 bool operator!() const
4475 {
4477 }
4478
4479 private:
4480 VkDescriptorUpdateTemplate m_descriptorUpdateTemplate;
4481 };
4482
4483 static_assert( sizeof( DescriptorUpdateTemplate ) == sizeof( VkDescriptorUpdateTemplate ), "handle and wrapper have different size!" );
4484
4486
4488 {
4489 public:
4492 {}
4493
4496 {}
4497
4498 VULKAN_HPP_TYPESAFE_EXPLICIT SamplerYcbcrConversion( VkSamplerYcbcrConversion samplerYcbcrConversion )
4499 : m_samplerYcbcrConversion( samplerYcbcrConversion )
4500 {}
4501
4502#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
4503 SamplerYcbcrConversion & operator=(VkSamplerYcbcrConversion samplerYcbcrConversion)
4504 {
4505 m_samplerYcbcrConversion = samplerYcbcrConversion;
4506 return *this;
4507 }
4508#endif
4509
4511 {
4513 return *this;
4514 }
4515
4516 bool operator==( SamplerYcbcrConversion const & rhs ) const
4517 {
4519 }
4520
4521 bool operator!=(SamplerYcbcrConversion const & rhs ) const
4522 {
4524 }
4525
4526 bool operator<(SamplerYcbcrConversion const & rhs ) const
4527 {
4529 }
4530
4531
4532
4533 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSamplerYcbcrConversion() const
4534 {
4536 }
4537
4538 explicit operator bool() const
4539 {
4541 }
4542
4543 bool operator!() const
4544 {
4546 }
4547
4548 private:
4549 VkSamplerYcbcrConversion m_samplerYcbcrConversion;
4550 };
4551
4552 static_assert( sizeof( SamplerYcbcrConversion ) == sizeof( VkSamplerYcbcrConversion ), "handle and wrapper have different size!" );
4553
4555
4557 {
4558 public:
4561 {}
4562
4565 {}
4566
4567 VULKAN_HPP_TYPESAFE_EXPLICIT ValidationCacheEXT( VkValidationCacheEXT validationCacheEXT )
4568 : m_validationCacheEXT( validationCacheEXT )
4569 {}
4570
4571#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
4572 ValidationCacheEXT & operator=(VkValidationCacheEXT validationCacheEXT)
4573 {
4574 m_validationCacheEXT = validationCacheEXT;
4575 return *this;
4576 }
4577#endif
4578
4579 ValidationCacheEXT & operator=( std::nullptr_t )
4580 {
4582 return *this;
4583 }
4584
4585 bool operator==( ValidationCacheEXT const & rhs ) const
4586 {
4588 }
4589
4590 bool operator!=(ValidationCacheEXT const & rhs ) const
4591 {
4593 }
4594
4595 bool operator<(ValidationCacheEXT const & rhs ) const
4596 {
4598 }
4599
4600
4601
4602 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkValidationCacheEXT() const
4603 {
4604 return m_validationCacheEXT;
4605 }
4606
4607 explicit operator bool() const
4608 {
4610 }
4611
4612 bool operator!() const
4613 {
4615 }
4616
4617 private:
4618 VkValidationCacheEXT m_validationCacheEXT;
4619 };
4620
4621 static_assert( sizeof( ValidationCacheEXT ) == sizeof( VkValidationCacheEXT ), "handle and wrapper have different size!" );
4622
4624 {
4625 public:
4628 {}
4629
4632 {}
4633
4634 VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureNV( VkAccelerationStructureNV accelerationStructureNV )
4635 : m_accelerationStructureNV( accelerationStructureNV )
4636 {}
4637
4638#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
4639 AccelerationStructureNV & operator=(VkAccelerationStructureNV accelerationStructureNV)
4640 {
4641 m_accelerationStructureNV = accelerationStructureNV;
4642 return *this;
4643 }
4644#endif
4645
4647 {
4649 return *this;
4650 }
4651
4652 bool operator==( AccelerationStructureNV const & rhs ) const
4653 {
4655 }
4656
4657 bool operator!=(AccelerationStructureNV const & rhs ) const
4658 {
4660 }
4661
4662 bool operator<(AccelerationStructureNV const & rhs ) const
4663 {
4665 }
4666
4667
4668
4669 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureNV() const
4670 {
4672 }
4673
4674 explicit operator bool() const
4675 {
4677 }
4678
4679 bool operator!() const
4680 {
4682 }
4683
4684 private:
4685 VkAccelerationStructureNV m_accelerationStructureNV;
4686 };
4687
4688 static_assert( sizeof( AccelerationStructureNV ) == sizeof( VkAccelerationStructureNV ), "handle and wrapper have different size!" );
4689
4691 {
4692 public:
4695 {}
4696
4699 {}
4700
4701 VULKAN_HPP_TYPESAFE_EXPLICIT DisplayKHR( VkDisplayKHR displayKHR )
4702 : m_displayKHR( displayKHR )
4703 {}
4704
4705#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
4706 DisplayKHR & operator=(VkDisplayKHR displayKHR)
4707 {
4708 m_displayKHR = displayKHR;
4709 return *this;
4710 }
4711#endif
4712
4713 DisplayKHR & operator=( std::nullptr_t )
4714 {
4716 return *this;
4717 }
4718
4719 bool operator==( DisplayKHR const & rhs ) const
4720 {
4721 return m_displayKHR == rhs.m_displayKHR;
4722 }
4723
4724 bool operator!=(DisplayKHR const & rhs ) const
4725 {
4726 return m_displayKHR != rhs.m_displayKHR;
4727 }
4728
4729 bool operator<(DisplayKHR const & rhs ) const
4730 {
4731 return m_displayKHR < rhs.m_displayKHR;
4732 }
4733
4734
4735
4736 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayKHR() const
4737 {
4738 return m_displayKHR;
4739 }
4740
4741 explicit operator bool() const
4742 {
4743 return m_displayKHR != VK_NULL_HANDLE;
4744 }
4745
4746 bool operator!() const
4747 {
4748 return m_displayKHR == VK_NULL_HANDLE;
4749 }
4750
4751 private:
4752 VkDisplayKHR m_displayKHR;
4753 };
4754
4755 static_assert( sizeof( DisplayKHR ) == sizeof( VkDisplayKHR ), "handle and wrapper have different size!" );
4756
4758 {
4759 public:
4762 {}
4763
4766 {}
4767
4768 VULKAN_HPP_TYPESAFE_EXPLICIT DisplayModeKHR( VkDisplayModeKHR displayModeKHR )
4769 : m_displayModeKHR( displayModeKHR )
4770 {}
4771
4772#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
4773 DisplayModeKHR & operator=(VkDisplayModeKHR displayModeKHR)
4774 {
4775 m_displayModeKHR = displayModeKHR;
4776 return *this;
4777 }
4778#endif
4779
4780 DisplayModeKHR & operator=( std::nullptr_t )
4781 {
4783 return *this;
4784 }
4785
4786 bool operator==( DisplayModeKHR const & rhs ) const
4787 {
4788 return m_displayModeKHR == rhs.m_displayModeKHR;
4789 }
4790
4791 bool operator!=(DisplayModeKHR const & rhs ) const
4792 {
4793 return m_displayModeKHR != rhs.m_displayModeKHR;
4794 }
4795
4796 bool operator<(DisplayModeKHR const & rhs ) const
4797 {
4799 }
4800
4801
4802
4803 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayModeKHR() const
4804 {
4805 return m_displayModeKHR;
4806 }
4807
4808 explicit operator bool() const
4809 {
4811 }
4812
4813 bool operator!() const
4814 {
4816 }
4817
4818 private:
4819 VkDisplayModeKHR m_displayModeKHR;
4820 };
4821
4822 static_assert( sizeof( DisplayModeKHR ) == sizeof( VkDisplayModeKHR ), "handle and wrapper have different size!" );
4823
4825 {
4826 public:
4829 {}
4830
4833 {}
4834
4835 VULKAN_HPP_TYPESAFE_EXPLICIT SurfaceKHR( VkSurfaceKHR surfaceKHR )
4836 : m_surfaceKHR( surfaceKHR )
4837 {}
4838
4839#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
4840 SurfaceKHR & operator=(VkSurfaceKHR surfaceKHR)
4841 {
4842 m_surfaceKHR = surfaceKHR;
4843 return *this;
4844 }
4845#endif
4846
4847 SurfaceKHR & operator=( std::nullptr_t )
4848 {
4850 return *this;
4851 }
4852
4853 bool operator==( SurfaceKHR const & rhs ) const
4854 {
4855 return m_surfaceKHR == rhs.m_surfaceKHR;
4856 }
4857
4858 bool operator!=(SurfaceKHR const & rhs ) const
4859 {
4860 return m_surfaceKHR != rhs.m_surfaceKHR;
4861 }
4862
4863 bool operator<(SurfaceKHR const & rhs ) const
4864 {
4865 return m_surfaceKHR < rhs.m_surfaceKHR;
4866 }
4867
4868
4869
4870 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSurfaceKHR() const
4871 {
4872 return m_surfaceKHR;
4873 }
4874
4875 explicit operator bool() const
4876 {
4877 return m_surfaceKHR != VK_NULL_HANDLE;
4878 }
4879
4880 bool operator!() const
4881 {
4882 return m_surfaceKHR == VK_NULL_HANDLE;
4883 }
4884
4885 private:
4886 VkSurfaceKHR m_surfaceKHR;
4887 };
4888
4889 static_assert( sizeof( SurfaceKHR ) == sizeof( VkSurfaceKHR ), "handle and wrapper have different size!" );
4890
4892 {
4893 public:
4896 {}
4897
4900 {}
4901
4902 VULKAN_HPP_TYPESAFE_EXPLICIT SwapchainKHR( VkSwapchainKHR swapchainKHR )
4903 : m_swapchainKHR( swapchainKHR )
4904 {}
4905
4906#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
4907 SwapchainKHR & operator=(VkSwapchainKHR swapchainKHR)
4908 {
4909 m_swapchainKHR = swapchainKHR;
4910 return *this;
4911 }
4912#endif
4913
4914 SwapchainKHR & operator=( std::nullptr_t )
4915 {
4917 return *this;
4918 }
4919
4920 bool operator==( SwapchainKHR const & rhs ) const
4921 {
4922 return m_swapchainKHR == rhs.m_swapchainKHR;
4923 }
4924
4925 bool operator!=(SwapchainKHR const & rhs ) const
4926 {
4927 return m_swapchainKHR != rhs.m_swapchainKHR;
4928 }
4929
4930 bool operator<(SwapchainKHR const & rhs ) const
4931 {
4932 return m_swapchainKHR < rhs.m_swapchainKHR;
4933 }
4934
4935
4936
4937 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSwapchainKHR() const
4938 {
4939 return m_swapchainKHR;
4940 }
4941
4942 explicit operator bool() const
4943 {
4945 }
4946
4947 bool operator!() const
4948 {
4950 }
4951
4952 private:
4953 VkSwapchainKHR m_swapchainKHR;
4954 };
4955
4956 static_assert( sizeof( SwapchainKHR ) == sizeof( VkSwapchainKHR ), "handle and wrapper have different size!" );
4957
4959 {
4960 public:
4963 {}
4964
4967 {}
4968
4969 VULKAN_HPP_TYPESAFE_EXPLICIT DebugReportCallbackEXT( VkDebugReportCallbackEXT debugReportCallbackEXT )
4970 : m_debugReportCallbackEXT( debugReportCallbackEXT )
4971 {}
4972
4973#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
4974 DebugReportCallbackEXT & operator=(VkDebugReportCallbackEXT debugReportCallbackEXT)
4975 {
4976 m_debugReportCallbackEXT = debugReportCallbackEXT;
4977 return *this;
4978 }
4979#endif
4980
4982 {
4984 return *this;
4985 }
4986
4987 bool operator==( DebugReportCallbackEXT const & rhs ) const
4988 {
4990 }
4991
4992 bool operator!=(DebugReportCallbackEXT const & rhs ) const
4993 {
4995 }
4996
4997 bool operator<(DebugReportCallbackEXT const & rhs ) const
4998 {
5000 }
5001
5002
5003
5004 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugReportCallbackEXT() const
5005 {
5007 }
5008
5009 explicit operator bool() const
5010 {
5012 }
5013
5014 bool operator!() const
5015 {
5017 }
5018
5019 private:
5020 VkDebugReportCallbackEXT m_debugReportCallbackEXT;
5021 };
5022
5023 static_assert( sizeof( DebugReportCallbackEXT ) == sizeof( VkDebugReportCallbackEXT ), "handle and wrapper have different size!" );
5024
5026 {
5027 public:
5030 {}
5031
5034 {}
5035
5036 VULKAN_HPP_TYPESAFE_EXPLICIT DebugUtilsMessengerEXT( VkDebugUtilsMessengerEXT debugUtilsMessengerEXT )
5037 : m_debugUtilsMessengerEXT( debugUtilsMessengerEXT )
5038 {}
5039
5040#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
5041 DebugUtilsMessengerEXT & operator=(VkDebugUtilsMessengerEXT debugUtilsMessengerEXT)
5042 {
5043 m_debugUtilsMessengerEXT = debugUtilsMessengerEXT;
5044 return *this;
5045 }
5046#endif
5047
5049 {
5051 return *this;
5052 }
5053
5054 bool operator==( DebugUtilsMessengerEXT const & rhs ) const
5055 {
5057 }
5058
5059 bool operator!=(DebugUtilsMessengerEXT const & rhs ) const
5060 {
5062 }
5063
5064 bool operator<(DebugUtilsMessengerEXT const & rhs ) const
5065 {
5067 }
5068
5069
5070
5071 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugUtilsMessengerEXT() const
5072 {
5074 }
5075
5076 explicit operator bool() const
5077 {
5079 }
5080
5081 bool operator!() const
5082 {
5084 }
5085
5086 private:
5087 VkDebugUtilsMessengerEXT m_debugUtilsMessengerEXT;
5088 };
5089
5090 static_assert( sizeof( DebugUtilsMessengerEXT ) == sizeof( VkDebugUtilsMessengerEXT ), "handle and wrapper have different size!" );
5091
5093 {
5095 int32_t y_ = 0 )
5096 : x( x_ )
5097 , y( y_ )
5098 {
5099 }
5100
5101 Offset2D( VkOffset2D const & rhs )
5102 {
5103 memcpy( this, &rhs, sizeof( Offset2D ) );
5104 }
5105
5107 {
5108 memcpy( this, &rhs, sizeof( Offset2D ) );
5109 return *this;
5110 }
5112 {
5113 x = x_;
5114 return *this;
5115 }
5116
5118 {
5119 y = y_;
5120 return *this;
5121 }
5122
5123 operator VkOffset2D const&() const
5124 {
5125 return *reinterpret_cast<const VkOffset2D*>(this);
5126 }
5127
5128 operator VkOffset2D &()
5129 {
5130 return *reinterpret_cast<VkOffset2D*>(this);
5131 }
5132
5133 bool operator==( Offset2D const& rhs ) const
5134 {
5135 return ( x == rhs.x )
5136 && ( y == rhs.y );
5137 }
5138
5139 bool operator!=( Offset2D const& rhs ) const
5140 {
5141 return !operator==( rhs );
5142 }
5143
5146 };
5147 static_assert( sizeof( Offset2D ) == sizeof( VkOffset2D ), "struct and wrapper have different size!" );
5148
5150 {
5152 int32_t y_ = 0,
5153 int32_t z_ = 0 )
5154 : x( x_ )
5155 , y( y_ )
5156 , z( z_ )
5157 {
5158 }
5159
5160 explicit Offset3D( Offset2D const& offset2D,
5161 int32_t z_ = 0 )
5162 : x( offset2D.x )
5163 , y( offset2D.y )
5164 , z( z_ )
5165 {}
5166
5167 Offset3D( VkOffset3D const & rhs )
5168 {
5169 memcpy( this, &rhs, sizeof( Offset3D ) );
5170 }
5171
5173 {
5174 memcpy( this, &rhs, sizeof( Offset3D ) );
5175 return *this;
5176 }
5178 {
5179 x = x_;
5180 return *this;
5181 }
5182
5184 {
5185 y = y_;
5186 return *this;
5187 }
5188
5190 {
5191 z = z_;
5192 return *this;
5193 }
5194
5195 operator VkOffset3D const&() const
5196 {
5197 return *reinterpret_cast<const VkOffset3D*>(this);
5198 }
5199
5200 operator VkOffset3D &()
5201 {
5202 return *reinterpret_cast<VkOffset3D*>(this);
5203 }
5204
5205 bool operator==( Offset3D const& rhs ) const
5206 {
5207 return ( x == rhs.x )
5208 && ( y == rhs.y )
5209 && ( z == rhs.z );
5210 }
5211
5212 bool operator!=( Offset3D const& rhs ) const
5213 {
5214 return !operator==( rhs );
5215 }
5216
5220 };
5221 static_assert( sizeof( Offset3D ) == sizeof( VkOffset3D ), "struct and wrapper have different size!" );
5222
5224 {
5225 Extent2D( uint32_t width_ = 0,
5226 uint32_t height_ = 0 )
5227 : width( width_ )
5228 , height( height_ )
5229 {
5230 }
5231
5232 Extent2D( VkExtent2D const & rhs )
5233 {
5234 memcpy( this, &rhs, sizeof( Extent2D ) );
5235 }
5236
5238 {
5239 memcpy( this, &rhs, sizeof( Extent2D ) );
5240 return *this;
5241 }
5243 {
5244 width = width_;
5245 return *this;
5246 }
5247
5249 {
5250 height = height_;
5251 return *this;
5252 }
5253
5254 operator VkExtent2D const&() const
5255 {
5256 return *reinterpret_cast<const VkExtent2D*>(this);
5257 }
5258
5259 operator VkExtent2D &()
5260 {
5261 return *reinterpret_cast<VkExtent2D*>(this);
5262 }
5263
5264 bool operator==( Extent2D const& rhs ) const
5265 {
5266 return ( width == rhs.width )
5267 && ( height == rhs.height );
5268 }
5269
5270 bool operator!=( Extent2D const& rhs ) const
5271 {
5272 return !operator==( rhs );
5273 }
5274
5277 };
5278 static_assert( sizeof( Extent2D ) == sizeof( VkExtent2D ), "struct and wrapper have different size!" );
5279
5281 {
5282 Extent3D( uint32_t width_ = 0,
5283 uint32_t height_ = 0,
5284 uint32_t depth_ = 0 )
5285 : width( width_ )
5286 , height( height_ )
5287 , depth( depth_ )
5288 {
5289 }
5290
5291 explicit Extent3D( Extent2D const& extent2D,
5292 uint32_t depth_ = 0 )
5293 : width( extent2D.width )
5294 , height( extent2D.height )
5295 , depth( depth_ )
5296 {}
5297
5298 Extent3D( VkExtent3D const & rhs )
5299 {
5300 memcpy( this, &rhs, sizeof( Extent3D ) );
5301 }
5302
5304 {
5305 memcpy( this, &rhs, sizeof( Extent3D ) );
5306 return *this;
5307 }
5309 {
5310 width = width_;
5311 return *this;
5312 }
5313
5315 {
5316 height = height_;
5317 return *this;
5318 }
5319
5321 {
5322 depth = depth_;
5323 return *this;
5324 }
5325
5326 operator VkExtent3D const&() const
5327 {
5328 return *reinterpret_cast<const VkExtent3D*>(this);
5329 }
5330
5331 operator VkExtent3D &()
5332 {
5333 return *reinterpret_cast<VkExtent3D*>(this);
5334 }
5335
5336 bool operator==( Extent3D const& rhs ) const
5337 {
5338 return ( width == rhs.width )
5339 && ( height == rhs.height )
5340 && ( depth == rhs.depth );
5341 }
5342
5343 bool operator!=( Extent3D const& rhs ) const
5344 {
5345 return !operator==( rhs );
5346 }
5347
5351 };
5352 static_assert( sizeof( Extent3D ) == sizeof( VkExtent3D ), "struct and wrapper have different size!" );
5353
5355 {
5356 Viewport( float x_ = 0,
5357 float y_ = 0,
5358 float width_ = 0,
5359 float height_ = 0,
5360 float minDepth_ = 0,
5361 float maxDepth_ = 0 )
5362 : x( x_ )
5363 , y( y_ )
5364 , width( width_ )
5365 , height( height_ )
5366 , minDepth( minDepth_ )
5367 , maxDepth( maxDepth_ )
5368 {
5369 }
5370
5371 Viewport( VkViewport const & rhs )
5372 {
5373 memcpy( this, &rhs, sizeof( Viewport ) );
5374 }
5375
5377 {
5378 memcpy( this, &rhs, sizeof( Viewport ) );
5379 return *this;
5380 }
5381 Viewport& setX( float x_ )
5382 {
5383 x = x_;
5384 return *this;
5385 }
5386
5387 Viewport& setY( float y_ )
5388 {
5389 y = y_;
5390 return *this;
5391 }
5392
5393 Viewport& setWidth( float width_ )
5394 {
5395 width = width_;
5396 return *this;
5397 }
5398
5399 Viewport& setHeight( float height_ )
5400 {
5401 height = height_;
5402 return *this;
5403 }
5404
5405 Viewport& setMinDepth( float minDepth_ )
5406 {
5407 minDepth = minDepth_;
5408 return *this;
5409 }
5410
5411 Viewport& setMaxDepth( float maxDepth_ )
5412 {
5413 maxDepth = maxDepth_;
5414 return *this;
5415 }
5416
5417 operator VkViewport const&() const
5418 {
5419 return *reinterpret_cast<const VkViewport*>(this);
5420 }
5421
5422 operator VkViewport &()
5423 {
5424 return *reinterpret_cast<VkViewport*>(this);
5425 }
5426
5427 bool operator==( Viewport const& rhs ) const
5428 {
5429 return ( x == rhs.x )
5430 && ( y == rhs.y )
5431 && ( width == rhs.width )
5432 && ( height == rhs.height )
5433 && ( minDepth == rhs.minDepth )
5434 && ( maxDepth == rhs.maxDepth );
5435 }
5436
5437 bool operator!=( Viewport const& rhs ) const
5438 {
5439 return !operator==( rhs );
5440 }
5441
5442 float x;
5443 float y;
5444 float width;
5445 float height;
5448 };
5449 static_assert( sizeof( Viewport ) == sizeof( VkViewport ), "struct and wrapper have different size!" );
5450
5451 struct Rect2D
5452 {
5454 Extent2D extent_ = Extent2D() )
5455 : offset( offset_ )
5456 , extent( extent_ )
5457 {
5458 }
5459
5460 Rect2D( VkRect2D const & rhs )
5461 {
5462 memcpy( this, &rhs, sizeof( Rect2D ) );
5463 }
5464
5465 Rect2D& operator=( VkRect2D const & rhs )
5466 {
5467 memcpy( this, &rhs, sizeof( Rect2D ) );
5468 return *this;
5469 }
5471 {
5472 offset = offset_;
5473 return *this;
5474 }
5475
5477 {
5478 extent = extent_;
5479 return *this;
5480 }
5481
5482 operator VkRect2D const&() const
5483 {
5484 return *reinterpret_cast<const VkRect2D*>(this);
5485 }
5486
5487 operator VkRect2D &()
5488 {
5489 return *reinterpret_cast<VkRect2D*>(this);
5490 }
5491
5492 bool operator==( Rect2D const& rhs ) const
5493 {
5494 return ( offset == rhs.offset )
5495 && ( extent == rhs.extent );
5496 }
5497
5498 bool operator!=( Rect2D const& rhs ) const
5499 {
5500 return !operator==( rhs );
5501 }
5502
5505 };
5506 static_assert( sizeof( Rect2D ) == sizeof( VkRect2D ), "struct and wrapper have different size!" );
5507
5509 {
5511 uint32_t baseArrayLayer_ = 0,
5512 uint32_t layerCount_ = 0 )
5513 : rect( rect_ )
5514 , baseArrayLayer( baseArrayLayer_ )
5515 , layerCount( layerCount_ )
5516 {
5517 }
5518
5519 ClearRect( VkClearRect const & rhs )
5520 {
5521 memcpy( this, &rhs, sizeof( ClearRect ) );
5522 }
5523
5525 {
5526 memcpy( this, &rhs, sizeof( ClearRect ) );
5527 return *this;
5528 }
5530 {
5531 rect = rect_;
5532 return *this;
5533 }
5534
5536 {
5537 baseArrayLayer = baseArrayLayer_;
5538 return *this;
5539 }
5540
5542 {
5543 layerCount = layerCount_;
5544 return *this;
5545 }
5546
5547 operator VkClearRect const&() const
5548 {
5549 return *reinterpret_cast<const VkClearRect*>(this);
5550 }
5551
5552 operator VkClearRect &()
5553 {
5554 return *reinterpret_cast<VkClearRect*>(this);
5555 }
5556
5557 bool operator==( ClearRect const& rhs ) const
5558 {
5559 return ( rect == rhs.rect )
5560 && ( baseArrayLayer == rhs.baseArrayLayer )
5561 && ( layerCount == rhs.layerCount );
5562 }
5563
5564 bool operator!=( ClearRect const& rhs ) const
5565 {
5566 return !operator==( rhs );
5567 }
5568
5572 };
5573 static_assert( sizeof( ClearRect ) == sizeof( VkClearRect ), "struct and wrapper have different size!" );
5574
5576 {
5577 operator VkExtensionProperties const&() const
5578 {
5579 return *reinterpret_cast<const VkExtensionProperties*>(this);
5580 }
5581
5583 {
5584 return *reinterpret_cast<VkExtensionProperties*>(this);
5585 }
5586
5587 bool operator==( ExtensionProperties const& rhs ) const
5588 {
5589 return ( memcmp( extensionName, rhs.extensionName, VK_MAX_EXTENSION_NAME_SIZE * sizeof( char ) ) == 0 )
5590 && ( specVersion == rhs.specVersion );
5591 }
5592
5593 bool operator!=( ExtensionProperties const& rhs ) const
5594 {
5595 return !operator==( rhs );
5596 }
5597
5600 };
5601 static_assert( sizeof( ExtensionProperties ) == sizeof( VkExtensionProperties ), "struct and wrapper have different size!" );
5602
5604 {
5605 operator VkLayerProperties const&() const
5606 {
5607 return *reinterpret_cast<const VkLayerProperties*>(this);
5608 }
5609
5611 {
5612 return *reinterpret_cast<VkLayerProperties*>(this);
5613 }
5614
5615 bool operator==( LayerProperties const& rhs ) const
5616 {
5617 return ( memcmp( layerName, rhs.layerName, VK_MAX_EXTENSION_NAME_SIZE * sizeof( char ) ) == 0 )
5618 && ( specVersion == rhs.specVersion )
5620 && ( memcmp( description, rhs.description, VK_MAX_DESCRIPTION_SIZE * sizeof( char ) ) == 0 );
5621 }
5622
5623 bool operator!=( LayerProperties const& rhs ) const
5624 {
5625 return !operator==( rhs );
5626 }
5627
5632 };
5633 static_assert( sizeof( LayerProperties ) == sizeof( VkLayerProperties ), "struct and wrapper have different size!" );
5634
5636 {
5637 AllocationCallbacks( void* pUserData_ = nullptr,
5638 PFN_vkAllocationFunction pfnAllocation_ = nullptr,
5639 PFN_vkReallocationFunction pfnReallocation_ = nullptr,
5640 PFN_vkFreeFunction pfnFree_ = nullptr,
5641 PFN_vkInternalAllocationNotification pfnInternalAllocation_ = nullptr,
5642 PFN_vkInternalFreeNotification pfnInternalFree_ = nullptr )
5643 : pUserData( pUserData_ )
5644 , pfnAllocation( pfnAllocation_ )
5645 , pfnReallocation( pfnReallocation_ )
5646 , pfnFree( pfnFree_ )
5647 , pfnInternalAllocation( pfnInternalAllocation_ )
5648 , pfnInternalFree( pfnInternalFree_ )
5649 {
5650 }
5651
5653 {
5654 memcpy( this, &rhs, sizeof( AllocationCallbacks ) );
5655 }
5656
5658 {
5659 memcpy( this, &rhs, sizeof( AllocationCallbacks ) );
5660 return *this;
5661 }
5663 {
5664 pUserData = pUserData_;
5665 return *this;
5666 }
5667
5669 {
5670 pfnAllocation = pfnAllocation_;
5671 return *this;
5672 }
5673
5675 {
5676 pfnReallocation = pfnReallocation_;
5677 return *this;
5678 }
5679
5681 {
5682 pfnFree = pfnFree_;
5683 return *this;
5684 }
5685
5687 {
5688 pfnInternalAllocation = pfnInternalAllocation_;
5689 return *this;
5690 }
5691
5693 {
5694 pfnInternalFree = pfnInternalFree_;
5695 return *this;
5696 }
5697
5698 operator VkAllocationCallbacks const&() const
5699 {
5700 return *reinterpret_cast<const VkAllocationCallbacks*>(this);
5701 }
5702
5704 {
5705 return *reinterpret_cast<VkAllocationCallbacks*>(this);
5706 }
5707
5708 bool operator==( AllocationCallbacks const& rhs ) const
5709 {
5710 return ( pUserData == rhs.pUserData )
5711 && ( pfnAllocation == rhs.pfnAllocation )
5712 && ( pfnReallocation == rhs.pfnReallocation )
5713 && ( pfnFree == rhs.pfnFree )
5715 && ( pfnInternalFree == rhs.pfnInternalFree );
5716 }
5717
5718 bool operator!=( AllocationCallbacks const& rhs ) const
5719 {
5720 return !operator==( rhs );
5721 }
5722
5729 };
5730 static_assert( sizeof( AllocationCallbacks ) == sizeof( VkAllocationCallbacks ), "struct and wrapper have different size!" );
5731
5733 {
5734 operator VkMemoryRequirements const&() const
5735 {
5736 return *reinterpret_cast<const VkMemoryRequirements*>(this);
5737 }
5738
5740 {
5741 return *reinterpret_cast<VkMemoryRequirements*>(this);
5742 }
5743
5744 bool operator==( MemoryRequirements const& rhs ) const
5745 {
5746 return ( size == rhs.size )
5747 && ( alignment == rhs.alignment )
5748 && ( memoryTypeBits == rhs.memoryTypeBits );
5749 }
5750
5751 bool operator!=( MemoryRequirements const& rhs ) const
5752 {
5753 return !operator==( rhs );
5754 }
5755
5759 };
5760 static_assert( sizeof( MemoryRequirements ) == sizeof( VkMemoryRequirements ), "struct and wrapper have different size!" );
5761
5763 {
5765 DeviceSize offset_ = 0,
5766 DeviceSize range_ = 0 )
5767 : buffer( buffer_ )
5768 , offset( offset_ )
5769 , range( range_ )
5770 {
5771 }
5772
5774 {
5775 memcpy( this, &rhs, sizeof( DescriptorBufferInfo ) );
5776 }
5777
5779 {
5780 memcpy( this, &rhs, sizeof( DescriptorBufferInfo ) );
5781 return *this;
5782 }
5784 {
5785 buffer = buffer_;
5786 return *this;
5787 }
5788
5790 {
5791 offset = offset_;
5792 return *this;
5793 }
5794
5796 {
5797 range = range_;
5798 return *this;
5799 }
5800
5801 operator VkDescriptorBufferInfo const&() const
5802 {
5803 return *reinterpret_cast<const VkDescriptorBufferInfo*>(this);
5804 }
5805
5807 {
5808 return *reinterpret_cast<VkDescriptorBufferInfo*>(this);
5809 }
5810
5811 bool operator==( DescriptorBufferInfo const& rhs ) const
5812 {
5813 return ( buffer == rhs.buffer )
5814 && ( offset == rhs.offset )
5815 && ( range == rhs.range );
5816 }
5817
5818 bool operator!=( DescriptorBufferInfo const& rhs ) const
5819 {
5820 return !operator==( rhs );
5821 }
5822
5826 };
5827 static_assert( sizeof( DescriptorBufferInfo ) == sizeof( VkDescriptorBufferInfo ), "struct and wrapper have different size!" );
5828
5830 {
5831 operator VkSubresourceLayout const&() const
5832 {
5833 return *reinterpret_cast<const VkSubresourceLayout*>(this);
5834 }
5835
5837 {
5838 return *reinterpret_cast<VkSubresourceLayout*>(this);
5839 }
5840
5841 bool operator==( SubresourceLayout const& rhs ) const
5842 {
5843 return ( offset == rhs.offset )
5844 && ( size == rhs.size )
5845 && ( rowPitch == rhs.rowPitch )
5846 && ( arrayPitch == rhs.arrayPitch )
5847 && ( depthPitch == rhs.depthPitch );
5848 }
5849
5850 bool operator!=( SubresourceLayout const& rhs ) const
5851 {
5852 return !operator==( rhs );
5853 }
5854
5860 };
5861 static_assert( sizeof( SubresourceLayout ) == sizeof( VkSubresourceLayout ), "struct and wrapper have different size!" );
5862
5864 {
5865 BufferCopy( DeviceSize srcOffset_ = 0,
5866 DeviceSize dstOffset_ = 0,
5867 DeviceSize size_ = 0 )
5868 : srcOffset( srcOffset_ )
5869 , dstOffset( dstOffset_ )
5870 , size( size_ )
5871 {
5872 }
5873
5875 {
5876 memcpy( this, &rhs, sizeof( BufferCopy ) );
5877 }
5878
5880 {
5881 memcpy( this, &rhs, sizeof( BufferCopy ) );
5882 return *this;
5883 }
5885 {
5886 srcOffset = srcOffset_;
5887 return *this;
5888 }
5889
5891 {
5892 dstOffset = dstOffset_;
5893 return *this;
5894 }
5895
5897 {
5898 size = size_;
5899 return *this;
5900 }
5901
5902 operator VkBufferCopy const&() const
5903 {
5904 return *reinterpret_cast<const VkBufferCopy*>(this);
5905 }
5906
5907 operator VkBufferCopy &()
5908 {
5909 return *reinterpret_cast<VkBufferCopy*>(this);
5910 }
5911
5912 bool operator==( BufferCopy const& rhs ) const
5913 {
5914 return ( srcOffset == rhs.srcOffset )
5915 && ( dstOffset == rhs.dstOffset )
5916 && ( size == rhs.size );
5917 }
5918
5919 bool operator!=( BufferCopy const& rhs ) const
5920 {
5921 return !operator==( rhs );
5922 }
5923
5927 };
5928 static_assert( sizeof( BufferCopy ) == sizeof( VkBufferCopy ), "struct and wrapper have different size!" );
5929
5931 {
5933 uint32_t offset_ = 0,
5934 size_t size_ = 0 )
5935 : constantID( constantID_ )
5936 , offset( offset_ )
5937 , size( size_ )
5938 {
5939 }
5940
5942 {
5943 memcpy( this, &rhs, sizeof( SpecializationMapEntry ) );
5944 }
5945
5947 {
5948 memcpy( this, &rhs, sizeof( SpecializationMapEntry ) );
5949 return *this;
5950 }
5952 {
5953 constantID = constantID_;
5954 return *this;
5955 }
5956
5958 {
5959 offset = offset_;
5960 return *this;
5961 }
5962
5964 {
5965 size = size_;
5966 return *this;
5967 }
5968
5969 operator VkSpecializationMapEntry const&() const
5970 {
5971 return *reinterpret_cast<const VkSpecializationMapEntry*>(this);
5972 }
5973
5975 {
5976 return *reinterpret_cast<VkSpecializationMapEntry*>(this);
5977 }
5978
5979 bool operator==( SpecializationMapEntry const& rhs ) const
5980 {
5981 return ( constantID == rhs.constantID )
5982 && ( offset == rhs.offset )
5983 && ( size == rhs.size );
5984 }
5985
5986 bool operator!=( SpecializationMapEntry const& rhs ) const
5987 {
5988 return !operator==( rhs );
5989 }
5990
5993 size_t size;
5994 };
5995 static_assert( sizeof( SpecializationMapEntry ) == sizeof( VkSpecializationMapEntry ), "struct and wrapper have different size!" );
5996
5998 {
5999 SpecializationInfo( uint32_t mapEntryCount_ = 0,
6000 const SpecializationMapEntry* pMapEntries_ = nullptr,
6001 size_t dataSize_ = 0,
6002 const void* pData_ = nullptr )
6003 : mapEntryCount( mapEntryCount_ )
6004 , pMapEntries( pMapEntries_ )
6005 , dataSize( dataSize_ )
6006 , pData( pData_ )
6007 {
6008 }
6009
6011 {
6012 memcpy( this, &rhs, sizeof( SpecializationInfo ) );
6013 }
6014
6016 {
6017 memcpy( this, &rhs, sizeof( SpecializationInfo ) );
6018 return *this;
6019 }
6021 {
6022 mapEntryCount = mapEntryCount_;
6023 return *this;
6024 }
6025
6027 {
6028 pMapEntries = pMapEntries_;
6029 return *this;
6030 }
6031
6032 SpecializationInfo& setDataSize( size_t dataSize_ )
6033 {
6034 dataSize = dataSize_;
6035 return *this;
6036 }
6037
6038 SpecializationInfo& setPData( const void* pData_ )
6039 {
6040 pData = pData_;
6041 return *this;
6042 }
6043
6044 operator VkSpecializationInfo const&() const
6045 {
6046 return *reinterpret_cast<const VkSpecializationInfo*>(this);
6047 }
6048
6050 {
6051 return *reinterpret_cast<VkSpecializationInfo*>(this);
6052 }
6053
6054 bool operator==( SpecializationInfo const& rhs ) const
6055 {
6056 return ( mapEntryCount == rhs.mapEntryCount )
6057 && ( pMapEntries == rhs.pMapEntries )
6058 && ( dataSize == rhs.dataSize )
6059 && ( pData == rhs.pData );
6060 }
6061
6062 bool operator!=( SpecializationInfo const& rhs ) const
6063 {
6064 return !operator==( rhs );
6065 }
6066
6069 size_t dataSize;
6070 const void* pData;
6071 };
6072 static_assert( sizeof( SpecializationInfo ) == sizeof( VkSpecializationInfo ), "struct and wrapper have different size!" );
6073
6075 {
6076 ClearColorValue( const std::array<float,4>& float32_ = { {0} } )
6077 {
6078 memcpy( &float32, float32_.data(), 4 * sizeof( float ) );
6079 }
6080
6081 ClearColorValue( const std::array<int32_t,4>& int32_ )
6082 {
6083 memcpy( &int32, int32_.data(), 4 * sizeof( int32_t ) );
6084 }
6085
6086 ClearColorValue( const std::array<uint32_t,4>& uint32_ )
6087 {
6088 memcpy( &uint32, uint32_.data(), 4 * sizeof( uint32_t ) );
6089 }
6090
6091 ClearColorValue& setFloat32( std::array<float,4> float32_ )
6092 {
6093 memcpy( &float32, float32_.data(), 4 * sizeof( float ) );
6094 return *this;
6095 }
6096
6097 ClearColorValue& setInt32( std::array<int32_t,4> int32_ )
6098 {
6099 memcpy( &int32, int32_.data(), 4 * sizeof( int32_t ) );
6100 return *this;
6101 }
6102
6103 ClearColorValue& setUint32( std::array<uint32_t,4> uint32_ )
6104 {
6105 memcpy( &uint32, uint32_.data(), 4 * sizeof( uint32_t ) );
6106 return *this;
6107 }
6108
6109 operator VkClearColorValue const&() const
6110 {
6111 return *reinterpret_cast<const VkClearColorValue*>(this);
6112 }
6113
6115 {
6116 return *reinterpret_cast<VkClearColorValue*>(this);
6117 }
6118
6119 float float32[4];
6122 };
6123
6125 {
6126 ClearDepthStencilValue( float depth_ = 0,
6127 uint32_t stencil_ = 0 )
6128 : depth( depth_ )
6129 , stencil( stencil_ )
6130 {
6131 }
6132
6134 {
6135 memcpy( this, &rhs, sizeof( ClearDepthStencilValue ) );
6136 }
6137
6139 {
6140 memcpy( this, &rhs, sizeof( ClearDepthStencilValue ) );
6141 return *this;
6142 }
6144 {
6145 depth = depth_;
6146 return *this;
6147 }
6148
6150 {
6151 stencil = stencil_;
6152 return *this;
6153 }
6154
6155 operator VkClearDepthStencilValue const&() const
6156 {
6157 return *reinterpret_cast<const VkClearDepthStencilValue*>(this);
6158 }
6159
6161 {
6162 return *reinterpret_cast<VkClearDepthStencilValue*>(this);
6163 }
6164
6165 bool operator==( ClearDepthStencilValue const& rhs ) const
6166 {
6167 return ( depth == rhs.depth )
6168 && ( stencil == rhs.stencil );
6169 }
6170
6171 bool operator!=( ClearDepthStencilValue const& rhs ) const
6172 {
6173 return !operator==( rhs );
6174 }
6175
6176 float depth;
6178 };
6179 static_assert( sizeof( ClearDepthStencilValue ) == sizeof( VkClearDepthStencilValue ), "struct and wrapper have different size!" );
6180
6182 {
6184 {
6185 color = color_;
6186 }
6187
6189 {
6190 depthStencil = depthStencil_;
6191 }
6192
6194 {
6195 color = color_;
6196 return *this;
6197 }
6198
6200 {
6201 depthStencil = depthStencil_;
6202 return *this;
6203 }
6204
6205 operator VkClearValue const&() const
6206 {
6207 return *reinterpret_cast<const VkClearValue*>(this);
6208 }
6209
6210 operator VkClearValue &()
6211 {
6212 return *reinterpret_cast<VkClearValue*>(this);
6213 }
6214
6215#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
6218#else
6221#endif // VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
6222 };
6223
6225 {
6226 PhysicalDeviceFeatures( Bool32 robustBufferAccess_ = 0,
6227 Bool32 fullDrawIndexUint32_ = 0,
6228 Bool32 imageCubeArray_ = 0,
6229 Bool32 independentBlend_ = 0,
6230 Bool32 geometryShader_ = 0,
6231 Bool32 tessellationShader_ = 0,
6232 Bool32 sampleRateShading_ = 0,
6233 Bool32 dualSrcBlend_ = 0,
6234 Bool32 logicOp_ = 0,
6235 Bool32 multiDrawIndirect_ = 0,
6236 Bool32 drawIndirectFirstInstance_ = 0,
6237 Bool32 depthClamp_ = 0,
6238 Bool32 depthBiasClamp_ = 0,
6239 Bool32 fillModeNonSolid_ = 0,
6240 Bool32 depthBounds_ = 0,
6241 Bool32 wideLines_ = 0,
6242 Bool32 largePoints_ = 0,
6243 Bool32 alphaToOne_ = 0,
6244 Bool32 multiViewport_ = 0,
6245 Bool32 samplerAnisotropy_ = 0,
6246 Bool32 textureCompressionETC2_ = 0,
6247 Bool32 textureCompressionASTC_LDR_ = 0,
6248 Bool32 textureCompressionBC_ = 0,
6249 Bool32 occlusionQueryPrecise_ = 0,
6250 Bool32 pipelineStatisticsQuery_ = 0,
6251 Bool32 vertexPipelineStoresAndAtomics_ = 0,
6252 Bool32 fragmentStoresAndAtomics_ = 0,
6253 Bool32 shaderTessellationAndGeometryPointSize_ = 0,
6254 Bool32 shaderImageGatherExtended_ = 0,
6255 Bool32 shaderStorageImageExtendedFormats_ = 0,
6256 Bool32 shaderStorageImageMultisample_ = 0,
6257 Bool32 shaderStorageImageReadWithoutFormat_ = 0,
6258 Bool32 shaderStorageImageWriteWithoutFormat_ = 0,
6259 Bool32 shaderUniformBufferArrayDynamicIndexing_ = 0,
6260 Bool32 shaderSampledImageArrayDynamicIndexing_ = 0,
6261 Bool32 shaderStorageBufferArrayDynamicIndexing_ = 0,
6262 Bool32 shaderStorageImageArrayDynamicIndexing_ = 0,
6263 Bool32 shaderClipDistance_ = 0,
6264 Bool32 shaderCullDistance_ = 0,
6265 Bool32 shaderFloat64_ = 0,
6266 Bool32 shaderInt64_ = 0,
6267 Bool32 shaderInt16_ = 0,
6268 Bool32 shaderResourceResidency_ = 0,
6269 Bool32 shaderResourceMinLod_ = 0,
6270 Bool32 sparseBinding_ = 0,
6271 Bool32 sparseResidencyBuffer_ = 0,
6272 Bool32 sparseResidencyImage2D_ = 0,
6273 Bool32 sparseResidencyImage3D_ = 0,
6274 Bool32 sparseResidency2Samples_ = 0,
6275 Bool32 sparseResidency4Samples_ = 0,
6276 Bool32 sparseResidency8Samples_ = 0,
6277 Bool32 sparseResidency16Samples_ = 0,
6278 Bool32 sparseResidencyAliased_ = 0,
6279 Bool32 variableMultisampleRate_ = 0,
6280 Bool32 inheritedQueries_ = 0 )
6281 : robustBufferAccess( robustBufferAccess_ )
6282 , fullDrawIndexUint32( fullDrawIndexUint32_ )
6283 , imageCubeArray( imageCubeArray_ )
6284 , independentBlend( independentBlend_ )
6285 , geometryShader( geometryShader_ )
6286 , tessellationShader( tessellationShader_ )
6287 , sampleRateShading( sampleRateShading_ )
6288 , dualSrcBlend( dualSrcBlend_ )
6289 , logicOp( logicOp_ )
6290 , multiDrawIndirect( multiDrawIndirect_ )
6291 , drawIndirectFirstInstance( drawIndirectFirstInstance_ )
6292 , depthClamp( depthClamp_ )
6293 , depthBiasClamp( depthBiasClamp_ )
6294 , fillModeNonSolid( fillModeNonSolid_ )
6295 , depthBounds( depthBounds_ )
6296 , wideLines( wideLines_ )
6297 , largePoints( largePoints_ )
6298 , alphaToOne( alphaToOne_ )
6299 , multiViewport( multiViewport_ )
6300 , samplerAnisotropy( samplerAnisotropy_ )
6301 , textureCompressionETC2( textureCompressionETC2_ )
6302 , textureCompressionASTC_LDR( textureCompressionASTC_LDR_ )
6303 , textureCompressionBC( textureCompressionBC_ )
6304 , occlusionQueryPrecise( occlusionQueryPrecise_ )
6305 , pipelineStatisticsQuery( pipelineStatisticsQuery_ )
6306 , vertexPipelineStoresAndAtomics( vertexPipelineStoresAndAtomics_ )
6307 , fragmentStoresAndAtomics( fragmentStoresAndAtomics_ )
6308 , shaderTessellationAndGeometryPointSize( shaderTessellationAndGeometryPointSize_ )
6309 , shaderImageGatherExtended( shaderImageGatherExtended_ )
6310 , shaderStorageImageExtendedFormats( shaderStorageImageExtendedFormats_ )
6311 , shaderStorageImageMultisample( shaderStorageImageMultisample_ )
6312 , shaderStorageImageReadWithoutFormat( shaderStorageImageReadWithoutFormat_ )
6313 , shaderStorageImageWriteWithoutFormat( shaderStorageImageWriteWithoutFormat_ )
6314 , shaderUniformBufferArrayDynamicIndexing( shaderUniformBufferArrayDynamicIndexing_ )
6315 , shaderSampledImageArrayDynamicIndexing( shaderSampledImageArrayDynamicIndexing_ )
6316 , shaderStorageBufferArrayDynamicIndexing( shaderStorageBufferArrayDynamicIndexing_ )
6317 , shaderStorageImageArrayDynamicIndexing( shaderStorageImageArrayDynamicIndexing_ )
6318 , shaderClipDistance( shaderClipDistance_ )
6319 , shaderCullDistance( shaderCullDistance_ )
6320 , shaderFloat64( shaderFloat64_ )
6321 , shaderInt64( shaderInt64_ )
6322 , shaderInt16( shaderInt16_ )
6323 , shaderResourceResidency( shaderResourceResidency_ )
6324 , shaderResourceMinLod( shaderResourceMinLod_ )
6325 , sparseBinding( sparseBinding_ )
6326 , sparseResidencyBuffer( sparseResidencyBuffer_ )
6327 , sparseResidencyImage2D( sparseResidencyImage2D_ )
6328 , sparseResidencyImage3D( sparseResidencyImage3D_ )
6329 , sparseResidency2Samples( sparseResidency2Samples_ )
6330 , sparseResidency4Samples( sparseResidency4Samples_ )
6331 , sparseResidency8Samples( sparseResidency8Samples_ )
6332 , sparseResidency16Samples( sparseResidency16Samples_ )
6333 , sparseResidencyAliased( sparseResidencyAliased_ )
6334 , variableMultisampleRate( variableMultisampleRate_ )
6335 , inheritedQueries( inheritedQueries_ )
6336 {
6337 }
6338
6340 {
6341 memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures ) );
6342 }
6343
6345 {
6346 memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures ) );
6347 return *this;
6348 }
6350 {
6351 robustBufferAccess = robustBufferAccess_;
6352 return *this;
6353 }
6354
6356 {
6357 fullDrawIndexUint32 = fullDrawIndexUint32_;
6358 return *this;
6359 }
6360
6362 {
6363 imageCubeArray = imageCubeArray_;
6364 return *this;
6365 }
6366
6368 {
6369 independentBlend = independentBlend_;
6370 return *this;
6371 }
6372
6374 {
6375 geometryShader = geometryShader_;
6376 return *this;
6377 }
6378
6380 {
6381 tessellationShader = tessellationShader_;
6382 return *this;
6383 }
6384
6386 {
6387 sampleRateShading = sampleRateShading_;
6388 return *this;
6389 }
6390
6392 {
6393 dualSrcBlend = dualSrcBlend_;
6394 return *this;
6395 }
6396
6398 {
6399 logicOp = logicOp_;
6400 return *this;
6401 }
6402
6404 {
6405 multiDrawIndirect = multiDrawIndirect_;
6406 return *this;
6407 }
6408
6410 {
6411 drawIndirectFirstInstance = drawIndirectFirstInstance_;
6412 return *this;
6413 }
6414
6416 {
6417 depthClamp = depthClamp_;
6418 return *this;
6419 }
6420
6422 {
6423 depthBiasClamp = depthBiasClamp_;
6424 return *this;
6425 }
6426
6428 {
6429 fillModeNonSolid = fillModeNonSolid_;
6430 return *this;
6431 }
6432
6434 {
6435 depthBounds = depthBounds_;
6436 return *this;
6437 }
6438
6440 {
6441 wideLines = wideLines_;
6442 return *this;
6443 }
6444
6446 {
6447 largePoints = largePoints_;
6448 return *this;
6449 }
6450
6452 {
6453 alphaToOne = alphaToOne_;
6454 return *this;
6455 }
6456
6458 {
6459 multiViewport = multiViewport_;
6460 return *this;
6461 }
6462
6464 {
6465 samplerAnisotropy = samplerAnisotropy_;
6466 return *this;
6467 }
6468
6470 {
6471 textureCompressionETC2 = textureCompressionETC2_;
6472 return *this;
6473 }
6474
6476 {
6477 textureCompressionASTC_LDR = textureCompressionASTC_LDR_;
6478 return *this;
6479 }
6480
6482 {
6483 textureCompressionBC = textureCompressionBC_;
6484 return *this;
6485 }
6486
6488 {
6489 occlusionQueryPrecise = occlusionQueryPrecise_;
6490 return *this;
6491 }
6492
6494 {
6495 pipelineStatisticsQuery = pipelineStatisticsQuery_;
6496 return *this;
6497 }
6498
6500 {
6501 vertexPipelineStoresAndAtomics = vertexPipelineStoresAndAtomics_;
6502 return *this;
6503 }
6504
6506 {
6507 fragmentStoresAndAtomics = fragmentStoresAndAtomics_;
6508 return *this;
6509 }
6510
6512 {
6513 shaderTessellationAndGeometryPointSize = shaderTessellationAndGeometryPointSize_;
6514 return *this;
6515 }
6516
6518 {
6519 shaderImageGatherExtended = shaderImageGatherExtended_;
6520 return *this;
6521 }
6522
6524 {
6525 shaderStorageImageExtendedFormats = shaderStorageImageExtendedFormats_;
6526 return *this;
6527 }
6528
6530 {
6531 shaderStorageImageMultisample = shaderStorageImageMultisample_;
6532 return *this;
6533 }
6534
6536 {
6537 shaderStorageImageReadWithoutFormat = shaderStorageImageReadWithoutFormat_;
6538 return *this;
6539 }
6540
6542 {
6543 shaderStorageImageWriteWithoutFormat = shaderStorageImageWriteWithoutFormat_;
6544 return *this;
6545 }
6546
6548 {
6549 shaderUniformBufferArrayDynamicIndexing = shaderUniformBufferArrayDynamicIndexing_;
6550 return *this;
6551 }
6552
6554 {
6555 shaderSampledImageArrayDynamicIndexing = shaderSampledImageArrayDynamicIndexing_;
6556 return *this;
6557 }
6558
6560 {
6561 shaderStorageBufferArrayDynamicIndexing = shaderStorageBufferArrayDynamicIndexing_;
6562 return *this;
6563 }
6564
6566 {
6567 shaderStorageImageArrayDynamicIndexing = shaderStorageImageArrayDynamicIndexing_;
6568 return *this;
6569 }
6570
6572 {
6573 shaderClipDistance = shaderClipDistance_;
6574 return *this;
6575 }
6576
6578 {
6579 shaderCullDistance = shaderCullDistance_;
6580 return *this;
6581 }
6582
6584 {
6585 shaderFloat64 = shaderFloat64_;
6586 return *this;
6587 }
6588
6590 {
6591 shaderInt64 = shaderInt64_;
6592 return *this;
6593 }
6594
6596 {
6597 shaderInt16 = shaderInt16_;
6598 return *this;
6599 }
6600
6602 {
6603 shaderResourceResidency = shaderResourceResidency_;
6604 return *this;
6605 }
6606
6608 {
6609 shaderResourceMinLod = shaderResourceMinLod_;
6610 return *this;
6611 }
6612
6614 {
6615 sparseBinding = sparseBinding_;
6616 return *this;
6617 }
6618
6620 {
6621 sparseResidencyBuffer = sparseResidencyBuffer_;
6622 return *this;
6623 }
6624
6626 {
6627 sparseResidencyImage2D = sparseResidencyImage2D_;
6628 return *this;
6629 }
6630
6632 {
6633 sparseResidencyImage3D = sparseResidencyImage3D_;
6634 return *this;
6635 }
6636
6638 {
6639 sparseResidency2Samples = sparseResidency2Samples_;
6640 return *this;
6641 }
6642
6644 {
6645 sparseResidency4Samples = sparseResidency4Samples_;
6646 return *this;
6647 }
6648
6650 {
6651 sparseResidency8Samples = sparseResidency8Samples_;
6652 return *this;
6653 }
6654
6656 {
6657 sparseResidency16Samples = sparseResidency16Samples_;
6658 return *this;
6659 }
6660
6662 {
6663 sparseResidencyAliased = sparseResidencyAliased_;
6664 return *this;
6665 }
6666
6668 {
6669 variableMultisampleRate = variableMultisampleRate_;
6670 return *this;
6671 }
6672
6674 {
6675 inheritedQueries = inheritedQueries_;
6676 return *this;
6677 }
6678
6679 operator VkPhysicalDeviceFeatures const&() const
6680 {
6681 return *reinterpret_cast<const VkPhysicalDeviceFeatures*>(this);
6682 }
6683
6685 {
6686 return *reinterpret_cast<VkPhysicalDeviceFeatures*>(this);
6687 }
6688
6689 bool operator==( PhysicalDeviceFeatures const& rhs ) const
6690 {
6691 return ( robustBufferAccess == rhs.robustBufferAccess )
6693 && ( imageCubeArray == rhs.imageCubeArray )
6695 && ( geometryShader == rhs.geometryShader )
6698 && ( dualSrcBlend == rhs.dualSrcBlend )
6699 && ( logicOp == rhs.logicOp )
6702 && ( depthClamp == rhs.depthClamp )
6703 && ( depthBiasClamp == rhs.depthBiasClamp )
6705 && ( depthBounds == rhs.depthBounds )
6706 && ( wideLines == rhs.wideLines )
6707 && ( largePoints == rhs.largePoints )
6708 && ( alphaToOne == rhs.alphaToOne )
6709 && ( multiViewport == rhs.multiViewport )
6730 && ( shaderFloat64 == rhs.shaderFloat64 )
6731 && ( shaderInt64 == rhs.shaderInt64 )
6732 && ( shaderInt16 == rhs.shaderInt16 )
6735 && ( sparseBinding == rhs.sparseBinding )
6745 && ( inheritedQueries == rhs.inheritedQueries );
6746 }
6747
6748 bool operator!=( PhysicalDeviceFeatures const& rhs ) const
6749 {
6750 return !operator==( rhs );
6751 }
6752
6808 };
6809 static_assert( sizeof( PhysicalDeviceFeatures ) == sizeof( VkPhysicalDeviceFeatures ), "struct and wrapper have different size!" );
6810
6812 {
6813 operator VkPhysicalDeviceSparseProperties const&() const
6814 {
6815 return *reinterpret_cast<const VkPhysicalDeviceSparseProperties*>(this);
6816 }
6817
6819 {
6820 return *reinterpret_cast<VkPhysicalDeviceSparseProperties*>(this);
6821 }
6822
6824 {
6830 }
6831
6833 {
6834 return !operator==( rhs );
6835 }
6836
6842 };
6843 static_assert( sizeof( PhysicalDeviceSparseProperties ) == sizeof( VkPhysicalDeviceSparseProperties ), "struct and wrapper have different size!" );
6844
6846 {
6848 uint32_t instanceCount_ = 0,
6849 uint32_t firstVertex_ = 0,
6850 uint32_t firstInstance_ = 0 )
6851 : vertexCount( vertexCount_ )
6852 , instanceCount( instanceCount_ )
6853 , firstVertex( firstVertex_ )
6854 , firstInstance( firstInstance_ )
6855 {
6856 }
6857
6859 {
6860 memcpy( this, &rhs, sizeof( DrawIndirectCommand ) );
6861 }
6862
6864 {
6865 memcpy( this, &rhs, sizeof( DrawIndirectCommand ) );
6866 return *this;
6867 }
6869 {
6870 vertexCount = vertexCount_;
6871 return *this;
6872 }
6873
6875 {
6876 instanceCount = instanceCount_;
6877 return *this;
6878 }
6879
6881 {
6882 firstVertex = firstVertex_;
6883 return *this;
6884 }
6885
6887 {
6888 firstInstance = firstInstance_;
6889 return *this;
6890 }
6891
6892 operator VkDrawIndirectCommand const&() const
6893 {
6894 return *reinterpret_cast<const VkDrawIndirectCommand*>(this);
6895 }
6896
6898 {
6899 return *reinterpret_cast<VkDrawIndirectCommand*>(this);
6900 }
6901
6902 bool operator==( DrawIndirectCommand const& rhs ) const
6903 {
6904 return ( vertexCount == rhs.vertexCount )
6905 && ( instanceCount == rhs.instanceCount )
6906 && ( firstVertex == rhs.firstVertex )
6907 && ( firstInstance == rhs.firstInstance );
6908 }
6909
6910 bool operator!=( DrawIndirectCommand const& rhs ) const
6911 {
6912 return !operator==( rhs );
6913 }
6914
6919 };
6920 static_assert( sizeof( DrawIndirectCommand ) == sizeof( VkDrawIndirectCommand ), "struct and wrapper have different size!" );
6921
6923 {
6925 uint32_t instanceCount_ = 0,
6926 uint32_t firstIndex_ = 0,
6927 int32_t vertexOffset_ = 0,
6928 uint32_t firstInstance_ = 0 )
6929 : indexCount( indexCount_ )
6930 , instanceCount( instanceCount_ )
6931 , firstIndex( firstIndex_ )
6932 , vertexOffset( vertexOffset_ )
6933 , firstInstance( firstInstance_ )
6934 {
6935 }
6936
6938 {
6939 memcpy( this, &rhs, sizeof( DrawIndexedIndirectCommand ) );
6940 }
6941
6943 {
6944 memcpy( this, &rhs, sizeof( DrawIndexedIndirectCommand ) );
6945 return *this;
6946 }
6948 {
6949 indexCount = indexCount_;
6950 return *this;
6951 }
6952
6954 {
6955 instanceCount = instanceCount_;
6956 return *this;
6957 }
6958
6960 {
6961 firstIndex = firstIndex_;
6962 return *this;
6963 }
6964
6966 {
6967 vertexOffset = vertexOffset_;
6968 return *this;
6969 }
6970
6972 {
6973 firstInstance = firstInstance_;
6974 return *this;
6975 }
6976
6977 operator VkDrawIndexedIndirectCommand const&() const
6978 {
6979 return *reinterpret_cast<const VkDrawIndexedIndirectCommand*>(this);
6980 }
6981
6983 {
6984 return *reinterpret_cast<VkDrawIndexedIndirectCommand*>(this);
6985 }
6986
6988 {
6989 return ( indexCount == rhs.indexCount )
6990 && ( instanceCount == rhs.instanceCount )
6991 && ( firstIndex == rhs.firstIndex )
6992 && ( vertexOffset == rhs.vertexOffset )
6993 && ( firstInstance == rhs.firstInstance );
6994 }
6995
6997 {
6998 return !operator==( rhs );
6999 }
7000
7006 };
7007 static_assert( sizeof( DrawIndexedIndirectCommand ) == sizeof( VkDrawIndexedIndirectCommand ), "struct and wrapper have different size!" );
7008
7010 {
7012 uint32_t y_ = 0,
7013 uint32_t z_ = 0 )
7014 : x( x_ )
7015 , y( y_ )
7016 , z( z_ )
7017 {
7018 }
7019
7021 {
7022 memcpy( this, &rhs, sizeof( DispatchIndirectCommand ) );
7023 }
7024
7026 {
7027 memcpy( this, &rhs, sizeof( DispatchIndirectCommand ) );
7028 return *this;
7029 }
7031 {
7032 x = x_;
7033 return *this;
7034 }
7035
7037 {
7038 y = y_;
7039 return *this;
7040 }
7041
7043 {
7044 z = z_;
7045 return *this;
7046 }
7047
7048 operator VkDispatchIndirectCommand const&() const
7049 {
7050 return *reinterpret_cast<const VkDispatchIndirectCommand*>(this);
7051 }
7052
7054 {
7055 return *reinterpret_cast<VkDispatchIndirectCommand*>(this);
7056 }
7057
7058 bool operator==( DispatchIndirectCommand const& rhs ) const
7059 {
7060 return ( x == rhs.x )
7061 && ( y == rhs.y )
7062 && ( z == rhs.z );
7063 }
7064
7065 bool operator!=( DispatchIndirectCommand const& rhs ) const
7066 {
7067 return !operator==( rhs );
7068 }
7069
7073 };
7074 static_assert( sizeof( DispatchIndirectCommand ) == sizeof( VkDispatchIndirectCommand ), "struct and wrapper have different size!" );
7075
7077 {
7078 operator VkDisplayPlanePropertiesKHR const&() const
7079 {
7080 return *reinterpret_cast<const VkDisplayPlanePropertiesKHR*>(this);
7081 }
7082
7084 {
7085 return *reinterpret_cast<VkDisplayPlanePropertiesKHR*>(this);
7086 }
7087
7088 bool operator==( DisplayPlanePropertiesKHR const& rhs ) const
7089 {
7090 return ( currentDisplay == rhs.currentDisplay )
7092 }
7093
7094 bool operator!=( DisplayPlanePropertiesKHR const& rhs ) const
7095 {
7096 return !operator==( rhs );
7097 }
7098
7101 };
7102 static_assert( sizeof( DisplayPlanePropertiesKHR ) == sizeof( VkDisplayPlanePropertiesKHR ), "struct and wrapper have different size!" );
7103
7105 {
7107 uint32_t refreshRate_ = 0 )
7108 : visibleRegion( visibleRegion_ )
7109 , refreshRate( refreshRate_ )
7110 {
7111 }
7112
7114 {
7115 memcpy( this, &rhs, sizeof( DisplayModeParametersKHR ) );
7116 }
7117
7119 {
7120 memcpy( this, &rhs, sizeof( DisplayModeParametersKHR ) );
7121 return *this;
7122 }
7124 {
7125 visibleRegion = visibleRegion_;
7126 return *this;
7127 }
7128
7130 {
7131 refreshRate = refreshRate_;
7132 return *this;
7133 }
7134
7135 operator VkDisplayModeParametersKHR const&() const
7136 {
7137 return *reinterpret_cast<const VkDisplayModeParametersKHR*>(this);
7138 }
7139
7141 {
7142 return *reinterpret_cast<VkDisplayModeParametersKHR*>(this);
7143 }
7144
7145 bool operator==( DisplayModeParametersKHR const& rhs ) const
7146 {
7147 return ( visibleRegion == rhs.visibleRegion )
7148 && ( refreshRate == rhs.refreshRate );
7149 }
7150
7151 bool operator!=( DisplayModeParametersKHR const& rhs ) const
7152 {
7153 return !operator==( rhs );
7154 }
7155
7158 };
7159 static_assert( sizeof( DisplayModeParametersKHR ) == sizeof( VkDisplayModeParametersKHR ), "struct and wrapper have different size!" );
7160
7162 {
7163 operator VkDisplayModePropertiesKHR const&() const
7164 {
7165 return *reinterpret_cast<const VkDisplayModePropertiesKHR*>(this);
7166 }
7167
7169 {
7170 return *reinterpret_cast<VkDisplayModePropertiesKHR*>(this);
7171 }
7172
7173 bool operator==( DisplayModePropertiesKHR const& rhs ) const
7174 {
7175 return ( displayMode == rhs.displayMode )
7176 && ( parameters == rhs.parameters );
7177 }
7178
7179 bool operator!=( DisplayModePropertiesKHR const& rhs ) const
7180 {
7181 return !operator==( rhs );
7182 }
7183
7186 };
7187 static_assert( sizeof( DisplayModePropertiesKHR ) == sizeof( VkDisplayModePropertiesKHR ), "struct and wrapper have different size!" );
7188
7190 {
7192 uint8_t minor_ = 0,
7193 uint8_t subminor_ = 0,
7194 uint8_t patch_ = 0 )
7195 : major( major_ )
7196 , minor( minor_ )
7197 , subminor( subminor_ )
7198 , patch( patch_ )
7199 {
7200 }
7201
7203 {
7204 memcpy( this, &rhs, sizeof( ConformanceVersionKHR ) );
7205 }
7206
7208 {
7209 memcpy( this, &rhs, sizeof( ConformanceVersionKHR ) );
7210 return *this;
7211 }
7213 {
7214 major = major_;
7215 return *this;
7216 }
7217
7219 {
7220 minor = minor_;
7221 return *this;
7222 }
7223
7225 {
7226 subminor = subminor_;
7227 return *this;
7228 }
7229
7231 {
7232 patch = patch_;
7233 return *this;
7234 }
7235
7236 operator VkConformanceVersionKHR const&() const
7237 {
7238 return *reinterpret_cast<const VkConformanceVersionKHR*>(this);
7239 }
7240
7242 {
7243 return *reinterpret_cast<VkConformanceVersionKHR*>(this);
7244 }
7245
7246 bool operator==( ConformanceVersionKHR const& rhs ) const
7247 {
7248 return ( major == rhs.major )
7249 && ( minor == rhs.minor )
7250 && ( subminor == rhs.subminor )
7251 && ( patch == rhs.patch );
7252 }
7253
7254 bool operator!=( ConformanceVersionKHR const& rhs ) const
7255 {
7256 return !operator==( rhs );
7257 }
7258
7263 };
7264 static_assert( sizeof( ConformanceVersionKHR ) == sizeof( VkConformanceVersionKHR ), "struct and wrapper have different size!" );
7265
7267 {
7269 Extent2D extent_ = Extent2D(),
7270 uint32_t layer_ = 0 )
7271 : offset( offset_ )
7272 , extent( extent_ )
7273 , layer( layer_ )
7274 {
7275 }
7276
7277 explicit RectLayerKHR( Rect2D const& rect2D,
7278 uint32_t layer_ = 0 )
7279 : offset( rect2D.offset )
7280 , extent( rect2D.extent )
7281 , layer( layer_ )
7282 {}
7283
7285 {
7286 memcpy( this, &rhs, sizeof( RectLayerKHR ) );
7287 }
7288
7290 {
7291 memcpy( this, &rhs, sizeof( RectLayerKHR ) );
7292 return *this;
7293 }
7295 {
7296 offset = offset_;
7297 return *this;
7298 }
7299
7301 {
7302 extent = extent_;
7303 return *this;
7304 }
7305
7307 {
7308 layer = layer_;
7309 return *this;
7310 }
7311
7312 operator VkRectLayerKHR const&() const
7313 {
7314 return *reinterpret_cast<const VkRectLayerKHR*>(this);
7315 }
7316
7317 operator VkRectLayerKHR &()
7318 {
7319 return *reinterpret_cast<VkRectLayerKHR*>(this);
7320 }
7321
7322 bool operator==( RectLayerKHR const& rhs ) const
7323 {
7324 return ( offset == rhs.offset )
7325 && ( extent == rhs.extent )
7326 && ( layer == rhs.layer );
7327 }
7328
7329 bool operator!=( RectLayerKHR const& rhs ) const
7330 {
7331 return !operator==( rhs );
7332 }
7333
7337 };
7338 static_assert( sizeof( RectLayerKHR ) == sizeof( VkRectLayerKHR ), "struct and wrapper have different size!" );
7339
7341 {
7342 PresentRegionKHR( uint32_t rectangleCount_ = 0,
7343 const RectLayerKHR* pRectangles_ = nullptr )
7344 : rectangleCount( rectangleCount_ )
7345 , pRectangles( pRectangles_ )
7346 {
7347 }
7348
7350 {
7351 memcpy( this, &rhs, sizeof( PresentRegionKHR ) );
7352 }
7353
7355 {
7356 memcpy( this, &rhs, sizeof( PresentRegionKHR ) );
7357 return *this;
7358 }
7360 {
7361 rectangleCount = rectangleCount_;
7362 return *this;
7363 }
7364
7366 {
7367 pRectangles = pRectangles_;
7368 return *this;
7369 }
7370
7371 operator VkPresentRegionKHR const&() const
7372 {
7373 return *reinterpret_cast<const VkPresentRegionKHR*>(this);
7374 }
7375
7377 {
7378 return *reinterpret_cast<VkPresentRegionKHR*>(this);
7379 }
7380
7381 bool operator==( PresentRegionKHR const& rhs ) const
7382 {
7383 return ( rectangleCount == rhs.rectangleCount )
7384 && ( pRectangles == rhs.pRectangles );
7385 }
7386
7387 bool operator!=( PresentRegionKHR const& rhs ) const
7388 {
7389 return !operator==( rhs );
7390 }
7391
7394 };
7395 static_assert( sizeof( PresentRegionKHR ) == sizeof( VkPresentRegionKHR ), "struct and wrapper have different size!" );
7396
7398 {
7399 XYColorEXT( float x_ = 0,
7400 float y_ = 0 )
7401 : x( x_ )
7402 , y( y_ )
7403 {
7404 }
7405
7407 {
7408 memcpy( this, &rhs, sizeof( XYColorEXT ) );
7409 }
7410
7412 {
7413 memcpy( this, &rhs, sizeof( XYColorEXT ) );
7414 return *this;
7415 }
7416 XYColorEXT& setX( float x_ )
7417 {
7418 x = x_;
7419 return *this;
7420 }
7421
7422 XYColorEXT& setY( float y_ )
7423 {
7424 y = y_;
7425 return *this;
7426 }
7427
7428 operator VkXYColorEXT const&() const
7429 {
7430 return *reinterpret_cast<const VkXYColorEXT*>(this);
7431 }
7432
7433 operator VkXYColorEXT &()
7434 {
7435 return *reinterpret_cast<VkXYColorEXT*>(this);
7436 }
7437
7438 bool operator==( XYColorEXT const& rhs ) const
7439 {
7440 return ( x == rhs.x )
7441 && ( y == rhs.y );
7442 }
7443
7444 bool operator!=( XYColorEXT const& rhs ) const
7445 {
7446 return !operator==( rhs );
7447 }
7448
7449 float x;
7450 float y;
7451 };
7452 static_assert( sizeof( XYColorEXT ) == sizeof( VkXYColorEXT ), "struct and wrapper have different size!" );
7453
7455 {
7456 operator VkRefreshCycleDurationGOOGLE const&() const
7457 {
7458 return *reinterpret_cast<const VkRefreshCycleDurationGOOGLE*>(this);
7459 }
7460
7462 {
7463 return *reinterpret_cast<VkRefreshCycleDurationGOOGLE*>(this);
7464 }
7465
7467 {
7468 return ( refreshDuration == rhs.refreshDuration );
7469 }
7470
7472 {
7473 return !operator==( rhs );
7474 }
7475
7477 };
7478 static_assert( sizeof( RefreshCycleDurationGOOGLE ) == sizeof( VkRefreshCycleDurationGOOGLE ), "struct and wrapper have different size!" );
7479
7481 {
7482 operator VkPastPresentationTimingGOOGLE const&() const
7483 {
7484 return *reinterpret_cast<const VkPastPresentationTimingGOOGLE*>(this);
7485 }
7486
7488 {
7489 return *reinterpret_cast<VkPastPresentationTimingGOOGLE*>(this);
7490 }
7491
7493 {
7494 return ( presentID == rhs.presentID )
7498 && ( presentMargin == rhs.presentMargin );
7499 }
7500
7502 {
7503 return !operator==( rhs );
7504 }
7505
7511 };
7512 static_assert( sizeof( PastPresentationTimingGOOGLE ) == sizeof( VkPastPresentationTimingGOOGLE ), "struct and wrapper have different size!" );
7513
7515 {
7517 uint64_t desiredPresentTime_ = 0 )
7518 : presentID( presentID_ )
7519 , desiredPresentTime( desiredPresentTime_ )
7520 {
7521 }
7522
7524 {
7525 memcpy( this, &rhs, sizeof( PresentTimeGOOGLE ) );
7526 }
7527
7529 {
7530 memcpy( this, &rhs, sizeof( PresentTimeGOOGLE ) );
7531 return *this;
7532 }
7534 {
7535 presentID = presentID_;
7536 return *this;
7537 }
7538
7540 {
7541 desiredPresentTime = desiredPresentTime_;
7542 return *this;
7543 }
7544
7545 operator VkPresentTimeGOOGLE const&() const
7546 {
7547 return *reinterpret_cast<const VkPresentTimeGOOGLE*>(this);
7548 }
7549
7551 {
7552 return *reinterpret_cast<VkPresentTimeGOOGLE*>(this);
7553 }
7554
7555 bool operator==( PresentTimeGOOGLE const& rhs ) const
7556 {
7557 return ( presentID == rhs.presentID )
7559 }
7560
7561 bool operator!=( PresentTimeGOOGLE const& rhs ) const
7562 {
7563 return !operator==( rhs );
7564 }
7565
7568 };
7569 static_assert( sizeof( PresentTimeGOOGLE ) == sizeof( VkPresentTimeGOOGLE ), "struct and wrapper have different size!" );
7570
7572 {
7573 ViewportWScalingNV( float xcoeff_ = 0,
7574 float ycoeff_ = 0 )
7575 : xcoeff( xcoeff_ )
7576 , ycoeff( ycoeff_ )
7577 {
7578 }
7579
7581 {
7582 memcpy( this, &rhs, sizeof( ViewportWScalingNV ) );
7583 }
7584
7586 {
7587 memcpy( this, &rhs, sizeof( ViewportWScalingNV ) );
7588 return *this;
7589 }
7591 {
7592 xcoeff = xcoeff_;
7593 return *this;
7594 }
7595
7597 {
7598 ycoeff = ycoeff_;
7599 return *this;
7600 }
7601
7602 operator VkViewportWScalingNV const&() const
7603 {
7604 return *reinterpret_cast<const VkViewportWScalingNV*>(this);
7605 }
7606
7608 {
7609 return *reinterpret_cast<VkViewportWScalingNV*>(this);
7610 }
7611
7612 bool operator==( ViewportWScalingNV const& rhs ) const
7613 {
7614 return ( xcoeff == rhs.xcoeff )
7615 && ( ycoeff == rhs.ycoeff );
7616 }
7617
7618 bool operator!=( ViewportWScalingNV const& rhs ) const
7619 {
7620 return !operator==( rhs );
7621 }
7622
7623 float xcoeff;
7624 float ycoeff;
7625 };
7626 static_assert( sizeof( ViewportWScalingNV ) == sizeof( VkViewportWScalingNV ), "struct and wrapper have different size!" );
7627
7629 {
7630 SampleLocationEXT( float x_ = 0,
7631 float y_ = 0 )
7632 : x( x_ )
7633 , y( y_ )
7634 {
7635 }
7636
7638 {
7639 memcpy( this, &rhs, sizeof( SampleLocationEXT ) );
7640 }
7641
7643 {
7644 memcpy( this, &rhs, sizeof( SampleLocationEXT ) );
7645 return *this;
7646 }
7648 {
7649 x = x_;
7650 return *this;
7651 }
7652
7654 {
7655 y = y_;
7656 return *this;
7657 }
7658
7659 operator VkSampleLocationEXT const&() const
7660 {
7661 return *reinterpret_cast<const VkSampleLocationEXT*>(this);
7662 }
7663
7665 {
7666 return *reinterpret_cast<VkSampleLocationEXT*>(this);
7667 }
7668
7669 bool operator==( SampleLocationEXT const& rhs ) const
7670 {
7671 return ( x == rhs.x )
7672 && ( y == rhs.y );
7673 }
7674
7675 bool operator!=( SampleLocationEXT const& rhs ) const
7676 {
7677 return !operator==( rhs );
7678 }
7679
7680 float x;
7681 float y;
7682 };
7683 static_assert( sizeof( SampleLocationEXT ) == sizeof( VkSampleLocationEXT ), "struct and wrapper have different size!" );
7684
7686 {
7687 operator VkShaderResourceUsageAMD const&() const
7688 {
7689 return *reinterpret_cast<const VkShaderResourceUsageAMD*>(this);
7690 }
7691
7693 {
7694 return *reinterpret_cast<VkShaderResourceUsageAMD*>(this);
7695 }
7696
7697 bool operator==( ShaderResourceUsageAMD const& rhs ) const
7698 {
7699 return ( numUsedVgprs == rhs.numUsedVgprs )
7700 && ( numUsedSgprs == rhs.numUsedSgprs )
7704 }
7705
7706 bool operator!=( ShaderResourceUsageAMD const& rhs ) const
7707 {
7708 return !operator==( rhs );
7709 }
7710
7716 };
7717 static_assert( sizeof( ShaderResourceUsageAMD ) == sizeof( VkShaderResourceUsageAMD ), "struct and wrapper have different size!" );
7718
7720 {
7722 uint32_t divisor_ = 0 )
7723 : binding( binding_ )
7724 , divisor( divisor_ )
7725 {
7726 }
7727
7729 {
7730 memcpy( this, &rhs, sizeof( VertexInputBindingDivisorDescriptionEXT ) );
7731 }
7732
7734 {
7735 memcpy( this, &rhs, sizeof( VertexInputBindingDivisorDescriptionEXT ) );
7736 return *this;
7737 }
7739 {
7740 binding = binding_;
7741 return *this;
7742 }
7743
7745 {
7746 divisor = divisor_;
7747 return *this;
7748 }
7749
7751 {
7752 return *reinterpret_cast<const VkVertexInputBindingDivisorDescriptionEXT*>(this);
7753 }
7754
7756 {
7757 return *reinterpret_cast<VkVertexInputBindingDivisorDescriptionEXT*>(this);
7758 }
7759
7761 {
7762 return ( binding == rhs.binding )
7763 && ( divisor == rhs.divisor );
7764 }
7765
7767 {
7768 return !operator==( rhs );
7769 }
7770
7773 };
7774 static_assert( sizeof( VertexInputBindingDivisorDescriptionEXT ) == sizeof( VkVertexInputBindingDivisorDescriptionEXT ), "struct and wrapper have different size!" );
7775
7777 {
7779 uint32_t pixelY_ = 0,
7780 uint32_t sample_ = 0 )
7781 : pixelX( pixelX_ )
7782 , pixelY( pixelY_ )
7783 , sample( sample_ )
7784 {
7785 }
7786
7788 {
7789 memcpy( this, &rhs, sizeof( CoarseSampleLocationNV ) );
7790 }
7791
7793 {
7794 memcpy( this, &rhs, sizeof( CoarseSampleLocationNV ) );
7795 return *this;
7796 }
7798 {
7799 pixelX = pixelX_;
7800 return *this;
7801 }
7802
7804 {
7805 pixelY = pixelY_;
7806 return *this;
7807 }
7808
7810 {
7811 sample = sample_;
7812 return *this;
7813 }
7814
7815 operator VkCoarseSampleLocationNV const&() const
7816 {
7817 return *reinterpret_cast<const VkCoarseSampleLocationNV*>(this);
7818 }
7819
7821 {
7822 return *reinterpret_cast<VkCoarseSampleLocationNV*>(this);
7823 }
7824
7825 bool operator==( CoarseSampleLocationNV const& rhs ) const
7826 {
7827 return ( pixelX == rhs.pixelX )
7828 && ( pixelY == rhs.pixelY )
7829 && ( sample == rhs.sample );
7830 }
7831
7832 bool operator!=( CoarseSampleLocationNV const& rhs ) const
7833 {
7834 return !operator==( rhs );
7835 }
7836
7840 };
7841 static_assert( sizeof( CoarseSampleLocationNV ) == sizeof( VkCoarseSampleLocationNV ), "struct and wrapper have different size!" );
7842
7844 {
7846 uint32_t firstTask_ = 0 )
7847 : taskCount( taskCount_ )
7848 , firstTask( firstTask_ )
7849 {
7850 }
7851
7853 {
7854 memcpy( this, &rhs, sizeof( DrawMeshTasksIndirectCommandNV ) );
7855 }
7856
7858 {
7859 memcpy( this, &rhs, sizeof( DrawMeshTasksIndirectCommandNV ) );
7860 return *this;
7861 }
7863 {
7864 taskCount = taskCount_;
7865 return *this;
7866 }
7867
7869 {
7870 firstTask = firstTask_;
7871 return *this;
7872 }
7873
7874 operator VkDrawMeshTasksIndirectCommandNV const&() const
7875 {
7876 return *reinterpret_cast<const VkDrawMeshTasksIndirectCommandNV*>(this);
7877 }
7878
7880 {
7881 return *reinterpret_cast<VkDrawMeshTasksIndirectCommandNV*>(this);
7882 }
7883
7885 {
7886 return ( taskCount == rhs.taskCount )
7887 && ( firstTask == rhs.firstTask );
7888 }
7889
7891 {
7892 return !operator==( rhs );
7893 }
7894
7897 };
7898 static_assert( sizeof( DrawMeshTasksIndirectCommandNV ) == sizeof( VkDrawMeshTasksIndirectCommandNV ), "struct and wrapper have different size!" );
7899
7900 enum class ImageLayout
7901 {
7918 };
7919
7921 {
7923 ImageView imageView_ = ImageView(),
7924 ImageLayout imageLayout_ = ImageLayout::eUndefined )
7925 : sampler( sampler_ )
7926 , imageView( imageView_ )
7927 , imageLayout( imageLayout_ )
7928 {
7929 }
7930
7932 {
7933 memcpy( this, &rhs, sizeof( DescriptorImageInfo ) );
7934 }
7935
7937 {
7938 memcpy( this, &rhs, sizeof( DescriptorImageInfo ) );
7939 return *this;
7940 }
7942 {
7943 sampler = sampler_;
7944 return *this;
7945 }
7946
7948 {
7949 imageView = imageView_;
7950 return *this;
7951 }
7952
7954 {
7955 imageLayout = imageLayout_;
7956 return *this;
7957 }
7958
7959 operator VkDescriptorImageInfo const&() const
7960 {
7961 return *reinterpret_cast<const VkDescriptorImageInfo*>(this);
7962 }
7963
7965 {
7966 return *reinterpret_cast<VkDescriptorImageInfo*>(this);
7967 }
7968
7969 bool operator==( DescriptorImageInfo const& rhs ) const
7970 {
7971 return ( sampler == rhs.sampler )
7972 && ( imageView == rhs.imageView )
7973 && ( imageLayout == rhs.imageLayout );
7974 }
7975
7976 bool operator!=( DescriptorImageInfo const& rhs ) const
7977 {
7978 return !operator==( rhs );
7979 }
7980
7984 };
7985 static_assert( sizeof( DescriptorImageInfo ) == sizeof( VkDescriptorImageInfo ), "struct and wrapper have different size!" );
7986
7988 {
7991 : attachment( attachment_ )
7992 , layout( layout_ )
7993 {
7994 }
7995
7997 {
7998 memcpy( this, &rhs, sizeof( AttachmentReference ) );
7999 }
8000
8002 {
8003 memcpy( this, &rhs, sizeof( AttachmentReference ) );
8004 return *this;
8005 }
8007 {
8008 attachment = attachment_;
8009 return *this;
8010 }
8011
8013 {
8014 layout = layout_;
8015 return *this;
8016 }
8017
8018 operator VkAttachmentReference const&() const
8019 {
8020 return *reinterpret_cast<const VkAttachmentReference*>(this);
8021 }
8022
8024 {
8025 return *reinterpret_cast<VkAttachmentReference*>(this);
8026 }
8027
8028 bool operator==( AttachmentReference const& rhs ) const
8029 {
8030 return ( attachment == rhs.attachment )
8031 && ( layout == rhs.layout );
8032 }
8033
8034 bool operator!=( AttachmentReference const& rhs ) const
8035 {
8036 return !operator==( rhs );
8037 }
8038
8041 };
8042 static_assert( sizeof( AttachmentReference ) == sizeof( VkAttachmentReference ), "struct and wrapper have different size!" );
8043
8045 {
8049 };
8050
8052 {
8055 };
8056
8057 enum class ImageType
8058 {
8062 };
8063
8064 enum class ImageTiling
8065 {
8069 };
8070
8071 enum class ImageViewType
8072 {
8080 };
8081
8083 {
8086 };
8087
8089 {
8097 };
8098
8100 {
8105 : r( r_ )
8106 , g( g_ )
8107 , b( b_ )
8108 , a( a_ )
8109 {
8110 }
8111
8113 {
8114 memcpy( this, &rhs, sizeof( ComponentMapping ) );
8115 }
8116
8118 {
8119 memcpy( this, &rhs, sizeof( ComponentMapping ) );
8120 return *this;
8121 }
8123 {
8124 r = r_;
8125 return *this;
8126 }
8127
8129 {
8130 g = g_;
8131 return *this;
8132 }
8133
8135 {
8136 b = b_;
8137 return *this;
8138 }
8139
8141 {
8142 a = a_;
8143 return *this;
8144 }
8145
8146 operator VkComponentMapping const&() const
8147 {
8148 return *reinterpret_cast<const VkComponentMapping*>(this);
8149 }
8150
8152 {
8153 return *reinterpret_cast<VkComponentMapping*>(this);
8154 }
8155
8156 bool operator==( ComponentMapping const& rhs ) const
8157 {
8158 return ( r == rhs.r )
8159 && ( g == rhs.g )
8160 && ( b == rhs.b )
8161 && ( a == rhs.a );
8162 }
8163
8164 bool operator!=( ComponentMapping const& rhs ) const
8165 {
8166 return !operator==( rhs );
8167 }
8168
8173 };
8174 static_assert( sizeof( ComponentMapping ) == sizeof( VkComponentMapping ), "struct and wrapper have different size!" );
8175
8177 {
8191 };
8192
8194 {
8196 uint32_t descriptorCount_ = 0 )
8197 : type( type_ )
8198 , descriptorCount( descriptorCount_ )
8199 {
8200 }
8201
8203 {
8204 memcpy( this, &rhs, sizeof( DescriptorPoolSize ) );
8205 }
8206
8208 {
8209 memcpy( this, &rhs, sizeof( DescriptorPoolSize ) );
8210 return *this;
8211 }
8213 {
8214 type = type_;
8215 return *this;
8216 }
8217
8219 {
8220 descriptorCount = descriptorCount_;
8221 return *this;
8222 }
8223
8224 operator VkDescriptorPoolSize const&() const
8225 {
8226 return *reinterpret_cast<const VkDescriptorPoolSize*>(this);
8227 }
8228
8230 {
8231 return *reinterpret_cast<VkDescriptorPoolSize*>(this);
8232 }
8233
8234 bool operator==( DescriptorPoolSize const& rhs ) const
8235 {
8236 return ( type == rhs.type )
8237 && ( descriptorCount == rhs.descriptorCount );
8238 }
8239
8240 bool operator!=( DescriptorPoolSize const& rhs ) const
8241 {
8242 return !operator==( rhs );
8243 }
8244
8247 };
8248 static_assert( sizeof( DescriptorPoolSize ) == sizeof( VkDescriptorPoolSize ), "struct and wrapper have different size!" );
8249
8251 {
8253 uint32_t dstArrayElement_ = 0,
8254 uint32_t descriptorCount_ = 0,
8255 DescriptorType descriptorType_ = DescriptorType::eSampler,
8256 size_t offset_ = 0,
8257 size_t stride_ = 0 )
8258 : dstBinding( dstBinding_ )
8259 , dstArrayElement( dstArrayElement_ )
8260 , descriptorCount( descriptorCount_ )
8261 , descriptorType( descriptorType_ )
8262 , offset( offset_ )
8263 , stride( stride_ )
8264 {
8265 }
8266
8268 {
8269 memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateEntry ) );
8270 }
8271
8273 {
8274 memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateEntry ) );
8275 return *this;
8276 }
8278 {
8279 dstBinding = dstBinding_;
8280 return *this;
8281 }
8282
8284 {
8285 dstArrayElement = dstArrayElement_;
8286 return *this;
8287 }
8288
8290 {
8291 descriptorCount = descriptorCount_;
8292 return *this;
8293 }
8294
8296 {
8297 descriptorType = descriptorType_;
8298 return *this;
8299 }
8300
8302 {
8303 offset = offset_;
8304 return *this;
8305 }
8306
8308 {
8309 stride = stride_;
8310 return *this;
8311 }
8312
8313 operator VkDescriptorUpdateTemplateEntry const&() const
8314 {
8315 return *reinterpret_cast<const VkDescriptorUpdateTemplateEntry*>(this);
8316 }
8317
8319 {
8320 return *reinterpret_cast<VkDescriptorUpdateTemplateEntry*>(this);
8321 }
8322
8324 {
8325 return ( dstBinding == rhs.dstBinding )
8326 && ( dstArrayElement == rhs.dstArrayElement )
8327 && ( descriptorCount == rhs.descriptorCount )
8328 && ( descriptorType == rhs.descriptorType )
8329 && ( offset == rhs.offset )
8330 && ( stride == rhs.stride );
8331 }
8332
8334 {
8335 return !operator==( rhs );
8336 }
8337
8342 size_t offset;
8343 size_t stride;
8344 };
8345 static_assert( sizeof( DescriptorUpdateTemplateEntry ) == sizeof( VkDescriptorUpdateTemplateEntry ), "struct and wrapper have different size!" );
8346
8348
8349 enum class QueryType
8350 {
8356 };
8357
8358 enum class BorderColor
8359 {
8366 };
8367
8369 {
8373 };
8374
8376 {
8378 };
8379
8381 {
8393 };
8394
8395 enum class SharingMode
8396 {
8399 };
8400
8401 enum class IndexType
8402 {
8406 };
8407
8408 enum class Filter
8409 {
8413 };
8414
8416 {
8419 };
8420
8422 {
8428 };
8429
8430 enum class CompareOp
8431 {
8440 };
8441
8442 enum class PolygonMode
8443 {
8448 };
8449
8451 {
8456 };
8457
8459
8461 {
8462 return CullModeFlags( bit0 ) | bit1;
8463 }
8464
8466 {
8467 return ~( CullModeFlags( bits ) );
8468 }
8469
8470 template <> struct FlagTraits<CullModeFlagBits>
8471 {
8472 enum
8473 {
8476 };
8477
8478 enum class FrontFace
8479 {
8482 };
8483
8484 enum class BlendFactor
8485 {
8505 };
8506
8507 enum class BlendOp
8508 {
8560 };
8561
8562 enum class StencilOp
8563 {
8572 };
8573
8575 {
8577 StencilOp passOp_ = StencilOp::eKeep,
8578 StencilOp depthFailOp_ = StencilOp::eKeep,
8579 CompareOp compareOp_ = CompareOp::eNever,
8580 uint32_t compareMask_ = 0,
8581 uint32_t writeMask_ = 0,
8582 uint32_t reference_ = 0 )
8583 : failOp( failOp_ )
8584 , passOp( passOp_ )
8585 , depthFailOp( depthFailOp_ )
8586 , compareOp( compareOp_ )
8587 , compareMask( compareMask_ )
8588 , writeMask( writeMask_ )
8589 , reference( reference_ )
8590 {
8591 }
8592
8594 {
8595 memcpy( this, &rhs, sizeof( StencilOpState ) );
8596 }
8597
8599 {
8600 memcpy( this, &rhs, sizeof( StencilOpState ) );
8601 return *this;
8602 }
8604 {
8605 failOp = failOp_;
8606 return *this;
8607 }
8608
8610 {
8611 passOp = passOp_;
8612 return *this;
8613 }
8614
8616 {
8617 depthFailOp = depthFailOp_;
8618 return *this;
8619 }
8620
8622 {
8623 compareOp = compareOp_;
8624 return *this;
8625 }
8626
8628 {
8629 compareMask = compareMask_;
8630 return *this;
8631 }
8632
8634 {
8635 writeMask = writeMask_;
8636 return *this;
8637 }
8638
8640 {
8641 reference = reference_;
8642 return *this;
8643 }
8644
8645 operator VkStencilOpState const&() const
8646 {
8647 return *reinterpret_cast<const VkStencilOpState*>(this);
8648 }
8649
8650 operator VkStencilOpState &()
8651 {
8652 return *reinterpret_cast<VkStencilOpState*>(this);
8653 }
8654
8655 bool operator==( StencilOpState const& rhs ) const
8656 {
8657 return ( failOp == rhs.failOp )
8658 && ( passOp == rhs.passOp )
8659 && ( depthFailOp == rhs.depthFailOp )
8660 && ( compareOp == rhs.compareOp )
8661 && ( compareMask == rhs.compareMask )
8662 && ( writeMask == rhs.writeMask )
8663 && ( reference == rhs.reference );
8664 }
8665
8666 bool operator!=( StencilOpState const& rhs ) const
8667 {
8668 return !operator==( rhs );
8669 }
8670
8678 };
8679 static_assert( sizeof( StencilOpState ) == sizeof( VkStencilOpState ), "struct and wrapper have different size!" );
8680
8681 enum class LogicOp
8682 {
8699 };
8700
8702 {
8704 };
8705
8707 {
8713 };
8714
8716 {
8722 };
8723
8725 {
8728 };
8729
8731 {
8733 uint32_t stride_ = 0,
8735 : binding( binding_ )
8736 , stride( stride_ )
8737 , inputRate( inputRate_ )
8738 {
8739 }
8740
8742 {
8743 memcpy( this, &rhs, sizeof( VertexInputBindingDescription ) );
8744 }
8745
8747 {
8748 memcpy( this, &rhs, sizeof( VertexInputBindingDescription ) );
8749 return *this;
8750 }
8752 {
8753 binding = binding_;
8754 return *this;
8755 }
8756
8758 {
8759 stride = stride_;
8760 return *this;
8761 }
8762
8764 {
8765 inputRate = inputRate_;
8766 return *this;
8767 }
8768
8769 operator VkVertexInputBindingDescription const&() const
8770 {
8771 return *reinterpret_cast<const VkVertexInputBindingDescription*>(this);
8772 }
8773
8775 {
8776 return *reinterpret_cast<VkVertexInputBindingDescription*>(this);
8777 }
8778
8780 {
8781 return ( binding == rhs.binding )
8782 && ( stride == rhs.stride )
8783 && ( inputRate == rhs.inputRate );
8784 }
8785
8787 {
8788 return !operator==( rhs );
8789 }
8790
8794 };
8795 static_assert( sizeof( VertexInputBindingDescription ) == sizeof( VkVertexInputBindingDescription ), "struct and wrapper have different size!" );
8796
8797 enum class Format
8798 {
9060 };
9061
9063 {
9065 uint32_t binding_ = 0,
9066 Format format_ = Format::eUndefined,
9067 uint32_t offset_ = 0 )
9068 : location( location_ )
9069 , binding( binding_ )
9070 , format( format_ )
9071 , offset( offset_ )
9072 {
9073 }
9074
9076 {
9077 memcpy( this, &rhs, sizeof( VertexInputAttributeDescription ) );
9078 }
9079
9081 {
9082 memcpy( this, &rhs, sizeof( VertexInputAttributeDescription ) );
9083 return *this;
9084 }
9086 {
9087 location = location_;
9088 return *this;
9089 }
9090
9092 {
9093 binding = binding_;
9094 return *this;
9095 }
9096
9098 {
9099 format = format_;
9100 return *this;
9101 }
9102
9104 {
9105 offset = offset_;
9106 return *this;
9107 }
9108
9110 {
9111 return *reinterpret_cast<const VkVertexInputAttributeDescription*>(this);
9112 }
9113
9115 {
9116 return *reinterpret_cast<VkVertexInputAttributeDescription*>(this);
9117 }
9118
9120 {
9121 return ( location == rhs.location )
9122 && ( binding == rhs.binding )
9123 && ( format == rhs.format )
9124 && ( offset == rhs.offset );
9125 }
9126
9128 {
9129 return !operator==( rhs );
9130 }
9131
9136 };
9137 static_assert( sizeof( VertexInputAttributeDescription ) == sizeof( VkVertexInputAttributeDescription ), "struct and wrapper have different size!" );
9138
9139 enum class StructureType
9140 {
9498 };
9499
9501 {
9502 ApplicationInfo( const char* pApplicationName_ = nullptr,
9503 uint32_t applicationVersion_ = 0,
9504 const char* pEngineName_ = nullptr,
9505 uint32_t engineVersion_ = 0,
9506 uint32_t apiVersion_ = 0 )
9507 : pApplicationName( pApplicationName_ )
9508 , applicationVersion( applicationVersion_ )
9509 , pEngineName( pEngineName_ )
9510 , engineVersion( engineVersion_ )
9511 , apiVersion( apiVersion_ )
9512 {
9513 }
9514
9516 {
9517 memcpy( this, &rhs, sizeof( ApplicationInfo ) );
9518 }
9519
9521 {
9522 memcpy( this, &rhs, sizeof( ApplicationInfo ) );
9523 return *this;
9524 }
9525 ApplicationInfo& setPNext( const void* pNext_ )
9526 {
9527 pNext = pNext_;
9528 return *this;
9529 }
9530
9531 ApplicationInfo& setPApplicationName( const char* pApplicationName_ )
9532 {
9533 pApplicationName = pApplicationName_;
9534 return *this;
9535 }
9536
9538 {
9539 applicationVersion = applicationVersion_;
9540 return *this;
9541 }
9542
9543 ApplicationInfo& setPEngineName( const char* pEngineName_ )
9544 {
9545 pEngineName = pEngineName_;
9546 return *this;
9547 }
9548
9550 {
9551 engineVersion = engineVersion_;
9552 return *this;
9553 }
9554
9556 {
9557 apiVersion = apiVersion_;
9558 return *this;
9559 }
9560
9561 operator VkApplicationInfo const&() const
9562 {
9563 return *reinterpret_cast<const VkApplicationInfo*>(this);
9564 }
9565
9567 {
9568 return *reinterpret_cast<VkApplicationInfo*>(this);
9569 }
9570
9571 bool operator==( ApplicationInfo const& rhs ) const
9572 {
9573 return ( sType == rhs.sType )
9574 && ( pNext == rhs.pNext )
9577 && ( pEngineName == rhs.pEngineName )
9578 && ( engineVersion == rhs.engineVersion )
9579 && ( apiVersion == rhs.apiVersion );
9580 }
9581
9582 bool operator!=( ApplicationInfo const& rhs ) const
9583 {
9584 return !operator==( rhs );
9585 }
9586
9587 private:
9589
9590 public:
9591 const void* pNext = nullptr;
9592 const char* pApplicationName;
9594 const char* pEngineName;
9597 };
9598 static_assert( sizeof( ApplicationInfo ) == sizeof( VkApplicationInfo ), "struct and wrapper have different size!" );
9599
9601 {
9603 const ApplicationInfo* pApplicationInfo_ = nullptr,
9604 uint32_t enabledLayerCount_ = 0,
9605 const char* const* ppEnabledLayerNames_ = nullptr,
9606 uint32_t enabledExtensionCount_ = 0,
9607 const char* const* ppEnabledExtensionNames_ = nullptr )
9608 : flags( flags_ )
9609 , pApplicationInfo( pApplicationInfo_ )
9610 , enabledLayerCount( enabledLayerCount_ )
9611 , ppEnabledLayerNames( ppEnabledLayerNames_ )
9612 , enabledExtensionCount( enabledExtensionCount_ )
9613 , ppEnabledExtensionNames( ppEnabledExtensionNames_ )
9614 {
9615 }
9616
9618 {
9619 memcpy( this, &rhs, sizeof( InstanceCreateInfo ) );
9620 }
9621
9623 {
9624 memcpy( this, &rhs, sizeof( InstanceCreateInfo ) );
9625 return *this;
9626 }
9627 InstanceCreateInfo& setPNext( const void* pNext_ )
9628 {
9629 pNext = pNext_;
9630 return *this;
9631 }
9632
9634 {
9635 flags = flags_;
9636 return *this;
9637 }
9638
9640 {
9641 pApplicationInfo = pApplicationInfo_;
9642 return *this;
9643 }
9644
9646 {
9647 enabledLayerCount = enabledLayerCount_;
9648 return *this;
9649 }
9650
9651 InstanceCreateInfo& setPpEnabledLayerNames( const char* const* ppEnabledLayerNames_ )
9652 {
9653 ppEnabledLayerNames = ppEnabledLayerNames_;
9654 return *this;
9655 }
9656
9658 {
9659 enabledExtensionCount = enabledExtensionCount_;
9660 return *this;
9661 }
9662
9663 InstanceCreateInfo& setPpEnabledExtensionNames( const char* const* ppEnabledExtensionNames_ )
9664 {
9665 ppEnabledExtensionNames = ppEnabledExtensionNames_;
9666 return *this;
9667 }
9668
9669 operator VkInstanceCreateInfo const&() const
9670 {
9671 return *reinterpret_cast<const VkInstanceCreateInfo*>(this);
9672 }
9673
9675 {
9676 return *reinterpret_cast<VkInstanceCreateInfo*>(this);
9677 }
9678
9679 bool operator==( InstanceCreateInfo const& rhs ) const
9680 {
9681 return ( sType == rhs.sType )
9682 && ( pNext == rhs.pNext )
9683 && ( flags == rhs.flags )
9689 }
9690
9691 bool operator!=( InstanceCreateInfo const& rhs ) const
9692 {
9693 return !operator==( rhs );
9694 }
9695
9696 private:
9698
9699 public:
9700 const void* pNext = nullptr;
9704 const char* const* ppEnabledLayerNames;
9706 const char* const* ppEnabledExtensionNames;
9707 };
9708 static_assert( sizeof( InstanceCreateInfo ) == sizeof( VkInstanceCreateInfo ), "struct and wrapper have different size!" );
9709
9711 {
9712 MemoryAllocateInfo( DeviceSize allocationSize_ = 0,
9713 uint32_t memoryTypeIndex_ = 0 )
9714 : allocationSize( allocationSize_ )
9715 , memoryTypeIndex( memoryTypeIndex_ )
9716 {
9717 }
9718
9720 {
9721 memcpy( this, &rhs, sizeof( MemoryAllocateInfo ) );
9722 }
9723
9725 {
9726 memcpy( this, &rhs, sizeof( MemoryAllocateInfo ) );
9727 return *this;
9728 }
9729 MemoryAllocateInfo& setPNext( const void* pNext_ )
9730 {
9731 pNext = pNext_;
9732 return *this;
9733 }
9734
9736 {
9737 allocationSize = allocationSize_;
9738 return *this;
9739 }
9740
9742 {
9743 memoryTypeIndex = memoryTypeIndex_;
9744 return *this;
9745 }
9746
9747 operator VkMemoryAllocateInfo const&() const
9748 {
9749 return *reinterpret_cast<const VkMemoryAllocateInfo*>(this);
9750 }
9751
9753 {
9754 return *reinterpret_cast<VkMemoryAllocateInfo*>(this);
9755 }
9756
9757 bool operator==( MemoryAllocateInfo const& rhs ) const
9758 {
9759 return ( sType == rhs.sType )
9760 && ( pNext == rhs.pNext )
9761 && ( allocationSize == rhs.allocationSize )
9762 && ( memoryTypeIndex == rhs.memoryTypeIndex );
9763 }
9764
9765 bool operator!=( MemoryAllocateInfo const& rhs ) const
9766 {
9767 return !operator==( rhs );
9768 }
9769
9770 private:
9772
9773 public:
9774 const void* pNext = nullptr;
9777 };
9778 static_assert( sizeof( MemoryAllocateInfo ) == sizeof( VkMemoryAllocateInfo ), "struct and wrapper have different size!" );
9779
9781 {
9783 DeviceSize offset_ = 0,
9784 DeviceSize size_ = 0 )
9785 : memory( memory_ )
9786 , offset( offset_ )
9787 , size( size_ )
9788 {
9789 }
9790
9792 {
9793 memcpy( this, &rhs, sizeof( MappedMemoryRange ) );
9794 }
9795
9797 {
9798 memcpy( this, &rhs, sizeof( MappedMemoryRange ) );
9799 return *this;
9800 }
9801 MappedMemoryRange& setPNext( const void* pNext_ )
9802 {
9803 pNext = pNext_;
9804 return *this;
9805 }
9806
9808 {
9809 memory = memory_;
9810 return *this;
9811 }
9812
9814 {
9815 offset = offset_;
9816 return *this;
9817 }
9818
9820 {
9821 size = size_;
9822 return *this;
9823 }
9824
9825 operator VkMappedMemoryRange const&() const
9826 {
9827 return *reinterpret_cast<const VkMappedMemoryRange*>(this);
9828 }
9829
9831 {
9832 return *reinterpret_cast<VkMappedMemoryRange*>(this);
9833 }
9834
9835 bool operator==( MappedMemoryRange const& rhs ) const
9836 {
9837 return ( sType == rhs.sType )
9838 && ( pNext == rhs.pNext )
9839 && ( memory == rhs.memory )
9840 && ( offset == rhs.offset )
9841 && ( size == rhs.size );
9842 }
9843
9844 bool operator!=( MappedMemoryRange const& rhs ) const
9845 {
9846 return !operator==( rhs );
9847 }
9848
9849 private:
9851
9852 public:
9853 const void* pNext = nullptr;
9857 };
9858 static_assert( sizeof( MappedMemoryRange ) == sizeof( VkMappedMemoryRange ), "struct and wrapper have different size!" );
9859
9861 {
9863 uint32_t dstBinding_ = 0,
9864 uint32_t dstArrayElement_ = 0,
9865 uint32_t descriptorCount_ = 0,
9866 DescriptorType descriptorType_ = DescriptorType::eSampler,
9867 const DescriptorImageInfo* pImageInfo_ = nullptr,
9868 const DescriptorBufferInfo* pBufferInfo_ = nullptr,
9869 const BufferView* pTexelBufferView_ = nullptr )
9870 : dstSet( dstSet_ )
9871 , dstBinding( dstBinding_ )
9872 , dstArrayElement( dstArrayElement_ )
9873 , descriptorCount( descriptorCount_ )
9874 , descriptorType( descriptorType_ )
9875 , pImageInfo( pImageInfo_ )
9876 , pBufferInfo( pBufferInfo_ )
9877 , pTexelBufferView( pTexelBufferView_ )
9878 {
9879 }
9880
9882 {
9883 memcpy( this, &rhs, sizeof( WriteDescriptorSet ) );
9884 }
9885
9887 {
9888 memcpy( this, &rhs, sizeof( WriteDescriptorSet ) );
9889 return *this;
9890 }
9891 WriteDescriptorSet& setPNext( const void* pNext_ )
9892 {
9893 pNext = pNext_;
9894 return *this;
9895 }
9896
9898 {
9899 dstSet = dstSet_;
9900 return *this;
9901 }
9902
9904 {
9905 dstBinding = dstBinding_;
9906 return *this;
9907 }
9908
9910 {
9911 dstArrayElement = dstArrayElement_;
9912 return *this;
9913 }
9914
9916 {
9917 descriptorCount = descriptorCount_;
9918 return *this;
9919 }
9920
9922 {
9923 descriptorType = descriptorType_;
9924 return *this;
9925 }
9926
9928 {
9929 pImageInfo = pImageInfo_;
9930 return *this;
9931 }
9932
9934 {
9935 pBufferInfo = pBufferInfo_;
9936 return *this;
9937 }
9938
9940 {
9941 pTexelBufferView = pTexelBufferView_;
9942 return *this;
9943 }
9944
9945 operator VkWriteDescriptorSet const&() const
9946 {
9947 return *reinterpret_cast<const VkWriteDescriptorSet*>(this);
9948 }
9949
9951 {
9952 return *reinterpret_cast<VkWriteDescriptorSet*>(this);
9953 }
9954
9955 bool operator==( WriteDescriptorSet const& rhs ) const
9956 {
9957 return ( sType == rhs.sType )
9958 && ( pNext == rhs.pNext )
9959 && ( dstSet == rhs.dstSet )
9960 && ( dstBinding == rhs.dstBinding )
9961 && ( dstArrayElement == rhs.dstArrayElement )
9962 && ( descriptorCount == rhs.descriptorCount )
9963 && ( descriptorType == rhs.descriptorType )
9964 && ( pImageInfo == rhs.pImageInfo )
9965 && ( pBufferInfo == rhs.pBufferInfo )
9966 && ( pTexelBufferView == rhs.pTexelBufferView );
9967 }
9968
9969 bool operator!=( WriteDescriptorSet const& rhs ) const
9970 {
9971 return !operator==( rhs );
9972 }
9973
9974 private:
9976
9977 public:
9978 const void* pNext = nullptr;
9987 };
9988 static_assert( sizeof( WriteDescriptorSet ) == sizeof( VkWriteDescriptorSet ), "struct and wrapper have different size!" );
9989
9991 {
9993 uint32_t srcBinding_ = 0,
9994 uint32_t srcArrayElement_ = 0,
9995 DescriptorSet dstSet_ = DescriptorSet(),
9996 uint32_t dstBinding_ = 0,
9997 uint32_t dstArrayElement_ = 0,
9998 uint32_t descriptorCount_ = 0 )
9999 : srcSet( srcSet_ )
10000 , srcBinding( srcBinding_ )
10001 , srcArrayElement( srcArrayElement_ )
10002 , dstSet( dstSet_ )
10003 , dstBinding( dstBinding_ )
10004 , dstArrayElement( dstArrayElement_ )
10005 , descriptorCount( descriptorCount_ )
10006 {
10007 }
10008
10010 {
10011 memcpy( this, &rhs, sizeof( CopyDescriptorSet ) );
10012 }
10013
10015 {
10016 memcpy( this, &rhs, sizeof( CopyDescriptorSet ) );
10017 return *this;
10018 }
10019 CopyDescriptorSet& setPNext( const void* pNext_ )
10020 {
10021 pNext = pNext_;
10022 return *this;
10023 }
10024
10026 {
10027 srcSet = srcSet_;
10028 return *this;
10029 }
10030
10032 {
10033 srcBinding = srcBinding_;
10034 return *this;
10035 }
10036
10038 {
10039 srcArrayElement = srcArrayElement_;
10040 return *this;
10041 }
10042
10044 {
10045 dstSet = dstSet_;
10046 return *this;
10047 }
10048
10050 {
10051 dstBinding = dstBinding_;
10052 return *this;
10053 }
10054
10056 {
10057 dstArrayElement = dstArrayElement_;
10058 return *this;
10059 }
10060
10062 {
10063 descriptorCount = descriptorCount_;
10064 return *this;
10065 }
10066
10067 operator VkCopyDescriptorSet const&() const
10068 {
10069 return *reinterpret_cast<const VkCopyDescriptorSet*>(this);
10070 }
10071
10073 {
10074 return *reinterpret_cast<VkCopyDescriptorSet*>(this);
10075 }
10076
10077 bool operator==( CopyDescriptorSet const& rhs ) const
10078 {
10079 return ( sType == rhs.sType )
10080 && ( pNext == rhs.pNext )
10081 && ( srcSet == rhs.srcSet )
10082 && ( srcBinding == rhs.srcBinding )
10083 && ( srcArrayElement == rhs.srcArrayElement )
10084 && ( dstSet == rhs.dstSet )
10085 && ( dstBinding == rhs.dstBinding )
10086 && ( dstArrayElement == rhs.dstArrayElement )
10087 && ( descriptorCount == rhs.descriptorCount );
10088 }
10089
10090 bool operator!=( CopyDescriptorSet const& rhs ) const
10091 {
10092 return !operator==( rhs );
10093 }
10094
10095 private:
10097
10098 public:
10099 const void* pNext = nullptr;
10107 };
10108 static_assert( sizeof( CopyDescriptorSet ) == sizeof( VkCopyDescriptorSet ), "struct and wrapper have different size!" );
10109
10111 {
10113 Buffer buffer_ = Buffer(),
10114 Format format_ = Format::eUndefined,
10115 DeviceSize offset_ = 0,
10116 DeviceSize range_ = 0 )
10117 : flags( flags_ )
10118 , buffer( buffer_ )
10119 , format( format_ )
10120 , offset( offset_ )
10121 , range( range_ )
10122 {
10123 }
10124
10126 {
10127 memcpy( this, &rhs, sizeof( BufferViewCreateInfo ) );
10128 }
10129
10131 {
10132 memcpy( this, &rhs, sizeof( BufferViewCreateInfo ) );
10133 return *this;
10134 }
10135 BufferViewCreateInfo& setPNext( const void* pNext_ )
10136 {
10137 pNext = pNext_;
10138 return *this;
10139 }
10140
10142 {
10143 flags = flags_;
10144 return *this;
10145 }
10146
10148 {
10149 buffer = buffer_;
10150 return *this;
10151 }
10152
10154 {
10155 format = format_;
10156 return *this;
10157 }
10158
10160 {
10161 offset = offset_;
10162 return *this;
10163 }
10164
10166 {
10167 range = range_;
10168 return *this;
10169 }
10170
10171 operator VkBufferViewCreateInfo const&() const
10172 {
10173 return *reinterpret_cast<const VkBufferViewCreateInfo*>(this);
10174 }
10175
10177 {
10178 return *reinterpret_cast<VkBufferViewCreateInfo*>(this);
10179 }
10180
10181 bool operator==( BufferViewCreateInfo const& rhs ) const
10182 {
10183 return ( sType == rhs.sType )
10184 && ( pNext == rhs.pNext )
10185 && ( flags == rhs.flags )
10186 && ( buffer == rhs.buffer )
10187 && ( format == rhs.format )
10188 && ( offset == rhs.offset )
10189 && ( range == rhs.range );
10190 }
10191
10192 bool operator!=( BufferViewCreateInfo const& rhs ) const
10193 {
10194 return !operator==( rhs );
10195 }
10196
10197 private:
10199
10200 public:
10201 const void* pNext = nullptr;
10207 };
10208 static_assert( sizeof( BufferViewCreateInfo ) == sizeof( VkBufferViewCreateInfo ), "struct and wrapper have different size!" );
10209
10211 {
10213 size_t codeSize_ = 0,
10214 const uint32_t* pCode_ = nullptr )
10215 : flags( flags_ )
10216 , codeSize( codeSize_ )
10217 , pCode( pCode_ )
10218 {
10219 }
10220
10222 {
10223 memcpy( this, &rhs, sizeof( ShaderModuleCreateInfo ) );
10224 }
10225
10227 {
10228 memcpy( this, &rhs, sizeof( ShaderModuleCreateInfo ) );
10229 return *this;
10230 }
10231 ShaderModuleCreateInfo& setPNext( const void* pNext_ )
10232 {
10233 pNext = pNext_;
10234 return *this;
10235 }
10236
10238 {
10239 flags = flags_;
10240 return *this;
10241 }
10242
10244 {
10245 codeSize = codeSize_;
10246 return *this;
10247 }
10248
10250 {
10251 pCode = pCode_;
10252 return *this;
10253 }
10254
10255 operator VkShaderModuleCreateInfo const&() const
10256 {
10257 return *reinterpret_cast<const VkShaderModuleCreateInfo*>(this);
10258 }
10259
10261 {
10262 return *reinterpret_cast<VkShaderModuleCreateInfo*>(this);
10263 }
10264
10265 bool operator==( ShaderModuleCreateInfo const& rhs ) const
10266 {
10267 return ( sType == rhs.sType )
10268 && ( pNext == rhs.pNext )
10269 && ( flags == rhs.flags )
10270 && ( codeSize == rhs.codeSize )
10271 && ( pCode == rhs.pCode );
10272 }
10273
10274 bool operator!=( ShaderModuleCreateInfo const& rhs ) const
10275 {
10276 return !operator==( rhs );
10277 }
10278
10279 private:
10281
10282 public:
10283 const void* pNext = nullptr;
10285 size_t codeSize;
10287 };
10288 static_assert( sizeof( ShaderModuleCreateInfo ) == sizeof( VkShaderModuleCreateInfo ), "struct and wrapper have different size!" );
10289
10291 {
10293 uint32_t descriptorSetCount_ = 0,
10294 const DescriptorSetLayout* pSetLayouts_ = nullptr )
10295 : descriptorPool( descriptorPool_ )
10296 , descriptorSetCount( descriptorSetCount_ )
10297 , pSetLayouts( pSetLayouts_ )
10298 {
10299 }
10300
10302 {
10303 memcpy( this, &rhs, sizeof( DescriptorSetAllocateInfo ) );
10304 }
10305
10307 {
10308 memcpy( this, &rhs, sizeof( DescriptorSetAllocateInfo ) );
10309 return *this;
10310 }
10312 {
10313 pNext = pNext_;
10314 return *this;
10315 }
10316
10318 {
10319 descriptorPool = descriptorPool_;
10320 return *this;
10321 }
10322
10324 {
10325 descriptorSetCount = descriptorSetCount_;
10326 return *this;
10327 }
10328
10330 {
10331 pSetLayouts = pSetLayouts_;
10332 return *this;
10333 }
10334
10335 operator VkDescriptorSetAllocateInfo const&() const
10336 {
10337 return *reinterpret_cast<const VkDescriptorSetAllocateInfo*>(this);
10338 }
10339
10341 {
10342 return *reinterpret_cast<VkDescriptorSetAllocateInfo*>(this);
10343 }
10344
10345 bool operator==( DescriptorSetAllocateInfo const& rhs ) const
10346 {
10347 return ( sType == rhs.sType )
10348 && ( pNext == rhs.pNext )
10349 && ( descriptorPool == rhs.descriptorPool )
10351 && ( pSetLayouts == rhs.pSetLayouts );
10352 }
10353
10354 bool operator!=( DescriptorSetAllocateInfo const& rhs ) const
10355 {
10356 return !operator==( rhs );
10357 }
10358
10359 private:
10361
10362 public:
10363 const void* pNext = nullptr;
10367 };
10368 static_assert( sizeof( DescriptorSetAllocateInfo ) == sizeof( VkDescriptorSetAllocateInfo ), "struct and wrapper have different size!" );
10369
10371 {
10373 uint32_t vertexBindingDescriptionCount_ = 0,
10374 const VertexInputBindingDescription* pVertexBindingDescriptions_ = nullptr,
10375 uint32_t vertexAttributeDescriptionCount_ = 0,
10376 const VertexInputAttributeDescription* pVertexAttributeDescriptions_ = nullptr )
10377 : flags( flags_ )
10378 , vertexBindingDescriptionCount( vertexBindingDescriptionCount_ )
10379 , pVertexBindingDescriptions( pVertexBindingDescriptions_ )
10380 , vertexAttributeDescriptionCount( vertexAttributeDescriptionCount_ )
10381 , pVertexAttributeDescriptions( pVertexAttributeDescriptions_ )
10382 {
10383 }
10384
10386 {
10387 memcpy( this, &rhs, sizeof( PipelineVertexInputStateCreateInfo ) );
10388 }
10389
10391 {
10392 memcpy( this, &rhs, sizeof( PipelineVertexInputStateCreateInfo ) );
10393 return *this;
10394 }
10396 {
10397 pNext = pNext_;
10398 return *this;
10399 }
10400
10402 {
10403 flags = flags_;
10404 return *this;
10405 }
10406
10408 {
10409 vertexBindingDescriptionCount = vertexBindingDescriptionCount_;
10410 return *this;
10411 }
10412
10414 {
10415 pVertexBindingDescriptions = pVertexBindingDescriptions_;
10416 return *this;
10417 }
10418
10420 {
10421 vertexAttributeDescriptionCount = vertexAttributeDescriptionCount_;
10422 return *this;
10423 }
10424
10426 {
10427 pVertexAttributeDescriptions = pVertexAttributeDescriptions_;
10428 return *this;
10429 }
10430
10432 {
10433 return *reinterpret_cast<const VkPipelineVertexInputStateCreateInfo*>(this);
10434 }
10435
10437 {
10438 return *reinterpret_cast<VkPipelineVertexInputStateCreateInfo*>(this);
10439 }
10440
10442 {
10443 return ( sType == rhs.sType )
10444 && ( pNext == rhs.pNext )
10445 && ( flags == rhs.flags )
10450 }
10451
10453 {
10454 return !operator==( rhs );
10455 }
10456
10457 private:
10459
10460 public:
10461 const void* pNext = nullptr;
10467 };
10468 static_assert( sizeof( PipelineVertexInputStateCreateInfo ) == sizeof( VkPipelineVertexInputStateCreateInfo ), "struct and wrapper have different size!" );
10469
10471 {
10474 Bool32 primitiveRestartEnable_ = 0 )
10475 : flags( flags_ )
10476 , topology( topology_ )
10477 , primitiveRestartEnable( primitiveRestartEnable_ )
10478 {
10479 }
10480
10482 {
10483 memcpy( this, &rhs, sizeof( PipelineInputAssemblyStateCreateInfo ) );
10484 }
10485
10487 {
10488 memcpy( this, &rhs, sizeof( PipelineInputAssemblyStateCreateInfo ) );
10489 return *this;
10490 }
10492 {
10493 pNext = pNext_;
10494 return *this;
10495 }
10496
10498 {
10499 flags = flags_;
10500 return *this;
10501 }
10502
10504 {
10505 topology = topology_;
10506 return *this;
10507 }
10508
10510 {
10511 primitiveRestartEnable = primitiveRestartEnable_;
10512 return *this;
10513 }
10514
10516 {
10517 return *reinterpret_cast<const VkPipelineInputAssemblyStateCreateInfo*>(this);
10518 }
10519
10521 {
10522 return *reinterpret_cast<VkPipelineInputAssemblyStateCreateInfo*>(this);
10523 }
10524
10526 {
10527 return ( sType == rhs.sType )
10528 && ( pNext == rhs.pNext )
10529 && ( flags == rhs.flags )
10530 && ( topology == rhs.topology )
10532 }
10533
10535 {
10536 return !operator==( rhs );
10537 }
10538
10539 private:
10541
10542 public:
10543 const void* pNext = nullptr;
10547 };
10548 static_assert( sizeof( PipelineInputAssemblyStateCreateInfo ) == sizeof( VkPipelineInputAssemblyStateCreateInfo ), "struct and wrapper have different size!" );
10549
10551 {
10553 uint32_t patchControlPoints_ = 0 )
10554 : flags( flags_ )
10555 , patchControlPoints( patchControlPoints_ )
10556 {
10557 }
10558
10560 {
10561 memcpy( this, &rhs, sizeof( PipelineTessellationStateCreateInfo ) );
10562 }
10563
10565 {
10566 memcpy( this, &rhs, sizeof( PipelineTessellationStateCreateInfo ) );
10567 return *this;
10568 }
10570 {
10571 pNext = pNext_;
10572 return *this;
10573 }
10574
10576 {
10577 flags = flags_;
10578 return *this;
10579 }
10580
10582 {
10583 patchControlPoints = patchControlPoints_;
10584 return *this;
10585 }
10586
10588 {
10589 return *reinterpret_cast<const VkPipelineTessellationStateCreateInfo*>(this);
10590 }
10591
10593 {
10594 return *reinterpret_cast<VkPipelineTessellationStateCreateInfo*>(this);
10595 }
10596
10598 {
10599 return ( sType == rhs.sType )
10600 && ( pNext == rhs.pNext )
10601 && ( flags == rhs.flags )
10603 }
10604
10606 {
10607 return !operator==( rhs );
10608 }
10609
10610 private:
10612
10613 public:
10614 const void* pNext = nullptr;
10617 };
10618 static_assert( sizeof( PipelineTessellationStateCreateInfo ) == sizeof( VkPipelineTessellationStateCreateInfo ), "struct and wrapper have different size!" );
10619
10621 {
10623 uint32_t viewportCount_ = 0,
10624 const Viewport* pViewports_ = nullptr,
10625 uint32_t scissorCount_ = 0,
10626 const Rect2D* pScissors_ = nullptr )
10627 : flags( flags_ )
10628 , viewportCount( viewportCount_ )
10629 , pViewports( pViewports_ )
10630 , scissorCount( scissorCount_ )
10631 , pScissors( pScissors_ )
10632 {
10633 }
10634
10636 {
10637 memcpy( this, &rhs, sizeof( PipelineViewportStateCreateInfo ) );
10638 }
10639
10641 {
10642 memcpy( this, &rhs, sizeof( PipelineViewportStateCreateInfo ) );
10643 return *this;
10644 }
10646 {
10647 pNext = pNext_;
10648 return *this;
10649 }
10650
10652 {
10653 flags = flags_;
10654 return *this;
10655 }
10656
10658 {
10659 viewportCount = viewportCount_;
10660 return *this;
10661 }
10662
10664 {
10665 pViewports = pViewports_;
10666 return *this;
10667 }
10668
10670 {
10671 scissorCount = scissorCount_;
10672 return *this;
10673 }
10674
10676 {
10677 pScissors = pScissors_;
10678 return *this;
10679 }
10680
10682 {
10683 return *reinterpret_cast<const VkPipelineViewportStateCreateInfo*>(this);
10684 }
10685
10687 {
10688 return *reinterpret_cast<VkPipelineViewportStateCreateInfo*>(this);
10689 }
10690
10692 {
10693 return ( sType == rhs.sType )
10694 && ( pNext == rhs.pNext )
10695 && ( flags == rhs.flags )
10696 && ( viewportCount == rhs.viewportCount )
10697 && ( pViewports == rhs.pViewports )
10698 && ( scissorCount == rhs.scissorCount )
10699 && ( pScissors == rhs.pScissors );
10700 }
10701
10703 {
10704 return !operator==( rhs );
10705 }
10706
10707 private:
10709
10710 public:
10711 const void* pNext = nullptr;
10717 };
10718 static_assert( sizeof( PipelineViewportStateCreateInfo ) == sizeof( VkPipelineViewportStateCreateInfo ), "struct and wrapper have different size!" );
10719
10721 {
10723 Bool32 depthClampEnable_ = 0,
10724 Bool32 rasterizerDiscardEnable_ = 0,
10725 PolygonMode polygonMode_ = PolygonMode::eFill,
10726 CullModeFlags cullMode_ = CullModeFlags(),
10728 Bool32 depthBiasEnable_ = 0,
10729 float depthBiasConstantFactor_ = 0,
10730 float depthBiasClamp_ = 0,
10731 float depthBiasSlopeFactor_ = 0,
10732 float lineWidth_ = 0 )
10733 : flags( flags_ )
10734 , depthClampEnable( depthClampEnable_ )
10735 , rasterizerDiscardEnable( rasterizerDiscardEnable_ )
10736 , polygonMode( polygonMode_ )
10737 , cullMode( cullMode_ )
10738 , frontFace( frontFace_ )
10739 , depthBiasEnable( depthBiasEnable_ )
10740 , depthBiasConstantFactor( depthBiasConstantFactor_ )
10741 , depthBiasClamp( depthBiasClamp_ )
10742 , depthBiasSlopeFactor( depthBiasSlopeFactor_ )
10743 , lineWidth( lineWidth_ )
10744 {
10745 }
10746
10748 {
10749 memcpy( this, &rhs, sizeof( PipelineRasterizationStateCreateInfo ) );
10750 }
10751
10753 {
10754 memcpy( this, &rhs, sizeof( PipelineRasterizationStateCreateInfo ) );
10755 return *this;
10756 }
10758 {
10759 pNext = pNext_;
10760 return *this;
10761 }
10762
10764 {
10765 flags = flags_;
10766 return *this;
10767 }
10768
10770 {
10771 depthClampEnable = depthClampEnable_;
10772 return *this;
10773 }
10774
10776 {
10777 rasterizerDiscardEnable = rasterizerDiscardEnable_;
10778 return *this;
10779 }
10780
10782 {
10783 polygonMode = polygonMode_;
10784 return *this;
10785 }
10786
10788 {
10789 cullMode = cullMode_;
10790 return *this;
10791 }
10792
10794 {
10795 frontFace = frontFace_;
10796 return *this;
10797 }
10798
10800 {
10801 depthBiasEnable = depthBiasEnable_;
10802 return *this;
10803 }
10804
10806 {
10807 depthBiasConstantFactor = depthBiasConstantFactor_;
10808 return *this;
10809 }
10810
10812 {
10813 depthBiasClamp = depthBiasClamp_;
10814 return *this;
10815 }
10816
10818 {
10819 depthBiasSlopeFactor = depthBiasSlopeFactor_;
10820 return *this;
10821 }
10822
10824 {
10825 lineWidth = lineWidth_;
10826 return *this;
10827 }
10828
10830 {
10831 return *reinterpret_cast<const VkPipelineRasterizationStateCreateInfo*>(this);
10832 }
10833
10835 {
10836 return *reinterpret_cast<VkPipelineRasterizationStateCreateInfo*>(this);
10837 }
10838
10840 {
10841 return ( sType == rhs.sType )
10842 && ( pNext == rhs.pNext )
10843 && ( flags == rhs.flags )
10846 && ( polygonMode == rhs.polygonMode )
10847 && ( cullMode == rhs.cullMode )
10848 && ( frontFace == rhs.frontFace )
10849 && ( depthBiasEnable == rhs.depthBiasEnable )
10851 && ( depthBiasClamp == rhs.depthBiasClamp )
10853 && ( lineWidth == rhs.lineWidth );
10854 }
10855
10857 {
10858 return !operator==( rhs );
10859 }
10860
10861 private:
10863
10864 public:
10865 const void* pNext = nullptr;
10877 };
10878 static_assert( sizeof( PipelineRasterizationStateCreateInfo ) == sizeof( VkPipelineRasterizationStateCreateInfo ), "struct and wrapper have different size!" );
10879
10881 {
10883 Bool32 depthTestEnable_ = 0,
10884 Bool32 depthWriteEnable_ = 0,
10885 CompareOp depthCompareOp_ = CompareOp::eNever,
10886 Bool32 depthBoundsTestEnable_ = 0,
10887 Bool32 stencilTestEnable_ = 0,
10888 StencilOpState front_ = StencilOpState(),
10890 float minDepthBounds_ = 0,
10891 float maxDepthBounds_ = 0 )
10892 : flags( flags_ )
10893 , depthTestEnable( depthTestEnable_ )
10894 , depthWriteEnable( depthWriteEnable_ )
10895 , depthCompareOp( depthCompareOp_ )
10896 , depthBoundsTestEnable( depthBoundsTestEnable_ )
10897 , stencilTestEnable( stencilTestEnable_ )
10898 , front( front_ )
10899 , back( back_ )
10900 , minDepthBounds( minDepthBounds_ )
10901 , maxDepthBounds( maxDepthBounds_ )
10902 {
10903 }
10904
10906 {
10907 memcpy( this, &rhs, sizeof( PipelineDepthStencilStateCreateInfo ) );
10908 }
10909
10911 {
10912 memcpy( this, &rhs, sizeof( PipelineDepthStencilStateCreateInfo ) );
10913 return *this;
10914 }
10916 {
10917 pNext = pNext_;
10918 return *this;
10919 }
10920
10922 {
10923 flags = flags_;
10924 return *this;
10925 }
10926
10928 {
10929 depthTestEnable = depthTestEnable_;
10930 return *this;
10931 }
10932
10934 {
10935 depthWriteEnable = depthWriteEnable_;
10936 return *this;
10937 }
10938
10940 {
10941 depthCompareOp = depthCompareOp_;
10942 return *this;
10943 }
10944
10946 {
10947 depthBoundsTestEnable = depthBoundsTestEnable_;
10948 return *this;
10949 }
10950
10952 {
10953 stencilTestEnable = stencilTestEnable_;
10954 return *this;
10955 }
10956
10958 {
10959 front = front_;
10960 return *this;
10961 }
10962
10964 {
10965 back = back_;
10966 return *this;
10967 }
10968
10970 {
10971 minDepthBounds = minDepthBounds_;
10972 return *this;
10973 }
10974
10976 {
10977 maxDepthBounds = maxDepthBounds_;
10978 return *this;
10979 }
10980
10982 {
10983 return *reinterpret_cast<const VkPipelineDepthStencilStateCreateInfo*>(this);
10984 }
10985
10987 {
10988 return *reinterpret_cast<VkPipelineDepthStencilStateCreateInfo*>(this);
10989 }
10990
10992 {
10993 return ( sType == rhs.sType )
10994 && ( pNext == rhs.pNext )
10995 && ( flags == rhs.flags )
10996 && ( depthTestEnable == rhs.depthTestEnable )
10998 && ( depthCompareOp == rhs.depthCompareOp )
11001 && ( front == rhs.front )
11002 && ( back == rhs.back )
11003 && ( minDepthBounds == rhs.minDepthBounds )
11004 && ( maxDepthBounds == rhs.maxDepthBounds );
11005 }
11006
11008 {
11009 return !operator==( rhs );
11010 }
11011
11012 private:
11014
11015 public:
11016 const void* pNext = nullptr;
11027 };
11028 static_assert( sizeof( PipelineDepthStencilStateCreateInfo ) == sizeof( VkPipelineDepthStencilStateCreateInfo ), "struct and wrapper have different size!" );
11029
11031 {
11033 size_t initialDataSize_ = 0,
11034 const void* pInitialData_ = nullptr )
11035 : flags( flags_ )
11036 , initialDataSize( initialDataSize_ )
11037 , pInitialData( pInitialData_ )
11038 {
11039 }
11040
11042 {
11043 memcpy( this, &rhs, sizeof( PipelineCacheCreateInfo ) );
11044 }
11045
11047 {
11048 memcpy( this, &rhs, sizeof( PipelineCacheCreateInfo ) );
11049 return *this;
11050 }
11051 PipelineCacheCreateInfo& setPNext( const void* pNext_ )
11052 {
11053 pNext = pNext_;
11054 return *this;
11055 }
11056
11058 {
11059 flags = flags_;
11060 return *this;
11061 }
11062
11064 {
11065 initialDataSize = initialDataSize_;
11066 return *this;
11067 }
11068
11069 PipelineCacheCreateInfo& setPInitialData( const void* pInitialData_ )
11070 {
11071 pInitialData = pInitialData_;
11072 return *this;
11073 }
11074
11075 operator VkPipelineCacheCreateInfo const&() const
11076 {
11077 return *reinterpret_cast<const VkPipelineCacheCreateInfo*>(this);
11078 }
11079
11081 {
11082 return *reinterpret_cast<VkPipelineCacheCreateInfo*>(this);
11083 }
11084
11085 bool operator==( PipelineCacheCreateInfo const& rhs ) const
11086 {
11087 return ( sType == rhs.sType )
11088 && ( pNext == rhs.pNext )
11089 && ( flags == rhs.flags )
11090 && ( initialDataSize == rhs.initialDataSize )
11091 && ( pInitialData == rhs.pInitialData );
11092 }
11093
11094 bool operator!=( PipelineCacheCreateInfo const& rhs ) const
11095 {
11096 return !operator==( rhs );
11097 }
11098
11099 private:
11101
11102 public:
11103 const void* pNext = nullptr;
11106 const void* pInitialData;
11107 };
11108 static_assert( sizeof( PipelineCacheCreateInfo ) == sizeof( VkPipelineCacheCreateInfo ), "struct and wrapper have different size!" );
11109
11111 {
11113 Filter magFilter_ = Filter::eNearest,
11114 Filter minFilter_ = Filter::eNearest,
11119 float mipLodBias_ = 0,
11120 Bool32 anisotropyEnable_ = 0,
11121 float maxAnisotropy_ = 0,
11122 Bool32 compareEnable_ = 0,
11123 CompareOp compareOp_ = CompareOp::eNever,
11124 float minLod_ = 0,
11125 float maxLod_ = 0,
11127 Bool32 unnormalizedCoordinates_ = 0 )
11128 : flags( flags_ )
11129 , magFilter( magFilter_ )
11130 , minFilter( minFilter_ )
11131 , mipmapMode( mipmapMode_ )
11132 , addressModeU( addressModeU_ )
11133 , addressModeV( addressModeV_ )
11134 , addressModeW( addressModeW_ )
11135 , mipLodBias( mipLodBias_ )
11136 , anisotropyEnable( anisotropyEnable_ )
11137 , maxAnisotropy( maxAnisotropy_ )
11138 , compareEnable( compareEnable_ )
11139 , compareOp( compareOp_ )
11140 , minLod( minLod_ )
11141 , maxLod( maxLod_ )
11142 , borderColor( borderColor_ )
11143 , unnormalizedCoordinates( unnormalizedCoordinates_ )
11144 {
11145 }
11146
11148 {
11149 memcpy( this, &rhs, sizeof( SamplerCreateInfo ) );
11150 }
11151
11153 {
11154 memcpy( this, &rhs, sizeof( SamplerCreateInfo ) );
11155 return *this;
11156 }
11157 SamplerCreateInfo& setPNext( const void* pNext_ )
11158 {
11159 pNext = pNext_;
11160 return *this;
11161 }
11162
11164 {
11165 flags = flags_;
11166 return *this;
11167 }
11168
11170 {
11171 magFilter = magFilter_;
11172 return *this;
11173 }
11174
11176 {
11177 minFilter = minFilter_;
11178 return *this;
11179 }
11180
11182 {
11183 mipmapMode = mipmapMode_;
11184 return *this;
11185 }
11186
11188 {
11189 addressModeU = addressModeU_;
11190 return *this;
11191 }
11192
11194 {
11195 addressModeV = addressModeV_;
11196 return *this;
11197 }
11198
11200 {
11201 addressModeW = addressModeW_;
11202 return *this;
11203 }
11204
11205 SamplerCreateInfo& setMipLodBias( float mipLodBias_ )
11206 {
11207 mipLodBias = mipLodBias_;
11208 return *this;
11209 }
11210
11212 {
11213 anisotropyEnable = anisotropyEnable_;
11214 return *this;
11215 }
11216
11217 SamplerCreateInfo& setMaxAnisotropy( float maxAnisotropy_ )
11218 {
11219 maxAnisotropy = maxAnisotropy_;
11220 return *this;
11221 }
11222
11224 {
11225 compareEnable = compareEnable_;
11226 return *this;
11227 }
11228
11230 {
11231 compareOp = compareOp_;
11232 return *this;
11233 }
11234
11236 {
11237 minLod = minLod_;
11238 return *this;
11239 }
11240
11242 {
11243 maxLod = maxLod_;
11244 return *this;
11245 }
11246
11248 {
11249 borderColor = borderColor_;
11250 return *this;
11251 }
11252
11254 {
11255 unnormalizedCoordinates = unnormalizedCoordinates_;
11256 return *this;
11257 }
11258
11259 operator VkSamplerCreateInfo const&() const
11260 {
11261 return *reinterpret_cast<const VkSamplerCreateInfo*>(this);
11262 }
11263
11265 {
11266 return *reinterpret_cast<VkSamplerCreateInfo*>(this);
11267 }
11268
11269 bool operator==( SamplerCreateInfo const& rhs ) const
11270 {
11271 return ( sType == rhs.sType )
11272 && ( pNext == rhs.pNext )
11273 && ( flags == rhs.flags )
11274 && ( magFilter == rhs.magFilter )
11275 && ( minFilter == rhs.minFilter )
11276 && ( mipmapMode == rhs.mipmapMode )
11277 && ( addressModeU == rhs.addressModeU )
11278 && ( addressModeV == rhs.addressModeV )
11279 && ( addressModeW == rhs.addressModeW )
11280 && ( mipLodBias == rhs.mipLodBias )
11282 && ( maxAnisotropy == rhs.maxAnisotropy )
11283 && ( compareEnable == rhs.compareEnable )
11284 && ( compareOp == rhs.compareOp )
11285 && ( minLod == rhs.minLod )
11286 && ( maxLod == rhs.maxLod )
11287 && ( borderColor == rhs.borderColor )
11289 }
11290
11291 bool operator!=( SamplerCreateInfo const& rhs ) const
11292 {
11293 return !operator==( rhs );
11294 }
11295
11296 private:
11298
11299 public:
11300 const void* pNext = nullptr;
11313 float minLod;
11314 float maxLod;
11317 };
11318 static_assert( sizeof( SamplerCreateInfo ) == sizeof( VkSamplerCreateInfo ), "struct and wrapper have different size!" );
11319
11321 {
11324 uint32_t commandBufferCount_ = 0 )
11325 : commandPool( commandPool_ )
11326 , level( level_ )
11327 , commandBufferCount( commandBufferCount_ )
11328 {
11329 }
11330
11332 {
11333 memcpy( this, &rhs, sizeof( CommandBufferAllocateInfo ) );
11334 }
11335
11337 {
11338 memcpy( this, &rhs, sizeof( CommandBufferAllocateInfo ) );
11339 return *this;
11340 }
11342 {
11343 pNext = pNext_;
11344 return *this;
11345 }
11346
11348 {
11349 commandPool = commandPool_;
11350 return *this;
11351 }
11352
11354 {
11355 level = level_;
11356 return *this;
11357 }
11358
11360 {
11361 commandBufferCount = commandBufferCount_;
11362 return *this;
11363 }
11364
11365 operator VkCommandBufferAllocateInfo const&() const
11366 {
11367 return *reinterpret_cast<const VkCommandBufferAllocateInfo*>(this);
11368 }
11369
11371 {
11372 return *reinterpret_cast<VkCommandBufferAllocateInfo*>(this);
11373 }
11374
11375 bool operator==( CommandBufferAllocateInfo const& rhs ) const
11376 {
11377 return ( sType == rhs.sType )
11378 && ( pNext == rhs.pNext )
11379 && ( commandPool == rhs.commandPool )
11380 && ( level == rhs.level )
11382 }
11383
11384 bool operator!=( CommandBufferAllocateInfo const& rhs ) const
11385 {
11386 return !operator==( rhs );
11387 }
11388
11389 private:
11391
11392 public:
11393 const void* pNext = nullptr;
11397 };
11398 static_assert( sizeof( CommandBufferAllocateInfo ) == sizeof( VkCommandBufferAllocateInfo ), "struct and wrapper have different size!" );
11399
11401 {
11403 Framebuffer framebuffer_ = Framebuffer(),
11404 Rect2D renderArea_ = Rect2D(),
11405 uint32_t clearValueCount_ = 0,
11406 const ClearValue* pClearValues_ = nullptr )
11407 : renderPass( renderPass_ )
11408 , framebuffer( framebuffer_ )
11409 , renderArea( renderArea_ )
11410 , clearValueCount( clearValueCount_ )
11411 , pClearValues( pClearValues_ )
11412 {
11413 }
11414
11416 {
11417 memcpy( this, &rhs, sizeof( RenderPassBeginInfo ) );
11418 }
11419
11421 {
11422 memcpy( this, &rhs, sizeof( RenderPassBeginInfo ) );
11423 return *this;
11424 }
11425 RenderPassBeginInfo& setPNext( const void* pNext_ )
11426 {
11427 pNext = pNext_;
11428 return *this;
11429 }
11430
11432 {
11433 renderPass = renderPass_;
11434 return *this;
11435 }
11436
11438 {
11439 framebuffer = framebuffer_;
11440 return *this;
11441 }
11442
11444 {
11445 renderArea = renderArea_;
11446 return *this;
11447 }
11448
11450 {
11451 clearValueCount = clearValueCount_;
11452 return *this;
11453 }
11454
11456 {
11457 pClearValues = pClearValues_;
11458 return *this;
11459 }
11460
11461 operator VkRenderPassBeginInfo const&() const
11462 {
11463 return *reinterpret_cast<const VkRenderPassBeginInfo*>(this);
11464 }
11465
11467 {
11468 return *reinterpret_cast<VkRenderPassBeginInfo*>(this);
11469 }
11470
11471 bool operator==( RenderPassBeginInfo const& rhs ) const
11472 {
11473 return ( sType == rhs.sType )
11474 && ( pNext == rhs.pNext )
11475 && ( renderPass == rhs.renderPass )
11476 && ( framebuffer == rhs.framebuffer )
11477 && ( renderArea == rhs.renderArea )
11478 && ( clearValueCount == rhs.clearValueCount )
11479 && ( pClearValues == rhs.pClearValues );
11480 }
11481
11482 bool operator!=( RenderPassBeginInfo const& rhs ) const
11483 {
11484 return !operator==( rhs );
11485 }
11486
11487 private:
11489
11490 public:
11491 const void* pNext = nullptr;
11497 };
11498 static_assert( sizeof( RenderPassBeginInfo ) == sizeof( VkRenderPassBeginInfo ), "struct and wrapper have different size!" );
11499
11501 {
11503 : flags( flags_ )
11504 {
11505 }
11506
11508 {
11509 memcpy( this, &rhs, sizeof( EventCreateInfo ) );
11510 }
11511
11513 {
11514 memcpy( this, &rhs, sizeof( EventCreateInfo ) );
11515 return *this;
11516 }
11517 EventCreateInfo& setPNext( const void* pNext_ )
11518 {
11519 pNext = pNext_;
11520 return *this;
11521 }
11522
11524 {
11525 flags = flags_;
11526 return *this;
11527 }
11528
11529 operator VkEventCreateInfo const&() const
11530 {
11531 return *reinterpret_cast<const VkEventCreateInfo*>(this);
11532 }
11533
11535 {
11536 return *reinterpret_cast<VkEventCreateInfo*>(this);
11537 }
11538
11539 bool operator==( EventCreateInfo const& rhs ) const
11540 {
11541 return ( sType == rhs.sType )
11542 && ( pNext == rhs.pNext )
11543 && ( flags == rhs.flags );
11544 }
11545
11546 bool operator!=( EventCreateInfo const& rhs ) const
11547 {
11548 return !operator==( rhs );
11549 }
11550
11551 private:
11553
11554 public:
11555 const void* pNext = nullptr;
11557 };
11558 static_assert( sizeof( EventCreateInfo ) == sizeof( VkEventCreateInfo ), "struct and wrapper have different size!" );
11559
11561 {
11563 : flags( flags_ )
11564 {
11565 }
11566
11568 {
11569 memcpy( this, &rhs, sizeof( SemaphoreCreateInfo ) );
11570 }
11571
11573 {
11574 memcpy( this, &rhs, sizeof( SemaphoreCreateInfo ) );
11575 return *this;
11576 }
11577 SemaphoreCreateInfo& setPNext( const void* pNext_ )
11578 {
11579 pNext = pNext_;
11580 return *this;
11581 }
11582
11584 {
11585 flags = flags_;
11586 return *this;
11587 }
11588
11589 operator VkSemaphoreCreateInfo const&() const
11590 {
11591 return *reinterpret_cast<const VkSemaphoreCreateInfo*>(this);
11592 }
11593
11595 {
11596 return *reinterpret_cast<VkSemaphoreCreateInfo*>(this);
11597 }
11598
11599 bool operator==( SemaphoreCreateInfo const& rhs ) const
11600 {
11601 return ( sType == rhs.sType )
11602 && ( pNext == rhs.pNext )
11603 && ( flags == rhs.flags );
11604 }
11605
11606 bool operator!=( SemaphoreCreateInfo const& rhs ) const
11607 {
11608 return !operator==( rhs );
11609 }
11610
11611 private:
11613
11614 public:
11615 const void* pNext = nullptr;
11617 };
11618 static_assert( sizeof( SemaphoreCreateInfo ) == sizeof( VkSemaphoreCreateInfo ), "struct and wrapper have different size!" );
11619
11621 {
11623 RenderPass renderPass_ = RenderPass(),
11624 uint32_t attachmentCount_ = 0,
11625 const ImageView* pAttachments_ = nullptr,
11626 uint32_t width_ = 0,
11627 uint32_t height_ = 0,
11628 uint32_t layers_ = 0 )
11629 : flags( flags_ )
11630 , renderPass( renderPass_ )
11631 , attachmentCount( attachmentCount_ )
11632 , pAttachments( pAttachments_ )
11633 , width( width_ )
11634 , height( height_ )
11635 , layers( layers_ )
11636 {
11637 }
11638
11640 {
11641 memcpy( this, &rhs, sizeof( FramebufferCreateInfo ) );
11642 }
11643
11645 {
11646 memcpy( this, &rhs, sizeof( FramebufferCreateInfo ) );
11647 return *this;
11648 }
11649 FramebufferCreateInfo& setPNext( const void* pNext_ )
11650 {
11651 pNext = pNext_;
11652 return *this;
11653 }
11654
11656 {
11657 flags = flags_;
11658 return *this;
11659 }
11660
11662 {
11663 renderPass = renderPass_;
11664 return *this;
11665 }
11666
11668 {
11669 attachmentCount = attachmentCount_;
11670 return *this;
11671 }
11672
11674 {
11675 pAttachments = pAttachments_;
11676 return *this;
11677 }
11678
11680 {
11681 width = width_;
11682 return *this;
11683 }
11684
11686 {
11687 height = height_;
11688 return *this;
11689 }
11690
11692 {
11693 layers = layers_;
11694 return *this;
11695 }
11696
11697 operator VkFramebufferCreateInfo const&() const
11698 {
11699 return *reinterpret_cast<const VkFramebufferCreateInfo*>(this);
11700 }
11701
11703 {
11704 return *reinterpret_cast<VkFramebufferCreateInfo*>(this);
11705 }
11706
11707 bool operator==( FramebufferCreateInfo const& rhs ) const
11708 {
11709 return ( sType == rhs.sType )
11710 && ( pNext == rhs.pNext )
11711 && ( flags == rhs.flags )
11712 && ( renderPass == rhs.renderPass )
11713 && ( attachmentCount == rhs.attachmentCount )
11714 && ( pAttachments == rhs.pAttachments )
11715 && ( width == rhs.width )
11716 && ( height == rhs.height )
11717 && ( layers == rhs.layers );
11718 }
11719
11720 bool operator!=( FramebufferCreateInfo const& rhs ) const
11721 {
11722 return !operator==( rhs );
11723 }
11724
11725 private:
11727
11728 public:
11729 const void* pNext = nullptr;
11737 };
11738 static_assert( sizeof( FramebufferCreateInfo ) == sizeof( VkFramebufferCreateInfo ), "struct and wrapper have different size!" );
11739
11741 {
11744 : flags( flags_ )
11745 , parameters( parameters_ )
11746 {
11747 }
11748
11750 {
11751 memcpy( this, &rhs, sizeof( DisplayModeCreateInfoKHR ) );
11752 }
11753
11755 {
11756 memcpy( this, &rhs, sizeof( DisplayModeCreateInfoKHR ) );
11757 return *this;
11758 }
11759 DisplayModeCreateInfoKHR& setPNext( const void* pNext_ )
11760 {
11761 pNext = pNext_;
11762 return *this;
11763 }
11764
11766 {
11767 flags = flags_;
11768 return *this;
11769 }
11770
11772 {
11773 parameters = parameters_;
11774 return *this;
11775 }
11776
11777 operator VkDisplayModeCreateInfoKHR const&() const
11778 {
11779 return *reinterpret_cast<const VkDisplayModeCreateInfoKHR*>(this);
11780 }
11781
11783 {
11784 return *reinterpret_cast<VkDisplayModeCreateInfoKHR*>(this);
11785 }
11786
11787 bool operator==( DisplayModeCreateInfoKHR const& rhs ) const
11788 {
11789 return ( sType == rhs.sType )
11790 && ( pNext == rhs.pNext )
11791 && ( flags == rhs.flags )
11792 && ( parameters == rhs.parameters );
11793 }
11794
11795 bool operator!=( DisplayModeCreateInfoKHR const& rhs ) const
11796 {
11797 return !operator==( rhs );
11798 }
11799
11800 private:
11802
11803 public:
11804 const void* pNext = nullptr;
11807 };
11808 static_assert( sizeof( DisplayModeCreateInfoKHR ) == sizeof( VkDisplayModeCreateInfoKHR ), "struct and wrapper have different size!" );
11809
11811 {
11813 Rect2D dstRect_ = Rect2D(),
11814 Bool32 persistent_ = 0 )
11815 : srcRect( srcRect_ )
11816 , dstRect( dstRect_ )
11817 , persistent( persistent_ )
11818 {
11819 }
11820
11822 {
11823 memcpy( this, &rhs, sizeof( DisplayPresentInfoKHR ) );
11824 }
11825
11827 {
11828 memcpy( this, &rhs, sizeof( DisplayPresentInfoKHR ) );
11829 return *this;
11830 }
11831 DisplayPresentInfoKHR& setPNext( const void* pNext_ )
11832 {
11833 pNext = pNext_;
11834 return *this;
11835 }
11836
11838 {
11839 srcRect = srcRect_;
11840 return *this;
11841 }
11842
11844 {
11845 dstRect = dstRect_;
11846 return *this;
11847 }
11848
11850 {
11851 persistent = persistent_;
11852 return *this;
11853 }
11854
11855 operator VkDisplayPresentInfoKHR const&() const
11856 {
11857 return *reinterpret_cast<const VkDisplayPresentInfoKHR*>(this);
11858 }
11859
11861 {
11862 return *reinterpret_cast<VkDisplayPresentInfoKHR*>(this);
11863 }
11864
11865 bool operator==( DisplayPresentInfoKHR const& rhs ) const
11866 {
11867 return ( sType == rhs.sType )
11868 && ( pNext == rhs.pNext )
11869 && ( srcRect == rhs.srcRect )
11870 && ( dstRect == rhs.dstRect )
11871 && ( persistent == rhs.persistent );
11872 }
11873
11874 bool operator!=( DisplayPresentInfoKHR const& rhs ) const
11875 {
11876 return !operator==( rhs );
11877 }
11878
11879 private:
11881
11882 public:
11883 const void* pNext = nullptr;
11887 };
11888 static_assert( sizeof( DisplayPresentInfoKHR ) == sizeof( VkDisplayPresentInfoKHR ), "struct and wrapper have different size!" );
11889
11890#ifdef VK_USE_PLATFORM_ANDROID_KHR
11891 struct AndroidSurfaceCreateInfoKHR
11892 {
11893 AndroidSurfaceCreateInfoKHR( AndroidSurfaceCreateFlagsKHR flags_ = AndroidSurfaceCreateFlagsKHR(),
11894 struct ANativeWindow* window_ = nullptr )
11895 : flags( flags_ )
11896 , window( window_ )
11897 {
11898 }
11899
11900 AndroidSurfaceCreateInfoKHR( VkAndroidSurfaceCreateInfoKHR const & rhs )
11901 {
11902 memcpy( this, &rhs, sizeof( AndroidSurfaceCreateInfoKHR ) );
11903 }
11904
11905 AndroidSurfaceCreateInfoKHR& operator=( VkAndroidSurfaceCreateInfoKHR const & rhs )
11906 {
11907 memcpy( this, &rhs, sizeof( AndroidSurfaceCreateInfoKHR ) );
11908 return *this;
11909 }
11910 AndroidSurfaceCreateInfoKHR& setPNext( const void* pNext_ )
11911 {
11912 pNext = pNext_;
11913 return *this;
11914 }
11915
11916 AndroidSurfaceCreateInfoKHR& setFlags( AndroidSurfaceCreateFlagsKHR flags_ )
11917 {
11918 flags = flags_;
11919 return *this;
11920 }
11921
11922 AndroidSurfaceCreateInfoKHR& setWindow( struct ANativeWindow* window_ )
11923 {
11924 window = window_;
11925 return *this;
11926 }
11927
11928 operator VkAndroidSurfaceCreateInfoKHR const&() const
11929 {
11930 return *reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR*>(this);
11931 }
11932
11934 {
11935 return *reinterpret_cast<VkAndroidSurfaceCreateInfoKHR*>(this);
11936 }
11937
11938 bool operator==( AndroidSurfaceCreateInfoKHR const& rhs ) const
11939 {
11940 return ( sType == rhs.sType )
11941 && ( pNext == rhs.pNext )
11942 && ( flags == rhs.flags )
11943 && ( window == rhs.window );
11944 }
11945
11946 bool operator!=( AndroidSurfaceCreateInfoKHR const& rhs ) const
11947 {
11948 return !operator==( rhs );
11949 }
11950
11951 private:
11953
11954 public:
11955 const void* pNext = nullptr;
11956 AndroidSurfaceCreateFlagsKHR flags;
11957 struct ANativeWindow* window;
11958 };
11959 static_assert( sizeof( AndroidSurfaceCreateInfoKHR ) == sizeof( VkAndroidSurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
11960#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
11961
11962#ifdef VK_USE_PLATFORM_VI_NN
11963 struct ViSurfaceCreateInfoNN
11964 {
11965 ViSurfaceCreateInfoNN( ViSurfaceCreateFlagsNN flags_ = ViSurfaceCreateFlagsNN(),
11966 void* window_ = nullptr )
11967 : flags( flags_ )
11968 , window( window_ )
11969 {
11970 }
11971
11972 ViSurfaceCreateInfoNN( VkViSurfaceCreateInfoNN const & rhs )
11973 {
11974 memcpy( this, &rhs, sizeof( ViSurfaceCreateInfoNN ) );
11975 }
11976
11977 ViSurfaceCreateInfoNN& operator=( VkViSurfaceCreateInfoNN const & rhs )
11978 {
11979 memcpy( this, &rhs, sizeof( ViSurfaceCreateInfoNN ) );
11980 return *this;
11981 }
11982 ViSurfaceCreateInfoNN& setPNext( const void* pNext_ )
11983 {
11984 pNext = pNext_;
11985 return *this;
11986 }
11987
11988 ViSurfaceCreateInfoNN& setFlags( ViSurfaceCreateFlagsNN flags_ )
11989 {
11990 flags = flags_;
11991 return *this;
11992 }
11993
11994 ViSurfaceCreateInfoNN& setWindow( void* window_ )
11995 {
11996 window = window_;
11997 return *this;
11998 }
11999
12000 operator VkViSurfaceCreateInfoNN const&() const
12001 {
12002 return *reinterpret_cast<const VkViSurfaceCreateInfoNN*>(this);
12003 }
12004
12005 operator VkViSurfaceCreateInfoNN &()
12006 {
12007 return *reinterpret_cast<VkViSurfaceCreateInfoNN*>(this);
12008 }
12009
12010 bool operator==( ViSurfaceCreateInfoNN const& rhs ) const
12011 {
12012 return ( sType == rhs.sType )
12013 && ( pNext == rhs.pNext )
12014 && ( flags == rhs.flags )
12015 && ( window == rhs.window );
12016 }
12017
12018 bool operator!=( ViSurfaceCreateInfoNN const& rhs ) const
12019 {
12020 return !operator==( rhs );
12021 }
12022
12023 private:
12025
12026 public:
12027 const void* pNext = nullptr;
12028 ViSurfaceCreateFlagsNN flags;
12029 void* window;
12030 };
12031 static_assert( sizeof( ViSurfaceCreateInfoNN ) == sizeof( VkViSurfaceCreateInfoNN ), "struct and wrapper have different size!" );
12032#endif /*VK_USE_PLATFORM_VI_NN*/
12033
12034#ifdef VK_USE_PLATFORM_WAYLAND_KHR
12035 struct WaylandSurfaceCreateInfoKHR
12036 {
12037 WaylandSurfaceCreateInfoKHR( WaylandSurfaceCreateFlagsKHR flags_ = WaylandSurfaceCreateFlagsKHR(),
12038 struct wl_display* display_ = nullptr,
12039 struct wl_surface* surface_ = nullptr )
12040 : flags( flags_ )
12041 , display( display_ )
12042 , surface( surface_ )
12043 {
12044 }
12045
12046 WaylandSurfaceCreateInfoKHR( VkWaylandSurfaceCreateInfoKHR const & rhs )
12047 {
12048 memcpy( this, &rhs, sizeof( WaylandSurfaceCreateInfoKHR ) );
12049 }
12050
12051 WaylandSurfaceCreateInfoKHR& operator=( VkWaylandSurfaceCreateInfoKHR const & rhs )
12052 {
12053 memcpy( this, &rhs, sizeof( WaylandSurfaceCreateInfoKHR ) );
12054 return *this;
12055 }
12056 WaylandSurfaceCreateInfoKHR& setPNext( const void* pNext_ )
12057 {
12058 pNext = pNext_;
12059 return *this;
12060 }
12061
12062 WaylandSurfaceCreateInfoKHR& setFlags( WaylandSurfaceCreateFlagsKHR flags_ )
12063 {
12064 flags = flags_;
12065 return *this;
12066 }
12067
12068 WaylandSurfaceCreateInfoKHR& setDisplay( struct wl_display* display_ )
12069 {
12070 display = display_;
12071 return *this;
12072 }
12073
12074 WaylandSurfaceCreateInfoKHR& setSurface( struct wl_surface* surface_ )
12075 {
12076 surface = surface_;
12077 return *this;
12078 }
12079
12080 operator VkWaylandSurfaceCreateInfoKHR const&() const
12081 {
12082 return *reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR*>(this);
12083 }
12084
12086 {
12087 return *reinterpret_cast<VkWaylandSurfaceCreateInfoKHR*>(this);
12088 }
12089
12090 bool operator==( WaylandSurfaceCreateInfoKHR const& rhs ) const
12091 {
12092 return ( sType == rhs.sType )
12093 && ( pNext == rhs.pNext )
12094 && ( flags == rhs.flags )
12095 && ( display == rhs.display )
12096 && ( surface == rhs.surface );
12097 }
12098
12099 bool operator!=( WaylandSurfaceCreateInfoKHR const& rhs ) const
12100 {
12101 return !operator==( rhs );
12102 }
12103
12104 private:
12106
12107 public:
12108 const void* pNext = nullptr;
12109 WaylandSurfaceCreateFlagsKHR flags;
12110 struct wl_display* display;
12111 struct wl_surface* surface;
12112 };
12113 static_assert( sizeof( WaylandSurfaceCreateInfoKHR ) == sizeof( VkWaylandSurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
12114#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
12115
12116#ifdef VK_USE_PLATFORM_WIN32_KHR
12117 struct Win32SurfaceCreateInfoKHR
12118 {
12119 Win32SurfaceCreateInfoKHR( Win32SurfaceCreateFlagsKHR flags_ = Win32SurfaceCreateFlagsKHR(),
12120 HINSTANCE hinstance_ = 0,
12121 HWND hwnd_ = 0 )
12122 : flags( flags_ )
12123 , hinstance( hinstance_ )
12124 , hwnd( hwnd_ )
12125 {
12126 }
12127
12128 Win32SurfaceCreateInfoKHR( VkWin32SurfaceCreateInfoKHR const & rhs )
12129 {
12130 memcpy( this, &rhs, sizeof( Win32SurfaceCreateInfoKHR ) );
12131 }
12132
12133 Win32SurfaceCreateInfoKHR& operator=( VkWin32SurfaceCreateInfoKHR const & rhs )
12134 {
12135 memcpy( this, &rhs, sizeof( Win32SurfaceCreateInfoKHR ) );
12136 return *this;
12137 }
12138 Win32SurfaceCreateInfoKHR& setPNext( const void* pNext_ )
12139 {
12140 pNext = pNext_;
12141 return *this;
12142 }
12143
12144 Win32SurfaceCreateInfoKHR& setFlags( Win32SurfaceCreateFlagsKHR flags_ )
12145 {
12146 flags = flags_;
12147 return *this;
12148 }
12149
12150 Win32SurfaceCreateInfoKHR& setHinstance( HINSTANCE hinstance_ )
12151 {
12152 hinstance = hinstance_;
12153 return *this;
12154 }
12155
12156 Win32SurfaceCreateInfoKHR& setHwnd( HWND hwnd_ )
12157 {
12158 hwnd = hwnd_;
12159 return *this;
12160 }
12161
12162 operator VkWin32SurfaceCreateInfoKHR const&() const
12163 {
12164 return *reinterpret_cast<const VkWin32SurfaceCreateInfoKHR*>(this);
12165 }
12166
12167 operator VkWin32SurfaceCreateInfoKHR &()
12168 {
12169 return *reinterpret_cast<VkWin32SurfaceCreateInfoKHR*>(this);
12170 }
12171
12172 bool operator==( Win32SurfaceCreateInfoKHR const& rhs ) const
12173 {
12174 return ( sType == rhs.sType )
12175 && ( pNext == rhs.pNext )
12176 && ( flags == rhs.flags )
12177 && ( hinstance == rhs.hinstance )
12178 && ( hwnd == rhs.hwnd );
12179 }
12180
12181 bool operator!=( Win32SurfaceCreateInfoKHR const& rhs ) const
12182 {
12183 return !operator==( rhs );
12184 }
12185
12186 private:
12188
12189 public:
12190 const void* pNext = nullptr;
12191 Win32SurfaceCreateFlagsKHR flags;
12192 HINSTANCE hinstance;
12193 HWND hwnd;
12194 };
12195 static_assert( sizeof( Win32SurfaceCreateInfoKHR ) == sizeof( VkWin32SurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
12196#endif /*VK_USE_PLATFORM_WIN32_KHR*/
12197
12198#ifdef VK_USE_PLATFORM_XLIB_KHR
12199 struct XlibSurfaceCreateInfoKHR
12200 {
12201 XlibSurfaceCreateInfoKHR( XlibSurfaceCreateFlagsKHR flags_ = XlibSurfaceCreateFlagsKHR(),
12202 Display* dpy_ = nullptr,
12203 Window window_ = 0 )
12204 : flags( flags_ )
12205 , dpy( dpy_ )
12206 , window( window_ )
12207 {
12208 }
12209
12210 XlibSurfaceCreateInfoKHR( VkXlibSurfaceCreateInfoKHR const & rhs )
12211 {
12212 memcpy( this, &rhs, sizeof( XlibSurfaceCreateInfoKHR ) );
12213 }
12214
12215 XlibSurfaceCreateInfoKHR& operator=( VkXlibSurfaceCreateInfoKHR const & rhs )
12216 {
12217 memcpy( this, &rhs, sizeof( XlibSurfaceCreateInfoKHR ) );
12218 return *this;
12219 }
12220 XlibSurfaceCreateInfoKHR& setPNext( const void* pNext_ )
12221 {
12222 pNext = pNext_;
12223 return *this;
12224 }
12225
12226 XlibSurfaceCreateInfoKHR& setFlags( XlibSurfaceCreateFlagsKHR flags_ )
12227 {
12228 flags = flags_;
12229 return *this;
12230 }
12231
12232 XlibSurfaceCreateInfoKHR& setDpy( Display* dpy_ )
12233 {
12234 dpy = dpy_;
12235 return *this;
12236 }
12237
12238 XlibSurfaceCreateInfoKHR& setWindow( Window window_ )
12239 {
12240 window = window_;
12241 return *this;
12242 }
12243
12244 operator VkXlibSurfaceCreateInfoKHR const&() const
12245 {
12246 return *reinterpret_cast<const VkXlibSurfaceCreateInfoKHR*>(this);
12247 }
12248
12249 operator VkXlibSurfaceCreateInfoKHR &()
12250 {
12251 return *reinterpret_cast<VkXlibSurfaceCreateInfoKHR*>(this);
12252 }
12253
12254 bool operator==( XlibSurfaceCreateInfoKHR const& rhs ) const
12255 {
12256 return ( sType == rhs.sType )
12257 && ( pNext == rhs.pNext )
12258 && ( flags == rhs.flags )
12259 && ( dpy == rhs.dpy )
12260 && ( window == rhs.window );
12261 }
12262
12263 bool operator!=( XlibSurfaceCreateInfoKHR const& rhs ) const
12264 {
12265 return !operator==( rhs );
12266 }
12267
12268 private:
12270
12271 public:
12272 const void* pNext = nullptr;
12273 XlibSurfaceCreateFlagsKHR flags;
12274 Display* dpy;
12275 Window window;
12276 };
12277 static_assert( sizeof( XlibSurfaceCreateInfoKHR ) == sizeof( VkXlibSurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
12278#endif /*VK_USE_PLATFORM_XLIB_KHR*/
12279
12280#ifdef VK_USE_PLATFORM_XCB_KHR
12281 struct XcbSurfaceCreateInfoKHR
12282 {
12283 XcbSurfaceCreateInfoKHR( XcbSurfaceCreateFlagsKHR flags_ = XcbSurfaceCreateFlagsKHR(),
12284 xcb_connection_t* connection_ = nullptr,
12285 xcb_window_t window_ = 0 )
12286 : flags( flags_ )
12287 , connection( connection_ )
12288 , window( window_ )
12289 {
12290 }
12291
12292 XcbSurfaceCreateInfoKHR( VkXcbSurfaceCreateInfoKHR const & rhs )
12293 {
12294 memcpy( this, &rhs, sizeof( XcbSurfaceCreateInfoKHR ) );
12295 }
12296
12297 XcbSurfaceCreateInfoKHR& operator=( VkXcbSurfaceCreateInfoKHR const & rhs )
12298 {
12299 memcpy( this, &rhs, sizeof( XcbSurfaceCreateInfoKHR ) );
12300 return *this;
12301 }
12302 XcbSurfaceCreateInfoKHR& setPNext( const void* pNext_ )
12303 {
12304 pNext = pNext_;
12305 return *this;
12306 }
12307
12308 XcbSurfaceCreateInfoKHR& setFlags( XcbSurfaceCreateFlagsKHR flags_ )
12309 {
12310 flags = flags_;
12311 return *this;
12312 }
12313
12314 XcbSurfaceCreateInfoKHR& setConnection( xcb_connection_t* connection_ )
12315 {
12316 connection = connection_;
12317 return *this;
12318 }
12319
12320 XcbSurfaceCreateInfoKHR& setWindow( xcb_window_t window_ )
12321 {
12322 window = window_;
12323 return *this;
12324 }
12325
12326 operator VkXcbSurfaceCreateInfoKHR const&() const
12327 {
12328 return *reinterpret_cast<const VkXcbSurfaceCreateInfoKHR*>(this);
12329 }
12330
12331 operator VkXcbSurfaceCreateInfoKHR &()
12332 {
12333 return *reinterpret_cast<VkXcbSurfaceCreateInfoKHR*>(this);
12334 }
12335
12336 bool operator==( XcbSurfaceCreateInfoKHR const& rhs ) const
12337 {
12338 return ( sType == rhs.sType )
12339 && ( pNext == rhs.pNext )
12340 && ( flags == rhs.flags )
12341 && ( connection == rhs.connection )
12342 && ( window == rhs.window );
12343 }
12344
12345 bool operator!=( XcbSurfaceCreateInfoKHR const& rhs ) const
12346 {
12347 return !operator==( rhs );
12348 }
12349
12350 private:
12352
12353 public:
12354 const void* pNext = nullptr;
12355 XcbSurfaceCreateFlagsKHR flags;
12356 xcb_connection_t* connection;
12357 xcb_window_t window;
12358 };
12359 static_assert( sizeof( XcbSurfaceCreateInfoKHR ) == sizeof( VkXcbSurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
12360#endif /*VK_USE_PLATFORM_XCB_KHR*/
12361
12362#ifdef VK_USE_PLATFORM_FUCHSIA_FUCHSIA
12363 struct ImagePipeSurfaceCreateInfoFUCHSIA
12364 {
12365 ImagePipeSurfaceCreateInfoFUCHSIA( ImagePipeSurfaceCreateFlagsFUCHSIA flags_ = ImagePipeSurfaceCreateFlagsFUCHSIA(),
12366 zx_handle_t imagePipeHandle_ = 0 )
12367 : flags( flags_ )
12368 , imagePipeHandle( imagePipeHandle_ )
12369 {
12370 }
12371
12372 ImagePipeSurfaceCreateInfoFUCHSIA( VkImagePipeSurfaceCreateInfoFUCHSIA const & rhs )
12373 {
12374 memcpy( this, &rhs, sizeof( ImagePipeSurfaceCreateInfoFUCHSIA ) );
12375 }
12376
12377 ImagePipeSurfaceCreateInfoFUCHSIA& operator=( VkImagePipeSurfaceCreateInfoFUCHSIA const & rhs )
12378 {
12379 memcpy( this, &rhs, sizeof( ImagePipeSurfaceCreateInfoFUCHSIA ) );
12380 return *this;
12381 }
12382 ImagePipeSurfaceCreateInfoFUCHSIA& setPNext( const void* pNext_ )
12383 {
12384 pNext = pNext_;
12385 return *this;
12386 }
12387
12388 ImagePipeSurfaceCreateInfoFUCHSIA& setFlags( ImagePipeSurfaceCreateFlagsFUCHSIA flags_ )
12389 {
12390 flags = flags_;
12391 return *this;
12392 }
12393
12394 ImagePipeSurfaceCreateInfoFUCHSIA& setImagePipeHandle( zx_handle_t imagePipeHandle_ )
12395 {
12396 imagePipeHandle = imagePipeHandle_;
12397 return *this;
12398 }
12399
12400 operator VkImagePipeSurfaceCreateInfoFUCHSIA const&() const
12401 {
12402 return *reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA*>(this);
12403 }
12404
12406 {
12407 return *reinterpret_cast<VkImagePipeSurfaceCreateInfoFUCHSIA*>(this);
12408 }
12409
12410 bool operator==( ImagePipeSurfaceCreateInfoFUCHSIA const& rhs ) const
12411 {
12412 return ( sType == rhs.sType )
12413 && ( pNext == rhs.pNext )
12414 && ( flags == rhs.flags )
12415 && ( imagePipeHandle == rhs.imagePipeHandle );
12416 }
12417
12418 bool operator!=( ImagePipeSurfaceCreateInfoFUCHSIA const& rhs ) const
12419 {
12420 return !operator==( rhs );
12421 }
12422
12423 private:
12425
12426 public:
12427 const void* pNext = nullptr;
12428 ImagePipeSurfaceCreateFlagsFUCHSIA flags;
12429 zx_handle_t imagePipeHandle;
12430 };
12431 static_assert( sizeof( ImagePipeSurfaceCreateInfoFUCHSIA ) == sizeof( VkImagePipeSurfaceCreateInfoFUCHSIA ), "struct and wrapper have different size!" );
12432#endif /*VK_USE_PLATFORM_FUCHSIA_FUCHSIA*/
12433
12435 {
12436 DebugMarkerMarkerInfoEXT( const char* pMarkerName_ = nullptr,
12437 std::array<float,4> const& color_ = { { 0, 0, 0, 0 } } )
12438 : pMarkerName( pMarkerName_ )
12439 {
12440 memcpy( &color, color_.data(), 4 * sizeof( float ) );
12441 }
12442
12444 {
12445 memcpy( this, &rhs, sizeof( DebugMarkerMarkerInfoEXT ) );
12446 }
12447
12449 {
12450 memcpy( this, &rhs, sizeof( DebugMarkerMarkerInfoEXT ) );
12451 return *this;
12452 }
12453 DebugMarkerMarkerInfoEXT& setPNext( const void* pNext_ )
12454 {
12455 pNext = pNext_;
12456 return *this;
12457 }
12458
12459 DebugMarkerMarkerInfoEXT& setPMarkerName( const char* pMarkerName_ )
12460 {
12461 pMarkerName = pMarkerName_;
12462 return *this;
12463 }
12464
12465 DebugMarkerMarkerInfoEXT& setColor( std::array<float,4> color_ )
12466 {
12467 memcpy( &color, color_.data(), 4 * sizeof( float ) );
12468 return *this;
12469 }
12470
12471 operator VkDebugMarkerMarkerInfoEXT const&() const
12472 {
12473 return *reinterpret_cast<const VkDebugMarkerMarkerInfoEXT*>(this);
12474 }
12475
12477 {
12478 return *reinterpret_cast<VkDebugMarkerMarkerInfoEXT*>(this);
12479 }
12480
12481 bool operator==( DebugMarkerMarkerInfoEXT const& rhs ) const
12482 {
12483 return ( sType == rhs.sType )
12484 && ( pNext == rhs.pNext )
12485 && ( pMarkerName == rhs.pMarkerName )
12486 && ( memcmp( color, rhs.color, 4 * sizeof( float ) ) == 0 );
12487 }
12488
12489 bool operator!=( DebugMarkerMarkerInfoEXT const& rhs ) const
12490 {
12491 return !operator==( rhs );
12492 }
12493
12494 private:
12496
12497 public:
12498 const void* pNext = nullptr;
12499 const char* pMarkerName;
12500 float color[4];
12501 };
12502 static_assert( sizeof( DebugMarkerMarkerInfoEXT ) == sizeof( VkDebugMarkerMarkerInfoEXT ), "struct and wrapper have different size!" );
12503
12505 {
12507 : dedicatedAllocation( dedicatedAllocation_ )
12508 {
12509 }
12510
12512 {
12513 memcpy( this, &rhs, sizeof( DedicatedAllocationImageCreateInfoNV ) );
12514 }
12515
12517 {
12518 memcpy( this, &rhs, sizeof( DedicatedAllocationImageCreateInfoNV ) );
12519 return *this;
12520 }
12522 {
12523 pNext = pNext_;
12524 return *this;
12525 }
12526
12528 {
12529 dedicatedAllocation = dedicatedAllocation_;
12530 return *this;
12531 }
12532
12534 {
12535 return *reinterpret_cast<const VkDedicatedAllocationImageCreateInfoNV*>(this);
12536 }
12537
12539 {
12540 return *reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV*>(this);
12541 }
12542
12544 {
12545 return ( sType == rhs.sType )
12546 && ( pNext == rhs.pNext )
12548 }
12549
12551 {
12552 return !operator==( rhs );
12553 }
12554
12555 private:
12557
12558 public:
12559 const void* pNext = nullptr;
12561 };
12562 static_assert( sizeof( DedicatedAllocationImageCreateInfoNV ) == sizeof( VkDedicatedAllocationImageCreateInfoNV ), "struct and wrapper have different size!" );
12563
12565 {
12567 : dedicatedAllocation( dedicatedAllocation_ )
12568 {
12569 }
12570
12572 {
12573 memcpy( this, &rhs, sizeof( DedicatedAllocationBufferCreateInfoNV ) );
12574 }
12575
12577 {
12578 memcpy( this, &rhs, sizeof( DedicatedAllocationBufferCreateInfoNV ) );
12579 return *this;
12580 }
12582 {
12583 pNext = pNext_;
12584 return *this;
12585 }
12586
12588 {
12589 dedicatedAllocation = dedicatedAllocation_;
12590 return *this;
12591 }
12592
12594 {
12595 return *reinterpret_cast<const VkDedicatedAllocationBufferCreateInfoNV*>(this);
12596 }
12597
12599 {
12600 return *reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV*>(this);
12601 }
12602
12604 {
12605 return ( sType == rhs.sType )
12606 && ( pNext == rhs.pNext )
12608 }
12609
12611 {
12612 return !operator==( rhs );
12613 }
12614
12615 private:
12617
12618 public:
12619 const void* pNext = nullptr;
12621 };
12622 static_assert( sizeof( DedicatedAllocationBufferCreateInfoNV ) == sizeof( VkDedicatedAllocationBufferCreateInfoNV ), "struct and wrapper have different size!" );
12623
12625 {
12627 Buffer buffer_ = Buffer() )
12628 : image( image_ )
12629 , buffer( buffer_ )
12630 {
12631 }
12632
12634 {
12635 memcpy( this, &rhs, sizeof( DedicatedAllocationMemoryAllocateInfoNV ) );
12636 }
12637
12639 {
12640 memcpy( this, &rhs, sizeof( DedicatedAllocationMemoryAllocateInfoNV ) );
12641 return *this;
12642 }
12644 {
12645 pNext = pNext_;
12646 return *this;
12647 }
12648
12650 {
12651 image = image_;
12652 return *this;
12653 }
12654
12656 {
12657 buffer = buffer_;
12658 return *this;
12659 }
12660
12662 {
12663 return *reinterpret_cast<const VkDedicatedAllocationMemoryAllocateInfoNV*>(this);
12664 }
12665
12667 {
12668 return *reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV*>(this);
12669 }
12670
12672 {
12673 return ( sType == rhs.sType )
12674 && ( pNext == rhs.pNext )
12675 && ( image == rhs.image )
12676 && ( buffer == rhs.buffer );
12677 }
12678
12680 {
12681 return !operator==( rhs );
12682 }
12683
12684 private:
12686
12687 public:
12688 const void* pNext = nullptr;
12691 };
12692 static_assert( sizeof( DedicatedAllocationMemoryAllocateInfoNV ) == sizeof( VkDedicatedAllocationMemoryAllocateInfoNV ), "struct and wrapper have different size!" );
12693
12694#ifdef VK_USE_PLATFORM_WIN32_NV
12695 struct ExportMemoryWin32HandleInfoNV
12696 {
12697 ExportMemoryWin32HandleInfoNV( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr,
12698 DWORD dwAccess_ = 0 )
12699 : pAttributes( pAttributes_ )
12700 , dwAccess( dwAccess_ )
12701 {
12702 }
12703
12704 ExportMemoryWin32HandleInfoNV( VkExportMemoryWin32HandleInfoNV const & rhs )
12705 {
12706 memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoNV ) );
12707 }
12708
12709 ExportMemoryWin32HandleInfoNV& operator=( VkExportMemoryWin32HandleInfoNV const & rhs )
12710 {
12711 memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoNV ) );
12712 return *this;
12713 }
12714 ExportMemoryWin32HandleInfoNV& setPNext( const void* pNext_ )
12715 {
12716 pNext = pNext_;
12717 return *this;
12718 }
12719
12720 ExportMemoryWin32HandleInfoNV& setPAttributes( const SECURITY_ATTRIBUTES* pAttributes_ )
12721 {
12722 pAttributes = pAttributes_;
12723 return *this;
12724 }
12725
12726 ExportMemoryWin32HandleInfoNV& setDwAccess( DWORD dwAccess_ )
12727 {
12728 dwAccess = dwAccess_;
12729 return *this;
12730 }
12731
12732 operator VkExportMemoryWin32HandleInfoNV const&() const
12733 {
12734 return *reinterpret_cast<const VkExportMemoryWin32HandleInfoNV*>(this);
12735 }
12736
12738 {
12739 return *reinterpret_cast<VkExportMemoryWin32HandleInfoNV*>(this);
12740 }
12741
12742 bool operator==( ExportMemoryWin32HandleInfoNV const& rhs ) const
12743 {
12744 return ( sType == rhs.sType )
12745 && ( pNext == rhs.pNext )
12746 && ( pAttributes == rhs.pAttributes )
12747 && ( dwAccess == rhs.dwAccess );
12748 }
12749
12750 bool operator!=( ExportMemoryWin32HandleInfoNV const& rhs ) const
12751 {
12752 return !operator==( rhs );
12753 }
12754
12755 private:
12757
12758 public:
12759 const void* pNext = nullptr;
12760 const SECURITY_ATTRIBUTES* pAttributes;
12761 DWORD dwAccess;
12762 };
12763 static_assert( sizeof( ExportMemoryWin32HandleInfoNV ) == sizeof( VkExportMemoryWin32HandleInfoNV ), "struct and wrapper have different size!" );
12764#endif /*VK_USE_PLATFORM_WIN32_NV*/
12765
12766#ifdef VK_USE_PLATFORM_WIN32_NV
12767 struct Win32KeyedMutexAcquireReleaseInfoNV
12768 {
12769 Win32KeyedMutexAcquireReleaseInfoNV( uint32_t acquireCount_ = 0,
12770 const DeviceMemory* pAcquireSyncs_ = nullptr,
12771 const uint64_t* pAcquireKeys_ = nullptr,
12772 const uint32_t* pAcquireTimeoutMilliseconds_ = nullptr,
12773 uint32_t releaseCount_ = 0,
12774 const DeviceMemory* pReleaseSyncs_ = nullptr,
12775 const uint64_t* pReleaseKeys_ = nullptr )
12776 : acquireCount( acquireCount_ )
12777 , pAcquireSyncs( pAcquireSyncs_ )
12778 , pAcquireKeys( pAcquireKeys_ )
12779 , pAcquireTimeoutMilliseconds( pAcquireTimeoutMilliseconds_ )
12780 , releaseCount( releaseCount_ )
12781 , pReleaseSyncs( pReleaseSyncs_ )
12782 , pReleaseKeys( pReleaseKeys_ )
12783 {
12784 }
12785
12786 Win32KeyedMutexAcquireReleaseInfoNV( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs )
12787 {
12788 memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoNV ) );
12789 }
12790
12791 Win32KeyedMutexAcquireReleaseInfoNV& operator=( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs )
12792 {
12793 memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoNV ) );
12794 return *this;
12795 }
12796 Win32KeyedMutexAcquireReleaseInfoNV& setPNext( const void* pNext_ )
12797 {
12798 pNext = pNext_;
12799 return *this;
12800 }
12801
12802 Win32KeyedMutexAcquireReleaseInfoNV& setAcquireCount( uint32_t acquireCount_ )
12803 {
12804 acquireCount = acquireCount_;
12805 return *this;
12806 }
12807
12808 Win32KeyedMutexAcquireReleaseInfoNV& setPAcquireSyncs( const DeviceMemory* pAcquireSyncs_ )
12809 {
12810 pAcquireSyncs = pAcquireSyncs_;
12811 return *this;
12812 }
12813
12814 Win32KeyedMutexAcquireReleaseInfoNV& setPAcquireKeys( const uint64_t* pAcquireKeys_ )
12815 {
12816 pAcquireKeys = pAcquireKeys_;
12817 return *this;
12818 }
12819
12820 Win32KeyedMutexAcquireReleaseInfoNV& setPAcquireTimeoutMilliseconds( const uint32_t* pAcquireTimeoutMilliseconds_ )
12821 {
12822 pAcquireTimeoutMilliseconds = pAcquireTimeoutMilliseconds_;
12823 return *this;
12824 }
12825
12826 Win32KeyedMutexAcquireReleaseInfoNV& setReleaseCount( uint32_t releaseCount_ )
12827 {
12828 releaseCount = releaseCount_;
12829 return *this;
12830 }
12831
12832 Win32KeyedMutexAcquireReleaseInfoNV& setPReleaseSyncs( const DeviceMemory* pReleaseSyncs_ )
12833 {
12834 pReleaseSyncs = pReleaseSyncs_;
12835 return *this;
12836 }
12837
12838 Win32KeyedMutexAcquireReleaseInfoNV& setPReleaseKeys( const uint64_t* pReleaseKeys_ )
12839 {
12840 pReleaseKeys = pReleaseKeys_;
12841 return *this;
12842 }
12843
12844 operator VkWin32KeyedMutexAcquireReleaseInfoNV const&() const
12845 {
12846 return *reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoNV*>(this);
12847 }
12848
12850 {
12851 return *reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV*>(this);
12852 }
12853
12854 bool operator==( Win32KeyedMutexAcquireReleaseInfoNV const& rhs ) const
12855 {
12856 return ( sType == rhs.sType )
12857 && ( pNext == rhs.pNext )
12858 && ( acquireCount == rhs.acquireCount )
12859 && ( pAcquireSyncs == rhs.pAcquireSyncs )
12860 && ( pAcquireKeys == rhs.pAcquireKeys )
12861 && ( pAcquireTimeoutMilliseconds == rhs.pAcquireTimeoutMilliseconds )
12862 && ( releaseCount == rhs.releaseCount )
12863 && ( pReleaseSyncs == rhs.pReleaseSyncs )
12864 && ( pReleaseKeys == rhs.pReleaseKeys );
12865 }
12866
12867 bool operator!=( Win32KeyedMutexAcquireReleaseInfoNV const& rhs ) const
12868 {
12869 return !operator==( rhs );
12870 }
12871
12872 private:
12874
12875 public:
12876 const void* pNext = nullptr;
12877 uint32_t acquireCount;
12878 const DeviceMemory* pAcquireSyncs;
12879 const uint64_t* pAcquireKeys;
12880 const uint32_t* pAcquireTimeoutMilliseconds;
12881 uint32_t releaseCount;
12882 const DeviceMemory* pReleaseSyncs;
12883 const uint64_t* pReleaseKeys;
12884 };
12885 static_assert( sizeof( Win32KeyedMutexAcquireReleaseInfoNV ) == sizeof( VkWin32KeyedMutexAcquireReleaseInfoNV ), "struct and wrapper have different size!" );
12886#endif /*VK_USE_PLATFORM_WIN32_NV*/
12887
12889 {
12890 DeviceGeneratedCommandsFeaturesNVX( Bool32 computeBindingPointSupport_ = 0 )
12891 : computeBindingPointSupport( computeBindingPointSupport_ )
12892 {
12893 }
12894
12896 {
12897 memcpy( this, &rhs, sizeof( DeviceGeneratedCommandsFeaturesNVX ) );
12898 }
12899
12901 {
12902 memcpy( this, &rhs, sizeof( DeviceGeneratedCommandsFeaturesNVX ) );
12903 return *this;
12904 }
12906 {
12907 pNext = pNext_;
12908 return *this;
12909 }
12910
12912 {
12913 computeBindingPointSupport = computeBindingPointSupport_;
12914 return *this;
12915 }
12916
12918 {
12919 return *reinterpret_cast<const VkDeviceGeneratedCommandsFeaturesNVX*>(this);
12920 }
12921
12923 {
12924 return *reinterpret_cast<VkDeviceGeneratedCommandsFeaturesNVX*>(this);
12925 }
12926
12928 {
12929 return ( sType == rhs.sType )
12930 && ( pNext == rhs.pNext )
12932 }
12933
12935 {
12936 return !operator==( rhs );
12937 }
12938
12939 private:
12941
12942 public:
12943 const void* pNext = nullptr;
12945 };
12946 static_assert( sizeof( DeviceGeneratedCommandsFeaturesNVX ) == sizeof( VkDeviceGeneratedCommandsFeaturesNVX ), "struct and wrapper have different size!" );
12947
12949 {
12950 DeviceGeneratedCommandsLimitsNVX( uint32_t maxIndirectCommandsLayoutTokenCount_ = 0,
12951 uint32_t maxObjectEntryCounts_ = 0,
12952 uint32_t minSequenceCountBufferOffsetAlignment_ = 0,
12953 uint32_t minSequenceIndexBufferOffsetAlignment_ = 0,
12954 uint32_t minCommandsTokenBufferOffsetAlignment_ = 0 )
12955 : maxIndirectCommandsLayoutTokenCount( maxIndirectCommandsLayoutTokenCount_ )
12956 , maxObjectEntryCounts( maxObjectEntryCounts_ )
12957 , minSequenceCountBufferOffsetAlignment( minSequenceCountBufferOffsetAlignment_ )
12958 , minSequenceIndexBufferOffsetAlignment( minSequenceIndexBufferOffsetAlignment_ )
12959 , minCommandsTokenBufferOffsetAlignment( minCommandsTokenBufferOffsetAlignment_ )
12960 {
12961 }
12962
12964 {
12965 memcpy( this, &rhs, sizeof( DeviceGeneratedCommandsLimitsNVX ) );
12966 }
12967
12969 {
12970 memcpy( this, &rhs, sizeof( DeviceGeneratedCommandsLimitsNVX ) );
12971 return *this;
12972 }
12974 {
12975 pNext = pNext_;
12976 return *this;
12977 }
12978
12980 {
12981 maxIndirectCommandsLayoutTokenCount = maxIndirectCommandsLayoutTokenCount_;
12982 return *this;
12983 }
12984
12986 {
12987 maxObjectEntryCounts = maxObjectEntryCounts_;
12988 return *this;
12989 }
12990
12992 {
12993 minSequenceCountBufferOffsetAlignment = minSequenceCountBufferOffsetAlignment_;
12994 return *this;
12995 }
12996
12998 {
12999 minSequenceIndexBufferOffsetAlignment = minSequenceIndexBufferOffsetAlignment_;
13000 return *this;
13001 }
13002
13004 {
13005 minCommandsTokenBufferOffsetAlignment = minCommandsTokenBufferOffsetAlignment_;
13006 return *this;
13007 }
13008
13010 {
13011 return *reinterpret_cast<const VkDeviceGeneratedCommandsLimitsNVX*>(this);
13012 }
13013
13015 {
13016 return *reinterpret_cast<VkDeviceGeneratedCommandsLimitsNVX*>(this);
13017 }
13018
13020 {
13021 return ( sType == rhs.sType )
13022 && ( pNext == rhs.pNext )
13028 }
13029
13031 {
13032 return !operator==( rhs );
13033 }
13034
13035 private:
13037
13038 public:
13039 const void* pNext = nullptr;
13045 };
13046 static_assert( sizeof( DeviceGeneratedCommandsLimitsNVX ) == sizeof( VkDeviceGeneratedCommandsLimitsNVX ), "struct and wrapper have different size!" );
13047
13049 {
13051 IndirectCommandsLayoutNVX indirectCommandsLayout_ = IndirectCommandsLayoutNVX(),
13052 uint32_t maxSequencesCount_ = 0 )
13053 : objectTable( objectTable_ )
13054 , indirectCommandsLayout( indirectCommandsLayout_ )
13055 , maxSequencesCount( maxSequencesCount_ )
13056 {
13057 }
13058
13060 {
13061 memcpy( this, &rhs, sizeof( CmdReserveSpaceForCommandsInfoNVX ) );
13062 }
13063
13065 {
13066 memcpy( this, &rhs, sizeof( CmdReserveSpaceForCommandsInfoNVX ) );
13067 return *this;
13068 }
13070 {
13071 pNext = pNext_;
13072 return *this;
13073 }
13074
13076 {
13077 objectTable = objectTable_;
13078 return *this;
13079 }
13080
13082 {
13083 indirectCommandsLayout = indirectCommandsLayout_;
13084 return *this;
13085 }
13086
13088 {
13089 maxSequencesCount = maxSequencesCount_;
13090 return *this;
13091 }
13092
13094 {
13095 return *reinterpret_cast<const VkCmdReserveSpaceForCommandsInfoNVX*>(this);
13096 }
13097
13099 {
13100 return *reinterpret_cast<VkCmdReserveSpaceForCommandsInfoNVX*>(this);
13101 }
13102
13104 {
13105 return ( sType == rhs.sType )
13106 && ( pNext == rhs.pNext )
13107 && ( objectTable == rhs.objectTable )
13110 }
13111
13113 {
13114 return !operator==( rhs );
13115 }
13116
13117 private:
13119
13120 public:
13121 const void* pNext = nullptr;
13125 };
13126 static_assert( sizeof( CmdReserveSpaceForCommandsInfoNVX ) == sizeof( VkCmdReserveSpaceForCommandsInfoNVX ), "struct and wrapper have different size!" );
13127
13129 {
13131 : features( features_ )
13132 {
13133 }
13134
13136 {
13137 memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures2 ) );
13138 }
13139
13141 {
13142 memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures2 ) );
13143 return *this;
13144 }
13146 {
13147 pNext = pNext_;
13148 return *this;
13149 }
13150
13152 {
13153 features = features_;
13154 return *this;
13155 }
13156
13157 operator VkPhysicalDeviceFeatures2 const&() const
13158 {
13159 return *reinterpret_cast<const VkPhysicalDeviceFeatures2*>(this);
13160 }
13161
13163 {
13164 return *reinterpret_cast<VkPhysicalDeviceFeatures2*>(this);
13165 }
13166
13167 bool operator==( PhysicalDeviceFeatures2 const& rhs ) const
13168 {
13169 return ( sType == rhs.sType )
13170 && ( pNext == rhs.pNext )
13171 && ( features == rhs.features );
13172 }
13173
13174 bool operator!=( PhysicalDeviceFeatures2 const& rhs ) const
13175 {
13176 return !operator==( rhs );
13177 }
13178
13179 private:
13181
13182 public:
13183 void* pNext = nullptr;
13185 };
13186 static_assert( sizeof( PhysicalDeviceFeatures2 ) == sizeof( VkPhysicalDeviceFeatures2 ), "struct and wrapper have different size!" );
13187
13189
13191 {
13193 : maxPushDescriptors( maxPushDescriptors_ )
13194 {
13195 }
13196
13198 {
13199 memcpy( this, &rhs, sizeof( PhysicalDevicePushDescriptorPropertiesKHR ) );
13200 }
13201
13203 {
13204 memcpy( this, &rhs, sizeof( PhysicalDevicePushDescriptorPropertiesKHR ) );
13205 return *this;
13206 }
13208 {
13209 pNext = pNext_;
13210 return *this;
13211 }
13212
13214 {
13215 maxPushDescriptors = maxPushDescriptors_;
13216 return *this;
13217 }
13218
13220 {
13221 return *reinterpret_cast<const VkPhysicalDevicePushDescriptorPropertiesKHR*>(this);
13222 }
13223
13225 {
13226 return *reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR*>(this);
13227 }
13228
13230 {
13231 return ( sType == rhs.sType )
13232 && ( pNext == rhs.pNext )
13234 }
13235
13237 {
13238 return !operator==( rhs );
13239 }
13240
13241 private:
13243
13244 public:
13245 void* pNext = nullptr;
13247 };
13248 static_assert( sizeof( PhysicalDevicePushDescriptorPropertiesKHR ) == sizeof( VkPhysicalDevicePushDescriptorPropertiesKHR ), "struct and wrapper have different size!" );
13249
13251 {
13252 PresentRegionsKHR( uint32_t swapchainCount_ = 0,
13253 const PresentRegionKHR* pRegions_ = nullptr )
13254 : swapchainCount( swapchainCount_ )
13255 , pRegions( pRegions_ )
13256 {
13257 }
13258
13260 {
13261 memcpy( this, &rhs, sizeof( PresentRegionsKHR ) );
13262 }
13263
13265 {
13266 memcpy( this, &rhs, sizeof( PresentRegionsKHR ) );
13267 return *this;
13268 }
13269 PresentRegionsKHR& setPNext( const void* pNext_ )
13270 {
13271 pNext = pNext_;
13272 return *this;
13273 }
13274
13276 {
13277 swapchainCount = swapchainCount_;
13278 return *this;
13279 }
13280
13282 {
13283 pRegions = pRegions_;
13284 return *this;
13285 }
13286
13287 operator VkPresentRegionsKHR const&() const
13288 {
13289 return *reinterpret_cast<const VkPresentRegionsKHR*>(this);
13290 }
13291
13293 {
13294 return *reinterpret_cast<VkPresentRegionsKHR*>(this);
13295 }
13296
13297 bool operator==( PresentRegionsKHR const& rhs ) const
13298 {
13299 return ( sType == rhs.sType )
13300 && ( pNext == rhs.pNext )
13301 && ( swapchainCount == rhs.swapchainCount )
13302 && ( pRegions == rhs.pRegions );
13303 }
13304
13305 bool operator!=( PresentRegionsKHR const& rhs ) const
13306 {
13307 return !operator==( rhs );
13308 }
13309
13310 private:
13312
13313 public:
13314 const void* pNext = nullptr;
13317 };
13318 static_assert( sizeof( PresentRegionsKHR ) == sizeof( VkPresentRegionsKHR ), "struct and wrapper have different size!" );
13319
13321 {
13322 PhysicalDeviceVariablePointerFeatures( Bool32 variablePointersStorageBuffer_ = 0,
13323 Bool32 variablePointers_ = 0 )
13324 : variablePointersStorageBuffer( variablePointersStorageBuffer_ )
13325 , variablePointers( variablePointers_ )
13326 {
13327 }
13328
13330 {
13331 memcpy( this, &rhs, sizeof( PhysicalDeviceVariablePointerFeatures ) );
13332 }
13333
13335 {
13336 memcpy( this, &rhs, sizeof( PhysicalDeviceVariablePointerFeatures ) );
13337 return *this;
13338 }
13340 {
13341 pNext = pNext_;
13342 return *this;
13343 }
13344
13346 {
13347 variablePointersStorageBuffer = variablePointersStorageBuffer_;
13348 return *this;
13349 }
13350
13352 {
13353 variablePointers = variablePointers_;
13354 return *this;
13355 }
13356
13358 {
13359 return *reinterpret_cast<const VkPhysicalDeviceVariablePointerFeatures*>(this);
13360 }
13361
13363 {
13364 return *reinterpret_cast<VkPhysicalDeviceVariablePointerFeatures*>(this);
13365 }
13366
13368 {
13369 return ( sType == rhs.sType )
13370 && ( pNext == rhs.pNext )
13372 && ( variablePointers == rhs.variablePointers );
13373 }
13374
13376 {
13377 return !operator==( rhs );
13378 }
13379
13380 private:
13382
13383 public:
13384 void* pNext = nullptr;
13387 };
13388 static_assert( sizeof( PhysicalDeviceVariablePointerFeatures ) == sizeof( VkPhysicalDeviceVariablePointerFeatures ), "struct and wrapper have different size!" );
13389
13391
13393 {
13394 operator VkPhysicalDeviceIDProperties const&() const
13395 {
13396 return *reinterpret_cast<const VkPhysicalDeviceIDProperties*>(this);
13397 }
13398
13400 {
13401 return *reinterpret_cast<VkPhysicalDeviceIDProperties*>(this);
13402 }
13403
13405 {
13406 return ( sType == rhs.sType )
13407 && ( pNext == rhs.pNext )
13408 && ( memcmp( deviceUUID, rhs.deviceUUID, VK_UUID_SIZE * sizeof( uint8_t ) ) == 0 )
13409 && ( memcmp( driverUUID, rhs.driverUUID, VK_UUID_SIZE * sizeof( uint8_t ) ) == 0 )
13410 && ( memcmp( deviceLUID, rhs.deviceLUID, VK_LUID_SIZE * sizeof( uint8_t ) ) == 0 )
13411 && ( deviceNodeMask == rhs.deviceNodeMask )
13412 && ( deviceLUIDValid == rhs.deviceLUIDValid );
13413 }
13414
13416 {
13417 return !operator==( rhs );
13418 }
13419
13420 private:
13422
13423 public:
13424 void* pNext = nullptr;
13430 };
13431 static_assert( sizeof( PhysicalDeviceIDProperties ) == sizeof( VkPhysicalDeviceIDProperties ), "struct and wrapper have different size!" );
13432
13434
13435#ifdef VK_USE_PLATFORM_WIN32_KHR
13436 struct ExportMemoryWin32HandleInfoKHR
13437 {
13438 ExportMemoryWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr,
13439 DWORD dwAccess_ = 0,
13440 LPCWSTR name_ = 0 )
13441 : pAttributes( pAttributes_ )
13442 , dwAccess( dwAccess_ )
13443 , name( name_ )
13444 {
13445 }
13446
13447 ExportMemoryWin32HandleInfoKHR( VkExportMemoryWin32HandleInfoKHR const & rhs )
13448 {
13449 memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoKHR ) );
13450 }
13451
13452 ExportMemoryWin32HandleInfoKHR& operator=( VkExportMemoryWin32HandleInfoKHR const & rhs )
13453 {
13454 memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoKHR ) );
13455 return *this;
13456 }
13457 ExportMemoryWin32HandleInfoKHR& setPNext( const void* pNext_ )
13458 {
13459 pNext = pNext_;
13460 return *this;
13461 }
13462
13463 ExportMemoryWin32HandleInfoKHR& setPAttributes( const SECURITY_ATTRIBUTES* pAttributes_ )
13464 {
13465 pAttributes = pAttributes_;
13466 return *this;
13467 }
13468
13469 ExportMemoryWin32HandleInfoKHR& setDwAccess( DWORD dwAccess_ )
13470 {
13471 dwAccess = dwAccess_;
13472 return *this;
13473 }
13474
13475 ExportMemoryWin32HandleInfoKHR& setName( LPCWSTR name_ )
13476 {
13477 name = name_;
13478 return *this;
13479 }
13480
13481 operator VkExportMemoryWin32HandleInfoKHR const&() const
13482 {
13483 return *reinterpret_cast<const VkExportMemoryWin32HandleInfoKHR*>(this);
13484 }
13485
13487 {
13488 return *reinterpret_cast<VkExportMemoryWin32HandleInfoKHR*>(this);
13489 }
13490
13491 bool operator==( ExportMemoryWin32HandleInfoKHR const& rhs ) const
13492 {
13493 return ( sType == rhs.sType )
13494 && ( pNext == rhs.pNext )
13495 && ( pAttributes == rhs.pAttributes )
13496 && ( dwAccess == rhs.dwAccess )
13497 && ( name == rhs.name );
13498 }
13499
13500 bool operator!=( ExportMemoryWin32HandleInfoKHR const& rhs ) const
13501 {
13502 return !operator==( rhs );
13503 }
13504
13505 private:
13507
13508 public:
13509 const void* pNext = nullptr;
13510 const SECURITY_ATTRIBUTES* pAttributes;
13511 DWORD dwAccess;
13512 LPCWSTR name;
13513 };
13514 static_assert( sizeof( ExportMemoryWin32HandleInfoKHR ) == sizeof( VkExportMemoryWin32HandleInfoKHR ), "struct and wrapper have different size!" );
13515#endif /*VK_USE_PLATFORM_WIN32_KHR*/
13516
13517#ifdef VK_USE_PLATFORM_WIN32_KHR
13518 struct MemoryWin32HandlePropertiesKHR
13519 {
13520 operator VkMemoryWin32HandlePropertiesKHR const&() const
13521 {
13522 return *reinterpret_cast<const VkMemoryWin32HandlePropertiesKHR*>(this);
13523 }
13524
13526 {
13527 return *reinterpret_cast<VkMemoryWin32HandlePropertiesKHR*>(this);
13528 }
13529
13530 bool operator==( MemoryWin32HandlePropertiesKHR const& rhs ) const
13531 {
13532 return ( sType == rhs.sType )
13533 && ( pNext == rhs.pNext )
13534 && ( memoryTypeBits == rhs.memoryTypeBits );
13535 }
13536
13537 bool operator!=( MemoryWin32HandlePropertiesKHR const& rhs ) const
13538 {
13539 return !operator==( rhs );
13540 }
13541
13542 private:
13544
13545 public:
13546 void* pNext = nullptr;
13547 uint32_t memoryTypeBits;
13548 };
13549 static_assert( sizeof( MemoryWin32HandlePropertiesKHR ) == sizeof( VkMemoryWin32HandlePropertiesKHR ), "struct and wrapper have different size!" );
13550#endif /*VK_USE_PLATFORM_WIN32_KHR*/
13551
13553 {
13554 operator VkMemoryFdPropertiesKHR const&() const
13555 {
13556 return *reinterpret_cast<const VkMemoryFdPropertiesKHR*>(this);
13557 }
13558
13560 {
13561 return *reinterpret_cast<VkMemoryFdPropertiesKHR*>(this);
13562 }
13563
13564 bool operator==( MemoryFdPropertiesKHR const& rhs ) const
13565 {
13566 return ( sType == rhs.sType )
13567 && ( pNext == rhs.pNext )
13568 && ( memoryTypeBits == rhs.memoryTypeBits );
13569 }
13570
13571 bool operator!=( MemoryFdPropertiesKHR const& rhs ) const
13572 {
13573 return !operator==( rhs );
13574 }
13575
13576 private:
13578
13579 public:
13580 void* pNext = nullptr;
13582 };
13583 static_assert( sizeof( MemoryFdPropertiesKHR ) == sizeof( VkMemoryFdPropertiesKHR ), "struct and wrapper have different size!" );
13584
13585#ifdef VK_USE_PLATFORM_WIN32_KHR
13586 struct Win32KeyedMutexAcquireReleaseInfoKHR
13587 {
13588 Win32KeyedMutexAcquireReleaseInfoKHR( uint32_t acquireCount_ = 0,
13589 const DeviceMemory* pAcquireSyncs_ = nullptr,
13590 const uint64_t* pAcquireKeys_ = nullptr,
13591 const uint32_t* pAcquireTimeouts_ = nullptr,
13592 uint32_t releaseCount_ = 0,
13593 const DeviceMemory* pReleaseSyncs_ = nullptr,
13594 const uint64_t* pReleaseKeys_ = nullptr )
13595 : acquireCount( acquireCount_ )
13596 , pAcquireSyncs( pAcquireSyncs_ )
13597 , pAcquireKeys( pAcquireKeys_ )
13598 , pAcquireTimeouts( pAcquireTimeouts_ )
13599 , releaseCount( releaseCount_ )
13600 , pReleaseSyncs( pReleaseSyncs_ )
13601 , pReleaseKeys( pReleaseKeys_ )
13602 {
13603 }
13604
13605 Win32KeyedMutexAcquireReleaseInfoKHR( VkWin32KeyedMutexAcquireReleaseInfoKHR const & rhs )
13606 {
13607 memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoKHR ) );
13608 }
13609
13610 Win32KeyedMutexAcquireReleaseInfoKHR& operator=( VkWin32KeyedMutexAcquireReleaseInfoKHR const & rhs )
13611 {
13612 memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoKHR ) );
13613 return *this;
13614 }
13615 Win32KeyedMutexAcquireReleaseInfoKHR& setPNext( const void* pNext_ )
13616 {
13617 pNext = pNext_;
13618 return *this;
13619 }
13620
13621 Win32KeyedMutexAcquireReleaseInfoKHR& setAcquireCount( uint32_t acquireCount_ )
13622 {
13623 acquireCount = acquireCount_;
13624 return *this;
13625 }
13626
13627 Win32KeyedMutexAcquireReleaseInfoKHR& setPAcquireSyncs( const DeviceMemory* pAcquireSyncs_ )
13628 {
13629 pAcquireSyncs = pAcquireSyncs_;
13630 return *this;
13631 }
13632
13633 Win32KeyedMutexAcquireReleaseInfoKHR& setPAcquireKeys( const uint64_t* pAcquireKeys_ )
13634 {
13635 pAcquireKeys = pAcquireKeys_;
13636 return *this;
13637 }
13638
13639 Win32KeyedMutexAcquireReleaseInfoKHR& setPAcquireTimeouts( const uint32_t* pAcquireTimeouts_ )
13640 {
13641 pAcquireTimeouts = pAcquireTimeouts_;
13642 return *this;
13643 }
13644
13645 Win32KeyedMutexAcquireReleaseInfoKHR& setReleaseCount( uint32_t releaseCount_ )
13646 {
13647 releaseCount = releaseCount_;
13648 return *this;
13649 }
13650
13651 Win32KeyedMutexAcquireReleaseInfoKHR& setPReleaseSyncs( const DeviceMemory* pReleaseSyncs_ )
13652 {
13653 pReleaseSyncs = pReleaseSyncs_;
13654 return *this;
13655 }
13656
13657 Win32KeyedMutexAcquireReleaseInfoKHR& setPReleaseKeys( const uint64_t* pReleaseKeys_ )
13658 {
13659 pReleaseKeys = pReleaseKeys_;
13660 return *this;
13661 }
13662
13663 operator VkWin32KeyedMutexAcquireReleaseInfoKHR const&() const
13664 {
13665 return *reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoKHR*>(this);
13666 }
13667
13669 {
13670 return *reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR*>(this);
13671 }
13672
13673 bool operator==( Win32KeyedMutexAcquireReleaseInfoKHR const& rhs ) const
13674 {
13675 return ( sType == rhs.sType )
13676 && ( pNext == rhs.pNext )
13677 && ( acquireCount == rhs.acquireCount )
13678 && ( pAcquireSyncs == rhs.pAcquireSyncs )
13679 && ( pAcquireKeys == rhs.pAcquireKeys )
13680 && ( pAcquireTimeouts == rhs.pAcquireTimeouts )
13681 && ( releaseCount == rhs.releaseCount )
13682 && ( pReleaseSyncs == rhs.pReleaseSyncs )
13683 && ( pReleaseKeys == rhs.pReleaseKeys );
13684 }
13685
13686 bool operator!=( Win32KeyedMutexAcquireReleaseInfoKHR const& rhs ) const
13687 {
13688 return !operator==( rhs );
13689 }
13690
13691 private:
13693
13694 public:
13695 const void* pNext = nullptr;
13696 uint32_t acquireCount;
13697 const DeviceMemory* pAcquireSyncs;
13698 const uint64_t* pAcquireKeys;
13699 const uint32_t* pAcquireTimeouts;
13700 uint32_t releaseCount;
13701 const DeviceMemory* pReleaseSyncs;
13702 const uint64_t* pReleaseKeys;
13703 };
13704 static_assert( sizeof( Win32KeyedMutexAcquireReleaseInfoKHR ) == sizeof( VkWin32KeyedMutexAcquireReleaseInfoKHR ), "struct and wrapper have different size!" );
13705#endif /*VK_USE_PLATFORM_WIN32_KHR*/
13706
13707#ifdef VK_USE_PLATFORM_WIN32_KHR
13708 struct ExportSemaphoreWin32HandleInfoKHR
13709 {
13710 ExportSemaphoreWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr,
13711 DWORD dwAccess_ = 0,
13712 LPCWSTR name_ = 0 )
13713 : pAttributes( pAttributes_ )
13714 , dwAccess( dwAccess_ )
13715 , name( name_ )
13716 {
13717 }
13718
13719 ExportSemaphoreWin32HandleInfoKHR( VkExportSemaphoreWin32HandleInfoKHR const & rhs )
13720 {
13721 memcpy( this, &rhs, sizeof( ExportSemaphoreWin32HandleInfoKHR ) );
13722 }
13723
13724 ExportSemaphoreWin32HandleInfoKHR& operator=( VkExportSemaphoreWin32HandleInfoKHR const & rhs )
13725 {
13726 memcpy( this, &rhs, sizeof( ExportSemaphoreWin32HandleInfoKHR ) );
13727 return *this;
13728 }
13729 ExportSemaphoreWin32HandleInfoKHR& setPNext( const void* pNext_ )
13730 {
13731 pNext = pNext_;
13732 return *this;
13733 }
13734
13735 ExportSemaphoreWin32HandleInfoKHR& setPAttributes( const SECURITY_ATTRIBUTES* pAttributes_ )
13736 {
13737 pAttributes = pAttributes_;
13738 return *this;
13739 }
13740
13741 ExportSemaphoreWin32HandleInfoKHR& setDwAccess( DWORD dwAccess_ )
13742 {
13743 dwAccess = dwAccess_;
13744 return *this;
13745 }
13746
13747 ExportSemaphoreWin32HandleInfoKHR& setName( LPCWSTR name_ )
13748 {
13749 name = name_;
13750 return *this;
13751 }
13752
13753 operator VkExportSemaphoreWin32HandleInfoKHR const&() const
13754 {
13755 return *reinterpret_cast<const VkExportSemaphoreWin32HandleInfoKHR*>(this);
13756 }
13757
13759 {
13760 return *reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR*>(this);
13761 }
13762
13763 bool operator==( ExportSemaphoreWin32HandleInfoKHR const& rhs ) const
13764 {
13765 return ( sType == rhs.sType )
13766 && ( pNext == rhs.pNext )
13767 && ( pAttributes == rhs.pAttributes )
13768 && ( dwAccess == rhs.dwAccess )
13769 && ( name == rhs.name );
13770 }
13771
13772 bool operator!=( ExportSemaphoreWin32HandleInfoKHR const& rhs ) const
13773 {
13774 return !operator==( rhs );
13775 }
13776
13777 private:
13779
13780 public:
13781 const void* pNext = nullptr;
13782 const SECURITY_ATTRIBUTES* pAttributes;
13783 DWORD dwAccess;
13784 LPCWSTR name;
13785 };
13786 static_assert( sizeof( ExportSemaphoreWin32HandleInfoKHR ) == sizeof( VkExportSemaphoreWin32HandleInfoKHR ), "struct and wrapper have different size!" );
13787#endif /*VK_USE_PLATFORM_WIN32_KHR*/
13788
13789#ifdef VK_USE_PLATFORM_WIN32_KHR
13790 struct D3D12FenceSubmitInfoKHR
13791 {
13792 D3D12FenceSubmitInfoKHR( uint32_t waitSemaphoreValuesCount_ = 0,
13793 const uint64_t* pWaitSemaphoreValues_ = nullptr,
13794 uint32_t signalSemaphoreValuesCount_ = 0,
13795 const uint64_t* pSignalSemaphoreValues_ = nullptr )
13796 : waitSemaphoreValuesCount( waitSemaphoreValuesCount_ )
13797 , pWaitSemaphoreValues( pWaitSemaphoreValues_ )
13798 , signalSemaphoreValuesCount( signalSemaphoreValuesCount_ )
13799 , pSignalSemaphoreValues( pSignalSemaphoreValues_ )
13800 {
13801 }
13802
13803 D3D12FenceSubmitInfoKHR( VkD3D12FenceSubmitInfoKHR const & rhs )
13804 {
13805 memcpy( this, &rhs, sizeof( D3D12FenceSubmitInfoKHR ) );
13806 }
13807
13808 D3D12FenceSubmitInfoKHR& operator=( VkD3D12FenceSubmitInfoKHR const & rhs )
13809 {
13810 memcpy( this, &rhs, sizeof( D3D12FenceSubmitInfoKHR ) );
13811 return *this;
13812 }
13813 D3D12FenceSubmitInfoKHR& setPNext( const void* pNext_ )
13814 {
13815 pNext = pNext_;
13816 return *this;
13817 }
13818
13819 D3D12FenceSubmitInfoKHR& setWaitSemaphoreValuesCount( uint32_t waitSemaphoreValuesCount_ )
13820 {
13821 waitSemaphoreValuesCount = waitSemaphoreValuesCount_;
13822 return *this;
13823 }
13824
13825 D3D12FenceSubmitInfoKHR& setPWaitSemaphoreValues( const uint64_t* pWaitSemaphoreValues_ )
13826 {
13827 pWaitSemaphoreValues = pWaitSemaphoreValues_;
13828 return *this;
13829 }
13830
13831 D3D12FenceSubmitInfoKHR& setSignalSemaphoreValuesCount( uint32_t signalSemaphoreValuesCount_ )
13832 {
13833 signalSemaphoreValuesCount = signalSemaphoreValuesCount_;
13834 return *this;
13835 }
13836
13837 D3D12FenceSubmitInfoKHR& setPSignalSemaphoreValues( const uint64_t* pSignalSemaphoreValues_ )
13838 {
13839 pSignalSemaphoreValues = pSignalSemaphoreValues_;
13840 return *this;
13841 }
13842
13843 operator VkD3D12FenceSubmitInfoKHR const&() const
13844 {
13845 return *reinterpret_cast<const VkD3D12FenceSubmitInfoKHR*>(this);
13846 }
13847
13848 operator VkD3D12FenceSubmitInfoKHR &()
13849 {
13850 return *reinterpret_cast<VkD3D12FenceSubmitInfoKHR*>(this);
13851 }
13852
13853 bool operator==( D3D12FenceSubmitInfoKHR const& rhs ) const
13854 {
13855 return ( sType == rhs.sType )
13856 && ( pNext == rhs.pNext )
13857 && ( waitSemaphoreValuesCount == rhs.waitSemaphoreValuesCount )
13858 && ( pWaitSemaphoreValues == rhs.pWaitSemaphoreValues )
13859 && ( signalSemaphoreValuesCount == rhs.signalSemaphoreValuesCount )
13860 && ( pSignalSemaphoreValues == rhs.pSignalSemaphoreValues );
13861 }
13862
13863 bool operator!=( D3D12FenceSubmitInfoKHR const& rhs ) const
13864 {
13865 return !operator==( rhs );
13866 }
13867
13868 private:
13870
13871 public:
13872 const void* pNext = nullptr;
13873 uint32_t waitSemaphoreValuesCount;
13874 const uint64_t* pWaitSemaphoreValues;
13875 uint32_t signalSemaphoreValuesCount;
13876 const uint64_t* pSignalSemaphoreValues;
13877 };
13878 static_assert( sizeof( D3D12FenceSubmitInfoKHR ) == sizeof( VkD3D12FenceSubmitInfoKHR ), "struct and wrapper have different size!" );
13879#endif /*VK_USE_PLATFORM_WIN32_KHR*/
13880
13881#ifdef VK_USE_PLATFORM_WIN32_KHR
13882 struct ExportFenceWin32HandleInfoKHR
13883 {
13884 ExportFenceWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr,
13885 DWORD dwAccess_ = 0,
13886 LPCWSTR name_ = 0 )
13887 : pAttributes( pAttributes_ )
13888 , dwAccess( dwAccess_ )
13889 , name( name_ )
13890 {
13891 }
13892
13893 ExportFenceWin32HandleInfoKHR( VkExportFenceWin32HandleInfoKHR const & rhs )
13894 {
13895 memcpy( this, &rhs, sizeof( ExportFenceWin32HandleInfoKHR ) );
13896 }
13897
13898 ExportFenceWin32HandleInfoKHR& operator=( VkExportFenceWin32HandleInfoKHR const & rhs )
13899 {
13900 memcpy( this, &rhs, sizeof( ExportFenceWin32HandleInfoKHR ) );
13901 return *this;
13902 }
13903 ExportFenceWin32HandleInfoKHR& setPNext( const void* pNext_ )
13904 {
13905 pNext = pNext_;
13906 return *this;
13907 }
13908
13909 ExportFenceWin32HandleInfoKHR& setPAttributes( const SECURITY_ATTRIBUTES* pAttributes_ )
13910 {
13911 pAttributes = pAttributes_;
13912 return *this;
13913 }
13914
13915 ExportFenceWin32HandleInfoKHR& setDwAccess( DWORD dwAccess_ )
13916 {
13917 dwAccess = dwAccess_;
13918 return *this;
13919 }
13920
13921 ExportFenceWin32HandleInfoKHR& setName( LPCWSTR name_ )
13922 {
13923 name = name_;
13924 return *this;
13925 }
13926
13927 operator VkExportFenceWin32HandleInfoKHR const&() const
13928 {
13929 return *reinterpret_cast<const VkExportFenceWin32HandleInfoKHR*>(this);
13930 }
13931
13933 {
13934 return *reinterpret_cast<VkExportFenceWin32HandleInfoKHR*>(this);
13935 }
13936
13937 bool operator==( ExportFenceWin32HandleInfoKHR const& rhs ) const
13938 {
13939 return ( sType == rhs.sType )
13940 && ( pNext == rhs.pNext )
13941 && ( pAttributes == rhs.pAttributes )
13942 && ( dwAccess == rhs.dwAccess )
13943 && ( name == rhs.name );
13944 }
13945
13946 bool operator!=( ExportFenceWin32HandleInfoKHR const& rhs ) const
13947 {
13948 return !operator==( rhs );
13949 }
13950
13951 private:
13953
13954 public:
13955 const void* pNext = nullptr;
13956 const SECURITY_ATTRIBUTES* pAttributes;
13957 DWORD dwAccess;
13958 LPCWSTR name;
13959 };
13960 static_assert( sizeof( ExportFenceWin32HandleInfoKHR ) == sizeof( VkExportFenceWin32HandleInfoKHR ), "struct and wrapper have different size!" );
13961#endif /*VK_USE_PLATFORM_WIN32_KHR*/
13962
13964 {
13966 Bool32 multiviewGeometryShader_ = 0,
13967 Bool32 multiviewTessellationShader_ = 0 )
13968 : multiview( multiview_ )
13969 , multiviewGeometryShader( multiviewGeometryShader_ )
13970 , multiviewTessellationShader( multiviewTessellationShader_ )
13971 {
13972 }
13973
13975 {
13976 memcpy( this, &rhs, sizeof( PhysicalDeviceMultiviewFeatures ) );
13977 }
13978
13980 {
13981 memcpy( this, &rhs, sizeof( PhysicalDeviceMultiviewFeatures ) );
13982 return *this;
13983 }
13985 {
13986 pNext = pNext_;
13987 return *this;
13988 }
13989
13991 {
13992 multiview = multiview_;
13993 return *this;
13994 }
13995
13997 {
13998 multiviewGeometryShader = multiviewGeometryShader_;
13999 return *this;
14000 }
14001
14003 {
14004 multiviewTessellationShader = multiviewTessellationShader_;
14005 return *this;
14006 }
14007
14009 {
14010 return *reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures*>(this);
14011 }
14012
14014 {
14015 return *reinterpret_cast<VkPhysicalDeviceMultiviewFeatures*>(this);
14016 }
14017
14019 {
14020 return ( sType == rhs.sType )
14021 && ( pNext == rhs.pNext )
14022 && ( multiview == rhs.multiview )
14025 }
14026
14028 {
14029 return !operator==( rhs );
14030 }
14031
14032 private:
14034
14035 public:
14036 void* pNext = nullptr;
14040 };
14041 static_assert( sizeof( PhysicalDeviceMultiviewFeatures ) == sizeof( VkPhysicalDeviceMultiviewFeatures ), "struct and wrapper have different size!" );
14042
14044
14046 {
14048 {
14049 return *reinterpret_cast<const VkPhysicalDeviceMultiviewProperties*>(this);
14050 }
14051
14053 {
14054 return *reinterpret_cast<VkPhysicalDeviceMultiviewProperties*>(this);
14055 }
14056
14058 {
14059 return ( sType == rhs.sType )
14060 && ( pNext == rhs.pNext )
14063 }
14064
14066 {
14067 return !operator==( rhs );
14068 }
14069
14070 private:
14072
14073 public:
14074 void* pNext = nullptr;
14077 };
14078 static_assert( sizeof( PhysicalDeviceMultiviewProperties ) == sizeof( VkPhysicalDeviceMultiviewProperties ), "struct and wrapper have different size!" );
14079
14081
14083 {
14085 const uint32_t* pViewMasks_ = nullptr,
14086 uint32_t dependencyCount_ = 0,
14087 const int32_t* pViewOffsets_ = nullptr,
14088 uint32_t correlationMaskCount_ = 0,
14089 const uint32_t* pCorrelationMasks_ = nullptr )
14090 : subpassCount( subpassCount_ )
14091 , pViewMasks( pViewMasks_ )
14092 , dependencyCount( dependencyCount_ )
14093 , pViewOffsets( pViewOffsets_ )
14094 , correlationMaskCount( correlationMaskCount_ )
14095 , pCorrelationMasks( pCorrelationMasks_ )
14096 {
14097 }
14098
14100 {
14101 memcpy( this, &rhs, sizeof( RenderPassMultiviewCreateInfo ) );
14102 }
14103
14105 {
14106 memcpy( this, &rhs, sizeof( RenderPassMultiviewCreateInfo ) );
14107 return *this;
14108 }
14110 {
14111 pNext = pNext_;
14112 return *this;
14113 }
14114
14116 {
14117 subpassCount = subpassCount_;
14118 return *this;
14119 }
14120
14122 {
14123 pViewMasks = pViewMasks_;
14124 return *this;
14125 }
14126
14128 {
14129 dependencyCount = dependencyCount_;
14130 return *this;
14131 }
14132
14134 {
14135 pViewOffsets = pViewOffsets_;
14136 return *this;
14137 }
14138
14140 {
14141 correlationMaskCount = correlationMaskCount_;
14142 return *this;
14143 }
14144
14146 {
14147 pCorrelationMasks = pCorrelationMasks_;
14148 return *this;
14149 }
14150
14151 operator VkRenderPassMultiviewCreateInfo const&() const
14152 {
14153 return *reinterpret_cast<const VkRenderPassMultiviewCreateInfo*>(this);
14154 }
14155
14157 {
14158 return *reinterpret_cast<VkRenderPassMultiviewCreateInfo*>(this);
14159 }
14160
14162 {
14163 return ( sType == rhs.sType )
14164 && ( pNext == rhs.pNext )
14165 && ( subpassCount == rhs.subpassCount )
14166 && ( pViewMasks == rhs.pViewMasks )
14167 && ( dependencyCount == rhs.dependencyCount )
14168 && ( pViewOffsets == rhs.pViewOffsets )
14171 }
14172
14174 {
14175 return !operator==( rhs );
14176 }
14177
14178 private:
14180
14181 public:
14182 const void* pNext = nullptr;
14189 };
14190 static_assert( sizeof( RenderPassMultiviewCreateInfo ) == sizeof( VkRenderPassMultiviewCreateInfo ), "struct and wrapper have different size!" );
14191
14193
14195 {
14197 DeviceMemory memory_ = DeviceMemory(),
14198 DeviceSize memoryOffset_ = 0 )
14199 : buffer( buffer_ )
14200 , memory( memory_ )
14201 , memoryOffset( memoryOffset_ )
14202 {
14203 }
14204
14206 {
14207 memcpy( this, &rhs, sizeof( BindBufferMemoryInfo ) );
14208 }
14209
14211 {
14212 memcpy( this, &rhs, sizeof( BindBufferMemoryInfo ) );
14213 return *this;
14214 }
14215 BindBufferMemoryInfo& setPNext( const void* pNext_ )
14216 {
14217 pNext = pNext_;
14218 return *this;
14219 }
14220
14222 {
14223 buffer = buffer_;
14224 return *this;
14225 }
14226
14228 {
14229 memory = memory_;
14230 return *this;
14231 }
14232
14234 {
14235 memoryOffset = memoryOffset_;
14236 return *this;
14237 }
14238
14239 operator VkBindBufferMemoryInfo const&() const
14240 {
14241 return *reinterpret_cast<const VkBindBufferMemoryInfo*>(this);
14242 }
14243
14245 {
14246 return *reinterpret_cast<VkBindBufferMemoryInfo*>(this);
14247 }
14248
14249 bool operator==( BindBufferMemoryInfo const& rhs ) const
14250 {
14251 return ( sType == rhs.sType )
14252 && ( pNext == rhs.pNext )
14253 && ( buffer == rhs.buffer )
14254 && ( memory == rhs.memory )
14255 && ( memoryOffset == rhs.memoryOffset );
14256 }
14257
14258 bool operator!=( BindBufferMemoryInfo const& rhs ) const
14259 {
14260 return !operator==( rhs );
14261 }
14262
14263 private:
14265
14266 public:
14267 const void* pNext = nullptr;
14271 };
14272 static_assert( sizeof( BindBufferMemoryInfo ) == sizeof( VkBindBufferMemoryInfo ), "struct and wrapper have different size!" );
14273
14275
14277 {
14279 const uint32_t* pDeviceIndices_ = nullptr )
14280 : deviceIndexCount( deviceIndexCount_ )
14281 , pDeviceIndices( pDeviceIndices_ )
14282 {
14283 }
14284
14286 {
14287 memcpy( this, &rhs, sizeof( BindBufferMemoryDeviceGroupInfo ) );
14288 }
14289
14291 {
14292 memcpy( this, &rhs, sizeof( BindBufferMemoryDeviceGroupInfo ) );
14293 return *this;
14294 }
14296 {
14297 pNext = pNext_;
14298 return *this;
14299 }
14300
14302 {
14303 deviceIndexCount = deviceIndexCount_;
14304 return *this;
14305 }
14306
14308 {
14309 pDeviceIndices = pDeviceIndices_;
14310 return *this;
14311 }
14312
14314 {
14315 return *reinterpret_cast<const VkBindBufferMemoryDeviceGroupInfo*>(this);
14316 }
14317
14319 {
14320 return *reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo*>(this);
14321 }
14322
14324 {
14325 return ( sType == rhs.sType )
14326 && ( pNext == rhs.pNext )
14328 && ( pDeviceIndices == rhs.pDeviceIndices );
14329 }
14330
14332 {
14333 return !operator==( rhs );
14334 }
14335
14336 private:
14338
14339 public:
14340 const void* pNext = nullptr;
14343 };
14344 static_assert( sizeof( BindBufferMemoryDeviceGroupInfo ) == sizeof( VkBindBufferMemoryDeviceGroupInfo ), "struct and wrapper have different size!" );
14345
14347
14349 {
14351 DeviceMemory memory_ = DeviceMemory(),
14352 DeviceSize memoryOffset_ = 0 )
14353 : image( image_ )
14354 , memory( memory_ )
14355 , memoryOffset( memoryOffset_ )
14356 {
14357 }
14358
14360 {
14361 memcpy( this, &rhs, sizeof( BindImageMemoryInfo ) );
14362 }
14363
14365 {
14366 memcpy( this, &rhs, sizeof( BindImageMemoryInfo ) );
14367 return *this;
14368 }
14369 BindImageMemoryInfo& setPNext( const void* pNext_ )
14370 {
14371 pNext = pNext_;
14372 return *this;
14373 }
14374
14376 {
14377 image = image_;
14378 return *this;
14379 }
14380
14382 {
14383 memory = memory_;
14384 return *this;
14385 }
14386
14388 {
14389 memoryOffset = memoryOffset_;
14390 return *this;
14391 }
14392
14393 operator VkBindImageMemoryInfo const&() const
14394 {
14395 return *reinterpret_cast<const VkBindImageMemoryInfo*>(this);
14396 }
14397
14399 {
14400 return *reinterpret_cast<VkBindImageMemoryInfo*>(this);
14401 }
14402
14403 bool operator==( BindImageMemoryInfo const& rhs ) const
14404 {
14405 return ( sType == rhs.sType )
14406 && ( pNext == rhs.pNext )
14407 && ( image == rhs.image )
14408 && ( memory == rhs.memory )
14409 && ( memoryOffset == rhs.memoryOffset );
14410 }
14411
14412 bool operator!=( BindImageMemoryInfo const& rhs ) const
14413 {
14414 return !operator==( rhs );
14415 }
14416
14417 private:
14419
14420 public:
14421 const void* pNext = nullptr;
14425 };
14426 static_assert( sizeof( BindImageMemoryInfo ) == sizeof( VkBindImageMemoryInfo ), "struct and wrapper have different size!" );
14427
14429
14431 {
14433 const uint32_t* pDeviceIndices_ = nullptr,
14434 uint32_t splitInstanceBindRegionCount_ = 0,
14435 const Rect2D* pSplitInstanceBindRegions_ = nullptr )
14436 : deviceIndexCount( deviceIndexCount_ )
14437 , pDeviceIndices( pDeviceIndices_ )
14438 , splitInstanceBindRegionCount( splitInstanceBindRegionCount_ )
14439 , pSplitInstanceBindRegions( pSplitInstanceBindRegions_ )
14440 {
14441 }
14442
14444 {
14445 memcpy( this, &rhs, sizeof( BindImageMemoryDeviceGroupInfo ) );
14446 }
14447
14449 {
14450 memcpy( this, &rhs, sizeof( BindImageMemoryDeviceGroupInfo ) );
14451 return *this;
14452 }
14454 {
14455 pNext = pNext_;
14456 return *this;
14457 }
14458
14460 {
14461 deviceIndexCount = deviceIndexCount_;
14462 return *this;
14463 }
14464
14466 {
14467 pDeviceIndices = pDeviceIndices_;
14468 return *this;
14469 }
14470
14472 {
14473 splitInstanceBindRegionCount = splitInstanceBindRegionCount_;
14474 return *this;
14475 }
14476
14478 {
14479 pSplitInstanceBindRegions = pSplitInstanceBindRegions_;
14480 return *this;
14481 }
14482
14483 operator VkBindImageMemoryDeviceGroupInfo const&() const
14484 {
14485 return *reinterpret_cast<const VkBindImageMemoryDeviceGroupInfo*>(this);
14486 }
14487
14489 {
14490 return *reinterpret_cast<VkBindImageMemoryDeviceGroupInfo*>(this);
14491 }
14492
14494 {
14495 return ( sType == rhs.sType )
14496 && ( pNext == rhs.pNext )
14498 && ( pDeviceIndices == rhs.pDeviceIndices )
14501 }
14502
14504 {
14505 return !operator==( rhs );
14506 }
14507
14508 private:
14510
14511 public:
14512 const void* pNext = nullptr;
14517 };
14518 static_assert( sizeof( BindImageMemoryDeviceGroupInfo ) == sizeof( VkBindImageMemoryDeviceGroupInfo ), "struct and wrapper have different size!" );
14519
14521
14523 {
14525 uint32_t deviceRenderAreaCount_ = 0,
14526 const Rect2D* pDeviceRenderAreas_ = nullptr )
14527 : deviceMask( deviceMask_ )
14528 , deviceRenderAreaCount( deviceRenderAreaCount_ )
14529 , pDeviceRenderAreas( pDeviceRenderAreas_ )
14530 {
14531 }
14532
14534 {
14535 memcpy( this, &rhs, sizeof( DeviceGroupRenderPassBeginInfo ) );
14536 }
14537
14539 {
14540 memcpy( this, &rhs, sizeof( DeviceGroupRenderPassBeginInfo ) );
14541 return *this;
14542 }
14544 {
14545 pNext = pNext_;
14546 return *this;
14547 }
14548
14550 {
14551 deviceMask = deviceMask_;
14552 return *this;
14553 }
14554
14556 {
14557 deviceRenderAreaCount = deviceRenderAreaCount_;
14558 return *this;
14559 }
14560
14562 {
14563 pDeviceRenderAreas = pDeviceRenderAreas_;
14564 return *this;
14565 }
14566
14567 operator VkDeviceGroupRenderPassBeginInfo const&() const
14568 {
14569 return *reinterpret_cast<const VkDeviceGroupRenderPassBeginInfo*>(this);
14570 }
14571
14573 {
14574 return *reinterpret_cast<VkDeviceGroupRenderPassBeginInfo*>(this);
14575 }
14576
14578 {
14579 return ( sType == rhs.sType )
14580 && ( pNext == rhs.pNext )
14581 && ( deviceMask == rhs.deviceMask )
14584 }
14585
14587 {
14588 return !operator==( rhs );
14589 }
14590
14591 private:
14593
14594 public:
14595 const void* pNext = nullptr;
14599 };
14600 static_assert( sizeof( DeviceGroupRenderPassBeginInfo ) == sizeof( VkDeviceGroupRenderPassBeginInfo ), "struct and wrapper have different size!" );
14601
14603
14605 {
14607 : deviceMask( deviceMask_ )
14608 {
14609 }
14610
14612 {
14613 memcpy( this, &rhs, sizeof( DeviceGroupCommandBufferBeginInfo ) );
14614 }
14615
14617 {
14618 memcpy( this, &rhs, sizeof( DeviceGroupCommandBufferBeginInfo ) );
14619 return *this;
14620 }
14622 {
14623 pNext = pNext_;
14624 return *this;
14625 }
14626
14628 {
14629 deviceMask = deviceMask_;
14630 return *this;
14631 }
14632
14634 {
14635 return *reinterpret_cast<const VkDeviceGroupCommandBufferBeginInfo*>(this);
14636 }
14637
14639 {
14640 return *reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo*>(this);
14641 }
14642
14644 {
14645 return ( sType == rhs.sType )
14646 && ( pNext == rhs.pNext )
14647 && ( deviceMask == rhs.deviceMask );
14648 }
14649
14651 {
14652 return !operator==( rhs );
14653 }
14654
14655 private:
14657
14658 public:
14659 const void* pNext = nullptr;
14661 };
14662 static_assert( sizeof( DeviceGroupCommandBufferBeginInfo ) == sizeof( VkDeviceGroupCommandBufferBeginInfo ), "struct and wrapper have different size!" );
14663
14665
14667 {
14668 DeviceGroupSubmitInfo( uint32_t waitSemaphoreCount_ = 0,
14669 const uint32_t* pWaitSemaphoreDeviceIndices_ = nullptr,
14670 uint32_t commandBufferCount_ = 0,
14671 const uint32_t* pCommandBufferDeviceMasks_ = nullptr,
14672 uint32_t signalSemaphoreCount_ = 0,
14673 const uint32_t* pSignalSemaphoreDeviceIndices_ = nullptr )
14674 : waitSemaphoreCount( waitSemaphoreCount_ )
14675 , pWaitSemaphoreDeviceIndices( pWaitSemaphoreDeviceIndices_ )
14676 , commandBufferCount( commandBufferCount_ )
14677 , pCommandBufferDeviceMasks( pCommandBufferDeviceMasks_ )
14678 , signalSemaphoreCount( signalSemaphoreCount_ )
14679 , pSignalSemaphoreDeviceIndices( pSignalSemaphoreDeviceIndices_ )
14680 {
14681 }
14682
14684 {
14685 memcpy( this, &rhs, sizeof( DeviceGroupSubmitInfo ) );
14686 }
14687
14689 {
14690 memcpy( this, &rhs, sizeof( DeviceGroupSubmitInfo ) );
14691 return *this;
14692 }
14693 DeviceGroupSubmitInfo& setPNext( const void* pNext_ )
14694 {
14695 pNext = pNext_;
14696 return *this;
14697 }
14698
14700 {
14701 waitSemaphoreCount = waitSemaphoreCount_;
14702 return *this;
14703 }
14704
14705 DeviceGroupSubmitInfo& setPWaitSemaphoreDeviceIndices( const uint32_t* pWaitSemaphoreDeviceIndices_ )
14706 {
14707 pWaitSemaphoreDeviceIndices = pWaitSemaphoreDeviceIndices_;
14708 return *this;
14709 }
14710
14712 {
14713 commandBufferCount = commandBufferCount_;
14714 return *this;
14715 }
14716
14718 {
14719 pCommandBufferDeviceMasks = pCommandBufferDeviceMasks_;
14720 return *this;
14721 }
14722
14724 {
14725 signalSemaphoreCount = signalSemaphoreCount_;
14726 return *this;
14727 }
14728
14729 DeviceGroupSubmitInfo& setPSignalSemaphoreDeviceIndices( const uint32_t* pSignalSemaphoreDeviceIndices_ )
14730 {
14731 pSignalSemaphoreDeviceIndices = pSignalSemaphoreDeviceIndices_;
14732 return *this;
14733 }
14734
14735 operator VkDeviceGroupSubmitInfo const&() const
14736 {
14737 return *reinterpret_cast<const VkDeviceGroupSubmitInfo*>(this);
14738 }
14739
14741 {
14742 return *reinterpret_cast<VkDeviceGroupSubmitInfo*>(this);
14743 }
14744
14745 bool operator==( DeviceGroupSubmitInfo const& rhs ) const
14746 {
14747 return ( sType == rhs.sType )
14748 && ( pNext == rhs.pNext )
14755 }
14756
14757 bool operator!=( DeviceGroupSubmitInfo const& rhs ) const
14758 {
14759 return !operator==( rhs );
14760 }
14761
14762 private:
14764
14765 public:
14766 const void* pNext = nullptr;
14773 };
14774 static_assert( sizeof( DeviceGroupSubmitInfo ) == sizeof( VkDeviceGroupSubmitInfo ), "struct and wrapper have different size!" );
14775
14777
14779 {
14780 DeviceGroupBindSparseInfo( uint32_t resourceDeviceIndex_ = 0,
14781 uint32_t memoryDeviceIndex_ = 0 )
14782 : resourceDeviceIndex( resourceDeviceIndex_ )
14783 , memoryDeviceIndex( memoryDeviceIndex_ )
14784 {
14785 }
14786
14788 {
14789 memcpy( this, &rhs, sizeof( DeviceGroupBindSparseInfo ) );
14790 }
14791
14793 {
14794 memcpy( this, &rhs, sizeof( DeviceGroupBindSparseInfo ) );
14795 return *this;
14796 }
14798 {
14799 pNext = pNext_;
14800 return *this;
14801 }
14802
14804 {
14805 resourceDeviceIndex = resourceDeviceIndex_;
14806 return *this;
14807 }
14808
14810 {
14811 memoryDeviceIndex = memoryDeviceIndex_;
14812 return *this;
14813 }
14814
14815 operator VkDeviceGroupBindSparseInfo const&() const
14816 {
14817 return *reinterpret_cast<const VkDeviceGroupBindSparseInfo*>(this);
14818 }
14819
14821 {
14822 return *reinterpret_cast<VkDeviceGroupBindSparseInfo*>(this);
14823 }
14824
14825 bool operator==( DeviceGroupBindSparseInfo const& rhs ) const
14826 {
14827 return ( sType == rhs.sType )
14828 && ( pNext == rhs.pNext )
14831 }
14832
14833 bool operator!=( DeviceGroupBindSparseInfo const& rhs ) const
14834 {
14835 return !operator==( rhs );
14836 }
14837
14838 private:
14840
14841 public:
14842 const void* pNext = nullptr;
14845 };
14846 static_assert( sizeof( DeviceGroupBindSparseInfo ) == sizeof( VkDeviceGroupBindSparseInfo ), "struct and wrapper have different size!" );
14847
14849
14851 {
14853 : swapchain( swapchain_ )
14854 {
14855 }
14856
14858 {
14859 memcpy( this, &rhs, sizeof( ImageSwapchainCreateInfoKHR ) );
14860 }
14861
14863 {
14864 memcpy( this, &rhs, sizeof( ImageSwapchainCreateInfoKHR ) );
14865 return *this;
14866 }
14868 {
14869 pNext = pNext_;
14870 return *this;
14871 }
14872
14874 {
14875 swapchain = swapchain_;
14876 return *this;
14877 }
14878
14879 operator VkImageSwapchainCreateInfoKHR const&() const
14880 {
14881 return *reinterpret_cast<const VkImageSwapchainCreateInfoKHR*>(this);
14882 }
14883
14885 {
14886 return *reinterpret_cast<VkImageSwapchainCreateInfoKHR*>(this);
14887 }
14888
14890 {
14891 return ( sType == rhs.sType )
14892 && ( pNext == rhs.pNext )
14893 && ( swapchain == rhs.swapchain );
14894 }
14895
14897 {
14898 return !operator==( rhs );
14899 }
14900
14901 private:
14903
14904 public:
14905 const void* pNext = nullptr;
14907 };
14908 static_assert( sizeof( ImageSwapchainCreateInfoKHR ) == sizeof( VkImageSwapchainCreateInfoKHR ), "struct and wrapper have different size!" );
14909
14911 {
14913 uint32_t imageIndex_ = 0 )
14914 : swapchain( swapchain_ )
14915 , imageIndex( imageIndex_ )
14916 {
14917 }
14918
14920 {
14921 memcpy( this, &rhs, sizeof( BindImageMemorySwapchainInfoKHR ) );
14922 }
14923
14925 {
14926 memcpy( this, &rhs, sizeof( BindImageMemorySwapchainInfoKHR ) );
14927 return *this;
14928 }
14930 {
14931 pNext = pNext_;
14932 return *this;
14933 }
14934
14936 {
14937 swapchain = swapchain_;
14938 return *this;
14939 }
14940
14942 {
14943 imageIndex = imageIndex_;
14944 return *this;
14945 }
14946
14948 {
14949 return *reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR*>(this);
14950 }
14951
14953 {
14954 return *reinterpret_cast<VkBindImageMemorySwapchainInfoKHR*>(this);
14955 }
14956
14958 {
14959 return ( sType == rhs.sType )
14960 && ( pNext == rhs.pNext )
14961 && ( swapchain == rhs.swapchain )
14962 && ( imageIndex == rhs.imageIndex );
14963 }
14964
14966 {
14967 return !operator==( rhs );
14968 }
14969
14970 private:
14972
14973 public:
14974 const void* pNext = nullptr;
14977 };
14978 static_assert( sizeof( BindImageMemorySwapchainInfoKHR ) == sizeof( VkBindImageMemorySwapchainInfoKHR ), "struct and wrapper have different size!" );
14979
14981 {
14983 uint64_t timeout_ = 0,
14984 Semaphore semaphore_ = Semaphore(),
14985 Fence fence_ = Fence(),
14986 uint32_t deviceMask_ = 0 )
14987 : swapchain( swapchain_ )
14988 , timeout( timeout_ )
14989 , semaphore( semaphore_ )
14990 , fence( fence_ )
14991 , deviceMask( deviceMask_ )
14992 {
14993 }
14994
14996 {
14997 memcpy( this, &rhs, sizeof( AcquireNextImageInfoKHR ) );
14998 }
14999
15001 {
15002 memcpy( this, &rhs, sizeof( AcquireNextImageInfoKHR ) );
15003 return *this;
15004 }
15005 AcquireNextImageInfoKHR& setPNext( const void* pNext_ )
15006 {
15007 pNext = pNext_;
15008 return *this;
15009 }
15010
15012 {
15013 swapchain = swapchain_;
15014 return *this;
15015 }
15016
15018 {
15019 timeout = timeout_;
15020 return *this;
15021 }
15022
15024 {
15025 semaphore = semaphore_;
15026 return *this;
15027 }
15028
15030 {
15031 fence = fence_;
15032 return *this;
15033 }
15034
15036 {
15037 deviceMask = deviceMask_;
15038 return *this;
15039 }
15040
15041 operator VkAcquireNextImageInfoKHR const&() const
15042 {
15043 return *reinterpret_cast<const VkAcquireNextImageInfoKHR*>(this);
15044 }
15045
15047 {
15048 return *reinterpret_cast<VkAcquireNextImageInfoKHR*>(this);
15049 }
15050
15051 bool operator==( AcquireNextImageInfoKHR const& rhs ) const
15052 {
15053 return ( sType == rhs.sType )
15054 && ( pNext == rhs.pNext )
15055 && ( swapchain == rhs.swapchain )
15056 && ( timeout == rhs.timeout )
15057 && ( semaphore == rhs.semaphore )
15058 && ( fence == rhs.fence )
15059 && ( deviceMask == rhs.deviceMask );
15060 }
15061
15062 bool operator!=( AcquireNextImageInfoKHR const& rhs ) const
15063 {
15064 return !operator==( rhs );
15065 }
15066
15067 private:
15069
15070 public:
15071 const void* pNext = nullptr;
15077 };
15078 static_assert( sizeof( AcquireNextImageInfoKHR ) == sizeof( VkAcquireNextImageInfoKHR ), "struct and wrapper have different size!" );
15079
15081 {
15082 HdrMetadataEXT( XYColorEXT displayPrimaryRed_ = XYColorEXT(),
15083 XYColorEXT displayPrimaryGreen_ = XYColorEXT(),
15084 XYColorEXT displayPrimaryBlue_ = XYColorEXT(),
15085 XYColorEXT whitePoint_ = XYColorEXT(),
15086 float maxLuminance_ = 0,
15087 float minLuminance_ = 0,
15088 float maxContentLightLevel_ = 0,
15089 float maxFrameAverageLightLevel_ = 0 )
15090 : displayPrimaryRed( displayPrimaryRed_ )
15091 , displayPrimaryGreen( displayPrimaryGreen_ )
15092 , displayPrimaryBlue( displayPrimaryBlue_ )
15093 , whitePoint( whitePoint_ )
15094 , maxLuminance( maxLuminance_ )
15095 , minLuminance( minLuminance_ )
15096 , maxContentLightLevel( maxContentLightLevel_ )
15097 , maxFrameAverageLightLevel( maxFrameAverageLightLevel_ )
15098 {
15099 }
15100
15102 {
15103 memcpy( this, &rhs, sizeof( HdrMetadataEXT ) );
15104 }
15105
15107 {
15108 memcpy( this, &rhs, sizeof( HdrMetadataEXT ) );
15109 return *this;
15110 }
15111 HdrMetadataEXT& setPNext( const void* pNext_ )
15112 {
15113 pNext = pNext_;
15114 return *this;
15115 }
15116
15118 {
15119 displayPrimaryRed = displayPrimaryRed_;
15120 return *this;
15121 }
15122
15124 {
15125 displayPrimaryGreen = displayPrimaryGreen_;
15126 return *this;
15127 }
15128
15130 {
15131 displayPrimaryBlue = displayPrimaryBlue_;
15132 return *this;
15133 }
15134
15136 {
15137 whitePoint = whitePoint_;
15138 return *this;
15139 }
15140
15141 HdrMetadataEXT& setMaxLuminance( float maxLuminance_ )
15142 {
15143 maxLuminance = maxLuminance_;
15144 return *this;
15145 }
15146
15147 HdrMetadataEXT& setMinLuminance( float minLuminance_ )
15148 {
15149 minLuminance = minLuminance_;
15150 return *this;
15151 }
15152
15153 HdrMetadataEXT& setMaxContentLightLevel( float maxContentLightLevel_ )
15154 {
15155 maxContentLightLevel = maxContentLightLevel_;
15156 return *this;
15157 }
15158
15159 HdrMetadataEXT& setMaxFrameAverageLightLevel( float maxFrameAverageLightLevel_ )
15160 {
15161 maxFrameAverageLightLevel = maxFrameAverageLightLevel_;
15162 return *this;
15163 }
15164
15165 operator VkHdrMetadataEXT const&() const
15166 {
15167 return *reinterpret_cast<const VkHdrMetadataEXT*>(this);
15168 }
15169
15170 operator VkHdrMetadataEXT &()
15171 {
15172 return *reinterpret_cast<VkHdrMetadataEXT*>(this);
15173 }
15174
15175 bool operator==( HdrMetadataEXT const& rhs ) const
15176 {
15177 return ( sType == rhs.sType )
15178 && ( pNext == rhs.pNext )
15182 && ( whitePoint == rhs.whitePoint )
15183 && ( maxLuminance == rhs.maxLuminance )
15184 && ( minLuminance == rhs.minLuminance )
15187 }
15188
15189 bool operator!=( HdrMetadataEXT const& rhs ) const
15190 {
15191 return !operator==( rhs );
15192 }
15193
15194 private:
15196
15197 public:
15198 const void* pNext = nullptr;
15207 };
15208 static_assert( sizeof( HdrMetadataEXT ) == sizeof( VkHdrMetadataEXT ), "struct and wrapper have different size!" );
15209
15211 {
15212 PresentTimesInfoGOOGLE( uint32_t swapchainCount_ = 0,
15213 const PresentTimeGOOGLE* pTimes_ = nullptr )
15214 : swapchainCount( swapchainCount_ )
15215 , pTimes( pTimes_ )
15216 {
15217 }
15218
15220 {
15221 memcpy( this, &rhs, sizeof( PresentTimesInfoGOOGLE ) );
15222 }
15223
15225 {
15226 memcpy( this, &rhs, sizeof( PresentTimesInfoGOOGLE ) );
15227 return *this;
15228 }
15229 PresentTimesInfoGOOGLE& setPNext( const void* pNext_ )
15230 {
15231 pNext = pNext_;
15232 return *this;
15233 }
15234
15236 {
15237 swapchainCount = swapchainCount_;
15238 return *this;
15239 }
15240
15242 {
15243 pTimes = pTimes_;
15244 return *this;
15245 }
15246
15247 operator VkPresentTimesInfoGOOGLE const&() const
15248 {
15249 return *reinterpret_cast<const VkPresentTimesInfoGOOGLE*>(this);
15250 }
15251
15253 {
15254 return *reinterpret_cast<VkPresentTimesInfoGOOGLE*>(this);
15255 }
15256
15257 bool operator==( PresentTimesInfoGOOGLE const& rhs ) const
15258 {
15259 return ( sType == rhs.sType )
15260 && ( pNext == rhs.pNext )
15261 && ( swapchainCount == rhs.swapchainCount )
15262 && ( pTimes == rhs.pTimes );
15263 }
15264
15265 bool operator!=( PresentTimesInfoGOOGLE const& rhs ) const
15266 {
15267 return !operator==( rhs );
15268 }
15269
15270 private:
15272
15273 public:
15274 const void* pNext = nullptr;
15277 };
15278 static_assert( sizeof( PresentTimesInfoGOOGLE ) == sizeof( VkPresentTimesInfoGOOGLE ), "struct and wrapper have different size!" );
15279
15280#ifdef VK_USE_PLATFORM_IOS_MVK
15281 struct IOSSurfaceCreateInfoMVK
15282 {
15283 IOSSurfaceCreateInfoMVK( IOSSurfaceCreateFlagsMVK flags_ = IOSSurfaceCreateFlagsMVK(),
15284 const void* pView_ = nullptr )
15285 : flags( flags_ )
15286 , pView( pView_ )
15287 {
15288 }
15289
15290 IOSSurfaceCreateInfoMVK( VkIOSSurfaceCreateInfoMVK const & rhs )
15291 {
15292 memcpy( this, &rhs, sizeof( IOSSurfaceCreateInfoMVK ) );
15293 }
15294
15295 IOSSurfaceCreateInfoMVK& operator=( VkIOSSurfaceCreateInfoMVK const & rhs )
15296 {
15297 memcpy( this, &rhs, sizeof( IOSSurfaceCreateInfoMVK ) );
15298 return *this;
15299 }
15300 IOSSurfaceCreateInfoMVK& setPNext( const void* pNext_ )
15301 {
15302 pNext = pNext_;
15303 return *this;
15304 }
15305
15306 IOSSurfaceCreateInfoMVK& setFlags( IOSSurfaceCreateFlagsMVK flags_ )
15307 {
15308 flags = flags_;
15309 return *this;
15310 }
15311
15312 IOSSurfaceCreateInfoMVK& setPView( const void* pView_ )
15313 {
15314 pView = pView_;
15315 return *this;
15316 }
15317
15318 operator VkIOSSurfaceCreateInfoMVK const&() const
15319 {
15320 return *reinterpret_cast<const VkIOSSurfaceCreateInfoMVK*>(this);
15321 }
15322
15323 operator VkIOSSurfaceCreateInfoMVK &()
15324 {
15325 return *reinterpret_cast<VkIOSSurfaceCreateInfoMVK*>(this);
15326 }
15327
15328 bool operator==( IOSSurfaceCreateInfoMVK const& rhs ) const
15329 {
15330 return ( sType == rhs.sType )
15331 && ( pNext == rhs.pNext )
15332 && ( flags == rhs.flags )
15333 && ( pView == rhs.pView );
15334 }
15335
15336 bool operator!=( IOSSurfaceCreateInfoMVK const& rhs ) const
15337 {
15338 return !operator==( rhs );
15339 }
15340
15341 private:
15343
15344 public:
15345 const void* pNext = nullptr;
15346 IOSSurfaceCreateFlagsMVK flags;
15347 const void* pView;
15348 };
15349 static_assert( sizeof( IOSSurfaceCreateInfoMVK ) == sizeof( VkIOSSurfaceCreateInfoMVK ), "struct and wrapper have different size!" );
15350#endif /*VK_USE_PLATFORM_IOS_MVK*/
15351
15352#ifdef VK_USE_PLATFORM_MACOS_MVK
15353 struct MacOSSurfaceCreateInfoMVK
15354 {
15355 MacOSSurfaceCreateInfoMVK( MacOSSurfaceCreateFlagsMVK flags_ = MacOSSurfaceCreateFlagsMVK(),
15356 const void* pView_ = nullptr )
15357 : flags( flags_ )
15358 , pView( pView_ )
15359 {
15360 }
15361
15362 MacOSSurfaceCreateInfoMVK( VkMacOSSurfaceCreateInfoMVK const & rhs )
15363 {
15364 memcpy( this, &rhs, sizeof( MacOSSurfaceCreateInfoMVK ) );
15365 }
15366
15367 MacOSSurfaceCreateInfoMVK& operator=( VkMacOSSurfaceCreateInfoMVK const & rhs )
15368 {
15369 memcpy( this, &rhs, sizeof( MacOSSurfaceCreateInfoMVK ) );
15370 return *this;
15371 }
15372 MacOSSurfaceCreateInfoMVK& setPNext( const void* pNext_ )
15373 {
15374 pNext = pNext_;
15375 return *this;
15376 }
15377
15378 MacOSSurfaceCreateInfoMVK& setFlags( MacOSSurfaceCreateFlagsMVK flags_ )
15379 {
15380 flags = flags_;
15381 return *this;
15382 }
15383
15384 MacOSSurfaceCreateInfoMVK& setPView( const void* pView_ )
15385 {
15386 pView = pView_;
15387 return *this;
15388 }
15389
15390 operator VkMacOSSurfaceCreateInfoMVK const&() const
15391 {
15392 return *reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK*>(this);
15393 }
15394
15395 operator VkMacOSSurfaceCreateInfoMVK &()
15396 {
15397 return *reinterpret_cast<VkMacOSSurfaceCreateInfoMVK*>(this);
15398 }
15399
15400 bool operator==( MacOSSurfaceCreateInfoMVK const& rhs ) const
15401 {
15402 return ( sType == rhs.sType )
15403 && ( pNext == rhs.pNext )
15404 && ( flags == rhs.flags )
15405 && ( pView == rhs.pView );
15406 }
15407
15408 bool operator!=( MacOSSurfaceCreateInfoMVK const& rhs ) const
15409 {
15410 return !operator==( rhs );
15411 }
15412
15413 private:
15415
15416 public:
15417 const void* pNext = nullptr;
15418 MacOSSurfaceCreateFlagsMVK flags;
15419 const void* pView;
15420 };
15421 static_assert( sizeof( MacOSSurfaceCreateInfoMVK ) == sizeof( VkMacOSSurfaceCreateInfoMVK ), "struct and wrapper have different size!" );
15422#endif /*VK_USE_PLATFORM_MACOS_MVK*/
15423
15425 {
15427 uint32_t viewportCount_ = 0,
15428 const ViewportWScalingNV* pViewportWScalings_ = nullptr )
15429 : viewportWScalingEnable( viewportWScalingEnable_ )
15430 , viewportCount( viewportCount_ )
15431 , pViewportWScalings( pViewportWScalings_ )
15432 {
15433 }
15434
15436 {
15437 memcpy( this, &rhs, sizeof( PipelineViewportWScalingStateCreateInfoNV ) );
15438 }
15439
15441 {
15442 memcpy( this, &rhs, sizeof( PipelineViewportWScalingStateCreateInfoNV ) );
15443 return *this;
15444 }
15446 {
15447 pNext = pNext_;
15448 return *this;
15449 }
15450
15452 {
15453 viewportWScalingEnable = viewportWScalingEnable_;
15454 return *this;
15455 }
15456
15458 {
15459 viewportCount = viewportCount_;
15460 return *this;
15461 }
15462
15464 {
15465 pViewportWScalings = pViewportWScalings_;
15466 return *this;
15467 }
15468
15470 {
15471 return *reinterpret_cast<const VkPipelineViewportWScalingStateCreateInfoNV*>(this);
15472 }
15473
15475 {
15476 return *reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV*>(this);
15477 }
15478
15480 {
15481 return ( sType == rhs.sType )
15482 && ( pNext == rhs.pNext )
15484 && ( viewportCount == rhs.viewportCount )
15486 }
15487
15489 {
15490 return !operator==( rhs );
15491 }
15492
15493 private:
15495
15496 public:
15497 const void* pNext = nullptr;
15501 };
15502 static_assert( sizeof( PipelineViewportWScalingStateCreateInfoNV ) == sizeof( VkPipelineViewportWScalingStateCreateInfoNV ), "struct and wrapper have different size!" );
15503
15505 {
15507 : maxDiscardRectangles( maxDiscardRectangles_ )
15508 {
15509 }
15510
15512 {
15513 memcpy( this, &rhs, sizeof( PhysicalDeviceDiscardRectanglePropertiesEXT ) );
15514 }
15515
15517 {
15518 memcpy( this, &rhs, sizeof( PhysicalDeviceDiscardRectanglePropertiesEXT ) );
15519 return *this;
15520 }
15522 {
15523 pNext = pNext_;
15524 return *this;
15525 }
15526
15528 {
15529 maxDiscardRectangles = maxDiscardRectangles_;
15530 return *this;
15531 }
15532
15534 {
15535 return *reinterpret_cast<const VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(this);
15536 }
15537
15539 {
15540 return *reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(this);
15541 }
15542
15544 {
15545 return ( sType == rhs.sType )
15546 && ( pNext == rhs.pNext )
15548 }
15549
15551 {
15552 return !operator==( rhs );
15553 }
15554
15555 private:
15557
15558 public:
15559 void* pNext = nullptr;
15561 };
15562 static_assert( sizeof( PhysicalDeviceDiscardRectanglePropertiesEXT ) == sizeof( VkPhysicalDeviceDiscardRectanglePropertiesEXT ), "struct and wrapper have different size!" );
15563
15565 {
15567 {
15568 return *reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(this);
15569 }
15570
15572 {
15573 return *reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(this);
15574 }
15575
15577 {
15578 return ( sType == rhs.sType )
15579 && ( pNext == rhs.pNext )
15581 }
15582
15584 {
15585 return !operator==( rhs );
15586 }
15587
15588 private:
15590
15591 public:
15592 void* pNext = nullptr;
15594 };
15595 static_assert( sizeof( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ) == sizeof( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ), "struct and wrapper have different size!" );
15596
15598 {
15600 : surface( surface_ )
15601 {
15602 }
15603
15605 {
15606 memcpy( this, &rhs, sizeof( PhysicalDeviceSurfaceInfo2KHR ) );
15607 }
15608
15610 {
15611 memcpy( this, &rhs, sizeof( PhysicalDeviceSurfaceInfo2KHR ) );
15612 return *this;
15613 }
15615 {
15616 pNext = pNext_;
15617 return *this;
15618 }
15619
15621 {
15622 surface = surface_;
15623 return *this;
15624 }
15625
15626 operator VkPhysicalDeviceSurfaceInfo2KHR const&() const
15627 {
15628 return *reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>(this);
15629 }
15630
15632 {
15633 return *reinterpret_cast<VkPhysicalDeviceSurfaceInfo2KHR*>(this);
15634 }
15635
15637 {
15638 return ( sType == rhs.sType )
15639 && ( pNext == rhs.pNext )
15640 && ( surface == rhs.surface );
15641 }
15642
15644 {
15645 return !operator==( rhs );
15646 }
15647
15648 private:
15650
15651 public:
15652 const void* pNext = nullptr;
15654 };
15655 static_assert( sizeof( PhysicalDeviceSurfaceInfo2KHR ) == sizeof( VkPhysicalDeviceSurfaceInfo2KHR ), "struct and wrapper have different size!" );
15656
15658 {
15659 operator VkDisplayPlaneProperties2KHR const&() const
15660 {
15661 return *reinterpret_cast<const VkDisplayPlaneProperties2KHR*>(this);
15662 }
15663
15665 {
15666 return *reinterpret_cast<VkDisplayPlaneProperties2KHR*>(this);
15667 }
15668
15670 {
15671 return ( sType == rhs.sType )
15672 && ( pNext == rhs.pNext )
15674 }
15675
15677 {
15678 return !operator==( rhs );
15679 }
15680
15681 private:
15683
15684 public:
15685 void* pNext = nullptr;
15687 };
15688 static_assert( sizeof( DisplayPlaneProperties2KHR ) == sizeof( VkDisplayPlaneProperties2KHR ), "struct and wrapper have different size!" );
15689
15691 {
15692 operator VkDisplayModeProperties2KHR const&() const
15693 {
15694 return *reinterpret_cast<const VkDisplayModeProperties2KHR*>(this);
15695 }
15696
15698 {
15699 return *reinterpret_cast<VkDisplayModeProperties2KHR*>(this);
15700 }
15701
15702 bool operator==( DisplayModeProperties2KHR const& rhs ) const
15703 {
15704 return ( sType == rhs.sType )
15705 && ( pNext == rhs.pNext )
15707 }
15708
15709 bool operator!=( DisplayModeProperties2KHR const& rhs ) const
15710 {
15711 return !operator==( rhs );
15712 }
15713
15714 private:
15716
15717 public:
15718 void* pNext = nullptr;
15720 };
15721 static_assert( sizeof( DisplayModeProperties2KHR ) == sizeof( VkDisplayModeProperties2KHR ), "struct and wrapper have different size!" );
15722
15724 {
15726 uint32_t planeIndex_ = 0 )
15727 : mode( mode_ )
15728 , planeIndex( planeIndex_ )
15729 {
15730 }
15731
15733 {
15734 memcpy( this, &rhs, sizeof( DisplayPlaneInfo2KHR ) );
15735 }
15736
15738 {
15739 memcpy( this, &rhs, sizeof( DisplayPlaneInfo2KHR ) );
15740 return *this;
15741 }
15742 DisplayPlaneInfo2KHR& setPNext( const void* pNext_ )
15743 {
15744 pNext = pNext_;
15745 return *this;
15746 }
15747
15749 {
15750 mode = mode_;
15751 return *this;
15752 }
15753
15755 {
15756 planeIndex = planeIndex_;
15757 return *this;
15758 }
15759
15760 operator VkDisplayPlaneInfo2KHR const&() const
15761 {
15762 return *reinterpret_cast<const VkDisplayPlaneInfo2KHR*>(this);
15763 }
15764
15766 {
15767 return *reinterpret_cast<VkDisplayPlaneInfo2KHR*>(this);
15768 }
15769
15770 bool operator==( DisplayPlaneInfo2KHR const& rhs ) const
15771 {
15772 return ( sType == rhs.sType )
15773 && ( pNext == rhs.pNext )
15774 && ( mode == rhs.mode )
15775 && ( planeIndex == rhs.planeIndex );
15776 }
15777
15778 bool operator!=( DisplayPlaneInfo2KHR const& rhs ) const
15779 {
15780 return !operator==( rhs );
15781 }
15782
15783 private:
15785
15786 public:
15787 const void* pNext = nullptr;
15790 };
15791 static_assert( sizeof( DisplayPlaneInfo2KHR ) == sizeof( VkDisplayPlaneInfo2KHR ), "struct and wrapper have different size!" );
15792
15794 {
15795 PhysicalDevice16BitStorageFeatures( Bool32 storageBuffer16BitAccess_ = 0,
15796 Bool32 uniformAndStorageBuffer16BitAccess_ = 0,
15797 Bool32 storagePushConstant16_ = 0,
15798 Bool32 storageInputOutput16_ = 0 )
15799 : storageBuffer16BitAccess( storageBuffer16BitAccess_ )
15800 , uniformAndStorageBuffer16BitAccess( uniformAndStorageBuffer16BitAccess_ )
15801 , storagePushConstant16( storagePushConstant16_ )
15802 , storageInputOutput16( storageInputOutput16_ )
15803 {
15804 }
15805
15807 {
15808 memcpy( this, &rhs, sizeof( PhysicalDevice16BitStorageFeatures ) );
15809 }
15810
15812 {
15813 memcpy( this, &rhs, sizeof( PhysicalDevice16BitStorageFeatures ) );
15814 return *this;
15815 }
15817 {
15818 pNext = pNext_;
15819 return *this;
15820 }
15821
15823 {
15824 storageBuffer16BitAccess = storageBuffer16BitAccess_;
15825 return *this;
15826 }
15827
15829 {
15830 uniformAndStorageBuffer16BitAccess = uniformAndStorageBuffer16BitAccess_;
15831 return *this;
15832 }
15833
15835 {
15836 storagePushConstant16 = storagePushConstant16_;
15837 return *this;
15838 }
15839
15841 {
15842 storageInputOutput16 = storageInputOutput16_;
15843 return *this;
15844 }
15845
15847 {
15848 return *reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures*>(this);
15849 }
15850
15852 {
15853 return *reinterpret_cast<VkPhysicalDevice16BitStorageFeatures*>(this);
15854 }
15855
15857 {
15858 return ( sType == rhs.sType )
15859 && ( pNext == rhs.pNext )
15864 }
15865
15867 {
15868 return !operator==( rhs );
15869 }
15870
15871 private:
15873
15874 public:
15875 void* pNext = nullptr;
15880 };
15881 static_assert( sizeof( PhysicalDevice16BitStorageFeatures ) == sizeof( VkPhysicalDevice16BitStorageFeatures ), "struct and wrapper have different size!" );
15882
15884
15886 {
15888 : buffer( buffer_ )
15889 {
15890 }
15891
15893 {
15894 memcpy( this, &rhs, sizeof( BufferMemoryRequirementsInfo2 ) );
15895 }
15896
15898 {
15899 memcpy( this, &rhs, sizeof( BufferMemoryRequirementsInfo2 ) );
15900 return *this;
15901 }
15903 {
15904 pNext = pNext_;
15905 return *this;
15906 }
15907
15909 {
15910 buffer = buffer_;
15911 return *this;
15912 }
15913
15914 operator VkBufferMemoryRequirementsInfo2 const&() const
15915 {
15916 return *reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>(this);
15917 }
15918
15920 {
15921 return *reinterpret_cast<VkBufferMemoryRequirementsInfo2*>(this);
15922 }
15923
15925 {
15926 return ( sType == rhs.sType )
15927 && ( pNext == rhs.pNext )
15928 && ( buffer == rhs.buffer );
15929 }
15930
15932 {
15933 return !operator==( rhs );
15934 }
15935
15936 private:
15938
15939 public:
15940 const void* pNext = nullptr;
15942 };
15943 static_assert( sizeof( BufferMemoryRequirementsInfo2 ) == sizeof( VkBufferMemoryRequirementsInfo2 ), "struct and wrapper have different size!" );
15944
15946
15948 {
15950 : image( image_ )
15951 {
15952 }
15953
15955 {
15956 memcpy( this, &rhs, sizeof( ImageMemoryRequirementsInfo2 ) );
15957 }
15958
15960 {
15961 memcpy( this, &rhs, sizeof( ImageMemoryRequirementsInfo2 ) );
15962 return *this;
15963 }
15965 {
15966 pNext = pNext_;
15967 return *this;
15968 }
15969
15971 {
15972 image = image_;
15973 return *this;
15974 }
15975
15976 operator VkImageMemoryRequirementsInfo2 const&() const
15977 {
15978 return *reinterpret_cast<const VkImageMemoryRequirementsInfo2*>(this);
15979 }
15980
15982 {
15983 return *reinterpret_cast<VkImageMemoryRequirementsInfo2*>(this);
15984 }
15985
15987 {
15988 return ( sType == rhs.sType )
15989 && ( pNext == rhs.pNext )
15990 && ( image == rhs.image );
15991 }
15992
15994 {
15995 return !operator==( rhs );
15996 }
15997
15998 private:
16000
16001 public:
16002 const void* pNext = nullptr;
16004 };
16005 static_assert( sizeof( ImageMemoryRequirementsInfo2 ) == sizeof( VkImageMemoryRequirementsInfo2 ), "struct and wrapper have different size!" );
16006
16008
16010 {
16012 : image( image_ )
16013 {
16014 }
16015
16017 {
16018 memcpy( this, &rhs, sizeof( ImageSparseMemoryRequirementsInfo2 ) );
16019 }
16020
16022 {
16023 memcpy( this, &rhs, sizeof( ImageSparseMemoryRequirementsInfo2 ) );
16024 return *this;
16025 }
16027 {
16028 pNext = pNext_;
16029 return *this;
16030 }
16031
16033 {
16034 image = image_;
16035 return *this;
16036 }
16037
16039 {
16040 return *reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>(this);
16041 }
16042
16044 {
16045 return *reinterpret_cast<VkImageSparseMemoryRequirementsInfo2*>(this);
16046 }
16047
16049 {
16050 return ( sType == rhs.sType )
16051 && ( pNext == rhs.pNext )
16052 && ( image == rhs.image );
16053 }
16054
16056 {
16057 return !operator==( rhs );
16058 }
16059
16060 private:
16062
16063 public:
16064 const void* pNext = nullptr;
16066 };
16067 static_assert( sizeof( ImageSparseMemoryRequirementsInfo2 ) == sizeof( VkImageSparseMemoryRequirementsInfo2 ), "struct and wrapper have different size!" );
16068
16070
16072 {
16073 operator VkMemoryRequirements2 const&() const
16074 {
16075 return *reinterpret_cast<const VkMemoryRequirements2*>(this);
16076 }
16077
16079 {
16080 return *reinterpret_cast<VkMemoryRequirements2*>(this);
16081 }
16082
16083 bool operator==( MemoryRequirements2 const& rhs ) const
16084 {
16085 return ( sType == rhs.sType )
16086 && ( pNext == rhs.pNext )
16088 }
16089
16090 bool operator!=( MemoryRequirements2 const& rhs ) const
16091 {
16092 return !operator==( rhs );
16093 }
16094
16095 private:
16097
16098 public:
16099 void* pNext = nullptr;
16101 };
16102 static_assert( sizeof( MemoryRequirements2 ) == sizeof( VkMemoryRequirements2 ), "struct and wrapper have different size!" );
16103
16105
16107 {
16108 operator VkMemoryDedicatedRequirements const&() const
16109 {
16110 return *reinterpret_cast<const VkMemoryDedicatedRequirements*>(this);
16111 }
16112
16114 {
16115 return *reinterpret_cast<VkMemoryDedicatedRequirements*>(this);
16116 }
16117
16119 {
16120 return ( sType == rhs.sType )
16121 && ( pNext == rhs.pNext )
16124 }
16125
16127 {
16128 return !operator==( rhs );
16129 }
16130
16131 private:
16133
16134 public:
16135 void* pNext = nullptr;
16138 };
16139 static_assert( sizeof( MemoryDedicatedRequirements ) == sizeof( VkMemoryDedicatedRequirements ), "struct and wrapper have different size!" );
16140
16142
16144 {
16146 Buffer buffer_ = Buffer() )
16147 : image( image_ )
16148 , buffer( buffer_ )
16149 {
16150 }
16151
16153 {
16154 memcpy( this, &rhs, sizeof( MemoryDedicatedAllocateInfo ) );
16155 }
16156
16158 {
16159 memcpy( this, &rhs, sizeof( MemoryDedicatedAllocateInfo ) );
16160 return *this;
16161 }
16163 {
16164 pNext = pNext_;
16165 return *this;
16166 }
16167
16169 {
16170 image = image_;
16171 return *this;
16172 }
16173
16175 {
16176 buffer = buffer_;
16177 return *this;
16178 }
16179
16180 operator VkMemoryDedicatedAllocateInfo const&() const
16181 {
16182 return *reinterpret_cast<const VkMemoryDedicatedAllocateInfo*>(this);
16183 }
16184
16186 {
16187 return *reinterpret_cast<VkMemoryDedicatedAllocateInfo*>(this);
16188 }
16189
16191 {
16192 return ( sType == rhs.sType )
16193 && ( pNext == rhs.pNext )
16194 && ( image == rhs.image )
16195 && ( buffer == rhs.buffer );
16196 }
16197
16199 {
16200 return !operator==( rhs );
16201 }
16202
16203 private:
16205
16206 public:
16207 const void* pNext = nullptr;
16210 };
16211 static_assert( sizeof( MemoryDedicatedAllocateInfo ) == sizeof( VkMemoryDedicatedAllocateInfo ), "struct and wrapper have different size!" );
16212
16214
16216 {
16218 : conversion( conversion_ )
16219 {
16220 }
16221
16223 {
16224 memcpy( this, &rhs, sizeof( SamplerYcbcrConversionInfo ) );
16225 }
16226
16228 {
16229 memcpy( this, &rhs, sizeof( SamplerYcbcrConversionInfo ) );
16230 return *this;
16231 }
16233 {
16234 pNext = pNext_;
16235 return *this;
16236 }
16237
16239 {
16240 conversion = conversion_;
16241 return *this;
16242 }
16243
16244 operator VkSamplerYcbcrConversionInfo const&() const
16245 {
16246 return *reinterpret_cast<const VkSamplerYcbcrConversionInfo*>(this);
16247 }
16248
16250 {
16251 return *reinterpret_cast<VkSamplerYcbcrConversionInfo*>(this);
16252 }
16253
16255 {
16256 return ( sType == rhs.sType )
16257 && ( pNext == rhs.pNext )
16258 && ( conversion == rhs.conversion );
16259 }
16260
16262 {
16263 return !operator==( rhs );
16264 }
16265
16266 private:
16268
16269 public:
16270 const void* pNext = nullptr;
16272 };
16273 static_assert( sizeof( SamplerYcbcrConversionInfo ) == sizeof( VkSamplerYcbcrConversionInfo ), "struct and wrapper have different size!" );
16274
16276
16278 {
16280 : samplerYcbcrConversion( samplerYcbcrConversion_ )
16281 {
16282 }
16283
16285 {
16287 }
16288
16290 {
16292 return *this;
16293 }
16295 {
16296 pNext = pNext_;
16297 return *this;
16298 }
16299
16301 {
16302 samplerYcbcrConversion = samplerYcbcrConversion_;
16303 return *this;
16304 }
16305
16307 {
16308 return *reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(this);
16309 }
16310
16312 {
16313 return *reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(this);
16314 }
16315
16317 {
16318 return ( sType == rhs.sType )
16319 && ( pNext == rhs.pNext )
16321 }
16322
16324 {
16325 return !operator==( rhs );
16326 }
16327
16328 private:
16330
16331 public:
16332 void* pNext = nullptr;
16334 };
16335 static_assert( sizeof( PhysicalDeviceSamplerYcbcrConversionFeatures ) == sizeof( VkPhysicalDeviceSamplerYcbcrConversionFeatures ), "struct and wrapper have different size!" );
16336
16338
16340 {
16342 {
16343 return *reinterpret_cast<const VkSamplerYcbcrConversionImageFormatProperties*>(this);
16344 }
16345
16347 {
16348 return *reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties*>(this);
16349 }
16350
16352 {
16353 return ( sType == rhs.sType )
16354 && ( pNext == rhs.pNext )
16356 }
16357
16359 {
16360 return !operator==( rhs );
16361 }
16362
16363 private:
16365
16366 public:
16367 void* pNext = nullptr;
16369 };
16370 static_assert( sizeof( SamplerYcbcrConversionImageFormatProperties ) == sizeof( VkSamplerYcbcrConversionImageFormatProperties ), "struct and wrapper have different size!" );
16371
16373
16375 {
16377 {
16378 return *reinterpret_cast<const VkTextureLODGatherFormatPropertiesAMD*>(this);
16379 }
16380
16382 {
16383 return *reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD*>(this);
16384 }
16385
16387 {
16388 return ( sType == rhs.sType )
16389 && ( pNext == rhs.pNext )
16391 }
16392
16394 {
16395 return !operator==( rhs );
16396 }
16397
16398 private:
16400
16401 public:
16402 void* pNext = nullptr;
16404 };
16405 static_assert( sizeof( TextureLODGatherFormatPropertiesAMD ) == sizeof( VkTextureLODGatherFormatPropertiesAMD ), "struct and wrapper have different size!" );
16406
16408 {
16409 ProtectedSubmitInfo( Bool32 protectedSubmit_ = 0 )
16410 : protectedSubmit( protectedSubmit_ )
16411 {
16412 }
16413
16415 {
16416 memcpy( this, &rhs, sizeof( ProtectedSubmitInfo ) );
16417 }
16418
16420 {
16421 memcpy( this, &rhs, sizeof( ProtectedSubmitInfo ) );
16422 return *this;
16423 }
16424 ProtectedSubmitInfo& setPNext( const void* pNext_ )
16425 {
16426 pNext = pNext_;
16427 return *this;
16428 }
16429
16431 {
16432 protectedSubmit = protectedSubmit_;
16433 return *this;
16434 }
16435
16436 operator VkProtectedSubmitInfo const&() const
16437 {
16438 return *reinterpret_cast<const VkProtectedSubmitInfo*>(this);
16439 }
16440
16442 {
16443 return *reinterpret_cast<VkProtectedSubmitInfo*>(this);
16444 }
16445
16446 bool operator==( ProtectedSubmitInfo const& rhs ) const
16447 {
16448 return ( sType == rhs.sType )
16449 && ( pNext == rhs.pNext )
16450 && ( protectedSubmit == rhs.protectedSubmit );
16451 }
16452
16453 bool operator!=( ProtectedSubmitInfo const& rhs ) const
16454 {
16455 return !operator==( rhs );
16456 }
16457
16458 private:
16460
16461 public:
16462 const void* pNext = nullptr;
16464 };
16465 static_assert( sizeof( ProtectedSubmitInfo ) == sizeof( VkProtectedSubmitInfo ), "struct and wrapper have different size!" );
16466
16468 {
16470 : protectedMemory( protectedMemory_ )
16471 {
16472 }
16473
16475 {
16476 memcpy( this, &rhs, sizeof( PhysicalDeviceProtectedMemoryFeatures ) );
16477 }
16478
16480 {
16481 memcpy( this, &rhs, sizeof( PhysicalDeviceProtectedMemoryFeatures ) );
16482 return *this;
16483 }
16485 {
16486 pNext = pNext_;
16487 return *this;
16488 }
16489
16491 {
16492 protectedMemory = protectedMemory_;
16493 return *this;
16494 }
16495
16497 {
16498 return *reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures*>(this);
16499 }
16500
16502 {
16503 return *reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures*>(this);
16504 }
16505
16507 {
16508 return ( sType == rhs.sType )
16509 && ( pNext == rhs.pNext )
16510 && ( protectedMemory == rhs.protectedMemory );
16511 }
16512
16514 {
16515 return !operator==( rhs );
16516 }
16517
16518 private:
16520
16521 public:
16522 void* pNext = nullptr;
16524 };
16525 static_assert( sizeof( PhysicalDeviceProtectedMemoryFeatures ) == sizeof( VkPhysicalDeviceProtectedMemoryFeatures ), "struct and wrapper have different size!" );
16526
16528 {
16530 : protectedNoFault( protectedNoFault_ )
16531 {
16532 }
16533
16535 {
16536 memcpy( this, &rhs, sizeof( PhysicalDeviceProtectedMemoryProperties ) );
16537 }
16538
16540 {
16541 memcpy( this, &rhs, sizeof( PhysicalDeviceProtectedMemoryProperties ) );
16542 return *this;
16543 }
16545 {
16546 pNext = pNext_;
16547 return *this;
16548 }
16549
16551 {
16552 protectedNoFault = protectedNoFault_;
16553 return *this;
16554 }
16555
16557 {
16558 return *reinterpret_cast<const VkPhysicalDeviceProtectedMemoryProperties*>(this);
16559 }
16560
16562 {
16563 return *reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties*>(this);
16564 }
16565
16567 {
16568 return ( sType == rhs.sType )
16569 && ( pNext == rhs.pNext )
16570 && ( protectedNoFault == rhs.protectedNoFault );
16571 }
16572
16574 {
16575 return !operator==( rhs );
16576 }
16577
16578 private:
16580
16581 public:
16582 void* pNext = nullptr;
16584 };
16585 static_assert( sizeof( PhysicalDeviceProtectedMemoryProperties ) == sizeof( VkPhysicalDeviceProtectedMemoryProperties ), "struct and wrapper have different size!" );
16586
16588 {
16590 Bool32 coverageToColorEnable_ = 0,
16591 uint32_t coverageToColorLocation_ = 0 )
16592 : flags( flags_ )
16593 , coverageToColorEnable( coverageToColorEnable_ )
16594 , coverageToColorLocation( coverageToColorLocation_ )
16595 {
16596 }
16597
16599 {
16600 memcpy( this, &rhs, sizeof( PipelineCoverageToColorStateCreateInfoNV ) );
16601 }
16602
16604 {
16605 memcpy( this, &rhs, sizeof( PipelineCoverageToColorStateCreateInfoNV ) );
16606 return *this;
16607 }
16609 {
16610 pNext = pNext_;
16611 return *this;
16612 }
16613
16615 {
16616 flags = flags_;
16617 return *this;
16618 }
16619
16621 {
16622 coverageToColorEnable = coverageToColorEnable_;
16623 return *this;
16624 }
16625
16627 {
16628 coverageToColorLocation = coverageToColorLocation_;
16629 return *this;
16630 }
16631
16633 {
16634 return *reinterpret_cast<const VkPipelineCoverageToColorStateCreateInfoNV*>(this);
16635 }
16636
16638 {
16639 return *reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV*>(this);
16640 }
16641
16643 {
16644 return ( sType == rhs.sType )
16645 && ( pNext == rhs.pNext )
16646 && ( flags == rhs.flags )
16649 }
16650
16652 {
16653 return !operator==( rhs );
16654 }
16655
16656 private:
16658
16659 public:
16660 const void* pNext = nullptr;
16664 };
16665 static_assert( sizeof( PipelineCoverageToColorStateCreateInfoNV ) == sizeof( VkPipelineCoverageToColorStateCreateInfoNV ), "struct and wrapper have different size!" );
16666
16668 {
16670 {
16671 return *reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT*>(this);
16672 }
16673
16675 {
16676 return *reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT*>(this);
16677 }
16678
16680 {
16681 return ( sType == rhs.sType )
16682 && ( pNext == rhs.pNext )
16685 }
16686
16688 {
16689 return !operator==( rhs );
16690 }
16691
16692 private:
16694
16695 public:
16696 void* pNext = nullptr;
16699 };
16700 static_assert( sizeof( PhysicalDeviceSamplerFilterMinmaxPropertiesEXT ) == sizeof( VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT ), "struct and wrapper have different size!" );
16701
16703 {
16704 operator VkMultisamplePropertiesEXT const&() const
16705 {
16706 return *reinterpret_cast<const VkMultisamplePropertiesEXT*>(this);
16707 }
16708
16710 {
16711 return *reinterpret_cast<VkMultisamplePropertiesEXT*>(this);
16712 }
16713
16714 bool operator==( MultisamplePropertiesEXT const& rhs ) const
16715 {
16716 return ( sType == rhs.sType )
16717 && ( pNext == rhs.pNext )
16719 }
16720
16721 bool operator!=( MultisamplePropertiesEXT const& rhs ) const
16722 {
16723 return !operator==( rhs );
16724 }
16725
16726 private:
16728
16729 public:
16730 void* pNext = nullptr;
16732 };
16733 static_assert( sizeof( MultisamplePropertiesEXT ) == sizeof( VkMultisamplePropertiesEXT ), "struct and wrapper have different size!" );
16734
16736 {
16737 PhysicalDeviceBlendOperationAdvancedFeaturesEXT( Bool32 advancedBlendCoherentOperations_ = 0 )
16738 : advancedBlendCoherentOperations( advancedBlendCoherentOperations_ )
16739 {
16740 }
16741
16743 {
16745 }
16746
16748 {
16750 return *this;
16751 }
16753 {
16754 pNext = pNext_;
16755 return *this;
16756 }
16757
16759 {
16760 advancedBlendCoherentOperations = advancedBlendCoherentOperations_;
16761 return *this;
16762 }
16763
16765 {
16766 return *reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(this);
16767 }
16768
16770 {
16771 return *reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(this);
16772 }
16773
16775 {
16776 return ( sType == rhs.sType )
16777 && ( pNext == rhs.pNext )
16779 }
16780
16782 {
16783 return !operator==( rhs );
16784 }
16785
16786 private:
16788
16789 public:
16790 void* pNext = nullptr;
16792 };
16793 static_assert( sizeof( PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) == sizeof( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT ), "struct and wrapper have different size!" );
16794
16796 {
16798 {
16799 return *reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(this);
16800 }
16801
16803 {
16804 return *reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(this);
16805 }
16806
16808 {
16809 return ( sType == rhs.sType )
16810 && ( pNext == rhs.pNext )
16817 }
16818
16820 {
16821 return !operator==( rhs );
16822 }
16823
16824 private:
16826
16827 public:
16828 void* pNext = nullptr;
16835 };
16836 static_assert( sizeof( PhysicalDeviceBlendOperationAdvancedPropertiesEXT ) == sizeof( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT ), "struct and wrapper have different size!" );
16837
16839 {
16841 {
16842 return *reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(this);
16843 }
16844
16846 {
16847 return *reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(this);
16848 }
16849
16851 {
16852 return ( sType == rhs.sType )
16853 && ( pNext == rhs.pNext )
16856 }
16857
16859 {
16860 return !operator==( rhs );
16861 }
16862
16863 private:
16865
16866 public:
16867 void* pNext = nullptr;
16870 };
16871 static_assert( sizeof( PhysicalDeviceInlineUniformBlockFeaturesEXT ) == sizeof( VkPhysicalDeviceInlineUniformBlockFeaturesEXT ), "struct and wrapper have different size!" );
16872
16874 {
16876 {
16877 return *reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(this);
16878 }
16879
16881 {
16882 return *reinterpret_cast<VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(this);
16883 }
16884
16886 {
16887 return ( sType == rhs.sType )
16888 && ( pNext == rhs.pNext )
16894 }
16895
16897 {
16898 return !operator==( rhs );
16899 }
16900
16901 private:
16903
16904 public:
16905 void* pNext = nullptr;
16911 };
16912 static_assert( sizeof( PhysicalDeviceInlineUniformBlockPropertiesEXT ) == sizeof( VkPhysicalDeviceInlineUniformBlockPropertiesEXT ), "struct and wrapper have different size!" );
16913
16915 {
16917 const void* pData_ = nullptr )
16918 : dataSize( dataSize_ )
16919 , pData( pData_ )
16920 {
16921 }
16922
16924 {
16925 memcpy( this, &rhs, sizeof( WriteDescriptorSetInlineUniformBlockEXT ) );
16926 }
16927
16929 {
16930 memcpy( this, &rhs, sizeof( WriteDescriptorSetInlineUniformBlockEXT ) );
16931 return *this;
16932 }
16934 {
16935 pNext = pNext_;
16936 return *this;
16937 }
16938
16940 {
16941 dataSize = dataSize_;
16942 return *this;
16943 }
16944
16946 {
16947 pData = pData_;
16948 return *this;
16949 }
16950
16952 {
16953 return *reinterpret_cast<const VkWriteDescriptorSetInlineUniformBlockEXT*>(this);
16954 }
16955
16957 {
16958 return *reinterpret_cast<VkWriteDescriptorSetInlineUniformBlockEXT*>(this);
16959 }
16960
16962 {
16963 return ( sType == rhs.sType )
16964 && ( pNext == rhs.pNext )
16965 && ( dataSize == rhs.dataSize )
16966 && ( pData == rhs.pData );
16967 }
16968
16970 {
16971 return !operator==( rhs );
16972 }
16973
16974 private:
16976
16977 public:
16978 const void* pNext = nullptr;
16980 const void* pData;
16981 };
16982 static_assert( sizeof( WriteDescriptorSetInlineUniformBlockEXT ) == sizeof( VkWriteDescriptorSetInlineUniformBlockEXT ), "struct and wrapper have different size!" );
16983
16985 {
16986 DescriptorPoolInlineUniformBlockCreateInfoEXT( uint32_t maxInlineUniformBlockBindings_ = 0 )
16987 : maxInlineUniformBlockBindings( maxInlineUniformBlockBindings_ )
16988 {
16989 }
16990
16992 {
16994 }
16995
16997 {
16999 return *this;
17000 }
17002 {
17003 pNext = pNext_;
17004 return *this;
17005 }
17006
17008 {
17009 maxInlineUniformBlockBindings = maxInlineUniformBlockBindings_;
17010 return *this;
17011 }
17012
17014 {
17015 return *reinterpret_cast<const VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(this);
17016 }
17017
17019 {
17020 return *reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(this);
17021 }
17022
17024 {
17025 return ( sType == rhs.sType )
17026 && ( pNext == rhs.pNext )
17028 }
17029
17031 {
17032 return !operator==( rhs );
17033 }
17034
17035 private:
17037
17038 public:
17039 const void* pNext = nullptr;
17041 };
17042 static_assert( sizeof( DescriptorPoolInlineUniformBlockCreateInfoEXT ) == sizeof( VkDescriptorPoolInlineUniformBlockCreateInfoEXT ), "struct and wrapper have different size!" );
17043
17045 {
17047 const Format* pViewFormats_ = nullptr )
17048 : viewFormatCount( viewFormatCount_ )
17049 , pViewFormats( pViewFormats_ )
17050 {
17051 }
17052
17054 {
17055 memcpy( this, &rhs, sizeof( ImageFormatListCreateInfoKHR ) );
17056 }
17057
17059 {
17060 memcpy( this, &rhs, sizeof( ImageFormatListCreateInfoKHR ) );
17061 return *this;
17062 }
17064 {
17065 pNext = pNext_;
17066 return *this;
17067 }
17068
17070 {
17071 viewFormatCount = viewFormatCount_;
17072 return *this;
17073 }
17074
17076 {
17077 pViewFormats = pViewFormats_;
17078 return *this;
17079 }
17080
17081 operator VkImageFormatListCreateInfoKHR const&() const
17082 {
17083 return *reinterpret_cast<const VkImageFormatListCreateInfoKHR*>(this);
17084 }
17085
17087 {
17088 return *reinterpret_cast<VkImageFormatListCreateInfoKHR*>(this);
17089 }
17090
17092 {
17093 return ( sType == rhs.sType )
17094 && ( pNext == rhs.pNext )
17095 && ( viewFormatCount == rhs.viewFormatCount )
17096 && ( pViewFormats == rhs.pViewFormats );
17097 }
17098
17100 {
17101 return !operator==( rhs );
17102 }
17103
17104 private:
17106
17107 public:
17108 const void* pNext = nullptr;
17111 };
17112 static_assert( sizeof( ImageFormatListCreateInfoKHR ) == sizeof( VkImageFormatListCreateInfoKHR ), "struct and wrapper have different size!" );
17113
17115 {
17117 size_t initialDataSize_ = 0,
17118 const void* pInitialData_ = nullptr )
17119 : flags( flags_ )
17120 , initialDataSize( initialDataSize_ )
17121 , pInitialData( pInitialData_ )
17122 {
17123 }
17124
17126 {
17127 memcpy( this, &rhs, sizeof( ValidationCacheCreateInfoEXT ) );
17128 }
17129
17131 {
17132 memcpy( this, &rhs, sizeof( ValidationCacheCreateInfoEXT ) );
17133 return *this;
17134 }
17136 {
17137 pNext = pNext_;
17138 return *this;
17139 }
17140
17142 {
17143 flags = flags_;
17144 return *this;
17145 }
17146
17148 {
17149 initialDataSize = initialDataSize_;
17150 return *this;
17151 }
17152
17153 ValidationCacheCreateInfoEXT& setPInitialData( const void* pInitialData_ )
17154 {
17155 pInitialData = pInitialData_;
17156 return *this;
17157 }
17158
17159 operator VkValidationCacheCreateInfoEXT const&() const
17160 {
17161 return *reinterpret_cast<const VkValidationCacheCreateInfoEXT*>(this);
17162 }
17163
17165 {
17166 return *reinterpret_cast<VkValidationCacheCreateInfoEXT*>(this);
17167 }
17168
17170 {
17171 return ( sType == rhs.sType )
17172 && ( pNext == rhs.pNext )
17173 && ( flags == rhs.flags )
17174 && ( initialDataSize == rhs.initialDataSize )
17175 && ( pInitialData == rhs.pInitialData );
17176 }
17177
17179 {
17180 return !operator==( rhs );
17181 }
17182
17183 private:
17185
17186 public:
17187 const void* pNext = nullptr;
17190 const void* pInitialData;
17191 };
17192 static_assert( sizeof( ValidationCacheCreateInfoEXT ) == sizeof( VkValidationCacheCreateInfoEXT ), "struct and wrapper have different size!" );
17193
17195 {
17197 : validationCache( validationCache_ )
17198 {
17199 }
17200
17202 {
17203 memcpy( this, &rhs, sizeof( ShaderModuleValidationCacheCreateInfoEXT ) );
17204 }
17205
17207 {
17208 memcpy( this, &rhs, sizeof( ShaderModuleValidationCacheCreateInfoEXT ) );
17209 return *this;
17210 }
17212 {
17213 pNext = pNext_;
17214 return *this;
17215 }
17216
17218 {
17219 validationCache = validationCache_;
17220 return *this;
17221 }
17222
17224 {
17225 return *reinterpret_cast<const VkShaderModuleValidationCacheCreateInfoEXT*>(this);
17226 }
17227
17229 {
17230 return *reinterpret_cast<VkShaderModuleValidationCacheCreateInfoEXT*>(this);
17231 }
17232
17234 {
17235 return ( sType == rhs.sType )
17236 && ( pNext == rhs.pNext )
17237 && ( validationCache == rhs.validationCache );
17238 }
17239
17241 {
17242 return !operator==( rhs );
17243 }
17244
17245 private:
17247
17248 public:
17249 const void* pNext = nullptr;
17251 };
17252 static_assert( sizeof( ShaderModuleValidationCacheCreateInfoEXT ) == sizeof( VkShaderModuleValidationCacheCreateInfoEXT ), "struct and wrapper have different size!" );
17253
17255 {
17257 {
17258 return *reinterpret_cast<const VkPhysicalDeviceMaintenance3Properties*>(this);
17259 }
17260
17262 {
17263 return *reinterpret_cast<VkPhysicalDeviceMaintenance3Properties*>(this);
17264 }
17265
17267 {
17268 return ( sType == rhs.sType )
17269 && ( pNext == rhs.pNext )
17272 }
17273
17275 {
17276 return !operator==( rhs );
17277 }
17278
17279 private:
17281
17282 public:
17283 void* pNext = nullptr;
17286 };
17287 static_assert( sizeof( PhysicalDeviceMaintenance3Properties ) == sizeof( VkPhysicalDeviceMaintenance3Properties ), "struct and wrapper have different size!" );
17288
17290
17292 {
17293 operator VkDescriptorSetLayoutSupport const&() const
17294 {
17295 return *reinterpret_cast<const VkDescriptorSetLayoutSupport*>(this);
17296 }
17297
17299 {
17300 return *reinterpret_cast<VkDescriptorSetLayoutSupport*>(this);
17301 }
17302
17304 {
17305 return ( sType == rhs.sType )
17306 && ( pNext == rhs.pNext )
17307 && ( supported == rhs.supported );
17308 }
17309
17311 {
17312 return !operator==( rhs );
17313 }
17314
17315 private:
17317
17318 public:
17319 void* pNext = nullptr;
17321 };
17322 static_assert( sizeof( DescriptorSetLayoutSupport ) == sizeof( VkDescriptorSetLayoutSupport ), "struct and wrapper have different size!" );
17323
17325
17327 {
17329 : shaderDrawParameters( shaderDrawParameters_ )
17330 {
17331 }
17332
17334 {
17335 memcpy( this, &rhs, sizeof( PhysicalDeviceShaderDrawParameterFeatures ) );
17336 }
17337
17339 {
17340 memcpy( this, &rhs, sizeof( PhysicalDeviceShaderDrawParameterFeatures ) );
17341 return *this;
17342 }
17344 {
17345 pNext = pNext_;
17346 return *this;
17347 }
17348
17350 {
17351 shaderDrawParameters = shaderDrawParameters_;
17352 return *this;
17353 }
17354
17356 {
17357 return *reinterpret_cast<const VkPhysicalDeviceShaderDrawParameterFeatures*>(this);
17358 }
17359
17361 {
17362 return *reinterpret_cast<VkPhysicalDeviceShaderDrawParameterFeatures*>(this);
17363 }
17364
17366 {
17367 return ( sType == rhs.sType )
17368 && ( pNext == rhs.pNext )
17370 }
17371
17373 {
17374 return !operator==( rhs );
17375 }
17376
17377 private:
17379
17380 public:
17381 void* pNext = nullptr;
17383 };
17384 static_assert( sizeof( PhysicalDeviceShaderDrawParameterFeatures ) == sizeof( VkPhysicalDeviceShaderDrawParameterFeatures ), "struct and wrapper have different size!" );
17385
17387 {
17388 DebugUtilsLabelEXT( const char* pLabelName_ = nullptr,
17389 std::array<float,4> const& color_ = { { 0, 0, 0, 0 } } )
17390 : pLabelName( pLabelName_ )
17391 {
17392 memcpy( &color, color_.data(), 4 * sizeof( float ) );
17393 }
17394
17396 {
17397 memcpy( this, &rhs, sizeof( DebugUtilsLabelEXT ) );
17398 }
17399
17401 {
17402 memcpy( this, &rhs, sizeof( DebugUtilsLabelEXT ) );
17403 return *this;
17404 }
17405 DebugUtilsLabelEXT& setPNext( const void* pNext_ )
17406 {
17407 pNext = pNext_;
17408 return *this;
17409 }
17410
17411 DebugUtilsLabelEXT& setPLabelName( const char* pLabelName_ )
17412 {
17413 pLabelName = pLabelName_;
17414 return *this;
17415 }
17416
17417 DebugUtilsLabelEXT& setColor( std::array<float,4> color_ )
17418 {
17419 memcpy( &color, color_.data(), 4 * sizeof( float ) );
17420 return *this;
17421 }
17422
17423 operator VkDebugUtilsLabelEXT const&() const
17424 {
17425 return *reinterpret_cast<const VkDebugUtilsLabelEXT*>(this);
17426 }
17427
17429 {
17430 return *reinterpret_cast<VkDebugUtilsLabelEXT*>(this);
17431 }
17432
17433 bool operator==( DebugUtilsLabelEXT const& rhs ) const
17434 {
17435 return ( sType == rhs.sType )
17436 && ( pNext == rhs.pNext )
17437 && ( pLabelName == rhs.pLabelName )
17438 && ( memcmp( color, rhs.color, 4 * sizeof( float ) ) == 0 );
17439 }
17440
17441 bool operator!=( DebugUtilsLabelEXT const& rhs ) const
17442 {
17443 return !operator==( rhs );
17444 }
17445
17446 private:
17448
17449 public:
17450 const void* pNext = nullptr;
17451 const char* pLabelName;
17452 float color[4];
17453 };
17454 static_assert( sizeof( DebugUtilsLabelEXT ) == sizeof( VkDebugUtilsLabelEXT ), "struct and wrapper have different size!" );
17455
17457 {
17459 : memoryTypeBits( memoryTypeBits_ )
17460 {
17461 }
17462
17464 {
17465 memcpy( this, &rhs, sizeof( MemoryHostPointerPropertiesEXT ) );
17466 }
17467
17469 {
17470 memcpy( this, &rhs, sizeof( MemoryHostPointerPropertiesEXT ) );
17471 return *this;
17472 }
17474 {
17475 pNext = pNext_;
17476 return *this;
17477 }
17478
17480 {
17481 memoryTypeBits = memoryTypeBits_;
17482 return *this;
17483 }
17484
17485 operator VkMemoryHostPointerPropertiesEXT const&() const
17486 {
17487 return *reinterpret_cast<const VkMemoryHostPointerPropertiesEXT*>(this);
17488 }
17489
17491 {
17492 return *reinterpret_cast<VkMemoryHostPointerPropertiesEXT*>(this);
17493 }
17494
17496 {
17497 return ( sType == rhs.sType )
17498 && ( pNext == rhs.pNext )
17499 && ( memoryTypeBits == rhs.memoryTypeBits );
17500 }
17501
17503 {
17504 return !operator==( rhs );
17505 }
17506
17507 private:
17509
17510 public:
17511 void* pNext = nullptr;
17513 };
17514 static_assert( sizeof( MemoryHostPointerPropertiesEXT ) == sizeof( VkMemoryHostPointerPropertiesEXT ), "struct and wrapper have different size!" );
17515
17517 {
17518 PhysicalDeviceExternalMemoryHostPropertiesEXT( DeviceSize minImportedHostPointerAlignment_ = 0 )
17519 : minImportedHostPointerAlignment( minImportedHostPointerAlignment_ )
17520 {
17521 }
17522
17524 {
17526 }
17527
17529 {
17531 return *this;
17532 }
17534 {
17535 pNext = pNext_;
17536 return *this;
17537 }
17538
17540 {
17541 minImportedHostPointerAlignment = minImportedHostPointerAlignment_;
17542 return *this;
17543 }
17544
17546 {
17547 return *reinterpret_cast<const VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(this);
17548 }
17549
17551 {
17552 return *reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(this);
17553 }
17554
17556 {
17557 return ( sType == rhs.sType )
17558 && ( pNext == rhs.pNext )
17560 }
17561
17563 {
17564 return !operator==( rhs );
17565 }
17566
17567 private:
17569
17570 public:
17571 void* pNext = nullptr;
17573 };
17574 static_assert( sizeof( PhysicalDeviceExternalMemoryHostPropertiesEXT ) == sizeof( VkPhysicalDeviceExternalMemoryHostPropertiesEXT ), "struct and wrapper have different size!" );
17575
17577 {
17578 PhysicalDeviceConservativeRasterizationPropertiesEXT( float primitiveOverestimationSize_ = 0,
17579 float maxExtraPrimitiveOverestimationSize_ = 0,
17580 float extraPrimitiveOverestimationSizeGranularity_ = 0,
17581 Bool32 primitiveUnderestimation_ = 0,
17582 Bool32 conservativePointAndLineRasterization_ = 0,
17583 Bool32 degenerateTrianglesRasterized_ = 0,
17584 Bool32 degenerateLinesRasterized_ = 0,
17585 Bool32 fullyCoveredFragmentShaderInputVariable_ = 0,
17586 Bool32 conservativeRasterizationPostDepthCoverage_ = 0 )
17587 : primitiveOverestimationSize( primitiveOverestimationSize_ )
17588 , maxExtraPrimitiveOverestimationSize( maxExtraPrimitiveOverestimationSize_ )
17589 , extraPrimitiveOverestimationSizeGranularity( extraPrimitiveOverestimationSizeGranularity_ )
17590 , primitiveUnderestimation( primitiveUnderestimation_ )
17591 , conservativePointAndLineRasterization( conservativePointAndLineRasterization_ )
17592 , degenerateTrianglesRasterized( degenerateTrianglesRasterized_ )
17593 , degenerateLinesRasterized( degenerateLinesRasterized_ )
17594 , fullyCoveredFragmentShaderInputVariable( fullyCoveredFragmentShaderInputVariable_ )
17595 , conservativeRasterizationPostDepthCoverage( conservativeRasterizationPostDepthCoverage_ )
17596 {
17597 }
17598
17600 {
17602 }
17603
17605 {
17607 return *this;
17608 }
17610 {
17611 pNext = pNext_;
17612 return *this;
17613 }
17614
17616 {
17617 primitiveOverestimationSize = primitiveOverestimationSize_;
17618 return *this;
17619 }
17620
17622 {
17623 maxExtraPrimitiveOverestimationSize = maxExtraPrimitiveOverestimationSize_;
17624 return *this;
17625 }
17626
17628 {
17629 extraPrimitiveOverestimationSizeGranularity = extraPrimitiveOverestimationSizeGranularity_;
17630 return *this;
17631 }
17632
17634 {
17635 primitiveUnderestimation = primitiveUnderestimation_;
17636 return *this;
17637 }
17638
17640 {
17641 conservativePointAndLineRasterization = conservativePointAndLineRasterization_;
17642 return *this;
17643 }
17644
17646 {
17647 degenerateTrianglesRasterized = degenerateTrianglesRasterized_;
17648 return *this;
17649 }
17650
17652 {
17653 degenerateLinesRasterized = degenerateLinesRasterized_;
17654 return *this;
17655 }
17656
17658 {
17659 fullyCoveredFragmentShaderInputVariable = fullyCoveredFragmentShaderInputVariable_;
17660 return *this;
17661 }
17662
17664 {
17665 conservativeRasterizationPostDepthCoverage = conservativeRasterizationPostDepthCoverage_;
17666 return *this;
17667 }
17668
17670 {
17671 return *reinterpret_cast<const VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(this);
17672 }
17673
17675 {
17676 return *reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(this);
17677 }
17678
17680 {
17681 return ( sType == rhs.sType )
17682 && ( pNext == rhs.pNext )
17692 }
17693
17695 {
17696 return !operator==( rhs );
17697 }
17698
17699 private:
17701
17702 public:
17703 void* pNext = nullptr;
17713 };
17714 static_assert( sizeof( PhysicalDeviceConservativeRasterizationPropertiesEXT ) == sizeof( VkPhysicalDeviceConservativeRasterizationPropertiesEXT ), "struct and wrapper have different size!" );
17715
17717 {
17719 {
17720 return *reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesAMD*>(this);
17721 }
17722
17724 {
17725 return *reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD*>(this);
17726 }
17727
17729 {
17730 return ( sType == rhs.sType )
17731 && ( pNext == rhs.pNext )
17737 && ( wavefrontSize == rhs.wavefrontSize )
17738 && ( sgprsPerSimd == rhs.sgprsPerSimd )
17742 && ( vgprsPerSimd == rhs.vgprsPerSimd )
17746 }
17747
17749 {
17750 return !operator==( rhs );
17751 }
17752
17753 private:
17755
17756 public:
17757 void* pNext = nullptr;
17772 };
17773 static_assert( sizeof( PhysicalDeviceShaderCorePropertiesAMD ) == sizeof( VkPhysicalDeviceShaderCorePropertiesAMD ), "struct and wrapper have different size!" );
17774
17776 {
17777 PhysicalDeviceDescriptorIndexingFeaturesEXT( Bool32 shaderInputAttachmentArrayDynamicIndexing_ = 0,
17778 Bool32 shaderUniformTexelBufferArrayDynamicIndexing_ = 0,
17779 Bool32 shaderStorageTexelBufferArrayDynamicIndexing_ = 0,
17780 Bool32 shaderUniformBufferArrayNonUniformIndexing_ = 0,
17781 Bool32 shaderSampledImageArrayNonUniformIndexing_ = 0,
17782 Bool32 shaderStorageBufferArrayNonUniformIndexing_ = 0,
17783 Bool32 shaderStorageImageArrayNonUniformIndexing_ = 0,
17784 Bool32 shaderInputAttachmentArrayNonUniformIndexing_ = 0,
17785 Bool32 shaderUniformTexelBufferArrayNonUniformIndexing_ = 0,
17786 Bool32 shaderStorageTexelBufferArrayNonUniformIndexing_ = 0,
17787 Bool32 descriptorBindingUniformBufferUpdateAfterBind_ = 0,
17788 Bool32 descriptorBindingSampledImageUpdateAfterBind_ = 0,
17789 Bool32 descriptorBindingStorageImageUpdateAfterBind_ = 0,
17790 Bool32 descriptorBindingStorageBufferUpdateAfterBind_ = 0,
17791 Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind_ = 0,
17792 Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind_ = 0,
17793 Bool32 descriptorBindingUpdateUnusedWhilePending_ = 0,
17794 Bool32 descriptorBindingPartiallyBound_ = 0,
17795 Bool32 descriptorBindingVariableDescriptorCount_ = 0,
17796 Bool32 runtimeDescriptorArray_ = 0 )
17797 : shaderInputAttachmentArrayDynamicIndexing( shaderInputAttachmentArrayDynamicIndexing_ )
17798 , shaderUniformTexelBufferArrayDynamicIndexing( shaderUniformTexelBufferArrayDynamicIndexing_ )
17799 , shaderStorageTexelBufferArrayDynamicIndexing( shaderStorageTexelBufferArrayDynamicIndexing_ )
17800 , shaderUniformBufferArrayNonUniformIndexing( shaderUniformBufferArrayNonUniformIndexing_ )
17801 , shaderSampledImageArrayNonUniformIndexing( shaderSampledImageArrayNonUniformIndexing_ )
17802 , shaderStorageBufferArrayNonUniformIndexing( shaderStorageBufferArrayNonUniformIndexing_ )
17803 , shaderStorageImageArrayNonUniformIndexing( shaderStorageImageArrayNonUniformIndexing_ )
17804 , shaderInputAttachmentArrayNonUniformIndexing( shaderInputAttachmentArrayNonUniformIndexing_ )
17805 , shaderUniformTexelBufferArrayNonUniformIndexing( shaderUniformTexelBufferArrayNonUniformIndexing_ )
17806 , shaderStorageTexelBufferArrayNonUniformIndexing( shaderStorageTexelBufferArrayNonUniformIndexing_ )
17807 , descriptorBindingUniformBufferUpdateAfterBind( descriptorBindingUniformBufferUpdateAfterBind_ )
17808 , descriptorBindingSampledImageUpdateAfterBind( descriptorBindingSampledImageUpdateAfterBind_ )
17809 , descriptorBindingStorageImageUpdateAfterBind( descriptorBindingStorageImageUpdateAfterBind_ )
17810 , descriptorBindingStorageBufferUpdateAfterBind( descriptorBindingStorageBufferUpdateAfterBind_ )
17811 , descriptorBindingUniformTexelBufferUpdateAfterBind( descriptorBindingUniformTexelBufferUpdateAfterBind_ )
17812 , descriptorBindingStorageTexelBufferUpdateAfterBind( descriptorBindingStorageTexelBufferUpdateAfterBind_ )
17813 , descriptorBindingUpdateUnusedWhilePending( descriptorBindingUpdateUnusedWhilePending_ )
17814 , descriptorBindingPartiallyBound( descriptorBindingPartiallyBound_ )
17815 , descriptorBindingVariableDescriptorCount( descriptorBindingVariableDescriptorCount_ )
17816 , runtimeDescriptorArray( runtimeDescriptorArray_ )
17817 {
17818 }
17819
17821 {
17822 memcpy( this, &rhs, sizeof( PhysicalDeviceDescriptorIndexingFeaturesEXT ) );
17823 }
17824
17826 {
17827 memcpy( this, &rhs, sizeof( PhysicalDeviceDescriptorIndexingFeaturesEXT ) );
17828 return *this;
17829 }
17831 {
17832 pNext = pNext_;
17833 return *this;
17834 }
17835
17837 {
17838 shaderInputAttachmentArrayDynamicIndexing = shaderInputAttachmentArrayDynamicIndexing_;
17839 return *this;
17840 }
17841
17843 {
17844 shaderUniformTexelBufferArrayDynamicIndexing = shaderUniformTexelBufferArrayDynamicIndexing_;
17845 return *this;
17846 }
17847
17849 {
17850 shaderStorageTexelBufferArrayDynamicIndexing = shaderStorageTexelBufferArrayDynamicIndexing_;
17851 return *this;
17852 }
17853
17855 {
17856 shaderUniformBufferArrayNonUniformIndexing = shaderUniformBufferArrayNonUniformIndexing_;
17857 return *this;
17858 }
17859
17861 {
17862 shaderSampledImageArrayNonUniformIndexing = shaderSampledImageArrayNonUniformIndexing_;
17863 return *this;
17864 }
17865
17867 {
17868 shaderStorageBufferArrayNonUniformIndexing = shaderStorageBufferArrayNonUniformIndexing_;
17869 return *this;
17870 }
17871
17873 {
17874 shaderStorageImageArrayNonUniformIndexing = shaderStorageImageArrayNonUniformIndexing_;
17875 return *this;
17876 }
17877
17879 {
17880 shaderInputAttachmentArrayNonUniformIndexing = shaderInputAttachmentArrayNonUniformIndexing_;
17881 return *this;
17882 }
17883
17885 {
17886 shaderUniformTexelBufferArrayNonUniformIndexing = shaderUniformTexelBufferArrayNonUniformIndexing_;
17887 return *this;
17888 }
17889
17891 {
17892 shaderStorageTexelBufferArrayNonUniformIndexing = shaderStorageTexelBufferArrayNonUniformIndexing_;
17893 return *this;
17894 }
17895
17897 {
17898 descriptorBindingUniformBufferUpdateAfterBind = descriptorBindingUniformBufferUpdateAfterBind_;
17899 return *this;
17900 }
17901
17903 {
17904 descriptorBindingSampledImageUpdateAfterBind = descriptorBindingSampledImageUpdateAfterBind_;
17905 return *this;
17906 }
17907
17909 {
17910 descriptorBindingStorageImageUpdateAfterBind = descriptorBindingStorageImageUpdateAfterBind_;
17911 return *this;
17912 }
17913
17915 {
17916 descriptorBindingStorageBufferUpdateAfterBind = descriptorBindingStorageBufferUpdateAfterBind_;
17917 return *this;
17918 }
17919
17921 {
17922 descriptorBindingUniformTexelBufferUpdateAfterBind = descriptorBindingUniformTexelBufferUpdateAfterBind_;
17923 return *this;
17924 }
17925
17927 {
17928 descriptorBindingStorageTexelBufferUpdateAfterBind = descriptorBindingStorageTexelBufferUpdateAfterBind_;
17929 return *this;
17930 }
17931
17933 {
17934 descriptorBindingUpdateUnusedWhilePending = descriptorBindingUpdateUnusedWhilePending_;
17935 return *this;
17936 }
17937
17939 {
17940 descriptorBindingPartiallyBound = descriptorBindingPartiallyBound_;
17941 return *this;
17942 }
17943
17945 {
17946 descriptorBindingVariableDescriptorCount = descriptorBindingVariableDescriptorCount_;
17947 return *this;
17948 }
17949
17951 {
17952 runtimeDescriptorArray = runtimeDescriptorArray_;
17953 return *this;
17954 }
17955
17957 {
17958 return *reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeaturesEXT*>(this);
17959 }
17960
17962 {
17963 return *reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeaturesEXT*>(this);
17964 }
17965
17967 {
17968 return ( sType == rhs.sType )
17969 && ( pNext == rhs.pNext )
17990 }
17991
17993 {
17994 return !operator==( rhs );
17995 }
17996
17997 private:
17999
18000 public:
18001 void* pNext = nullptr;
18022 };
18023 static_assert( sizeof( PhysicalDeviceDescriptorIndexingFeaturesEXT ) == sizeof( VkPhysicalDeviceDescriptorIndexingFeaturesEXT ), "struct and wrapper have different size!" );
18024
18026 {
18028 {
18029 return *reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingPropertiesEXT*>(this);
18030 }
18031
18033 {
18034 return *reinterpret_cast<VkPhysicalDeviceDescriptorIndexingPropertiesEXT*>(this);
18035 }
18036
18038 {
18039 return ( sType == rhs.sType )
18040 && ( pNext == rhs.pNext )
18064 }
18065
18067 {
18068 return !operator==( rhs );
18069 }
18070
18071 private:
18073
18074 public:
18075 void* pNext = nullptr;
18099 };
18100 static_assert( sizeof( PhysicalDeviceDescriptorIndexingPropertiesEXT ) == sizeof( VkPhysicalDeviceDescriptorIndexingPropertiesEXT ), "struct and wrapper have different size!" );
18101
18103 {
18105 const uint32_t* pDescriptorCounts_ = nullptr )
18106 : descriptorSetCount( descriptorSetCount_ )
18107 , pDescriptorCounts( pDescriptorCounts_ )
18108 {
18109 }
18110
18112 {
18114 }
18115
18117 {
18119 return *this;
18120 }
18122 {
18123 pNext = pNext_;
18124 return *this;
18125 }
18126
18128 {
18129 descriptorSetCount = descriptorSetCount_;
18130 return *this;
18131 }
18132
18134 {
18135 pDescriptorCounts = pDescriptorCounts_;
18136 return *this;
18137 }
18138
18140 {
18141 return *reinterpret_cast<const VkDescriptorSetVariableDescriptorCountAllocateInfoEXT*>(this);
18142 }
18143
18145 {
18146 return *reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfoEXT*>(this);
18147 }
18148
18150 {
18151 return ( sType == rhs.sType )
18152 && ( pNext == rhs.pNext )
18155 }
18156
18158 {
18159 return !operator==( rhs );
18160 }
18161
18162 private:
18164
18165 public:
18166 const void* pNext = nullptr;
18169 };
18170 static_assert( sizeof( DescriptorSetVariableDescriptorCountAllocateInfoEXT ) == sizeof( VkDescriptorSetVariableDescriptorCountAllocateInfoEXT ), "struct and wrapper have different size!" );
18171
18173 {
18175 {
18176 return *reinterpret_cast<const VkDescriptorSetVariableDescriptorCountLayoutSupportEXT*>(this);
18177 }
18178
18180 {
18181 return *reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupportEXT*>(this);
18182 }
18183
18185 {
18186 return ( sType == rhs.sType )
18187 && ( pNext == rhs.pNext )
18189 }
18190
18192 {
18193 return !operator==( rhs );
18194 }
18195
18196 private:
18198
18199 public:
18200 void* pNext = nullptr;
18202 };
18203 static_assert( sizeof( DescriptorSetVariableDescriptorCountLayoutSupportEXT ) == sizeof( VkDescriptorSetVariableDescriptorCountLayoutSupportEXT ), "struct and wrapper have different size!" );
18204
18206 {
18208 {
18209 }
18210
18212 {
18213 memcpy( this, &rhs, sizeof( SubpassEndInfoKHR ) );
18214 }
18215
18217 {
18218 memcpy( this, &rhs, sizeof( SubpassEndInfoKHR ) );
18219 return *this;
18220 }
18221 SubpassEndInfoKHR& setPNext( const void* pNext_ )
18222 {
18223 pNext = pNext_;
18224 return *this;
18225 }
18226
18227 operator VkSubpassEndInfoKHR const&() const
18228 {
18229 return *reinterpret_cast<const VkSubpassEndInfoKHR*>(this);
18230 }
18231
18233 {
18234 return *reinterpret_cast<VkSubpassEndInfoKHR*>(this);
18235 }
18236
18237 bool operator==( SubpassEndInfoKHR const& rhs ) const
18238 {
18239 return ( sType == rhs.sType )
18240 && ( pNext == rhs.pNext );
18241 }
18242
18243 bool operator!=( SubpassEndInfoKHR const& rhs ) const
18244 {
18245 return !operator==( rhs );
18246 }
18247
18248 private:
18250
18251 public:
18252 const void* pNext = nullptr;
18253 };
18254 static_assert( sizeof( SubpassEndInfoKHR ) == sizeof( VkSubpassEndInfoKHR ), "struct and wrapper have different size!" );
18255
18257 {
18259 const VertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors_ = nullptr )
18260 : vertexBindingDivisorCount( vertexBindingDivisorCount_ )
18261 , pVertexBindingDivisors( pVertexBindingDivisors_ )
18262 {
18263 }
18264
18266 {
18268 }
18269
18271 {
18273 return *this;
18274 }
18276 {
18277 pNext = pNext_;
18278 return *this;
18279 }
18280
18282 {
18283 vertexBindingDivisorCount = vertexBindingDivisorCount_;
18284 return *this;
18285 }
18286
18288 {
18289 pVertexBindingDivisors = pVertexBindingDivisors_;
18290 return *this;
18291 }
18292
18294 {
18295 return *reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfoEXT*>(this);
18296 }
18297
18299 {
18300 return *reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoEXT*>(this);
18301 }
18302
18304 {
18305 return ( sType == rhs.sType )
18306 && ( pNext == rhs.pNext )
18309 }
18310
18312 {
18313 return !operator==( rhs );
18314 }
18315
18316 private:
18318
18319 public:
18320 const void* pNext = nullptr;
18323 };
18324 static_assert( sizeof( PipelineVertexInputDivisorStateCreateInfoEXT ) == sizeof( VkPipelineVertexInputDivisorStateCreateInfoEXT ), "struct and wrapper have different size!" );
18325
18327 {
18329 : maxVertexAttribDivisor( maxVertexAttribDivisor_ )
18330 {
18331 }
18332
18334 {
18336 }
18337
18339 {
18341 return *this;
18342 }
18344 {
18345 pNext = pNext_;
18346 return *this;
18347 }
18348
18350 {
18351 maxVertexAttribDivisor = maxVertexAttribDivisor_;
18352 return *this;
18353 }
18354
18356 {
18357 return *reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(this);
18358 }
18359
18361 {
18362 return *reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT*>(this);
18363 }
18364
18366 {
18367 return ( sType == rhs.sType )
18368 && ( pNext == rhs.pNext )
18370 }
18371
18373 {
18374 return !operator==( rhs );
18375 }
18376
18377 private:
18379
18380 public:
18381 void* pNext = nullptr;
18383 };
18384 static_assert( sizeof( PhysicalDeviceVertexAttributeDivisorPropertiesEXT ) == sizeof( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT ), "struct and wrapper have different size!" );
18385
18387 {
18389 {
18390 return *reinterpret_cast<const VkPhysicalDevicePCIBusInfoPropertiesEXT*>(this);
18391 }
18392
18394 {
18395 return *reinterpret_cast<VkPhysicalDevicePCIBusInfoPropertiesEXT*>(this);
18396 }
18397
18399 {
18400 return ( sType == rhs.sType )
18401 && ( pNext == rhs.pNext )
18402 && ( pciDomain == rhs.pciDomain )
18403 && ( pciBus == rhs.pciBus )
18404 && ( pciDevice == rhs.pciDevice )
18405 && ( pciFunction == rhs.pciFunction );
18406 }
18407
18409 {
18410 return !operator==( rhs );
18411 }
18412
18413 private:
18415
18416 public:
18417 void* pNext = nullptr;
18422 };
18423 static_assert( sizeof( PhysicalDevicePCIBusInfoPropertiesEXT ) == sizeof( VkPhysicalDevicePCIBusInfoPropertiesEXT ), "struct and wrapper have different size!" );
18424
18425#ifdef VK_USE_PLATFORM_ANDROID_ANDROID
18426 struct ImportAndroidHardwareBufferInfoANDROID
18427 {
18428 ImportAndroidHardwareBufferInfoANDROID( struct AHardwareBuffer* buffer_ = nullptr )
18429 : buffer( buffer_ )
18430 {
18431 }
18432
18433 ImportAndroidHardwareBufferInfoANDROID( VkImportAndroidHardwareBufferInfoANDROID const & rhs )
18434 {
18435 memcpy( this, &rhs, sizeof( ImportAndroidHardwareBufferInfoANDROID ) );
18436 }
18437
18438 ImportAndroidHardwareBufferInfoANDROID& operator=( VkImportAndroidHardwareBufferInfoANDROID const & rhs )
18439 {
18440 memcpy( this, &rhs, sizeof( ImportAndroidHardwareBufferInfoANDROID ) );
18441 return *this;
18442 }
18443 ImportAndroidHardwareBufferInfoANDROID& setPNext( const void* pNext_ )
18444 {
18445 pNext = pNext_;
18446 return *this;
18447 }
18448
18449 ImportAndroidHardwareBufferInfoANDROID& setBuffer( struct AHardwareBuffer* buffer_ )
18450 {
18451 buffer = buffer_;
18452 return *this;
18453 }
18454
18455 operator VkImportAndroidHardwareBufferInfoANDROID const&() const
18456 {
18457 return *reinterpret_cast<const VkImportAndroidHardwareBufferInfoANDROID*>(this);
18458 }
18459
18461 {
18462 return *reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID*>(this);
18463 }
18464
18465 bool operator==( ImportAndroidHardwareBufferInfoANDROID const& rhs ) const
18466 {
18467 return ( sType == rhs.sType )
18468 && ( pNext == rhs.pNext )
18469 && ( buffer == rhs.buffer );
18470 }
18471
18472 bool operator!=( ImportAndroidHardwareBufferInfoANDROID const& rhs ) const
18473 {
18474 return !operator==( rhs );
18475 }
18476
18477 private:
18479
18480 public:
18481 const void* pNext = nullptr;
18482 struct AHardwareBuffer* buffer;
18483 };
18484 static_assert( sizeof( ImportAndroidHardwareBufferInfoANDROID ) == sizeof( VkImportAndroidHardwareBufferInfoANDROID ), "struct and wrapper have different size!" );
18485#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/
18486
18487#ifdef VK_USE_PLATFORM_ANDROID_ANDROID
18488 struct AndroidHardwareBufferUsageANDROID
18489 {
18490 operator VkAndroidHardwareBufferUsageANDROID const&() const
18491 {
18492 return *reinterpret_cast<const VkAndroidHardwareBufferUsageANDROID*>(this);
18493 }
18494
18496 {
18497 return *reinterpret_cast<VkAndroidHardwareBufferUsageANDROID*>(this);
18498 }
18499
18500 bool operator==( AndroidHardwareBufferUsageANDROID const& rhs ) const
18501 {
18502 return ( sType == rhs.sType )
18503 && ( pNext == rhs.pNext )
18504 && ( androidHardwareBufferUsage == rhs.androidHardwareBufferUsage );
18505 }
18506
18507 bool operator!=( AndroidHardwareBufferUsageANDROID const& rhs ) const
18508 {
18509 return !operator==( rhs );
18510 }
18511
18512 private:
18514
18515 public:
18516 void* pNext = nullptr;
18517 uint64_t androidHardwareBufferUsage;
18518 };
18519 static_assert( sizeof( AndroidHardwareBufferUsageANDROID ) == sizeof( VkAndroidHardwareBufferUsageANDROID ), "struct and wrapper have different size!" );
18520#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/
18521
18522#ifdef VK_USE_PLATFORM_ANDROID_ANDROID
18523 struct AndroidHardwareBufferPropertiesANDROID
18524 {
18525 operator VkAndroidHardwareBufferPropertiesANDROID const&() const
18526 {
18527 return *reinterpret_cast<const VkAndroidHardwareBufferPropertiesANDROID*>(this);
18528 }
18529
18531 {
18532 return *reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID*>(this);
18533 }
18534
18535 bool operator==( AndroidHardwareBufferPropertiesANDROID const& rhs ) const
18536 {
18537 return ( sType == rhs.sType )
18538 && ( pNext == rhs.pNext )
18539 && ( allocationSize == rhs.allocationSize )
18540 && ( memoryTypeBits == rhs.memoryTypeBits );
18541 }
18542
18543 bool operator!=( AndroidHardwareBufferPropertiesANDROID const& rhs ) const
18544 {
18545 return !operator==( rhs );
18546 }
18547
18548 private:
18550
18551 public:
18552 void* pNext = nullptr;
18553 DeviceSize allocationSize;
18554 uint32_t memoryTypeBits;
18555 };
18556 static_assert( sizeof( AndroidHardwareBufferPropertiesANDROID ) == sizeof( VkAndroidHardwareBufferPropertiesANDROID ), "struct and wrapper have different size!" );
18557#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/
18558
18559#ifdef VK_USE_PLATFORM_ANDROID_ANDROID
18560 struct MemoryGetAndroidHardwareBufferInfoANDROID
18561 {
18562 MemoryGetAndroidHardwareBufferInfoANDROID( DeviceMemory memory_ = DeviceMemory() )
18563 : memory( memory_ )
18564 {
18565 }
18566
18567 MemoryGetAndroidHardwareBufferInfoANDROID( VkMemoryGetAndroidHardwareBufferInfoANDROID const & rhs )
18568 {
18569 memcpy( this, &rhs, sizeof( MemoryGetAndroidHardwareBufferInfoANDROID ) );
18570 }
18571
18572 MemoryGetAndroidHardwareBufferInfoANDROID& operator=( VkMemoryGetAndroidHardwareBufferInfoANDROID const & rhs )
18573 {
18574 memcpy( this, &rhs, sizeof( MemoryGetAndroidHardwareBufferInfoANDROID ) );
18575 return *this;
18576 }
18577 MemoryGetAndroidHardwareBufferInfoANDROID& setPNext( const void* pNext_ )
18578 {
18579 pNext = pNext_;
18580 return *this;
18581 }
18582
18583 MemoryGetAndroidHardwareBufferInfoANDROID& setMemory( DeviceMemory memory_ )
18584 {
18585 memory = memory_;
18586 return *this;
18587 }
18588
18589 operator VkMemoryGetAndroidHardwareBufferInfoANDROID const&() const
18590 {
18591 return *reinterpret_cast<const VkMemoryGetAndroidHardwareBufferInfoANDROID*>(this);
18592 }
18593
18595 {
18596 return *reinterpret_cast<VkMemoryGetAndroidHardwareBufferInfoANDROID*>(this);
18597 }
18598
18599 bool operator==( MemoryGetAndroidHardwareBufferInfoANDROID const& rhs ) const
18600 {
18601 return ( sType == rhs.sType )
18602 && ( pNext == rhs.pNext )
18603 && ( memory == rhs.memory );
18604 }
18605
18606 bool operator!=( MemoryGetAndroidHardwareBufferInfoANDROID const& rhs ) const
18607 {
18608 return !operator==( rhs );
18609 }
18610
18611 private:
18613
18614 public:
18615 const void* pNext = nullptr;
18616 DeviceMemory memory;
18617 };
18618 static_assert( sizeof( MemoryGetAndroidHardwareBufferInfoANDROID ) == sizeof( VkMemoryGetAndroidHardwareBufferInfoANDROID ), "struct and wrapper have different size!" );
18619#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/
18620
18622 {
18624 : conditionalRenderingEnable( conditionalRenderingEnable_ )
18625 {
18626 }
18627
18629 {
18631 }
18632
18634 {
18636 return *this;
18637 }
18639 {
18640 pNext = pNext_;
18641 return *this;
18642 }
18643
18645 {
18646 conditionalRenderingEnable = conditionalRenderingEnable_;
18647 return *this;
18648 }
18649
18651 {
18652 return *reinterpret_cast<const VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(this);
18653 }
18654
18656 {
18657 return *reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT*>(this);
18658 }
18659
18661 {
18662 return ( sType == rhs.sType )
18663 && ( pNext == rhs.pNext )
18665 }
18666
18668 {
18669 return !operator==( rhs );
18670 }
18671
18672 private:
18674
18675 public:
18676 const void* pNext = nullptr;
18678 };
18679 static_assert( sizeof( CommandBufferInheritanceConditionalRenderingInfoEXT ) == sizeof( VkCommandBufferInheritanceConditionalRenderingInfoEXT ), "struct and wrapper have different size!" );
18680
18681#ifdef VK_USE_PLATFORM_ANDROID_ANDROID
18682 struct ExternalFormatANDROID
18683 {
18684 ExternalFormatANDROID( uint64_t externalFormat_ = 0 )
18685 : externalFormat( externalFormat_ )
18686 {
18687 }
18688
18689 ExternalFormatANDROID( VkExternalFormatANDROID const & rhs )
18690 {
18691 memcpy( this, &rhs, sizeof( ExternalFormatANDROID ) );
18692 }
18693
18694 ExternalFormatANDROID& operator=( VkExternalFormatANDROID const & rhs )
18695 {
18696 memcpy( this, &rhs, sizeof( ExternalFormatANDROID ) );
18697 return *this;
18698 }
18699 ExternalFormatANDROID& setPNext( void* pNext_ )
18700 {
18701 pNext = pNext_;
18702 return *this;
18703 }
18704
18705 ExternalFormatANDROID& setExternalFormat( uint64_t externalFormat_ )
18706 {
18707 externalFormat = externalFormat_;
18708 return *this;
18709 }
18710
18711 operator VkExternalFormatANDROID const&() const
18712 {
18713 return *reinterpret_cast<const VkExternalFormatANDROID*>(this);
18714 }
18715
18716 operator VkExternalFormatANDROID &()
18717 {
18718 return *reinterpret_cast<VkExternalFormatANDROID*>(this);
18719 }
18720
18721 bool operator==( ExternalFormatANDROID const& rhs ) const
18722 {
18723 return ( sType == rhs.sType )
18724 && ( pNext == rhs.pNext )
18725 && ( externalFormat == rhs.externalFormat );
18726 }
18727
18728 bool operator!=( ExternalFormatANDROID const& rhs ) const
18729 {
18730 return !operator==( rhs );
18731 }
18732
18733 private:
18735
18736 public:
18737 void* pNext = nullptr;
18738 uint64_t externalFormat;
18739 };
18740 static_assert( sizeof( ExternalFormatANDROID ) == sizeof( VkExternalFormatANDROID ), "struct and wrapper have different size!" );
18741#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/
18742
18744 {
18745 PhysicalDevice8BitStorageFeaturesKHR( Bool32 storageBuffer8BitAccess_ = 0,
18746 Bool32 uniformAndStorageBuffer8BitAccess_ = 0,
18747 Bool32 storagePushConstant8_ = 0 )
18748 : storageBuffer8BitAccess( storageBuffer8BitAccess_ )
18749 , uniformAndStorageBuffer8BitAccess( uniformAndStorageBuffer8BitAccess_ )
18750 , storagePushConstant8( storagePushConstant8_ )
18751 {
18752 }
18753
18755 {
18756 memcpy( this, &rhs, sizeof( PhysicalDevice8BitStorageFeaturesKHR ) );
18757 }
18758
18760 {
18761 memcpy( this, &rhs, sizeof( PhysicalDevice8BitStorageFeaturesKHR ) );
18762 return *this;
18763 }
18765 {
18766 pNext = pNext_;
18767 return *this;
18768 }
18769
18771 {
18772 storageBuffer8BitAccess = storageBuffer8BitAccess_;
18773 return *this;
18774 }
18775
18777 {
18778 uniformAndStorageBuffer8BitAccess = uniformAndStorageBuffer8BitAccess_;
18779 return *this;
18780 }
18781
18783 {
18784 storagePushConstant8 = storagePushConstant8_;
18785 return *this;
18786 }
18787
18789 {
18790 return *reinterpret_cast<const VkPhysicalDevice8BitStorageFeaturesKHR*>(this);
18791 }
18792
18794 {
18795 return *reinterpret_cast<VkPhysicalDevice8BitStorageFeaturesKHR*>(this);
18796 }
18797
18799 {
18800 return ( sType == rhs.sType )
18801 && ( pNext == rhs.pNext )
18805 }
18806
18808 {
18809 return !operator==( rhs );
18810 }
18811
18812 private:
18814
18815 public:
18816 void* pNext = nullptr;
18820 };
18821 static_assert( sizeof( PhysicalDevice8BitStorageFeaturesKHR ) == sizeof( VkPhysicalDevice8BitStorageFeaturesKHR ), "struct and wrapper have different size!" );
18822
18824 {
18826 Bool32 inheritedConditionalRendering_ = 0 )
18827 : conditionalRendering( conditionalRendering_ )
18828 , inheritedConditionalRendering( inheritedConditionalRendering_ )
18829 {
18830 }
18831
18833 {
18835 }
18836
18838 {
18840 return *this;
18841 }
18843 {
18844 pNext = pNext_;
18845 return *this;
18846 }
18847
18849 {
18850 conditionalRendering = conditionalRendering_;
18851 return *this;
18852 }
18853
18855 {
18856 inheritedConditionalRendering = inheritedConditionalRendering_;
18857 return *this;
18858 }
18859
18861 {
18862 return *reinterpret_cast<const VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(this);
18863 }
18864
18866 {
18867 return *reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT*>(this);
18868 }
18869
18871 {
18872 return ( sType == rhs.sType )
18873 && ( pNext == rhs.pNext )
18876 }
18877
18879 {
18880 return !operator==( rhs );
18881 }
18882
18883 private:
18885
18886 public:
18887 void* pNext = nullptr;
18890 };
18891 static_assert( sizeof( PhysicalDeviceConditionalRenderingFeaturesEXT ) == sizeof( VkPhysicalDeviceConditionalRenderingFeaturesEXT ), "struct and wrapper have different size!" );
18892
18894 {
18896 {
18897 return *reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeaturesKHR*>(this);
18898 }
18899
18901 {
18902 return *reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeaturesKHR*>(this);
18903 }
18904
18906 {
18907 return ( sType == rhs.sType )
18908 && ( pNext == rhs.pNext )
18911 }
18912
18914 {
18915 return !operator==( rhs );
18916 }
18917
18918 private:
18920
18921 public:
18922 void* pNext = nullptr;
18925 };
18926 static_assert( sizeof( PhysicalDeviceVulkanMemoryModelFeaturesKHR ) == sizeof( VkPhysicalDeviceVulkanMemoryModelFeaturesKHR ), "struct and wrapper have different size!" );
18927
18929 {
18931 Bool32 shaderSharedInt64Atomics_ = 0 )
18932 : shaderBufferInt64Atomics( shaderBufferInt64Atomics_ )
18933 , shaderSharedInt64Atomics( shaderSharedInt64Atomics_ )
18934 {
18935 }
18936
18938 {
18939 memcpy( this, &rhs, sizeof( PhysicalDeviceShaderAtomicInt64FeaturesKHR ) );
18940 }
18941
18943 {
18944 memcpy( this, &rhs, sizeof( PhysicalDeviceShaderAtomicInt64FeaturesKHR ) );
18945 return *this;
18946 }
18948 {
18949 pNext = pNext_;
18950 return *this;
18951 }
18952
18954 {
18955 shaderBufferInt64Atomics = shaderBufferInt64Atomics_;
18956 return *this;
18957 }
18958
18960 {
18961 shaderSharedInt64Atomics = shaderSharedInt64Atomics_;
18962 return *this;
18963 }
18964
18966 {
18967 return *reinterpret_cast<const VkPhysicalDeviceShaderAtomicInt64FeaturesKHR*>(this);
18968 }
18969
18971 {
18972 return *reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64FeaturesKHR*>(this);
18973 }
18974
18976 {
18977 return ( sType == rhs.sType )
18978 && ( pNext == rhs.pNext )
18981 }
18982
18984 {
18985 return !operator==( rhs );
18986 }
18987
18988 private:
18990
18991 public:
18992 void* pNext = nullptr;
18995 };
18996 static_assert( sizeof( PhysicalDeviceShaderAtomicInt64FeaturesKHR ) == sizeof( VkPhysicalDeviceShaderAtomicInt64FeaturesKHR ), "struct and wrapper have different size!" );
18997
18999 {
19000 PhysicalDeviceVertexAttributeDivisorFeaturesEXT( Bool32 vertexAttributeInstanceRateDivisor_ = 0,
19001 Bool32 vertexAttributeInstanceRateZeroDivisor_ = 0 )
19002 : vertexAttributeInstanceRateDivisor( vertexAttributeInstanceRateDivisor_ )
19003 , vertexAttributeInstanceRateZeroDivisor( vertexAttributeInstanceRateZeroDivisor_ )
19004 {
19005 }
19006
19008 {
19010 }
19011
19013 {
19015 return *this;
19016 }
19018 {
19019 pNext = pNext_;
19020 return *this;
19021 }
19022
19024 {
19025 vertexAttributeInstanceRateDivisor = vertexAttributeInstanceRateDivisor_;
19026 return *this;
19027 }
19028
19030 {
19031 vertexAttributeInstanceRateZeroDivisor = vertexAttributeInstanceRateZeroDivisor_;
19032 return *this;
19033 }
19034
19036 {
19037 return *reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(this);
19038 }
19039
19041 {
19042 return *reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT*>(this);
19043 }
19044
19046 {
19047 return ( sType == rhs.sType )
19048 && ( pNext == rhs.pNext )
19051 }
19052
19054 {
19055 return !operator==( rhs );
19056 }
19057
19058 private:
19060
19061 public:
19062 void* pNext = nullptr;
19065 };
19066 static_assert( sizeof( PhysicalDeviceVertexAttributeDivisorFeaturesEXT ) == sizeof( VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT ), "struct and wrapper have different size!" );
19067
19069 {
19071 : decodeMode( decodeMode_ )
19072 {
19073 }
19074
19076 {
19077 memcpy( this, &rhs, sizeof( ImageViewASTCDecodeModeEXT ) );
19078 }
19079
19081 {
19082 memcpy( this, &rhs, sizeof( ImageViewASTCDecodeModeEXT ) );
19083 return *this;
19084 }
19086 {
19087 pNext = pNext_;
19088 return *this;
19089 }
19090
19092 {
19093 decodeMode = decodeMode_;
19094 return *this;
19095 }
19096
19097 operator VkImageViewASTCDecodeModeEXT const&() const
19098 {
19099 return *reinterpret_cast<const VkImageViewASTCDecodeModeEXT*>(this);
19100 }
19101
19103 {
19104 return *reinterpret_cast<VkImageViewASTCDecodeModeEXT*>(this);
19105 }
19106
19108 {
19109 return ( sType == rhs.sType )
19110 && ( pNext == rhs.pNext )
19111 && ( decodeMode == rhs.decodeMode );
19112 }
19113
19115 {
19116 return !operator==( rhs );
19117 }
19118
19119 private:
19121
19122 public:
19123 const void* pNext = nullptr;
19125 };
19126 static_assert( sizeof( ImageViewASTCDecodeModeEXT ) == sizeof( VkImageViewASTCDecodeModeEXT ), "struct and wrapper have different size!" );
19127
19129 {
19130 PhysicalDeviceASTCDecodeFeaturesEXT( Bool32 decodeModeSharedExponent_ = 0 )
19131 : decodeModeSharedExponent( decodeModeSharedExponent_ )
19132 {
19133 }
19134
19136 {
19137 memcpy( this, &rhs, sizeof( PhysicalDeviceASTCDecodeFeaturesEXT ) );
19138 }
19139
19141 {
19142 memcpy( this, &rhs, sizeof( PhysicalDeviceASTCDecodeFeaturesEXT ) );
19143 return *this;
19144 }
19146 {
19147 pNext = pNext_;
19148 return *this;
19149 }
19150
19152 {
19153 decodeModeSharedExponent = decodeModeSharedExponent_;
19154 return *this;
19155 }
19156
19158 {
19159 return *reinterpret_cast<const VkPhysicalDeviceASTCDecodeFeaturesEXT*>(this);
19160 }
19161
19163 {
19164 return *reinterpret_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT*>(this);
19165 }
19166
19168 {
19169 return ( sType == rhs.sType )
19170 && ( pNext == rhs.pNext )
19172 }
19173
19175 {
19176 return !operator==( rhs );
19177 }
19178
19179 private:
19181
19182 public:
19183 void* pNext = nullptr;
19185 };
19186 static_assert( sizeof( PhysicalDeviceASTCDecodeFeaturesEXT ) == sizeof( VkPhysicalDeviceASTCDecodeFeaturesEXT ), "struct and wrapper have different size!" );
19187
19189 {
19191 Bool32 geometryStreams_ = 0 )
19192 : transformFeedback( transformFeedback_ )
19193 , geometryStreams( geometryStreams_ )
19194 {
19195 }
19196
19198 {
19199 memcpy( this, &rhs, sizeof( PhysicalDeviceTransformFeedbackFeaturesEXT ) );
19200 }
19201
19203 {
19204 memcpy( this, &rhs, sizeof( PhysicalDeviceTransformFeedbackFeaturesEXT ) );
19205 return *this;
19206 }
19208 {
19209 pNext = pNext_;
19210 return *this;
19211 }
19212
19214 {
19215 transformFeedback = transformFeedback_;
19216 return *this;
19217 }
19218
19220 {
19221 geometryStreams = geometryStreams_;
19222 return *this;
19223 }
19224
19226 {
19227 return *reinterpret_cast<const VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(this);
19228 }
19229
19231 {
19232 return *reinterpret_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT*>(this);
19233 }
19234
19236 {
19237 return ( sType == rhs.sType )
19238 && ( pNext == rhs.pNext )
19240 && ( geometryStreams == rhs.geometryStreams );
19241 }
19242
19244 {
19245 return !operator==( rhs );
19246 }
19247
19248 private:
19250
19251 public:
19252 void* pNext = nullptr;
19255 };
19256 static_assert( sizeof( PhysicalDeviceTransformFeedbackFeaturesEXT ) == sizeof( VkPhysicalDeviceTransformFeedbackFeaturesEXT ), "struct and wrapper have different size!" );
19257
19259 {
19261 {
19262 return *reinterpret_cast<const VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(this);
19263 }
19264
19266 {
19267 return *reinterpret_cast<VkPhysicalDeviceTransformFeedbackPropertiesEXT*>(this);
19268 }
19269
19271 {
19272 return ( sType == rhs.sType )
19273 && ( pNext == rhs.pNext )
19284 }
19285
19287 {
19288 return !operator==( rhs );
19289 }
19290
19291 private:
19293
19294 public:
19295 void* pNext = nullptr;
19306 };
19307 static_assert( sizeof( PhysicalDeviceTransformFeedbackPropertiesEXT ) == sizeof( VkPhysicalDeviceTransformFeedbackPropertiesEXT ), "struct and wrapper have different size!" );
19308
19310 {
19312 uint32_t rasterizationStream_ = 0 )
19313 : flags( flags_ )
19314 , rasterizationStream( rasterizationStream_ )
19315 {
19316 }
19317
19319 {
19321 }
19322
19324 {
19326 return *this;
19327 }
19329 {
19330 pNext = pNext_;
19331 return *this;
19332 }
19333
19335 {
19336 flags = flags_;
19337 return *this;
19338 }
19339
19341 {
19342 rasterizationStream = rasterizationStream_;
19343 return *this;
19344 }
19345
19347 {
19348 return *reinterpret_cast<const VkPipelineRasterizationStateStreamCreateInfoEXT*>(this);
19349 }
19350
19352 {
19353 return *reinterpret_cast<VkPipelineRasterizationStateStreamCreateInfoEXT*>(this);
19354 }
19355
19357 {
19358 return ( sType == rhs.sType )
19359 && ( pNext == rhs.pNext )
19360 && ( flags == rhs.flags )
19362 }
19363
19365 {
19366 return !operator==( rhs );
19367 }
19368
19369 private:
19371
19372 public:
19373 const void* pNext = nullptr;
19376 };
19377 static_assert( sizeof( PipelineRasterizationStateStreamCreateInfoEXT ) == sizeof( VkPipelineRasterizationStateStreamCreateInfoEXT ), "struct and wrapper have different size!" );
19378
19380 {
19382 : representativeFragmentTest( representativeFragmentTest_ )
19383 {
19384 }
19385
19387 {
19389 }
19390
19392 {
19394 return *this;
19395 }
19397 {
19398 pNext = pNext_;
19399 return *this;
19400 }
19401
19403 {
19404 representativeFragmentTest = representativeFragmentTest_;
19405 return *this;
19406 }
19407
19409 {
19410 return *reinterpret_cast<const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(this);
19411 }
19412
19414 {
19415 return *reinterpret_cast<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV*>(this);
19416 }
19417
19419 {
19420 return ( sType == rhs.sType )
19421 && ( pNext == rhs.pNext )
19423 }
19424
19426 {
19427 return !operator==( rhs );
19428 }
19429
19430 private:
19432
19433 public:
19434 void* pNext = nullptr;
19436 };
19437 static_assert( sizeof( PhysicalDeviceRepresentativeFragmentTestFeaturesNV ) == sizeof( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV ), "struct and wrapper have different size!" );
19438
19440 {
19441 PipelineRepresentativeFragmentTestStateCreateInfoNV( Bool32 representativeFragmentTestEnable_ = 0 )
19442 : representativeFragmentTestEnable( representativeFragmentTestEnable_ )
19443 {
19444 }
19445
19447 {
19449 }
19450
19452 {
19454 return *this;
19455 }
19457 {
19458 pNext = pNext_;
19459 return *this;
19460 }
19461
19463 {
19464 representativeFragmentTestEnable = representativeFragmentTestEnable_;
19465 return *this;
19466 }
19467
19469 {
19470 return *reinterpret_cast<const VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(this);
19471 }
19472
19474 {
19475 return *reinterpret_cast<VkPipelineRepresentativeFragmentTestStateCreateInfoNV*>(this);
19476 }
19477
19479 {
19480 return ( sType == rhs.sType )
19481 && ( pNext == rhs.pNext )
19483 }
19484
19486 {
19487 return !operator==( rhs );
19488 }
19489
19490 private:
19492
19493 public:
19494 const void* pNext = nullptr;
19496 };
19497 static_assert( sizeof( PipelineRepresentativeFragmentTestStateCreateInfoNV ) == sizeof( VkPipelineRepresentativeFragmentTestStateCreateInfoNV ), "struct and wrapper have different size!" );
19498
19500 {
19502 : exclusiveScissor( exclusiveScissor_ )
19503 {
19504 }
19505
19507 {
19508 memcpy( this, &rhs, sizeof( PhysicalDeviceExclusiveScissorFeaturesNV ) );
19509 }
19510
19512 {
19513 memcpy( this, &rhs, sizeof( PhysicalDeviceExclusiveScissorFeaturesNV ) );
19514 return *this;
19515 }
19517 {
19518 pNext = pNext_;
19519 return *this;
19520 }
19521
19523 {
19524 exclusiveScissor = exclusiveScissor_;
19525 return *this;
19526 }
19527
19529 {
19530 return *reinterpret_cast<const VkPhysicalDeviceExclusiveScissorFeaturesNV*>(this);
19531 }
19532
19534 {
19535 return *reinterpret_cast<VkPhysicalDeviceExclusiveScissorFeaturesNV*>(this);
19536 }
19537
19539 {
19540 return ( sType == rhs.sType )
19541 && ( pNext == rhs.pNext )
19542 && ( exclusiveScissor == rhs.exclusiveScissor );
19543 }
19544
19546 {
19547 return !operator==( rhs );
19548 }
19549
19550 private:
19552
19553 public:
19554 void* pNext = nullptr;
19556 };
19557 static_assert( sizeof( PhysicalDeviceExclusiveScissorFeaturesNV ) == sizeof( VkPhysicalDeviceExclusiveScissorFeaturesNV ), "struct and wrapper have different size!" );
19558
19560 {
19562 const Rect2D* pExclusiveScissors_ = nullptr )
19563 : exclusiveScissorCount( exclusiveScissorCount_ )
19564 , pExclusiveScissors( pExclusiveScissors_ )
19565 {
19566 }
19567
19569 {
19571 }
19572
19574 {
19576 return *this;
19577 }
19579 {
19580 pNext = pNext_;
19581 return *this;
19582 }
19583
19585 {
19586 exclusiveScissorCount = exclusiveScissorCount_;
19587 return *this;
19588 }
19589
19591 {
19592 pExclusiveScissors = pExclusiveScissors_;
19593 return *this;
19594 }
19595
19597 {
19598 return *reinterpret_cast<const VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(this);
19599 }
19600
19602 {
19603 return *reinterpret_cast<VkPipelineViewportExclusiveScissorStateCreateInfoNV*>(this);
19604 }
19605
19607 {
19608 return ( sType == rhs.sType )
19609 && ( pNext == rhs.pNext )
19612 }
19613
19615 {
19616 return !operator==( rhs );
19617 }
19618
19619 private:
19621
19622 public:
19623 const void* pNext = nullptr;
19626 };
19627 static_assert( sizeof( PipelineViewportExclusiveScissorStateCreateInfoNV ) == sizeof( VkPipelineViewportExclusiveScissorStateCreateInfoNV ), "struct and wrapper have different size!" );
19628
19630 {
19632 : cornerSampledImage( cornerSampledImage_ )
19633 {
19634 }
19635
19637 {
19638 memcpy( this, &rhs, sizeof( PhysicalDeviceCornerSampledImageFeaturesNV ) );
19639 }
19640
19642 {
19643 memcpy( this, &rhs, sizeof( PhysicalDeviceCornerSampledImageFeaturesNV ) );
19644 return *this;
19645 }
19647 {
19648 pNext = pNext_;
19649 return *this;
19650 }
19651
19653 {
19654 cornerSampledImage = cornerSampledImage_;
19655 return *this;
19656 }
19657
19659 {
19660 return *reinterpret_cast<const VkPhysicalDeviceCornerSampledImageFeaturesNV*>(this);
19661 }
19662
19664 {
19665 return *reinterpret_cast<VkPhysicalDeviceCornerSampledImageFeaturesNV*>(this);
19666 }
19667
19669 {
19670 return ( sType == rhs.sType )
19671 && ( pNext == rhs.pNext )
19673 }
19674
19676 {
19677 return !operator==( rhs );
19678 }
19679
19680 private:
19682
19683 public:
19684 void* pNext = nullptr;
19686 };
19687 static_assert( sizeof( PhysicalDeviceCornerSampledImageFeaturesNV ) == sizeof( VkPhysicalDeviceCornerSampledImageFeaturesNV ), "struct and wrapper have different size!" );
19688
19690 {
19692 Bool32 computeDerivativeGroupLinear_ = 0 )
19693 : computeDerivativeGroupQuads( computeDerivativeGroupQuads_ )
19694 , computeDerivativeGroupLinear( computeDerivativeGroupLinear_ )
19695 {
19696 }
19697
19699 {
19701 }
19702
19704 {
19706 return *this;
19707 }
19709 {
19710 pNext = pNext_;
19711 return *this;
19712 }
19713
19715 {
19716 computeDerivativeGroupQuads = computeDerivativeGroupQuads_;
19717 return *this;
19718 }
19719
19721 {
19722 computeDerivativeGroupLinear = computeDerivativeGroupLinear_;
19723 return *this;
19724 }
19725
19727 {
19728 return *reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(this);
19729 }
19730
19732 {
19733 return *reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV*>(this);
19734 }
19735
19737 {
19738 return ( sType == rhs.sType )
19739 && ( pNext == rhs.pNext )
19742 }
19743
19745 {
19746 return !operator==( rhs );
19747 }
19748
19749 private:
19751
19752 public:
19753 void* pNext = nullptr;
19756 };
19757 static_assert( sizeof( PhysicalDeviceComputeShaderDerivativesFeaturesNV ) == sizeof( VkPhysicalDeviceComputeShaderDerivativesFeaturesNV ), "struct and wrapper have different size!" );
19758
19760 {
19762 : fragmentShaderBarycentric( fragmentShaderBarycentric_ )
19763 {
19764 }
19765
19767 {
19769 }
19770
19772 {
19774 return *this;
19775 }
19777 {
19778 pNext = pNext_;
19779 return *this;
19780 }
19781
19783 {
19784 fragmentShaderBarycentric = fragmentShaderBarycentric_;
19785 return *this;
19786 }
19787
19789 {
19790 return *reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(this);
19791 }
19792
19794 {
19795 return *reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(this);
19796 }
19797
19799 {
19800 return ( sType == rhs.sType )
19801 && ( pNext == rhs.pNext )
19803 }
19804
19806 {
19807 return !operator==( rhs );
19808 }
19809
19810 private:
19812
19813 public:
19814 void* pNext = nullptr;
19816 };
19817 static_assert( sizeof( PhysicalDeviceFragmentShaderBarycentricFeaturesNV ) == sizeof( VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV ), "struct and wrapper have different size!" );
19818
19820 {
19822 : imageFootprint( imageFootprint_ )
19823 {
19824 }
19825
19827 {
19829 }
19830
19832 {
19834 return *this;
19835 }
19837 {
19838 pNext = pNext_;
19839 return *this;
19840 }
19841
19843 {
19844 imageFootprint = imageFootprint_;
19845 return *this;
19846 }
19847
19849 {
19850 return *reinterpret_cast<const VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(this);
19851 }
19852
19854 {
19855 return *reinterpret_cast<VkPhysicalDeviceShaderImageFootprintFeaturesNV*>(this);
19856 }
19857
19859 {
19860 return ( sType == rhs.sType )
19861 && ( pNext == rhs.pNext )
19862 && ( imageFootprint == rhs.imageFootprint );
19863 }
19864
19866 {
19867 return !operator==( rhs );
19868 }
19869
19870 private:
19872
19873 public:
19874 void* pNext = nullptr;
19876 };
19877 static_assert( sizeof( PhysicalDeviceShaderImageFootprintFeaturesNV ) == sizeof( VkPhysicalDeviceShaderImageFootprintFeaturesNV ), "struct and wrapper have different size!" );
19878
19880 {
19882 Bool32 shadingRateCoarseSampleOrder_ = 0 )
19883 : shadingRateImage( shadingRateImage_ )
19884 , shadingRateCoarseSampleOrder( shadingRateCoarseSampleOrder_ )
19885 {
19886 }
19887
19889 {
19890 memcpy( this, &rhs, sizeof( PhysicalDeviceShadingRateImageFeaturesNV ) );
19891 }
19892
19894 {
19895 memcpy( this, &rhs, sizeof( PhysicalDeviceShadingRateImageFeaturesNV ) );
19896 return *this;
19897 }
19899 {
19900 pNext = pNext_;
19901 return *this;
19902 }
19903
19905 {
19906 shadingRateImage = shadingRateImage_;
19907 return *this;
19908 }
19909
19911 {
19912 shadingRateCoarseSampleOrder = shadingRateCoarseSampleOrder_;
19913 return *this;
19914 }
19915
19917 {
19918 return *reinterpret_cast<const VkPhysicalDeviceShadingRateImageFeaturesNV*>(this);
19919 }
19920
19922 {
19923 return *reinterpret_cast<VkPhysicalDeviceShadingRateImageFeaturesNV*>(this);
19924 }
19925
19927 {
19928 return ( sType == rhs.sType )
19929 && ( pNext == rhs.pNext )
19932 }
19933
19935 {
19936 return !operator==( rhs );
19937 }
19938
19939 private:
19941
19942 public:
19943 void* pNext = nullptr;
19946 };
19947 static_assert( sizeof( PhysicalDeviceShadingRateImageFeaturesNV ) == sizeof( VkPhysicalDeviceShadingRateImageFeaturesNV ), "struct and wrapper have different size!" );
19948
19950 {
19952 {
19953 return *reinterpret_cast<const VkPhysicalDeviceShadingRateImagePropertiesNV*>(this);
19954 }
19955
19957 {
19958 return *reinterpret_cast<VkPhysicalDeviceShadingRateImagePropertiesNV*>(this);
19959 }
19960
19962 {
19963 return ( sType == rhs.sType )
19964 && ( pNext == rhs.pNext )
19968 }
19969
19971 {
19972 return !operator==( rhs );
19973 }
19974
19975 private:
19977
19978 public:
19979 void* pNext = nullptr;
19983 };
19984 static_assert( sizeof( PhysicalDeviceShadingRateImagePropertiesNV ) == sizeof( VkPhysicalDeviceShadingRateImagePropertiesNV ), "struct and wrapper have different size!" );
19985
19987 {
19989 Bool32 meshShader_ = 0 )
19990 : taskShader( taskShader_ )
19991 , meshShader( meshShader_ )
19992 {
19993 }
19994
19996 {
19997 memcpy( this, &rhs, sizeof( PhysicalDeviceMeshShaderFeaturesNV ) );
19998 }
19999
20001 {
20002 memcpy( this, &rhs, sizeof( PhysicalDeviceMeshShaderFeaturesNV ) );
20003 return *this;
20004 }
20006 {
20007 pNext = pNext_;
20008 return *this;
20009 }
20010
20012 {
20013 taskShader = taskShader_;
20014 return *this;
20015 }
20016
20018 {
20019 meshShader = meshShader_;
20020 return *this;
20021 }
20022
20024 {
20025 return *reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesNV*>(this);
20026 }
20027
20029 {
20030 return *reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesNV*>(this);
20031 }
20032
20034 {
20035 return ( sType == rhs.sType )
20036 && ( pNext == rhs.pNext )
20037 && ( taskShader == rhs.taskShader )
20038 && ( meshShader == rhs.meshShader );
20039 }
20040
20042 {
20043 return !operator==( rhs );
20044 }
20045
20046 private:
20048
20049 public:
20050 void* pNext = nullptr;
20053 };
20054 static_assert( sizeof( PhysicalDeviceMeshShaderFeaturesNV ) == sizeof( VkPhysicalDeviceMeshShaderFeaturesNV ), "struct and wrapper have different size!" );
20055
20057 {
20059 uint32_t maxTaskWorkGroupInvocations_ = 0,
20060 std::array<uint32_t,3> const& maxTaskWorkGroupSize_ = { { 0, 0, 0 } },
20061 uint32_t maxTaskTotalMemorySize_ = 0,
20062 uint32_t maxTaskOutputCount_ = 0,
20063 uint32_t maxMeshWorkGroupInvocations_ = 0,
20064 std::array<uint32_t,3> const& maxMeshWorkGroupSize_ = { { 0, 0, 0 } },
20065 uint32_t maxMeshTotalMemorySize_ = 0,
20066 uint32_t maxMeshOutputVertices_ = 0,
20067 uint32_t maxMeshOutputPrimitives_ = 0,
20068 uint32_t maxMeshMultiviewViewCount_ = 0,
20069 uint32_t meshOutputPerVertexGranularity_ = 0,
20070 uint32_t meshOutputPerPrimitiveGranularity_ = 0 )
20071 : maxDrawMeshTasksCount( maxDrawMeshTasksCount_ )
20072 , maxTaskWorkGroupInvocations( maxTaskWorkGroupInvocations_ )
20073 , maxTaskTotalMemorySize( maxTaskTotalMemorySize_ )
20074 , maxTaskOutputCount( maxTaskOutputCount_ )
20075 , maxMeshWorkGroupInvocations( maxMeshWorkGroupInvocations_ )
20076 , maxMeshTotalMemorySize( maxMeshTotalMemorySize_ )
20077 , maxMeshOutputVertices( maxMeshOutputVertices_ )
20078 , maxMeshOutputPrimitives( maxMeshOutputPrimitives_ )
20079 , maxMeshMultiviewViewCount( maxMeshMultiviewViewCount_ )
20080 , meshOutputPerVertexGranularity( meshOutputPerVertexGranularity_ )
20081 , meshOutputPerPrimitiveGranularity( meshOutputPerPrimitiveGranularity_ )
20082 {
20083 memcpy( &maxTaskWorkGroupSize, maxTaskWorkGroupSize_.data(), 3 * sizeof( uint32_t ) );
20084 memcpy( &maxMeshWorkGroupSize, maxMeshWorkGroupSize_.data(), 3 * sizeof( uint32_t ) );
20085 }
20086
20088 {
20089 memcpy( this, &rhs, sizeof( PhysicalDeviceMeshShaderPropertiesNV ) );
20090 }
20091
20093 {
20094 memcpy( this, &rhs, sizeof( PhysicalDeviceMeshShaderPropertiesNV ) );
20095 return *this;
20096 }
20098 {
20099 pNext = pNext_;
20100 return *this;
20101 }
20102
20104 {
20105 maxDrawMeshTasksCount = maxDrawMeshTasksCount_;
20106 return *this;
20107 }
20108
20110 {
20111 maxTaskWorkGroupInvocations = maxTaskWorkGroupInvocations_;
20112 return *this;
20113 }
20114
20115 PhysicalDeviceMeshShaderPropertiesNV& setMaxTaskWorkGroupSize( std::array<uint32_t,3> maxTaskWorkGroupSize_ )
20116 {
20117 memcpy( &maxTaskWorkGroupSize, maxTaskWorkGroupSize_.data(), 3 * sizeof( uint32_t ) );
20118 return *this;
20119 }
20120
20122 {
20123 maxTaskTotalMemorySize = maxTaskTotalMemorySize_;
20124 return *this;
20125 }
20126
20128 {
20129 maxTaskOutputCount = maxTaskOutputCount_;
20130 return *this;
20131 }
20132
20134 {
20135 maxMeshWorkGroupInvocations = maxMeshWorkGroupInvocations_;
20136 return *this;
20137 }
20138
20139 PhysicalDeviceMeshShaderPropertiesNV& setMaxMeshWorkGroupSize( std::array<uint32_t,3> maxMeshWorkGroupSize_ )
20140 {
20141 memcpy( &maxMeshWorkGroupSize, maxMeshWorkGroupSize_.data(), 3 * sizeof( uint32_t ) );
20142 return *this;
20143 }
20144
20146 {
20147 maxMeshTotalMemorySize = maxMeshTotalMemorySize_;
20148 return *this;
20149 }
20150
20152 {
20153 maxMeshOutputVertices = maxMeshOutputVertices_;
20154 return *this;
20155 }
20156
20158 {
20159 maxMeshOutputPrimitives = maxMeshOutputPrimitives_;
20160 return *this;
20161 }
20162
20164 {
20165 maxMeshMultiviewViewCount = maxMeshMultiviewViewCount_;
20166 return *this;
20167 }
20168
20170 {
20171 meshOutputPerVertexGranularity = meshOutputPerVertexGranularity_;
20172 return *this;
20173 }
20174
20176 {
20177 meshOutputPerPrimitiveGranularity = meshOutputPerPrimitiveGranularity_;
20178 return *this;
20179 }
20180
20182 {
20183 return *reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesNV*>(this);
20184 }
20185
20187 {
20188 return *reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesNV*>(this);
20189 }
20190
20192 {
20193 return ( sType == rhs.sType )
20194 && ( pNext == rhs.pNext )
20197 && ( memcmp( maxTaskWorkGroupSize, rhs.maxTaskWorkGroupSize, 3 * sizeof( uint32_t ) ) == 0 )
20201 && ( memcmp( maxMeshWorkGroupSize, rhs.maxMeshWorkGroupSize, 3 * sizeof( uint32_t ) ) == 0 )
20208 }
20209
20211 {
20212 return !operator==( rhs );
20213 }
20214
20215 private:
20217
20218 public:
20219 void* pNext = nullptr;
20233 };
20234 static_assert( sizeof( PhysicalDeviceMeshShaderPropertiesNV ) == sizeof( VkPhysicalDeviceMeshShaderPropertiesNV ), "struct and wrapper have different size!" );
20235
20237 {
20239 DeviceSize vertexOffset_ = 0,
20240 uint32_t vertexCount_ = 0,
20241 DeviceSize vertexStride_ = 0,
20242 Format vertexFormat_ = Format::eUndefined,
20243 Buffer indexData_ = Buffer(),
20244 DeviceSize indexOffset_ = 0,
20245 uint32_t indexCount_ = 0,
20246 IndexType indexType_ = IndexType::eUint16,
20247 Buffer transformData_ = Buffer(),
20248 DeviceSize transformOffset_ = 0 )
20249 : vertexData( vertexData_ )
20250 , vertexOffset( vertexOffset_ )
20251 , vertexCount( vertexCount_ )
20252 , vertexStride( vertexStride_ )
20253 , vertexFormat( vertexFormat_ )
20254 , indexData( indexData_ )
20255 , indexOffset( indexOffset_ )
20256 , indexCount( indexCount_ )
20257 , indexType( indexType_ )
20258 , transformData( transformData_ )
20259 , transformOffset( transformOffset_ )
20260 {
20261 }
20262
20264 {
20265 memcpy( this, &rhs, sizeof( GeometryTrianglesNV ) );
20266 }
20267
20269 {
20270 memcpy( this, &rhs, sizeof( GeometryTrianglesNV ) );
20271 return *this;
20272 }
20273 GeometryTrianglesNV& setPNext( const void* pNext_ )
20274 {
20275 pNext = pNext_;
20276 return *this;
20277 }
20278
20280 {
20281 vertexData = vertexData_;
20282 return *this;
20283 }
20284
20286 {
20287 vertexOffset = vertexOffset_;
20288 return *this;
20289 }
20290
20292 {
20293 vertexCount = vertexCount_;
20294 return *this;
20295 }
20296
20298 {
20299 vertexStride = vertexStride_;
20300 return *this;
20301 }
20302
20304 {
20305 vertexFormat = vertexFormat_;
20306 return *this;
20307 }
20308
20310 {
20311 indexData = indexData_;
20312 return *this;
20313 }
20314
20316 {
20317 indexOffset = indexOffset_;
20318 return *this;
20319 }
20320
20322 {
20323 indexCount = indexCount_;
20324 return *this;
20325 }
20326
20328 {
20329 indexType = indexType_;
20330 return *this;
20331 }
20332
20334 {
20335 transformData = transformData_;
20336 return *this;
20337 }
20338
20340 {
20341 transformOffset = transformOffset_;
20342 return *this;
20343 }
20344
20345 operator VkGeometryTrianglesNV const&() const
20346 {
20347 return *reinterpret_cast<const VkGeometryTrianglesNV*>(this);
20348 }
20349
20351 {
20352 return *reinterpret_cast<VkGeometryTrianglesNV*>(this);
20353 }
20354
20355 bool operator==( GeometryTrianglesNV const& rhs ) const
20356 {
20357 return ( sType == rhs.sType )
20358 && ( pNext == rhs.pNext )
20359 && ( vertexData == rhs.vertexData )
20360 && ( vertexOffset == rhs.vertexOffset )
20361 && ( vertexCount == rhs.vertexCount )
20362 && ( vertexStride == rhs.vertexStride )
20363 && ( vertexFormat == rhs.vertexFormat )
20364 && ( indexData == rhs.indexData )
20365 && ( indexOffset == rhs.indexOffset )
20366 && ( indexCount == rhs.indexCount )
20367 && ( indexType == rhs.indexType )
20368 && ( transformData == rhs.transformData )
20369 && ( transformOffset == rhs.transformOffset );
20370 }
20371
20372 bool operator!=( GeometryTrianglesNV const& rhs ) const
20373 {
20374 return !operator==( rhs );
20375 }
20376
20377 private:
20379
20380 public:
20381 const void* pNext = nullptr;
20393 };
20394 static_assert( sizeof( GeometryTrianglesNV ) == sizeof( VkGeometryTrianglesNV ), "struct and wrapper have different size!" );
20395
20397 {
20399 uint32_t numAABBs_ = 0,
20400 uint32_t stride_ = 0,
20401 DeviceSize offset_ = 0 )
20402 : aabbData( aabbData_ )
20403 , numAABBs( numAABBs_ )
20404 , stride( stride_ )
20405 , offset( offset_ )
20406 {
20407 }
20408
20410 {
20411 memcpy( this, &rhs, sizeof( GeometryAABBNV ) );
20412 }
20413
20415 {
20416 memcpy( this, &rhs, sizeof( GeometryAABBNV ) );
20417 return *this;
20418 }
20419 GeometryAABBNV& setPNext( const void* pNext_ )
20420 {
20421 pNext = pNext_;
20422 return *this;
20423 }
20424
20426 {
20427 aabbData = aabbData_;
20428 return *this;
20429 }
20430
20432 {
20433 numAABBs = numAABBs_;
20434 return *this;
20435 }
20436
20438 {
20439 stride = stride_;
20440 return *this;
20441 }
20442
20444 {
20445 offset = offset_;
20446 return *this;
20447 }
20448
20449 operator VkGeometryAABBNV const&() const
20450 {
20451 return *reinterpret_cast<const VkGeometryAABBNV*>(this);
20452 }
20453
20454 operator VkGeometryAABBNV &()
20455 {
20456 return *reinterpret_cast<VkGeometryAABBNV*>(this);
20457 }
20458
20459 bool operator==( GeometryAABBNV const& rhs ) const
20460 {
20461 return ( sType == rhs.sType )
20462 && ( pNext == rhs.pNext )
20463 && ( aabbData == rhs.aabbData )
20464 && ( numAABBs == rhs.numAABBs )
20465 && ( stride == rhs.stride )
20466 && ( offset == rhs.offset );
20467 }
20468
20469 bool operator!=( GeometryAABBNV const& rhs ) const
20470 {
20471 return !operator==( rhs );
20472 }
20473
20474 private:
20476
20477 public:
20478 const void* pNext = nullptr;
20483 };
20484 static_assert( sizeof( GeometryAABBNV ) == sizeof( VkGeometryAABBNV ), "struct and wrapper have different size!" );
20485
20487 {
20489 GeometryAABBNV aabbs_ = GeometryAABBNV() )
20490 : triangles( triangles_ )
20491 , aabbs( aabbs_ )
20492 {
20493 }
20494
20496 {
20497 memcpy( this, &rhs, sizeof( GeometryDataNV ) );
20498 }
20499
20501 {
20502 memcpy( this, &rhs, sizeof( GeometryDataNV ) );
20503 return *this;
20504 }
20506 {
20507 triangles = triangles_;
20508 return *this;
20509 }
20510
20512 {
20513 aabbs = aabbs_;
20514 return *this;
20515 }
20516
20517 operator VkGeometryDataNV const&() const
20518 {
20519 return *reinterpret_cast<const VkGeometryDataNV*>(this);
20520 }
20521
20522 operator VkGeometryDataNV &()
20523 {
20524 return *reinterpret_cast<VkGeometryDataNV*>(this);
20525 }
20526
20527 bool operator==( GeometryDataNV const& rhs ) const
20528 {
20529 return ( triangles == rhs.triangles )
20530 && ( aabbs == rhs.aabbs );
20531 }
20532
20533 bool operator!=( GeometryDataNV const& rhs ) const
20534 {
20535 return !operator==( rhs );
20536 }
20537
20540 };
20541 static_assert( sizeof( GeometryDataNV ) == sizeof( VkGeometryDataNV ), "struct and wrapper have different size!" );
20542
20544 {
20546 DeviceMemory memory_ = DeviceMemory(),
20547 DeviceSize memoryOffset_ = 0,
20548 uint32_t deviceIndexCount_ = 0,
20549 const uint32_t* pDeviceIndices_ = nullptr )
20550 : accelerationStructure( accelerationStructure_ )
20551 , memory( memory_ )
20552 , memoryOffset( memoryOffset_ )
20553 , deviceIndexCount( deviceIndexCount_ )
20554 , pDeviceIndices( pDeviceIndices_ )
20555 {
20556 }
20557
20559 {
20560 memcpy( this, &rhs, sizeof( BindAccelerationStructureMemoryInfoNV ) );
20561 }
20562
20564 {
20565 memcpy( this, &rhs, sizeof( BindAccelerationStructureMemoryInfoNV ) );
20566 return *this;
20567 }
20569 {
20570 pNext = pNext_;
20571 return *this;
20572 }
20573
20575 {
20576 accelerationStructure = accelerationStructure_;
20577 return *this;
20578 }
20579
20581 {
20582 memory = memory_;
20583 return *this;
20584 }
20585
20587 {
20588 memoryOffset = memoryOffset_;
20589 return *this;
20590 }
20591
20593 {
20594 deviceIndexCount = deviceIndexCount_;
20595 return *this;
20596 }
20597
20599 {
20600 pDeviceIndices = pDeviceIndices_;
20601 return *this;
20602 }
20603
20605 {
20606 return *reinterpret_cast<const VkBindAccelerationStructureMemoryInfoNV*>(this);
20607 }
20608
20610 {
20611 return *reinterpret_cast<VkBindAccelerationStructureMemoryInfoNV*>(this);
20612 }
20613
20615 {
20616 return ( sType == rhs.sType )
20617 && ( pNext == rhs.pNext )
20619 && ( memory == rhs.memory )
20620 && ( memoryOffset == rhs.memoryOffset )
20622 && ( pDeviceIndices == rhs.pDeviceIndices );
20623 }
20624
20626 {
20627 return !operator==( rhs );
20628 }
20629
20630 private:
20632
20633 public:
20634 const void* pNext = nullptr;
20640 };
20641 static_assert( sizeof( BindAccelerationStructureMemoryInfoNV ) == sizeof( VkBindAccelerationStructureMemoryInfoNV ), "struct and wrapper have different size!" );
20642
20644 {
20645 WriteDescriptorSetAccelerationStructureNV( uint32_t accelerationStructureCount_ = 0,
20646 const AccelerationStructureNV* pAccelerationStructures_ = nullptr )
20647 : accelerationStructureCount( accelerationStructureCount_ )
20648 , pAccelerationStructures( pAccelerationStructures_ )
20649 {
20650 }
20651
20653 {
20654 memcpy( this, &rhs, sizeof( WriteDescriptorSetAccelerationStructureNV ) );
20655 }
20656
20658 {
20659 memcpy( this, &rhs, sizeof( WriteDescriptorSetAccelerationStructureNV ) );
20660 return *this;
20661 }
20663 {
20664 pNext = pNext_;
20665 return *this;
20666 }
20667
20669 {
20670 accelerationStructureCount = accelerationStructureCount_;
20671 return *this;
20672 }
20673
20675 {
20676 pAccelerationStructures = pAccelerationStructures_;
20677 return *this;
20678 }
20679
20681 {
20682 return *reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureNV*>(this);
20683 }
20684
20686 {
20687 return *reinterpret_cast<VkWriteDescriptorSetAccelerationStructureNV*>(this);
20688 }
20689
20691 {
20692 return ( sType == rhs.sType )
20693 && ( pNext == rhs.pNext )
20696 }
20697
20699 {
20700 return !operator==( rhs );
20701 }
20702
20703 private:
20705
20706 public:
20707 const void* pNext = nullptr;
20710 };
20711 static_assert( sizeof( WriteDescriptorSetAccelerationStructureNV ) == sizeof( VkWriteDescriptorSetAccelerationStructureNV ), "struct and wrapper have different size!" );
20712
20714 {
20716 uint32_t maxRecursionDepth_ = 0,
20717 uint32_t maxShaderGroupStride_ = 0,
20718 uint32_t shaderGroupBaseAlignment_ = 0,
20719 uint64_t maxGeometryCount_ = 0,
20720 uint64_t maxInstanceCount_ = 0,
20721 uint64_t maxTriangleCount_ = 0,
20722 uint32_t maxDescriptorSetAccelerationStructures_ = 0 )
20723 : shaderGroupHandleSize( shaderGroupHandleSize_ )
20724 , maxRecursionDepth( maxRecursionDepth_ )
20725 , maxShaderGroupStride( maxShaderGroupStride_ )
20726 , shaderGroupBaseAlignment( shaderGroupBaseAlignment_ )
20727 , maxGeometryCount( maxGeometryCount_ )
20728 , maxInstanceCount( maxInstanceCount_ )
20729 , maxTriangleCount( maxTriangleCount_ )
20730 , maxDescriptorSetAccelerationStructures( maxDescriptorSetAccelerationStructures_ )
20731 {
20732 }
20733
20735 {
20736 memcpy( this, &rhs, sizeof( PhysicalDeviceRayTracingPropertiesNV ) );
20737 }
20738
20740 {
20741 memcpy( this, &rhs, sizeof( PhysicalDeviceRayTracingPropertiesNV ) );
20742 return *this;
20743 }
20745 {
20746 pNext = pNext_;
20747 return *this;
20748 }
20749
20751 {
20752 shaderGroupHandleSize = shaderGroupHandleSize_;
20753 return *this;
20754 }
20755
20757 {
20758 maxRecursionDepth = maxRecursionDepth_;
20759 return *this;
20760 }
20761
20763 {
20764 maxShaderGroupStride = maxShaderGroupStride_;
20765 return *this;
20766 }
20767
20769 {
20770 shaderGroupBaseAlignment = shaderGroupBaseAlignment_;
20771 return *this;
20772 }
20773
20775 {
20776 maxGeometryCount = maxGeometryCount_;
20777 return *this;
20778 }
20779
20781 {
20782 maxInstanceCount = maxInstanceCount_;
20783 return *this;
20784 }
20785
20787 {
20788 maxTriangleCount = maxTriangleCount_;
20789 return *this;
20790 }
20791
20793 {
20794 maxDescriptorSetAccelerationStructures = maxDescriptorSetAccelerationStructures_;
20795 return *this;
20796 }
20797
20799 {
20800 return *reinterpret_cast<const VkPhysicalDeviceRayTracingPropertiesNV*>(this);
20801 }
20802
20804 {
20805 return *reinterpret_cast<VkPhysicalDeviceRayTracingPropertiesNV*>(this);
20806 }
20807
20809 {
20810 return ( sType == rhs.sType )
20811 && ( pNext == rhs.pNext )
20820 }
20821
20823 {
20824 return !operator==( rhs );
20825 }
20826
20827 private:
20829
20830 public:
20831 void* pNext = nullptr;
20840 };
20841 static_assert( sizeof( PhysicalDeviceRayTracingPropertiesNV ) == sizeof( VkPhysicalDeviceRayTracingPropertiesNV ), "struct and wrapper have different size!" );
20842
20844 {
20846 SharingMode sharingMode_ = SharingMode::eExclusive,
20847 uint32_t queueFamilyIndexCount_ = 0,
20848 const uint32_t* pQueueFamilyIndices_ = nullptr )
20849 : drmFormatModifier( drmFormatModifier_ )
20850 , sharingMode( sharingMode_ )
20851 , queueFamilyIndexCount( queueFamilyIndexCount_ )
20852 , pQueueFamilyIndices( pQueueFamilyIndices_ )
20853 {
20854 }
20855
20857 {
20858 memcpy( this, &rhs, sizeof( PhysicalDeviceImageDrmFormatModifierInfoEXT ) );
20859 }
20860
20862 {
20863 memcpy( this, &rhs, sizeof( PhysicalDeviceImageDrmFormatModifierInfoEXT ) );
20864 return *this;
20865 }
20867 {
20868 pNext = pNext_;
20869 return *this;
20870 }
20871
20873 {
20874 drmFormatModifier = drmFormatModifier_;
20875 return *this;
20876 }
20877
20879 {
20880 sharingMode = sharingMode_;
20881 return *this;
20882 }
20883
20885 {
20886 queueFamilyIndexCount = queueFamilyIndexCount_;
20887 return *this;
20888 }
20889
20891 {
20892 pQueueFamilyIndices = pQueueFamilyIndices_;
20893 return *this;
20894 }
20895
20897 {
20898 return *reinterpret_cast<const VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(this);
20899 }
20900
20902 {
20903 return *reinterpret_cast<VkPhysicalDeviceImageDrmFormatModifierInfoEXT*>(this);
20904 }
20905
20907 {
20908 return ( sType == rhs.sType )
20909 && ( pNext == rhs.pNext )
20911 && ( sharingMode == rhs.sharingMode )
20914 }
20915
20917 {
20918 return !operator==( rhs );
20919 }
20920
20921 private:
20923
20924 public:
20925 const void* pNext = nullptr;
20930 };
20931 static_assert( sizeof( PhysicalDeviceImageDrmFormatModifierInfoEXT ) == sizeof( VkPhysicalDeviceImageDrmFormatModifierInfoEXT ), "struct and wrapper have different size!" );
20932
20934 {
20936 const uint64_t* pDrmFormatModifiers_ = nullptr )
20937 : drmFormatModifierCount( drmFormatModifierCount_ )
20938 , pDrmFormatModifiers( pDrmFormatModifiers_ )
20939 {
20940 }
20941
20943 {
20944 memcpy( this, &rhs, sizeof( ImageDrmFormatModifierListCreateInfoEXT ) );
20945 }
20946
20948 {
20949 memcpy( this, &rhs, sizeof( ImageDrmFormatModifierListCreateInfoEXT ) );
20950 return *this;
20951 }
20953 {
20954 pNext = pNext_;
20955 return *this;
20956 }
20957
20959 {
20960 drmFormatModifierCount = drmFormatModifierCount_;
20961 return *this;
20962 }
20963
20965 {
20966 pDrmFormatModifiers = pDrmFormatModifiers_;
20967 return *this;
20968 }
20969
20971 {
20972 return *reinterpret_cast<const VkImageDrmFormatModifierListCreateInfoEXT*>(this);
20973 }
20974
20976 {
20977 return *reinterpret_cast<VkImageDrmFormatModifierListCreateInfoEXT*>(this);
20978 }
20979
20981 {
20982 return ( sType == rhs.sType )
20983 && ( pNext == rhs.pNext )
20986 }
20987
20989 {
20990 return !operator==( rhs );
20991 }
20992
20993 private:
20995
20996 public:
20997 const void* pNext = nullptr;
21000 };
21001 static_assert( sizeof( ImageDrmFormatModifierListCreateInfoEXT ) == sizeof( VkImageDrmFormatModifierListCreateInfoEXT ), "struct and wrapper have different size!" );
21002
21004 {
21006 uint32_t drmFormatModifierPlaneCount_ = 0,
21007 const SubresourceLayout* pPlaneLayouts_ = nullptr )
21008 : drmFormatModifier( drmFormatModifier_ )
21009 , drmFormatModifierPlaneCount( drmFormatModifierPlaneCount_ )
21010 , pPlaneLayouts( pPlaneLayouts_ )
21011 {
21012 }
21013
21015 {
21016 memcpy( this, &rhs, sizeof( ImageDrmFormatModifierExplicitCreateInfoEXT ) );
21017 }
21018
21020 {
21021 memcpy( this, &rhs, sizeof( ImageDrmFormatModifierExplicitCreateInfoEXT ) );
21022 return *this;
21023 }
21025 {
21026 pNext = pNext_;
21027 return *this;
21028 }
21029
21031 {
21032 drmFormatModifier = drmFormatModifier_;
21033 return *this;
21034 }
21035
21037 {
21038 drmFormatModifierPlaneCount = drmFormatModifierPlaneCount_;
21039 return *this;
21040 }
21041
21043 {
21044 pPlaneLayouts = pPlaneLayouts_;
21045 return *this;
21046 }
21047
21049 {
21050 return *reinterpret_cast<const VkImageDrmFormatModifierExplicitCreateInfoEXT*>(this);
21051 }
21052
21054 {
21055 return *reinterpret_cast<VkImageDrmFormatModifierExplicitCreateInfoEXT*>(this);
21056 }
21057
21059 {
21060 return ( sType == rhs.sType )
21061 && ( pNext == rhs.pNext )
21064 && ( pPlaneLayouts == rhs.pPlaneLayouts );
21065 }
21066
21068 {
21069 return !operator==( rhs );
21070 }
21071
21072 private:
21074
21075 public:
21076 const void* pNext = nullptr;
21080 };
21081 static_assert( sizeof( ImageDrmFormatModifierExplicitCreateInfoEXT ) == sizeof( VkImageDrmFormatModifierExplicitCreateInfoEXT ), "struct and wrapper have different size!" );
21082
21084 {
21086 {
21087 return *reinterpret_cast<const VkImageDrmFormatModifierPropertiesEXT*>(this);
21088 }
21089
21091 {
21092 return *reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT*>(this);
21093 }
21094
21096 {
21097 return ( sType == rhs.sType )
21098 && ( pNext == rhs.pNext )
21100 }
21101
21103 {
21104 return !operator==( rhs );
21105 }
21106
21107 private:
21109
21110 public:
21111 void* pNext = nullptr;
21113 };
21114 static_assert( sizeof( ImageDrmFormatModifierPropertiesEXT ) == sizeof( VkImageDrmFormatModifierPropertiesEXT ), "struct and wrapper have different size!" );
21115
21117 {
21120 };
21121
21123 {
21125 : contents( contents_ )
21126 {
21127 }
21128
21130 {
21131 memcpy( this, &rhs, sizeof( SubpassBeginInfoKHR ) );
21132 }
21133
21135 {
21136 memcpy( this, &rhs, sizeof( SubpassBeginInfoKHR ) );
21137 return *this;
21138 }
21139 SubpassBeginInfoKHR& setPNext( const void* pNext_ )
21140 {
21141 pNext = pNext_;
21142 return *this;
21143 }
21144
21146 {
21147 contents = contents_;
21148 return *this;
21149 }
21150
21151 operator VkSubpassBeginInfoKHR const&() const
21152 {
21153 return *reinterpret_cast<const VkSubpassBeginInfoKHR*>(this);
21154 }
21155
21157 {
21158 return *reinterpret_cast<VkSubpassBeginInfoKHR*>(this);
21159 }
21160
21161 bool operator==( SubpassBeginInfoKHR const& rhs ) const
21162 {
21163 return ( sType == rhs.sType )
21164 && ( pNext == rhs.pNext )
21165 && ( contents == rhs.contents );
21166 }
21167
21168 bool operator!=( SubpassBeginInfoKHR const& rhs ) const
21169 {
21170 return !operator==( rhs );
21171 }
21172
21173 private:
21175
21176 public:
21177 const void* pNext = nullptr;
21179 };
21180 static_assert( sizeof( SubpassBeginInfoKHR ) == sizeof( VkSubpassBeginInfoKHR ), "struct and wrapper have different size!" );
21181
21183 {
21184 PresentInfoKHR( uint32_t waitSemaphoreCount_ = 0,
21185 const Semaphore* pWaitSemaphores_ = nullptr,
21186 uint32_t swapchainCount_ = 0,
21187 const SwapchainKHR* pSwapchains_ = nullptr,
21188 const uint32_t* pImageIndices_ = nullptr,
21189 Result* pResults_ = nullptr )
21190 : waitSemaphoreCount( waitSemaphoreCount_ )
21191 , pWaitSemaphores( pWaitSemaphores_ )
21192 , swapchainCount( swapchainCount_ )
21193 , pSwapchains( pSwapchains_ )
21194 , pImageIndices( pImageIndices_ )
21195 , pResults( pResults_ )
21196 {
21197 }
21198
21200 {
21201 memcpy( this, &rhs, sizeof( PresentInfoKHR ) );
21202 }
21203
21205 {
21206 memcpy( this, &rhs, sizeof( PresentInfoKHR ) );
21207 return *this;
21208 }
21209 PresentInfoKHR& setPNext( const void* pNext_ )
21210 {
21211 pNext = pNext_;
21212 return *this;
21213 }
21214
21216 {
21217 waitSemaphoreCount = waitSemaphoreCount_;
21218 return *this;
21219 }
21220
21221 PresentInfoKHR& setPWaitSemaphores( const Semaphore* pWaitSemaphores_ )
21222 {
21223 pWaitSemaphores = pWaitSemaphores_;
21224 return *this;
21225 }
21226
21228 {
21229 swapchainCount = swapchainCount_;
21230 return *this;
21231 }
21232
21234 {
21235 pSwapchains = pSwapchains_;
21236 return *this;
21237 }
21238
21239 PresentInfoKHR& setPImageIndices( const uint32_t* pImageIndices_ )
21240 {
21241 pImageIndices = pImageIndices_;
21242 return *this;
21243 }
21244
21246 {
21247 pResults = pResults_;
21248 return *this;
21249 }
21250
21251 operator VkPresentInfoKHR const&() const
21252 {
21253 return *reinterpret_cast<const VkPresentInfoKHR*>(this);
21254 }
21255
21256 operator VkPresentInfoKHR &()
21257 {
21258 return *reinterpret_cast<VkPresentInfoKHR*>(this);
21259 }
21260
21261 bool operator==( PresentInfoKHR const& rhs ) const
21262 {
21263 return ( sType == rhs.sType )
21264 && ( pNext == rhs.pNext )
21266 && ( pWaitSemaphores == rhs.pWaitSemaphores )
21267 && ( swapchainCount == rhs.swapchainCount )
21268 && ( pSwapchains == rhs.pSwapchains )
21269 && ( pImageIndices == rhs.pImageIndices )
21270 && ( pResults == rhs.pResults );
21271 }
21272
21273 bool operator!=( PresentInfoKHR const& rhs ) const
21274 {
21275 return !operator==( rhs );
21276 }
21277
21278 private:
21280
21281 public:
21282 const void* pNext = nullptr;
21289 };
21290 static_assert( sizeof( PresentInfoKHR ) == sizeof( VkPresentInfoKHR ), "struct and wrapper have different size!" );
21291
21292 enum class DynamicState
21293 {
21309 };
21310
21312 {
21314 uint32_t dynamicStateCount_ = 0,
21315 const DynamicState* pDynamicStates_ = nullptr )
21316 : flags( flags_ )
21317 , dynamicStateCount( dynamicStateCount_ )
21318 , pDynamicStates( pDynamicStates_ )
21319 {
21320 }
21321
21323 {
21324 memcpy( this, &rhs, sizeof( PipelineDynamicStateCreateInfo ) );
21325 }
21326
21328 {
21329 memcpy( this, &rhs, sizeof( PipelineDynamicStateCreateInfo ) );
21330 return *this;
21331 }
21333 {
21334 pNext = pNext_;
21335 return *this;
21336 }
21337
21339 {
21340 flags = flags_;
21341 return *this;
21342 }
21343
21345 {
21346 dynamicStateCount = dynamicStateCount_;
21347 return *this;
21348 }
21349
21351 {
21352 pDynamicStates = pDynamicStates_;
21353 return *this;
21354 }
21355
21356 operator VkPipelineDynamicStateCreateInfo const&() const
21357 {
21358 return *reinterpret_cast<const VkPipelineDynamicStateCreateInfo*>(this);
21359 }
21360
21362 {
21363 return *reinterpret_cast<VkPipelineDynamicStateCreateInfo*>(this);
21364 }
21365
21367 {
21368 return ( sType == rhs.sType )
21369 && ( pNext == rhs.pNext )
21370 && ( flags == rhs.flags )
21372 && ( pDynamicStates == rhs.pDynamicStates );
21373 }
21374
21376 {
21377 return !operator==( rhs );
21378 }
21379
21380 private:
21382
21383 public:
21384 const void* pNext = nullptr;
21388 };
21389 static_assert( sizeof( PipelineDynamicStateCreateInfo ) == sizeof( VkPipelineDynamicStateCreateInfo ), "struct and wrapper have different size!" );
21390
21392 {
21396 };
21397
21399 {
21401 uint32_t descriptorUpdateEntryCount_ = 0,
21402 const DescriptorUpdateTemplateEntry* pDescriptorUpdateEntries_ = nullptr,
21404 DescriptorSetLayout descriptorSetLayout_ = DescriptorSetLayout(),
21406 PipelineLayout pipelineLayout_ = PipelineLayout(),
21407 uint32_t set_ = 0 )
21408 : flags( flags_ )
21409 , descriptorUpdateEntryCount( descriptorUpdateEntryCount_ )
21410 , pDescriptorUpdateEntries( pDescriptorUpdateEntries_ )
21411 , templateType( templateType_ )
21412 , descriptorSetLayout( descriptorSetLayout_ )
21413 , pipelineBindPoint( pipelineBindPoint_ )
21414 , pipelineLayout( pipelineLayout_ )
21415 , set( set_ )
21416 {
21417 }
21418
21420 {
21421 memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateCreateInfo ) );
21422 }
21423
21425 {
21426 memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateCreateInfo ) );
21427 return *this;
21428 }
21430 {
21431 pNext = pNext_;
21432 return *this;
21433 }
21434
21436 {
21437 flags = flags_;
21438 return *this;
21439 }
21440
21442 {
21443 descriptorUpdateEntryCount = descriptorUpdateEntryCount_;
21444 return *this;
21445 }
21446
21448 {
21449 pDescriptorUpdateEntries = pDescriptorUpdateEntries_;
21450 return *this;
21451 }
21452
21454 {
21455 templateType = templateType_;
21456 return *this;
21457 }
21458
21460 {
21461 descriptorSetLayout = descriptorSetLayout_;
21462 return *this;
21463 }
21464
21466 {
21467 pipelineBindPoint = pipelineBindPoint_;
21468 return *this;
21469 }
21470
21472 {
21473 pipelineLayout = pipelineLayout_;
21474 return *this;
21475 }
21476
21478 {
21479 set = set_;
21480 return *this;
21481 }
21482
21484 {
21485 return *reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo*>(this);
21486 }
21487
21489 {
21490 return *reinterpret_cast<VkDescriptorUpdateTemplateCreateInfo*>(this);
21491 }
21492
21494 {
21495 return ( sType == rhs.sType )
21496 && ( pNext == rhs.pNext )
21497 && ( flags == rhs.flags )
21500 && ( templateType == rhs.templateType )
21503 && ( pipelineLayout == rhs.pipelineLayout )
21504 && ( set == rhs.set );
21505 }
21506
21508 {
21509 return !operator==( rhs );
21510 }
21511
21512 private:
21514
21515 public:
21516 void* pNext = nullptr;
21525 };
21526 static_assert( sizeof( DescriptorUpdateTemplateCreateInfo ) == sizeof( VkDescriptorUpdateTemplateCreateInfo ), "struct and wrapper have different size!" );
21527
21529
21530 enum class ObjectType
21531 {
21572 };
21573
21575 {
21577 uint64_t objectHandle_ = 0,
21578 const char* pObjectName_ = nullptr )
21579 : objectType( objectType_ )
21580 , objectHandle( objectHandle_ )
21581 , pObjectName( pObjectName_ )
21582 {
21583 }
21584
21586 {
21587 memcpy( this, &rhs, sizeof( DebugUtilsObjectNameInfoEXT ) );
21588 }
21589
21591 {
21592 memcpy( this, &rhs, sizeof( DebugUtilsObjectNameInfoEXT ) );
21593 return *this;
21594 }
21596 {
21597 pNext = pNext_;
21598 return *this;
21599 }
21600
21602 {
21603 objectType = objectType_;
21604 return *this;
21605 }
21606
21608 {
21609 objectHandle = objectHandle_;
21610 return *this;
21611 }
21612
21613 DebugUtilsObjectNameInfoEXT& setPObjectName( const char* pObjectName_ )
21614 {
21615 pObjectName = pObjectName_;
21616 return *this;
21617 }
21618
21619 operator VkDebugUtilsObjectNameInfoEXT const&() const
21620 {
21621 return *reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT*>(this);
21622 }
21623
21625 {
21626 return *reinterpret_cast<VkDebugUtilsObjectNameInfoEXT*>(this);
21627 }
21628
21630 {
21631 return ( sType == rhs.sType )
21632 && ( pNext == rhs.pNext )
21633 && ( objectType == rhs.objectType )
21634 && ( objectHandle == rhs.objectHandle )
21635 && ( pObjectName == rhs.pObjectName );
21636 }
21637
21639 {
21640 return !operator==( rhs );
21641 }
21642
21643 private:
21645
21646 public:
21647 const void* pNext = nullptr;
21650 const char* pObjectName;
21651 };
21652 static_assert( sizeof( DebugUtilsObjectNameInfoEXT ) == sizeof( VkDebugUtilsObjectNameInfoEXT ), "struct and wrapper have different size!" );
21653
21655 {
21657 uint64_t objectHandle_ = 0,
21658 uint64_t tagName_ = 0,
21659 size_t tagSize_ = 0,
21660 const void* pTag_ = nullptr )
21661 : objectType( objectType_ )
21662 , objectHandle( objectHandle_ )
21663 , tagName( tagName_ )
21664 , tagSize( tagSize_ )
21665 , pTag( pTag_ )
21666 {
21667 }
21668
21670 {
21671 memcpy( this, &rhs, sizeof( DebugUtilsObjectTagInfoEXT ) );
21672 }
21673
21675 {
21676 memcpy( this, &rhs, sizeof( DebugUtilsObjectTagInfoEXT ) );
21677 return *this;
21678 }
21680 {
21681 pNext = pNext_;
21682 return *this;
21683 }
21684
21686 {
21687 objectType = objectType_;
21688 return *this;
21689 }
21690
21692 {
21693 objectHandle = objectHandle_;
21694 return *this;
21695 }
21696
21698 {
21699 tagName = tagName_;
21700 return *this;
21701 }
21702
21704 {
21705 tagSize = tagSize_;
21706 return *this;
21707 }
21708
21710 {
21711 pTag = pTag_;
21712 return *this;
21713 }
21714
21715 operator VkDebugUtilsObjectTagInfoEXT const&() const
21716 {
21717 return *reinterpret_cast<const VkDebugUtilsObjectTagInfoEXT*>(this);
21718 }
21719
21721 {
21722 return *reinterpret_cast<VkDebugUtilsObjectTagInfoEXT*>(this);
21723 }
21724
21726 {
21727 return ( sType == rhs.sType )
21728 && ( pNext == rhs.pNext )
21729 && ( objectType == rhs.objectType )
21730 && ( objectHandle == rhs.objectHandle )
21731 && ( tagName == rhs.tagName )
21732 && ( tagSize == rhs.tagSize )
21733 && ( pTag == rhs.pTag );
21734 }
21735
21737 {
21738 return !operator==( rhs );
21739 }
21740
21741 private:
21743
21744 public:
21745 const void* pNext = nullptr;
21749 size_t tagSize;
21750 const void* pTag;
21751 };
21752 static_assert( sizeof( DebugUtilsObjectTagInfoEXT ) == sizeof( VkDebugUtilsObjectTagInfoEXT ), "struct and wrapper have different size!" );
21753
21755 {
21757 const char* pMessageIdName_ = nullptr,
21758 int32_t messageIdNumber_ = 0,
21759 const char* pMessage_ = nullptr,
21760 uint32_t queueLabelCount_ = 0,
21761 DebugUtilsLabelEXT* pQueueLabels_ = nullptr,
21762 uint32_t cmdBufLabelCount_ = 0,
21763 DebugUtilsLabelEXT* pCmdBufLabels_ = nullptr,
21764 uint32_t objectCount_ = 0,
21765 DebugUtilsObjectNameInfoEXT* pObjects_ = nullptr )
21766 : flags( flags_ )
21767 , pMessageIdName( pMessageIdName_ )
21768 , messageIdNumber( messageIdNumber_ )
21769 , pMessage( pMessage_ )
21770 , queueLabelCount( queueLabelCount_ )
21771 , pQueueLabels( pQueueLabels_ )
21772 , cmdBufLabelCount( cmdBufLabelCount_ )
21773 , pCmdBufLabels( pCmdBufLabels_ )
21774 , objectCount( objectCount_ )
21775 , pObjects( pObjects_ )
21776 {
21777 }
21778
21780 {
21781 memcpy( this, &rhs, sizeof( DebugUtilsMessengerCallbackDataEXT ) );
21782 }
21783
21785 {
21786 memcpy( this, &rhs, sizeof( DebugUtilsMessengerCallbackDataEXT ) );
21787 return *this;
21788 }
21790 {
21791 pNext = pNext_;
21792 return *this;
21793 }
21794
21796 {
21797 flags = flags_;
21798 return *this;
21799 }
21800
21802 {
21803 pMessageIdName = pMessageIdName_;
21804 return *this;
21805 }
21806
21808 {
21809 messageIdNumber = messageIdNumber_;
21810 return *this;
21811 }
21812
21814 {
21815 pMessage = pMessage_;
21816 return *this;
21817 }
21818
21820 {
21821 queueLabelCount = queueLabelCount_;
21822 return *this;
21823 }
21824
21826 {
21827 pQueueLabels = pQueueLabels_;
21828 return *this;
21829 }
21830
21832 {
21833 cmdBufLabelCount = cmdBufLabelCount_;
21834 return *this;
21835 }
21836
21838 {
21839 pCmdBufLabels = pCmdBufLabels_;
21840 return *this;
21841 }
21842
21844 {
21845 objectCount = objectCount_;
21846 return *this;
21847 }
21848
21850 {
21851 pObjects = pObjects_;
21852 return *this;
21853 }
21854
21856 {
21857 return *reinterpret_cast<const VkDebugUtilsMessengerCallbackDataEXT*>(this);
21858 }
21859
21861 {
21862 return *reinterpret_cast<VkDebugUtilsMessengerCallbackDataEXT*>(this);
21863 }
21864
21866 {
21867 return ( sType == rhs.sType )
21868 && ( pNext == rhs.pNext )
21869 && ( flags == rhs.flags )
21870 && ( pMessageIdName == rhs.pMessageIdName )
21871 && ( messageIdNumber == rhs.messageIdNumber )
21872 && ( pMessage == rhs.pMessage )
21873 && ( queueLabelCount == rhs.queueLabelCount )
21874 && ( pQueueLabels == rhs.pQueueLabels )
21876 && ( pCmdBufLabels == rhs.pCmdBufLabels )
21877 && ( objectCount == rhs.objectCount )
21878 && ( pObjects == rhs.pObjects );
21879 }
21880
21882 {
21883 return !operator==( rhs );
21884 }
21885
21886 private:
21888
21889 public:
21890 const void* pNext = nullptr;
21892 const char* pMessageIdName;
21894 const char* pMessage;
21901 };
21902 static_assert( sizeof( DebugUtilsMessengerCallbackDataEXT ) == sizeof( VkDebugUtilsMessengerCallbackDataEXT ), "struct and wrapper have different size!" );
21903
21904 enum class QueueFlagBits
21905 {
21911 };
21912
21914
21916 {
21917 return QueueFlags( bit0 ) | bit1;
21918 }
21919
21921 {
21922 return ~( QueueFlags( bits ) );
21923 }
21924
21925 template <> struct FlagTraits<QueueFlagBits>
21926 {
21927 enum
21928 {
21931 };
21932
21934 {
21935 operator VkQueueFamilyProperties const&() const
21936 {
21937 return *reinterpret_cast<const VkQueueFamilyProperties*>(this);
21938 }
21939
21941 {
21942 return *reinterpret_cast<VkQueueFamilyProperties*>(this);
21943 }
21944
21945 bool operator==( QueueFamilyProperties const& rhs ) const
21946 {
21947 return ( queueFlags == rhs.queueFlags )
21948 && ( queueCount == rhs.queueCount )
21951 }
21952
21953 bool operator!=( QueueFamilyProperties const& rhs ) const
21954 {
21955 return !operator==( rhs );
21956 }
21957
21962 };
21963 static_assert( sizeof( QueueFamilyProperties ) == sizeof( VkQueueFamilyProperties ), "struct and wrapper have different size!" );
21964
21966 {
21967 operator VkQueueFamilyProperties2 const&() const
21968 {
21969 return *reinterpret_cast<const VkQueueFamilyProperties2*>(this);
21970 }
21971
21973 {
21974 return *reinterpret_cast<VkQueueFamilyProperties2*>(this);
21975 }
21976
21977 bool operator==( QueueFamilyProperties2 const& rhs ) const
21978 {
21979 return ( sType == rhs.sType )
21980 && ( pNext == rhs.pNext )
21982 }
21983
21984 bool operator!=( QueueFamilyProperties2 const& rhs ) const
21985 {
21986 return !operator==( rhs );
21987 }
21988
21989 private:
21991
21992 public:
21993 void* pNext = nullptr;
21995 };
21996 static_assert( sizeof( QueueFamilyProperties2 ) == sizeof( VkQueueFamilyProperties2 ), "struct and wrapper have different size!" );
21997
21999
22001 {
22003 };
22004
22006
22008 {
22009 return DeviceQueueCreateFlags( bit0 ) | bit1;
22010 }
22011
22013 {
22014 return ~( DeviceQueueCreateFlags( bits ) );
22015 }
22016
22018 {
22019 enum
22020 {
22023 };
22024
22026 {
22028 uint32_t queueFamilyIndex_ = 0,
22029 uint32_t queueCount_ = 0,
22030 const float* pQueuePriorities_ = nullptr )
22031 : flags( flags_ )
22032 , queueFamilyIndex( queueFamilyIndex_ )
22033 , queueCount( queueCount_ )
22034 , pQueuePriorities( pQueuePriorities_ )
22035 {
22036 }
22037
22039 {
22040 memcpy( this, &rhs, sizeof( DeviceQueueCreateInfo ) );
22041 }
22042
22044 {
22045 memcpy( this, &rhs, sizeof( DeviceQueueCreateInfo ) );
22046 return *this;
22047 }
22048 DeviceQueueCreateInfo& setPNext( const void* pNext_ )
22049 {
22050 pNext = pNext_;
22051 return *this;
22052 }
22053
22055 {
22056 flags = flags_;
22057 return *this;
22058 }
22059
22061 {
22062 queueFamilyIndex = queueFamilyIndex_;
22063 return *this;
22064 }
22065
22067 {
22068 queueCount = queueCount_;
22069 return *this;
22070 }
22071
22072 DeviceQueueCreateInfo& setPQueuePriorities( const float* pQueuePriorities_ )
22073 {
22074 pQueuePriorities = pQueuePriorities_;
22075 return *this;
22076 }
22077
22078 operator VkDeviceQueueCreateInfo const&() const
22079 {
22080 return *reinterpret_cast<const VkDeviceQueueCreateInfo*>(this);
22081 }
22082
22084 {
22085 return *reinterpret_cast<VkDeviceQueueCreateInfo*>(this);
22086 }
22087
22088 bool operator==( DeviceQueueCreateInfo const& rhs ) const
22089 {
22090 return ( sType == rhs.sType )
22091 && ( pNext == rhs.pNext )
22092 && ( flags == rhs.flags )
22094 && ( queueCount == rhs.queueCount )
22095 && ( pQueuePriorities == rhs.pQueuePriorities );
22096 }
22097
22098 bool operator!=( DeviceQueueCreateInfo const& rhs ) const
22099 {
22100 return !operator==( rhs );
22101 }
22102
22103 private:
22105
22106 public:
22107 const void* pNext = nullptr;
22111 const float* pQueuePriorities;
22112 };
22113 static_assert( sizeof( DeviceQueueCreateInfo ) == sizeof( VkDeviceQueueCreateInfo ), "struct and wrapper have different size!" );
22114
22116 {
22118 uint32_t queueCreateInfoCount_ = 0,
22119 const DeviceQueueCreateInfo* pQueueCreateInfos_ = nullptr,
22120 uint32_t enabledLayerCount_ = 0,
22121 const char* const* ppEnabledLayerNames_ = nullptr,
22122 uint32_t enabledExtensionCount_ = 0,
22123 const char* const* ppEnabledExtensionNames_ = nullptr,
22124 const PhysicalDeviceFeatures* pEnabledFeatures_ = nullptr )
22125 : flags( flags_ )
22126 , queueCreateInfoCount( queueCreateInfoCount_ )
22127 , pQueueCreateInfos( pQueueCreateInfos_ )
22128 , enabledLayerCount( enabledLayerCount_ )
22129 , ppEnabledLayerNames( ppEnabledLayerNames_ )
22130 , enabledExtensionCount( enabledExtensionCount_ )
22131 , ppEnabledExtensionNames( ppEnabledExtensionNames_ )
22132 , pEnabledFeatures( pEnabledFeatures_ )
22133 {
22134 }
22135
22137 {
22138 memcpy( this, &rhs, sizeof( DeviceCreateInfo ) );
22139 }
22140
22142 {
22143 memcpy( this, &rhs, sizeof( DeviceCreateInfo ) );
22144 return *this;
22145 }
22146 DeviceCreateInfo& setPNext( const void* pNext_ )
22147 {
22148 pNext = pNext_;
22149 return *this;
22150 }
22151
22153 {
22154 flags = flags_;
22155 return *this;
22156 }
22157
22159 {
22160 queueCreateInfoCount = queueCreateInfoCount_;
22161 return *this;
22162 }
22163
22165 {
22166 pQueueCreateInfos = pQueueCreateInfos_;
22167 return *this;
22168 }
22169
22171 {
22172 enabledLayerCount = enabledLayerCount_;
22173 return *this;
22174 }
22175
22176 DeviceCreateInfo& setPpEnabledLayerNames( const char* const* ppEnabledLayerNames_ )
22177 {
22178 ppEnabledLayerNames = ppEnabledLayerNames_;
22179 return *this;
22180 }
22181
22183 {
22184 enabledExtensionCount = enabledExtensionCount_;
22185 return *this;
22186 }
22187
22188 DeviceCreateInfo& setPpEnabledExtensionNames( const char* const* ppEnabledExtensionNames_ )
22189 {
22190 ppEnabledExtensionNames = ppEnabledExtensionNames_;
22191 return *this;
22192 }
22193
22195 {
22196 pEnabledFeatures = pEnabledFeatures_;
22197 return *this;
22198 }
22199
22200 operator VkDeviceCreateInfo const&() const
22201 {
22202 return *reinterpret_cast<const VkDeviceCreateInfo*>(this);
22203 }
22204
22206 {
22207 return *reinterpret_cast<VkDeviceCreateInfo*>(this);
22208 }
22209
22210 bool operator==( DeviceCreateInfo const& rhs ) const
22211 {
22212 return ( sType == rhs.sType )
22213 && ( pNext == rhs.pNext )
22214 && ( flags == rhs.flags )
22221 && ( pEnabledFeatures == rhs.pEnabledFeatures );
22222 }
22223
22224 bool operator!=( DeviceCreateInfo const& rhs ) const
22225 {
22226 return !operator==( rhs );
22227 }
22228
22229 private:
22231
22232 public:
22233 const void* pNext = nullptr;
22238 const char* const* ppEnabledLayerNames;
22240 const char* const* ppEnabledExtensionNames;
22242 };
22243 static_assert( sizeof( DeviceCreateInfo ) == sizeof( VkDeviceCreateInfo ), "struct and wrapper have different size!" );
22244
22246 {
22248 uint32_t queueFamilyIndex_ = 0,
22249 uint32_t queueIndex_ = 0 )
22250 : flags( flags_ )
22251 , queueFamilyIndex( queueFamilyIndex_ )
22252 , queueIndex( queueIndex_ )
22253 {
22254 }
22255
22257 {
22258 memcpy( this, &rhs, sizeof( DeviceQueueInfo2 ) );
22259 }
22260
22262 {
22263 memcpy( this, &rhs, sizeof( DeviceQueueInfo2 ) );
22264 return *this;
22265 }
22266 DeviceQueueInfo2& setPNext( const void* pNext_ )
22267 {
22268 pNext = pNext_;
22269 return *this;
22270 }
22271
22273 {
22274 flags = flags_;
22275 return *this;
22276 }
22277
22279 {
22280 queueFamilyIndex = queueFamilyIndex_;
22281 return *this;
22282 }
22283
22285 {
22286 queueIndex = queueIndex_;
22287 return *this;
22288 }
22289
22290 operator VkDeviceQueueInfo2 const&() const
22291 {
22292 return *reinterpret_cast<const VkDeviceQueueInfo2*>(this);
22293 }
22294
22296 {
22297 return *reinterpret_cast<VkDeviceQueueInfo2*>(this);
22298 }
22299
22300 bool operator==( DeviceQueueInfo2 const& rhs ) const
22301 {
22302 return ( sType == rhs.sType )
22303 && ( pNext == rhs.pNext )
22304 && ( flags == rhs.flags )
22306 && ( queueIndex == rhs.queueIndex );
22307 }
22308
22309 bool operator!=( DeviceQueueInfo2 const& rhs ) const
22310 {
22311 return !operator==( rhs );
22312 }
22313
22314 private:
22316
22317 public:
22318 const void* pNext = nullptr;
22322 };
22323 static_assert( sizeof( DeviceQueueInfo2 ) == sizeof( VkDeviceQueueInfo2 ), "struct and wrapper have different size!" );
22324
22326 {
22333 };
22334
22336
22338 {
22339 return MemoryPropertyFlags( bit0 ) | bit1;
22340 }
22341
22343 {
22344 return ~( MemoryPropertyFlags( bits ) );
22345 }
22346
22348 {
22349 enum
22350 {
22353 };
22354
22356 {
22357 operator VkMemoryType const&() const
22358 {
22359 return *reinterpret_cast<const VkMemoryType*>(this);
22360 }
22361
22362 operator VkMemoryType &()
22363 {
22364 return *reinterpret_cast<VkMemoryType*>(this);
22365 }
22366
22367 bool operator==( MemoryType const& rhs ) const
22368 {
22369 return ( propertyFlags == rhs.propertyFlags )
22370 && ( heapIndex == rhs.heapIndex );
22371 }
22372
22373 bool operator!=( MemoryType const& rhs ) const
22374 {
22375 return !operator==( rhs );
22376 }
22377
22380 };
22381 static_assert( sizeof( MemoryType ) == sizeof( VkMemoryType ), "struct and wrapper have different size!" );
22382
22384 {
22388 };
22389
22391
22393 {
22394 return MemoryHeapFlags( bit0 ) | bit1;
22395 }
22396
22398 {
22399 return ~( MemoryHeapFlags( bits ) );
22400 }
22401
22402 template <> struct FlagTraits<MemoryHeapFlagBits>
22403 {
22404 enum
22405 {
22408 };
22409
22411 {
22412 operator VkMemoryHeap const&() const
22413 {
22414 return *reinterpret_cast<const VkMemoryHeap*>(this);
22415 }
22416
22417 operator VkMemoryHeap &()
22418 {
22419 return *reinterpret_cast<VkMemoryHeap*>(this);
22420 }
22421
22422 bool operator==( MemoryHeap const& rhs ) const
22423 {
22424 return ( size == rhs.size )
22425 && ( flags == rhs.flags );
22426 }
22427
22428 bool operator!=( MemoryHeap const& rhs ) const
22429 {
22430 return !operator==( rhs );
22431 }
22432
22435 };
22436 static_assert( sizeof( MemoryHeap ) == sizeof( VkMemoryHeap ), "struct and wrapper have different size!" );
22437
22439 {
22440 operator VkPhysicalDeviceMemoryProperties const&() const
22441 {
22442 return *reinterpret_cast<const VkPhysicalDeviceMemoryProperties*>(this);
22443 }
22444
22446 {
22447 return *reinterpret_cast<VkPhysicalDeviceMemoryProperties*>(this);
22448 }
22449
22451 {
22452 return ( memoryTypeCount == rhs.memoryTypeCount )
22453 && ( memcmp( memoryTypes, rhs.memoryTypes, VK_MAX_MEMORY_TYPES * sizeof( MemoryType ) ) == 0 )
22454 && ( memoryHeapCount == rhs.memoryHeapCount )
22455 && ( memcmp( memoryHeaps, rhs.memoryHeaps, VK_MAX_MEMORY_HEAPS * sizeof( MemoryHeap ) ) == 0 );
22456 }
22457
22459 {
22460 return !operator==( rhs );
22461 }
22462
22467 };
22468 static_assert( sizeof( PhysicalDeviceMemoryProperties ) == sizeof( VkPhysicalDeviceMemoryProperties ), "struct and wrapper have different size!" );
22469
22471 {
22473 {
22474 return *reinterpret_cast<const VkPhysicalDeviceMemoryProperties2*>(this);
22475 }
22476
22478 {
22479 return *reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>(this);
22480 }
22481
22483 {
22484 return ( sType == rhs.sType )
22485 && ( pNext == rhs.pNext )
22486 && ( memoryProperties == rhs.memoryProperties );
22487 }
22488
22490 {
22491 return !operator==( rhs );
22492 }
22493
22494 private:
22496
22497 public:
22498 void* pNext = nullptr;
22500 };
22501 static_assert( sizeof( PhysicalDeviceMemoryProperties2 ) == sizeof( VkPhysicalDeviceMemoryProperties2 ), "struct and wrapper have different size!" );
22502
22504
22506 {
22534 };
22535
22537
22539 {
22540 return AccessFlags( bit0 ) | bit1;
22541 }
22542
22544 {
22545 return ~( AccessFlags( bits ) );
22546 }
22547
22548 template <> struct FlagTraits<AccessFlagBits>
22549 {
22550 enum
22551 {
22554 };
22555
22557 {
22559 AccessFlags dstAccessMask_ = AccessFlags() )
22560 : srcAccessMask( srcAccessMask_ )
22561 , dstAccessMask( dstAccessMask_ )
22562 {
22563 }
22564
22566 {
22567 memcpy( this, &rhs, sizeof( MemoryBarrier ) );
22568 }
22569
22571 {
22572 memcpy( this, &rhs, sizeof( MemoryBarrier ) );
22573 return *this;
22574 }
22575 MemoryBarrier& setPNext( const void* pNext_ )
22576 {
22577 pNext = pNext_;
22578 return *this;
22579 }
22580
22582 {
22583 srcAccessMask = srcAccessMask_;
22584 return *this;
22585 }
22586
22588 {
22589 dstAccessMask = dstAccessMask_;
22590 return *this;
22591 }
22592
22593 operator VkMemoryBarrier const&() const
22594 {
22595 return *reinterpret_cast<const VkMemoryBarrier*>(this);
22596 }
22597
22598 operator VkMemoryBarrier &()
22599 {
22600 return *reinterpret_cast<VkMemoryBarrier*>(this);
22601 }
22602
22603 bool operator==( MemoryBarrier const& rhs ) const
22604 {
22605 return ( sType == rhs.sType )
22606 && ( pNext == rhs.pNext )
22607 && ( srcAccessMask == rhs.srcAccessMask )
22608 && ( dstAccessMask == rhs.dstAccessMask );
22609 }
22610
22611 bool operator!=( MemoryBarrier const& rhs ) const
22612 {
22613 return !operator==( rhs );
22614 }
22615
22616 private:
22618
22619 public:
22620 const void* pNext = nullptr;
22623 };
22624 static_assert( sizeof( MemoryBarrier ) == sizeof( VkMemoryBarrier ), "struct and wrapper have different size!" );
22625
22627 {
22629 AccessFlags dstAccessMask_ = AccessFlags(),
22630 uint32_t srcQueueFamilyIndex_ = 0,
22631 uint32_t dstQueueFamilyIndex_ = 0,
22632 Buffer buffer_ = Buffer(),
22633 DeviceSize offset_ = 0,
22634 DeviceSize size_ = 0 )
22635 : srcAccessMask( srcAccessMask_ )
22636 , dstAccessMask( dstAccessMask_ )
22637 , srcQueueFamilyIndex( srcQueueFamilyIndex_ )
22638 , dstQueueFamilyIndex( dstQueueFamilyIndex_ )
22639 , buffer( buffer_ )
22640 , offset( offset_ )
22641 , size( size_ )
22642 {
22643 }
22644
22646 {
22647 memcpy( this, &rhs, sizeof( BufferMemoryBarrier ) );
22648 }
22649
22651 {
22652 memcpy( this, &rhs, sizeof( BufferMemoryBarrier ) );
22653 return *this;
22654 }
22655 BufferMemoryBarrier& setPNext( const void* pNext_ )
22656 {
22657 pNext = pNext_;
22658 return *this;
22659 }
22660
22662 {
22663 srcAccessMask = srcAccessMask_;
22664 return *this;
22665 }
22666
22668 {
22669 dstAccessMask = dstAccessMask_;
22670 return *this;
22671 }
22672
22674 {
22675 srcQueueFamilyIndex = srcQueueFamilyIndex_;
22676 return *this;
22677 }
22678
22680 {
22681 dstQueueFamilyIndex = dstQueueFamilyIndex_;
22682 return *this;
22683 }
22684
22686 {
22687 buffer = buffer_;
22688 return *this;
22689 }
22690
22692 {
22693 offset = offset_;
22694 return *this;
22695 }
22696
22698 {
22699 size = size_;
22700 return *this;
22701 }
22702
22703 operator VkBufferMemoryBarrier const&() const
22704 {
22705 return *reinterpret_cast<const VkBufferMemoryBarrier*>(this);
22706 }
22707
22709 {
22710 return *reinterpret_cast<VkBufferMemoryBarrier*>(this);
22711 }
22712
22713 bool operator==( BufferMemoryBarrier const& rhs ) const
22714 {
22715 return ( sType == rhs.sType )
22716 && ( pNext == rhs.pNext )
22717 && ( srcAccessMask == rhs.srcAccessMask )
22718 && ( dstAccessMask == rhs.dstAccessMask )
22721 && ( buffer == rhs.buffer )
22722 && ( offset == rhs.offset )
22723 && ( size == rhs.size );
22724 }
22725
22726 bool operator!=( BufferMemoryBarrier const& rhs ) const
22727 {
22728 return !operator==( rhs );
22729 }
22730
22731 private:
22733
22734 public:
22735 const void* pNext = nullptr;
22743 };
22744 static_assert( sizeof( BufferMemoryBarrier ) == sizeof( VkBufferMemoryBarrier ), "struct and wrapper have different size!" );
22745
22747 {
22761 };
22762
22764
22766 {
22767 return BufferUsageFlags( bit0 ) | bit1;
22768 }
22769
22771 {
22772 return ~( BufferUsageFlags( bits ) );
22773 }
22774
22776 {
22777 enum
22778 {
22781 };
22782
22784 {
22789 };
22790
22792
22794 {
22795 return BufferCreateFlags( bit0 ) | bit1;
22796 }
22797
22799 {
22800 return ~( BufferCreateFlags( bits ) );
22801 }
22802
22804 {
22805 enum
22806 {
22809 };
22810
22812 {
22814 DeviceSize size_ = 0,
22816 SharingMode sharingMode_ = SharingMode::eExclusive,
22817 uint32_t queueFamilyIndexCount_ = 0,
22818 const uint32_t* pQueueFamilyIndices_ = nullptr )
22819 : flags( flags_ )
22820 , size( size_ )
22821 , usage( usage_ )
22822 , sharingMode( sharingMode_ )
22823 , queueFamilyIndexCount( queueFamilyIndexCount_ )
22824 , pQueueFamilyIndices( pQueueFamilyIndices_ )
22825 {
22826 }
22827
22829 {
22830 memcpy( this, &rhs, sizeof( BufferCreateInfo ) );
22831 }
22832
22834 {
22835 memcpy( this, &rhs, sizeof( BufferCreateInfo ) );
22836 return *this;
22837 }
22838 BufferCreateInfo& setPNext( const void* pNext_ )
22839 {
22840 pNext = pNext_;
22841 return *this;
22842 }
22843
22845 {
22846 flags = flags_;
22847 return *this;
22848 }
22849
22851 {
22852 size = size_;
22853 return *this;
22854 }
22855
22857 {
22858 usage = usage_;
22859 return *this;
22860 }
22861
22863 {
22864 sharingMode = sharingMode_;
22865 return *this;
22866 }
22867
22869 {
22870 queueFamilyIndexCount = queueFamilyIndexCount_;
22871 return *this;
22872 }
22873
22874 BufferCreateInfo& setPQueueFamilyIndices( const uint32_t* pQueueFamilyIndices_ )
22875 {
22876 pQueueFamilyIndices = pQueueFamilyIndices_;
22877 return *this;
22878 }
22879
22880 operator VkBufferCreateInfo const&() const
22881 {
22882 return *reinterpret_cast<const VkBufferCreateInfo*>(this);
22883 }
22884
22886 {
22887 return *reinterpret_cast<VkBufferCreateInfo*>(this);
22888 }
22889
22890 bool operator==( BufferCreateInfo const& rhs ) const
22891 {
22892 return ( sType == rhs.sType )
22893 && ( pNext == rhs.pNext )
22894 && ( flags == rhs.flags )
22895 && ( size == rhs.size )
22896 && ( usage == rhs.usage )
22897 && ( sharingMode == rhs.sharingMode )
22900 }
22901
22902 bool operator!=( BufferCreateInfo const& rhs ) const
22903 {
22904 return !operator==( rhs );
22905 }
22906
22907 private:
22909
22910 public:
22911 const void* pNext = nullptr;
22918 };
22919 static_assert( sizeof( BufferCreateInfo ) == sizeof( VkBufferCreateInfo ), "struct and wrapper have different size!" );
22920
22922 {
22939 };
22940
22942
22944 {
22945 return ShaderStageFlags( bit0 ) | bit1;
22946 }
22947
22949 {
22950 return ~( ShaderStageFlags( bits ) );
22951 }
22952
22954 {
22955 enum
22956 {
22959 };
22960
22962 {
22964 DescriptorType descriptorType_ = DescriptorType::eSampler,
22965 uint32_t descriptorCount_ = 0,
22966 ShaderStageFlags stageFlags_ = ShaderStageFlags(),
22967 const Sampler* pImmutableSamplers_ = nullptr )
22968 : binding( binding_ )
22969 , descriptorType( descriptorType_ )
22970 , descriptorCount( descriptorCount_ )
22971 , stageFlags( stageFlags_ )
22972 , pImmutableSamplers( pImmutableSamplers_ )
22973 {
22974 }
22975
22977 {
22978 memcpy( this, &rhs, sizeof( DescriptorSetLayoutBinding ) );
22979 }
22980
22982 {
22983 memcpy( this, &rhs, sizeof( DescriptorSetLayoutBinding ) );
22984 return *this;
22985 }
22987 {
22988 binding = binding_;
22989 return *this;
22990 }
22991
22993 {
22994 descriptorType = descriptorType_;
22995 return *this;
22996 }
22997
22999 {
23000 descriptorCount = descriptorCount_;
23001 return *this;
23002 }
23003
23005 {
23006 stageFlags = stageFlags_;
23007 return *this;
23008 }
23009
23011 {
23012 pImmutableSamplers = pImmutableSamplers_;
23013 return *this;
23014 }
23015
23016 operator VkDescriptorSetLayoutBinding const&() const
23017 {
23018 return *reinterpret_cast<const VkDescriptorSetLayoutBinding*>(this);
23019 }
23020
23022 {
23023 return *reinterpret_cast<VkDescriptorSetLayoutBinding*>(this);
23024 }
23025
23027 {
23028 return ( binding == rhs.binding )
23029 && ( descriptorType == rhs.descriptorType )
23030 && ( descriptorCount == rhs.descriptorCount )
23031 && ( stageFlags == rhs.stageFlags )
23033 }
23034
23036 {
23037 return !operator==( rhs );
23038 }
23039
23045 };
23046 static_assert( sizeof( DescriptorSetLayoutBinding ) == sizeof( VkDescriptorSetLayoutBinding ), "struct and wrapper have different size!" );
23047
23049 {
23052 ShaderModule module_ = ShaderModule(),
23053 const char* pName_ = nullptr,
23054 const SpecializationInfo* pSpecializationInfo_ = nullptr )
23055 : flags( flags_ )
23056 , stage( stage_ )
23057 , module( module_ )
23058 , pName( pName_ )
23059 , pSpecializationInfo( pSpecializationInfo_ )
23060 {
23061 }
23062
23064 {
23065 memcpy( this, &rhs, sizeof( PipelineShaderStageCreateInfo ) );
23066 }
23067
23069 {
23070 memcpy( this, &rhs, sizeof( PipelineShaderStageCreateInfo ) );
23071 return *this;
23072 }
23074 {
23075 pNext = pNext_;
23076 return *this;
23077 }
23078
23080 {
23081 flags = flags_;
23082 return *this;
23083 }
23084
23086 {
23087 stage = stage_;
23088 return *this;
23089 }
23090
23092 {
23093 module = module_;
23094 return *this;
23095 }
23096
23098 {
23099 pName = pName_;
23100 return *this;
23101 }
23102
23104 {
23105 pSpecializationInfo = pSpecializationInfo_;
23106 return *this;
23107 }
23108
23109 operator VkPipelineShaderStageCreateInfo const&() const
23110 {
23111 return *reinterpret_cast<const VkPipelineShaderStageCreateInfo*>(this);
23112 }
23113
23115 {
23116 return *reinterpret_cast<VkPipelineShaderStageCreateInfo*>(this);
23117 }
23118
23120 {
23121 return ( sType == rhs.sType )
23122 && ( pNext == rhs.pNext )
23123 && ( flags == rhs.flags )
23124 && ( stage == rhs.stage )
23125 && ( module == rhs.module )
23126 && ( pName == rhs.pName )
23128 }
23129
23131 {
23132 return !operator==( rhs );
23133 }
23134
23135 private:
23137
23138 public:
23139 const void* pNext = nullptr;
23143 const char* pName;
23145 };
23146 static_assert( sizeof( PipelineShaderStageCreateInfo ) == sizeof( VkPipelineShaderStageCreateInfo ), "struct and wrapper have different size!" );
23147
23149 {
23151 uint32_t offset_ = 0,
23152 uint32_t size_ = 0 )
23153 : stageFlags( stageFlags_ )
23154 , offset( offset_ )
23155 , size( size_ )
23156 {
23157 }
23158
23160 {
23161 memcpy( this, &rhs, sizeof( PushConstantRange ) );
23162 }
23163
23165 {
23166 memcpy( this, &rhs, sizeof( PushConstantRange ) );
23167 return *this;
23168 }
23170 {
23171 stageFlags = stageFlags_;
23172 return *this;
23173 }
23174
23176 {
23177 offset = offset_;
23178 return *this;
23179 }
23180
23182 {
23183 size = size_;
23184 return *this;
23185 }
23186
23187 operator VkPushConstantRange const&() const
23188 {
23189 return *reinterpret_cast<const VkPushConstantRange*>(this);
23190 }
23191
23193 {
23194 return *reinterpret_cast<VkPushConstantRange*>(this);
23195 }
23196
23197 bool operator==( PushConstantRange const& rhs ) const
23198 {
23199 return ( stageFlags == rhs.stageFlags )
23200 && ( offset == rhs.offset )
23201 && ( size == rhs.size );
23202 }
23203
23204 bool operator!=( PushConstantRange const& rhs ) const
23205 {
23206 return !operator==( rhs );
23207 }
23208
23212 };
23213 static_assert( sizeof( PushConstantRange ) == sizeof( VkPushConstantRange ), "struct and wrapper have different size!" );
23214
23216 {
23218 uint32_t setLayoutCount_ = 0,
23219 const DescriptorSetLayout* pSetLayouts_ = nullptr,
23220 uint32_t pushConstantRangeCount_ = 0,
23221 const PushConstantRange* pPushConstantRanges_ = nullptr )
23222 : flags( flags_ )
23223 , setLayoutCount( setLayoutCount_ )
23224 , pSetLayouts( pSetLayouts_ )
23225 , pushConstantRangeCount( pushConstantRangeCount_ )
23226 , pPushConstantRanges( pPushConstantRanges_ )
23227 {
23228 }
23229
23231 {
23232 memcpy( this, &rhs, sizeof( PipelineLayoutCreateInfo ) );
23233 }
23234
23236 {
23237 memcpy( this, &rhs, sizeof( PipelineLayoutCreateInfo ) );
23238 return *this;
23239 }
23240 PipelineLayoutCreateInfo& setPNext( const void* pNext_ )
23241 {
23242 pNext = pNext_;
23243 return *this;
23244 }
23245
23247 {
23248 flags = flags_;
23249 return *this;
23250 }
23251
23253 {
23254 setLayoutCount = setLayoutCount_;
23255 return *this;
23256 }
23257
23259 {
23260 pSetLayouts = pSetLayouts_;
23261 return *this;
23262 }
23263
23265 {
23266 pushConstantRangeCount = pushConstantRangeCount_;
23267 return *this;
23268 }
23269
23271 {
23272 pPushConstantRanges = pPushConstantRanges_;
23273 return *this;
23274 }
23275
23276 operator VkPipelineLayoutCreateInfo const&() const
23277 {
23278 return *reinterpret_cast<const VkPipelineLayoutCreateInfo*>(this);
23279 }
23280
23282 {
23283 return *reinterpret_cast<VkPipelineLayoutCreateInfo*>(this);
23284 }
23285
23286 bool operator==( PipelineLayoutCreateInfo const& rhs ) const
23287 {
23288 return ( sType == rhs.sType )
23289 && ( pNext == rhs.pNext )
23290 && ( flags == rhs.flags )
23291 && ( setLayoutCount == rhs.setLayoutCount )
23292 && ( pSetLayouts == rhs.pSetLayouts )
23295 }
23296
23297 bool operator!=( PipelineLayoutCreateInfo const& rhs ) const
23298 {
23299 return !operator==( rhs );
23300 }
23301
23302 private:
23304
23305 public:
23306 const void* pNext = nullptr;
23312 };
23313 static_assert( sizeof( PipelineLayoutCreateInfo ) == sizeof( VkPipelineLayoutCreateInfo ), "struct and wrapper have different size!" );
23314
23316 {
23317 operator VkShaderStatisticsInfoAMD const&() const
23318 {
23319 return *reinterpret_cast<const VkShaderStatisticsInfoAMD*>(this);
23320 }
23321
23323 {
23324 return *reinterpret_cast<VkShaderStatisticsInfoAMD*>(this);
23325 }
23326
23327 bool operator==( ShaderStatisticsInfoAMD const& rhs ) const
23328 {
23329 return ( shaderStageMask == rhs.shaderStageMask )
23330 && ( resourceUsage == rhs.resourceUsage )
23335 && ( memcmp( computeWorkGroupSize, rhs.computeWorkGroupSize, 3 * sizeof( uint32_t ) ) == 0 );
23336 }
23337
23338 bool operator!=( ShaderStatisticsInfoAMD const& rhs ) const
23339 {
23340 return !operator==( rhs );
23341 }
23342
23350 };
23351 static_assert( sizeof( ShaderStatisticsInfoAMD ) == sizeof( VkShaderStatisticsInfoAMD ), "struct and wrapper have different size!" );
23352
23354 {
23364 };
23365
23367
23369 {
23370 return ImageUsageFlags( bit0 ) | bit1;
23371 }
23372
23374 {
23375 return ~( ImageUsageFlags( bits ) );
23376 }
23377
23378 template <> struct FlagTraits<ImageUsageFlagBits>
23379 {
23380 enum
23381 {
23384 };
23385
23387 {
23389 {
23390 return *reinterpret_cast<const VkSharedPresentSurfaceCapabilitiesKHR*>(this);
23391 }
23392
23394 {
23395 return *reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR*>(this);
23396 }
23397
23399 {
23400 return ( sType == rhs.sType )
23401 && ( pNext == rhs.pNext )
23403 }
23404
23406 {
23407 return !operator==( rhs );
23408 }
23409
23410 private:
23412
23413 public:
23414 void* pNext = nullptr;
23416 };
23417 static_assert( sizeof( SharedPresentSurfaceCapabilitiesKHR ) == sizeof( VkSharedPresentSurfaceCapabilitiesKHR ), "struct and wrapper have different size!" );
23418
23420 {
23422 : usage( usage_ )
23423 {
23424 }
23425
23427 {
23428 memcpy( this, &rhs, sizeof( ImageViewUsageCreateInfo ) );
23429 }
23430
23432 {
23433 memcpy( this, &rhs, sizeof( ImageViewUsageCreateInfo ) );
23434 return *this;
23435 }
23436 ImageViewUsageCreateInfo& setPNext( const void* pNext_ )
23437 {
23438 pNext = pNext_;
23439 return *this;
23440 }
23441
23443 {
23444 usage = usage_;
23445 return *this;
23446 }
23447
23448 operator VkImageViewUsageCreateInfo const&() const
23449 {
23450 return *reinterpret_cast<const VkImageViewUsageCreateInfo*>(this);
23451 }
23452
23454 {
23455 return *reinterpret_cast<VkImageViewUsageCreateInfo*>(this);
23456 }
23457
23458 bool operator==( ImageViewUsageCreateInfo const& rhs ) const
23459 {
23460 return ( sType == rhs.sType )
23461 && ( pNext == rhs.pNext )
23462 && ( usage == rhs.usage );
23463 }
23464
23465 bool operator!=( ImageViewUsageCreateInfo const& rhs ) const
23466 {
23467 return !operator==( rhs );
23468 }
23469
23470 private:
23472
23473 public:
23474 const void* pNext = nullptr;
23476 };
23477 static_assert( sizeof( ImageViewUsageCreateInfo ) == sizeof( VkImageViewUsageCreateInfo ), "struct and wrapper have different size!" );
23478
23480
23482 {
23503 };
23504
23506
23508 {
23509 return ImageCreateFlags( bit0 ) | bit1;
23510 }
23511
23513 {
23514 return ~( ImageCreateFlags( bits ) );
23515 }
23516
23518 {
23519 enum
23520 {
23523 };
23524
23526 {
23528 ImageType type_ = ImageType::e1D,
23532 : format( format_ )
23533 , type( type_ )
23534 , tiling( tiling_ )
23535 , usage( usage_ )
23536 , flags( flags_ )
23537 {
23538 }
23539
23541 {
23542 memcpy( this, &rhs, sizeof( PhysicalDeviceImageFormatInfo2 ) );
23543 }
23544
23546 {
23547 memcpy( this, &rhs, sizeof( PhysicalDeviceImageFormatInfo2 ) );
23548 return *this;
23549 }
23551 {
23552 pNext = pNext_;
23553 return *this;
23554 }
23555
23557 {
23558 format = format_;
23559 return *this;
23560 }
23561
23563 {
23564 type = type_;
23565 return *this;
23566 }
23567
23569 {
23570 tiling = tiling_;
23571 return *this;
23572 }
23573
23575 {
23576 usage = usage_;
23577 return *this;
23578 }
23579
23581 {
23582 flags = flags_;
23583 return *this;
23584 }
23585
23586 operator VkPhysicalDeviceImageFormatInfo2 const&() const
23587 {
23588 return *reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>(this);
23589 }
23590
23592 {
23593 return *reinterpret_cast<VkPhysicalDeviceImageFormatInfo2*>(this);
23594 }
23595
23597 {
23598 return ( sType == rhs.sType )
23599 && ( pNext == rhs.pNext )
23600 && ( format == rhs.format )
23601 && ( type == rhs.type )
23602 && ( tiling == rhs.tiling )
23603 && ( usage == rhs.usage )
23604 && ( flags == rhs.flags );
23605 }
23606
23608 {
23609 return !operator==( rhs );
23610 }
23611
23612 private:
23614
23615 public:
23616 const void* pNext = nullptr;
23622 };
23623 static_assert( sizeof( PhysicalDeviceImageFormatInfo2 ) == sizeof( VkPhysicalDeviceImageFormatInfo2 ), "struct and wrapper have different size!" );
23624
23626
23628 {
23637 };
23638
23640
23642 {
23643 return PipelineCreateFlags( bit0 ) | bit1;
23644 }
23645
23647 {
23648 return ~( PipelineCreateFlags( bits ) );
23649 }
23650
23652 {
23653 enum
23654 {
23657 };
23658
23660 {
23663 PipelineLayout layout_ = PipelineLayout(),
23664 Pipeline basePipelineHandle_ = Pipeline(),
23665 int32_t basePipelineIndex_ = 0 )
23666 : flags( flags_ )
23667 , stage( stage_ )
23668 , layout( layout_ )
23669 , basePipelineHandle( basePipelineHandle_ )
23670 , basePipelineIndex( basePipelineIndex_ )
23671 {
23672 }
23673
23675 {
23676 memcpy( this, &rhs, sizeof( ComputePipelineCreateInfo ) );
23677 }
23678
23680 {
23681 memcpy( this, &rhs, sizeof( ComputePipelineCreateInfo ) );
23682 return *this;
23683 }
23685 {
23686 pNext = pNext_;
23687 return *this;
23688 }
23689
23691 {
23692 flags = flags_;
23693 return *this;
23694 }
23695
23697 {
23698 stage = stage_;
23699 return *this;
23700 }
23701
23703 {
23704 layout = layout_;
23705 return *this;
23706 }
23707
23709 {
23710 basePipelineHandle = basePipelineHandle_;
23711 return *this;
23712 }
23713
23715 {
23716 basePipelineIndex = basePipelineIndex_;
23717 return *this;
23718 }
23719
23720 operator VkComputePipelineCreateInfo const&() const
23721 {
23722 return *reinterpret_cast<const VkComputePipelineCreateInfo*>(this);
23723 }
23724
23726 {
23727 return *reinterpret_cast<VkComputePipelineCreateInfo*>(this);
23728 }
23729
23730 bool operator==( ComputePipelineCreateInfo const& rhs ) const
23731 {
23732 return ( sType == rhs.sType )
23733 && ( pNext == rhs.pNext )
23734 && ( flags == rhs.flags )
23735 && ( stage == rhs.stage )
23736 && ( layout == rhs.layout )
23739 }
23740
23741 bool operator!=( ComputePipelineCreateInfo const& rhs ) const
23742 {
23743 return !operator==( rhs );
23744 }
23745
23746 private:
23748
23749 public:
23750 const void* pNext = nullptr;
23756 };
23757 static_assert( sizeof( ComputePipelineCreateInfo ) == sizeof( VkComputePipelineCreateInfo ), "struct and wrapper have different size!" );
23758
23760 {
23765 };
23766
23768
23770 {
23771 return ColorComponentFlags( bit0 ) | bit1;
23772 }
23773
23775 {
23776 return ~( ColorComponentFlags( bits ) );
23777 }
23778
23780 {
23781 enum
23782 {
23785 };
23786
23788 {
23790 BlendFactor srcColorBlendFactor_ = BlendFactor::eZero,
23791 BlendFactor dstColorBlendFactor_ = BlendFactor::eZero,
23792 BlendOp colorBlendOp_ = BlendOp::eAdd,
23793 BlendFactor srcAlphaBlendFactor_ = BlendFactor::eZero,
23794 BlendFactor dstAlphaBlendFactor_ = BlendFactor::eZero,
23795 BlendOp alphaBlendOp_ = BlendOp::eAdd,
23796 ColorComponentFlags colorWriteMask_ = ColorComponentFlags() )
23797 : blendEnable( blendEnable_ )
23798 , srcColorBlendFactor( srcColorBlendFactor_ )
23799 , dstColorBlendFactor( dstColorBlendFactor_ )
23800 , colorBlendOp( colorBlendOp_ )
23801 , srcAlphaBlendFactor( srcAlphaBlendFactor_ )
23802 , dstAlphaBlendFactor( dstAlphaBlendFactor_ )
23803 , alphaBlendOp( alphaBlendOp_ )
23804 , colorWriteMask( colorWriteMask_ )
23805 {
23806 }
23807
23809 {
23810 memcpy( this, &rhs, sizeof( PipelineColorBlendAttachmentState ) );
23811 }
23812
23814 {
23815 memcpy( this, &rhs, sizeof( PipelineColorBlendAttachmentState ) );
23816 return *this;
23817 }
23819 {
23820 blendEnable = blendEnable_;
23821 return *this;
23822 }
23823
23825 {
23826 srcColorBlendFactor = srcColorBlendFactor_;
23827 return *this;
23828 }
23829
23831 {
23832 dstColorBlendFactor = dstColorBlendFactor_;
23833 return *this;
23834 }
23835
23837 {
23838 colorBlendOp = colorBlendOp_;
23839 return *this;
23840 }
23841
23843 {
23844 srcAlphaBlendFactor = srcAlphaBlendFactor_;
23845 return *this;
23846 }
23847
23849 {
23850 dstAlphaBlendFactor = dstAlphaBlendFactor_;
23851 return *this;
23852 }
23853
23855 {
23856 alphaBlendOp = alphaBlendOp_;
23857 return *this;
23858 }
23859
23861 {
23862 colorWriteMask = colorWriteMask_;
23863 return *this;
23864 }
23865
23867 {
23868 return *reinterpret_cast<const VkPipelineColorBlendAttachmentState*>(this);
23869 }
23870
23872 {
23873 return *reinterpret_cast<VkPipelineColorBlendAttachmentState*>(this);
23874 }
23875
23877 {
23878 return ( blendEnable == rhs.blendEnable )
23881 && ( colorBlendOp == rhs.colorBlendOp )
23884 && ( alphaBlendOp == rhs.alphaBlendOp )
23885 && ( colorWriteMask == rhs.colorWriteMask );
23886 }
23887
23889 {
23890 return !operator==( rhs );
23891 }
23892
23901 };
23902 static_assert( sizeof( PipelineColorBlendAttachmentState ) == sizeof( VkPipelineColorBlendAttachmentState ), "struct and wrapper have different size!" );
23903
23905 {
23907 Bool32 logicOpEnable_ = 0,
23908 LogicOp logicOp_ = LogicOp::eClear,
23909 uint32_t attachmentCount_ = 0,
23910 const PipelineColorBlendAttachmentState* pAttachments_ = nullptr,
23911 std::array<float,4> const& blendConstants_ = { { 0, 0, 0, 0 } } )
23912 : flags( flags_ )
23913 , logicOpEnable( logicOpEnable_ )
23914 , logicOp( logicOp_ )
23915 , attachmentCount( attachmentCount_ )
23916 , pAttachments( pAttachments_ )
23917 {
23918 memcpy( &blendConstants, blendConstants_.data(), 4 * sizeof( float ) );
23919 }
23920
23922 {
23923 memcpy( this, &rhs, sizeof( PipelineColorBlendStateCreateInfo ) );
23924 }
23925
23927 {
23928 memcpy( this, &rhs, sizeof( PipelineColorBlendStateCreateInfo ) );
23929 return *this;
23930 }
23932 {
23933 pNext = pNext_;
23934 return *this;
23935 }
23936
23938 {
23939 flags = flags_;
23940 return *this;
23941 }
23942
23944 {
23945 logicOpEnable = logicOpEnable_;
23946 return *this;
23947 }
23948
23950 {
23951 logicOp = logicOp_;
23952 return *this;
23953 }
23954
23956 {
23957 attachmentCount = attachmentCount_;
23958 return *this;
23959 }
23960
23962 {
23963 pAttachments = pAttachments_;
23964 return *this;
23965 }
23966
23967 PipelineColorBlendStateCreateInfo& setBlendConstants( std::array<float,4> blendConstants_ )
23968 {
23969 memcpy( &blendConstants, blendConstants_.data(), 4 * sizeof( float ) );
23970 return *this;
23971 }
23972
23974 {
23975 return *reinterpret_cast<const VkPipelineColorBlendStateCreateInfo*>(this);
23976 }
23977
23979 {
23980 return *reinterpret_cast<VkPipelineColorBlendStateCreateInfo*>(this);
23981 }
23982
23984 {
23985 return ( sType == rhs.sType )
23986 && ( pNext == rhs.pNext )
23987 && ( flags == rhs.flags )
23988 && ( logicOpEnable == rhs.logicOpEnable )
23989 && ( logicOp == rhs.logicOp )
23990 && ( attachmentCount == rhs.attachmentCount )
23991 && ( pAttachments == rhs.pAttachments )
23992 && ( memcmp( blendConstants, rhs.blendConstants, 4 * sizeof( float ) ) == 0 );
23993 }
23994
23996 {
23997 return !operator==( rhs );
23998 }
23999
24000 private:
24002
24003 public:
24004 const void* pNext = nullptr;
24011 };
24012 static_assert( sizeof( PipelineColorBlendStateCreateInfo ) == sizeof( VkPipelineColorBlendStateCreateInfo ), "struct and wrapper have different size!" );
24013
24015 {
24017 };
24018
24020
24022 {
24023 return FenceCreateFlags( bit0 ) | bit1;
24024 }
24025
24027 {
24028 return ~( FenceCreateFlags( bits ) );
24029 }
24030
24032 {
24033 enum
24034 {
24037 };
24038
24040 {
24042 : flags( flags_ )
24043 {
24044 }
24045
24047 {
24048 memcpy( this, &rhs, sizeof( FenceCreateInfo ) );
24049 }
24050
24052 {
24053 memcpy( this, &rhs, sizeof( FenceCreateInfo ) );
24054 return *this;
24055 }
24056 FenceCreateInfo& setPNext( const void* pNext_ )
24057 {
24058 pNext = pNext_;
24059 return *this;
24060 }
24061
24063 {
24064 flags = flags_;
24065 return *this;
24066 }
24067
24068 operator VkFenceCreateInfo const&() const
24069 {
24070 return *reinterpret_cast<const VkFenceCreateInfo*>(this);
24071 }
24072
24074 {
24075 return *reinterpret_cast<VkFenceCreateInfo*>(this);
24076 }
24077
24078 bool operator==( FenceCreateInfo const& rhs ) const
24079 {
24080 return ( sType == rhs.sType )
24081 && ( pNext == rhs.pNext )
24082 && ( flags == rhs.flags );
24083 }
24084
24085 bool operator!=( FenceCreateInfo const& rhs ) const
24086 {
24087 return !operator==( rhs );
24088 }
24089
24090 private:
24092
24093 public:
24094 const void* pNext = nullptr;
24096 };
24097 static_assert( sizeof( FenceCreateInfo ) == sizeof( VkFenceCreateInfo ), "struct and wrapper have different size!" );
24098
24100 {
24134 };
24135
24137
24139 {
24140 return FormatFeatureFlags( bit0 ) | bit1;
24141 }
24142
24144 {
24145 return ~( FormatFeatureFlags( bits ) );
24146 }
24147
24149 {
24150 enum
24151 {
24154 };
24155
24157 {
24158 operator VkFormatProperties const&() const
24159 {
24160 return *reinterpret_cast<const VkFormatProperties*>(this);
24161 }
24162
24164 {
24165 return *reinterpret_cast<VkFormatProperties*>(this);
24166 }
24167
24168 bool operator==( FormatProperties const& rhs ) const
24169 {
24172 && ( bufferFeatures == rhs.bufferFeatures );
24173 }
24174
24175 bool operator!=( FormatProperties const& rhs ) const
24176 {
24177 return !operator==( rhs );
24178 }
24179
24183 };
24184 static_assert( sizeof( FormatProperties ) == sizeof( VkFormatProperties ), "struct and wrapper have different size!" );
24185
24187 {
24188 operator VkFormatProperties2 const&() const
24189 {
24190 return *reinterpret_cast<const VkFormatProperties2*>(this);
24191 }
24192
24194 {
24195 return *reinterpret_cast<VkFormatProperties2*>(this);
24196 }
24197
24198 bool operator==( FormatProperties2 const& rhs ) const
24199 {
24200 return ( sType == rhs.sType )
24201 && ( pNext == rhs.pNext )
24202 && ( formatProperties == rhs.formatProperties );
24203 }
24204
24205 bool operator!=( FormatProperties2 const& rhs ) const
24206 {
24207 return !operator==( rhs );
24208 }
24209
24210 private:
24212
24213 public:
24214 void* pNext = nullptr;
24216 };
24217 static_assert( sizeof( FormatProperties2 ) == sizeof( VkFormatProperties2 ), "struct and wrapper have different size!" );
24218
24220
24222 {
24223 operator VkDrmFormatModifierPropertiesEXT const&() const
24224 {
24225 return *reinterpret_cast<const VkDrmFormatModifierPropertiesEXT*>(this);
24226 }
24227
24229 {
24230 return *reinterpret_cast<VkDrmFormatModifierPropertiesEXT*>(this);
24231 }
24232
24234 {
24235 return ( drmFormatModifier == rhs.drmFormatModifier )
24238 }
24239
24241 {
24242 return !operator==( rhs );
24243 }
24244
24248 };
24249 static_assert( sizeof( DrmFormatModifierPropertiesEXT ) == sizeof( VkDrmFormatModifierPropertiesEXT ), "struct and wrapper have different size!" );
24250
24252 {
24253 DrmFormatModifierPropertiesListEXT( uint32_t drmFormatModifierCount_ = 0,
24254 DrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties_ = nullptr )
24255 : drmFormatModifierCount( drmFormatModifierCount_ )
24256 , pDrmFormatModifierProperties( pDrmFormatModifierProperties_ )
24257 {
24258 }
24259
24261 {
24262 memcpy( this, &rhs, sizeof( DrmFormatModifierPropertiesListEXT ) );
24263 }
24264
24266 {
24267 memcpy( this, &rhs, sizeof( DrmFormatModifierPropertiesListEXT ) );
24268 return *this;
24269 }
24271 {
24272 pNext = pNext_;
24273 return *this;
24274 }
24275
24277 {
24278 drmFormatModifierCount = drmFormatModifierCount_;
24279 return *this;
24280 }
24281
24283 {
24284 pDrmFormatModifierProperties = pDrmFormatModifierProperties_;
24285 return *this;
24286 }
24287
24289 {
24290 return *reinterpret_cast<const VkDrmFormatModifierPropertiesListEXT*>(this);
24291 }
24292
24294 {
24295 return *reinterpret_cast<VkDrmFormatModifierPropertiesListEXT*>(this);
24296 }
24297
24299 {
24300 return ( sType == rhs.sType )
24301 && ( pNext == rhs.pNext )
24304 }
24305
24307 {
24308 return !operator==( rhs );
24309 }
24310
24311 private:
24313
24314 public:
24315 void* pNext = nullptr;
24318 };
24319 static_assert( sizeof( DrmFormatModifierPropertiesListEXT ) == sizeof( VkDrmFormatModifierPropertiesListEXT ), "struct and wrapper have different size!" );
24320
24322 {
24324 };
24325
24327
24329 {
24330 return QueryControlFlags( bit0 ) | bit1;
24331 }
24332
24334 {
24335 return ~( QueryControlFlags( bits ) );
24336 }
24337
24339 {
24340 enum
24341 {
24344 };
24345
24347 {
24352 };
24353
24355
24357 {
24358 return QueryResultFlags( bit0 ) | bit1;
24359 }
24360
24362 {
24363 return ~( QueryResultFlags( bits ) );
24364 }
24365
24367 {
24368 enum
24369 {
24372 };
24373
24375 {
24379 };
24380
24382
24384 {
24385 return CommandBufferUsageFlags( bit0 ) | bit1;
24386 }
24387
24389 {
24390 return ~( CommandBufferUsageFlags( bits ) );
24391 }
24392
24394 {
24395 enum
24396 {
24399 };
24400
24402 {
24414 };
24415
24417
24419 {
24420 return QueryPipelineStatisticFlags( bit0 ) | bit1;
24421 }
24422
24424 {
24425 return ~( QueryPipelineStatisticFlags( bits ) );
24426 }
24427
24429 {
24430 enum
24431 {
24434 };
24435
24437 {
24439 uint32_t subpass_ = 0,
24440 Framebuffer framebuffer_ = Framebuffer(),
24441 Bool32 occlusionQueryEnable_ = 0,
24442 QueryControlFlags queryFlags_ = QueryControlFlags(),
24444 : renderPass( renderPass_ )
24445 , subpass( subpass_ )
24446 , framebuffer( framebuffer_ )
24447 , occlusionQueryEnable( occlusionQueryEnable_ )
24448 , queryFlags( queryFlags_ )
24449 , pipelineStatistics( pipelineStatistics_ )
24450 {
24451 }
24452
24454 {
24455 memcpy( this, &rhs, sizeof( CommandBufferInheritanceInfo ) );
24456 }
24457
24459 {
24460 memcpy( this, &rhs, sizeof( CommandBufferInheritanceInfo ) );
24461 return *this;
24462 }
24464 {
24465 pNext = pNext_;
24466 return *this;
24467 }
24468
24470 {
24471 renderPass = renderPass_;
24472 return *this;
24473 }
24474
24476 {
24477 subpass = subpass_;
24478 return *this;
24479 }
24480
24482 {
24483 framebuffer = framebuffer_;
24484 return *this;
24485 }
24486
24488 {
24489 occlusionQueryEnable = occlusionQueryEnable_;
24490 return *this;
24491 }
24492
24494 {
24495 queryFlags = queryFlags_;
24496 return *this;
24497 }
24498
24500 {
24501 pipelineStatistics = pipelineStatistics_;
24502 return *this;
24503 }
24504
24505 operator VkCommandBufferInheritanceInfo const&() const
24506 {
24507 return *reinterpret_cast<const VkCommandBufferInheritanceInfo*>(this);
24508 }
24509
24511 {
24512 return *reinterpret_cast<VkCommandBufferInheritanceInfo*>(this);
24513 }
24514
24516 {
24517 return ( sType == rhs.sType )
24518 && ( pNext == rhs.pNext )
24519 && ( renderPass == rhs.renderPass )
24520 && ( subpass == rhs.subpass )
24521 && ( framebuffer == rhs.framebuffer )
24523 && ( queryFlags == rhs.queryFlags )
24525 }
24526
24528 {
24529 return !operator==( rhs );
24530 }
24531
24532 private:
24534
24535 public:
24536 const void* pNext = nullptr;
24543 };
24544 static_assert( sizeof( CommandBufferInheritanceInfo ) == sizeof( VkCommandBufferInheritanceInfo ), "struct and wrapper have different size!" );
24545
24547 {
24549 const CommandBufferInheritanceInfo* pInheritanceInfo_ = nullptr )
24550 : flags( flags_ )
24551 , pInheritanceInfo( pInheritanceInfo_ )
24552 {
24553 }
24554
24556 {
24557 memcpy( this, &rhs, sizeof( CommandBufferBeginInfo ) );
24558 }
24559
24561 {
24562 memcpy( this, &rhs, sizeof( CommandBufferBeginInfo ) );
24563 return *this;
24564 }
24565 CommandBufferBeginInfo& setPNext( const void* pNext_ )
24566 {
24567 pNext = pNext_;
24568 return *this;
24569 }
24570
24572 {
24573 flags = flags_;
24574 return *this;
24575 }
24576
24578 {
24579 pInheritanceInfo = pInheritanceInfo_;
24580 return *this;
24581 }
24582
24583 operator VkCommandBufferBeginInfo const&() const
24584 {
24585 return *reinterpret_cast<const VkCommandBufferBeginInfo*>(this);
24586 }
24587
24589 {
24590 return *reinterpret_cast<VkCommandBufferBeginInfo*>(this);
24591 }
24592
24593 bool operator==( CommandBufferBeginInfo const& rhs ) const
24594 {
24595 return ( sType == rhs.sType )
24596 && ( pNext == rhs.pNext )
24597 && ( flags == rhs.flags )
24598 && ( pInheritanceInfo == rhs.pInheritanceInfo );
24599 }
24600
24601 bool operator!=( CommandBufferBeginInfo const& rhs ) const
24602 {
24603 return !operator==( rhs );
24604 }
24605
24606 private:
24608
24609 public:
24610 const void* pNext = nullptr;
24613 };
24614 static_assert( sizeof( CommandBufferBeginInfo ) == sizeof( VkCommandBufferBeginInfo ), "struct and wrapper have different size!" );
24615
24617 {
24619 QueryType queryType_ = QueryType::eOcclusion,
24620 uint32_t queryCount_ = 0,
24622 : flags( flags_ )
24623 , queryType( queryType_ )
24624 , queryCount( queryCount_ )
24625 , pipelineStatistics( pipelineStatistics_ )
24626 {
24627 }
24628
24630 {
24631 memcpy( this, &rhs, sizeof( QueryPoolCreateInfo ) );
24632 }
24633
24635 {
24636 memcpy( this, &rhs, sizeof( QueryPoolCreateInfo ) );
24637 return *this;
24638 }
24639 QueryPoolCreateInfo& setPNext( const void* pNext_ )
24640 {
24641 pNext = pNext_;
24642 return *this;
24643 }
24644
24646 {
24647 flags = flags_;
24648 return *this;
24649 }
24650
24652 {
24653 queryType = queryType_;
24654 return *this;
24655 }
24656
24658 {
24659 queryCount = queryCount_;
24660 return *this;
24661 }
24662
24664 {
24665 pipelineStatistics = pipelineStatistics_;
24666 return *this;
24667 }
24668
24669 operator VkQueryPoolCreateInfo const&() const
24670 {
24671 return *reinterpret_cast<const VkQueryPoolCreateInfo*>(this);
24672 }
24673
24675 {
24676 return *reinterpret_cast<VkQueryPoolCreateInfo*>(this);
24677 }
24678
24679 bool operator==( QueryPoolCreateInfo const& rhs ) const
24680 {
24681 return ( sType == rhs.sType )
24682 && ( pNext == rhs.pNext )
24683 && ( flags == rhs.flags )
24684 && ( queryType == rhs.queryType )
24685 && ( queryCount == rhs.queryCount )
24687 }
24688
24689 bool operator!=( QueryPoolCreateInfo const& rhs ) const
24690 {
24691 return !operator==( rhs );
24692 }
24693
24694 private:
24696
24697 public:
24698 const void* pNext = nullptr;
24703 };
24704 static_assert( sizeof( QueryPoolCreateInfo ) == sizeof( VkQueryPoolCreateInfo ), "struct and wrapper have different size!" );
24705
24707 {
24722 };
24723
24725
24727 {
24728 return ImageAspectFlags( bit0 ) | bit1;
24729 }
24730
24732 {
24733 return ~( ImageAspectFlags( bits ) );
24734 }
24735
24737 {
24738 enum
24739 {
24742 };
24743
24745 {
24747 uint32_t mipLevel_ = 0,
24748 uint32_t arrayLayer_ = 0 )
24749 : aspectMask( aspectMask_ )
24750 , mipLevel( mipLevel_ )
24751 , arrayLayer( arrayLayer_ )
24752 {
24753 }
24754
24756 {
24757 memcpy( this, &rhs, sizeof( ImageSubresource ) );
24758 }
24759
24761 {
24762 memcpy( this, &rhs, sizeof( ImageSubresource ) );
24763 return *this;
24764 }
24766 {
24767 aspectMask = aspectMask_;
24768 return *this;
24769 }
24770
24772 {
24773 mipLevel = mipLevel_;
24774 return *this;
24775 }
24776
24778 {
24779 arrayLayer = arrayLayer_;
24780 return *this;
24781 }
24782
24783 operator VkImageSubresource const&() const
24784 {
24785 return *reinterpret_cast<const VkImageSubresource*>(this);
24786 }
24787
24789 {
24790 return *reinterpret_cast<VkImageSubresource*>(this);
24791 }
24792
24793 bool operator==( ImageSubresource const& rhs ) const
24794 {
24795 return ( aspectMask == rhs.aspectMask )
24796 && ( mipLevel == rhs.mipLevel )
24797 && ( arrayLayer == rhs.arrayLayer );
24798 }
24799
24800 bool operator!=( ImageSubresource const& rhs ) const
24801 {
24802 return !operator==( rhs );
24803 }
24804
24808 };
24809 static_assert( sizeof( ImageSubresource ) == sizeof( VkImageSubresource ), "struct and wrapper have different size!" );
24810
24812 {
24814 uint32_t mipLevel_ = 0,
24815 uint32_t baseArrayLayer_ = 0,
24816 uint32_t layerCount_ = 0 )
24817 : aspectMask( aspectMask_ )
24818 , mipLevel( mipLevel_ )
24819 , baseArrayLayer( baseArrayLayer_ )
24820 , layerCount( layerCount_ )
24821 {
24822 }
24823
24825 {
24826 memcpy( this, &rhs, sizeof( ImageSubresourceLayers ) );
24827 }
24828
24830 {
24831 memcpy( this, &rhs, sizeof( ImageSubresourceLayers ) );
24832 return *this;
24833 }
24835 {
24836 aspectMask = aspectMask_;
24837 return *this;
24838 }
24839
24841 {
24842 mipLevel = mipLevel_;
24843 return *this;
24844 }
24845
24847 {
24848 baseArrayLayer = baseArrayLayer_;
24849 return *this;
24850 }
24851
24853 {
24854 layerCount = layerCount_;
24855 return *this;
24856 }
24857
24858 operator VkImageSubresourceLayers const&() const
24859 {
24860 return *reinterpret_cast<const VkImageSubresourceLayers*>(this);
24861 }
24862
24864 {
24865 return *reinterpret_cast<VkImageSubresourceLayers*>(this);
24866 }
24867
24868 bool operator==( ImageSubresourceLayers const& rhs ) const
24869 {
24870 return ( aspectMask == rhs.aspectMask )
24871 && ( mipLevel == rhs.mipLevel )
24872 && ( baseArrayLayer == rhs.baseArrayLayer )
24873 && ( layerCount == rhs.layerCount );
24874 }
24875
24876 bool operator!=( ImageSubresourceLayers const& rhs ) const
24877 {
24878 return !operator==( rhs );
24879 }
24880
24885 };
24886 static_assert( sizeof( ImageSubresourceLayers ) == sizeof( VkImageSubresourceLayers ), "struct and wrapper have different size!" );
24887
24889 {
24891 uint32_t baseMipLevel_ = 0,
24892 uint32_t levelCount_ = 0,
24893 uint32_t baseArrayLayer_ = 0,
24894 uint32_t layerCount_ = 0 )
24895 : aspectMask( aspectMask_ )
24896 , baseMipLevel( baseMipLevel_ )
24897 , levelCount( levelCount_ )
24898 , baseArrayLayer( baseArrayLayer_ )
24899 , layerCount( layerCount_ )
24900 {
24901 }
24902
24904 {
24905 memcpy( this, &rhs, sizeof( ImageSubresourceRange ) );
24906 }
24907
24909 {
24910 memcpy( this, &rhs, sizeof( ImageSubresourceRange ) );
24911 return *this;
24912 }
24914 {
24915 aspectMask = aspectMask_;
24916 return *this;
24917 }
24918
24920 {
24921 baseMipLevel = baseMipLevel_;
24922 return *this;
24923 }
24924
24926 {
24927 levelCount = levelCount_;
24928 return *this;
24929 }
24930
24932 {
24933 baseArrayLayer = baseArrayLayer_;
24934 return *this;
24935 }
24936
24938 {
24939 layerCount = layerCount_;
24940 return *this;
24941 }
24942
24943 operator VkImageSubresourceRange const&() const
24944 {
24945 return *reinterpret_cast<const VkImageSubresourceRange*>(this);
24946 }
24947
24949 {
24950 return *reinterpret_cast<VkImageSubresourceRange*>(this);
24951 }
24952
24953 bool operator==( ImageSubresourceRange const& rhs ) const
24954 {
24955 return ( aspectMask == rhs.aspectMask )
24956 && ( baseMipLevel == rhs.baseMipLevel )
24957 && ( levelCount == rhs.levelCount )
24958 && ( baseArrayLayer == rhs.baseArrayLayer )
24959 && ( layerCount == rhs.layerCount );
24960 }
24961
24962 bool operator!=( ImageSubresourceRange const& rhs ) const
24963 {
24964 return !operator==( rhs );
24965 }
24966
24972 };
24973 static_assert( sizeof( ImageSubresourceRange ) == sizeof( VkImageSubresourceRange ), "struct and wrapper have different size!" );
24974
24976 {
24978 AccessFlags dstAccessMask_ = AccessFlags(),
24981 uint32_t srcQueueFamilyIndex_ = 0,
24982 uint32_t dstQueueFamilyIndex_ = 0,
24983 Image image_ = Image(),
24984 ImageSubresourceRange subresourceRange_ = ImageSubresourceRange() )
24985 : srcAccessMask( srcAccessMask_ )
24986 , dstAccessMask( dstAccessMask_ )
24987 , oldLayout( oldLayout_ )
24988 , newLayout( newLayout_ )
24989 , srcQueueFamilyIndex( srcQueueFamilyIndex_ )
24990 , dstQueueFamilyIndex( dstQueueFamilyIndex_ )
24991 , image( image_ )
24992 , subresourceRange( subresourceRange_ )
24993 {
24994 }
24995
24997 {
24998 memcpy( this, &rhs, sizeof( ImageMemoryBarrier ) );
24999 }
25000
25002 {
25003 memcpy( this, &rhs, sizeof( ImageMemoryBarrier ) );
25004 return *this;
25005 }
25006 ImageMemoryBarrier& setPNext( const void* pNext_ )
25007 {
25008 pNext = pNext_;
25009 return *this;
25010 }
25011
25013 {
25014 srcAccessMask = srcAccessMask_;
25015 return *this;
25016 }
25017
25019 {
25020 dstAccessMask = dstAccessMask_;
25021 return *this;
25022 }
25023
25025 {
25026 oldLayout = oldLayout_;
25027 return *this;
25028 }
25029
25031 {
25032 newLayout = newLayout_;
25033 return *this;
25034 }
25035
25037 {
25038 srcQueueFamilyIndex = srcQueueFamilyIndex_;
25039 return *this;
25040 }
25041
25043 {
25044 dstQueueFamilyIndex = dstQueueFamilyIndex_;
25045 return *this;
25046 }
25047
25049 {
25050 image = image_;
25051 return *this;
25052 }
25053
25055 {
25056 subresourceRange = subresourceRange_;
25057 return *this;
25058 }
25059
25060 operator VkImageMemoryBarrier const&() const
25061 {
25062 return *reinterpret_cast<const VkImageMemoryBarrier*>(this);
25063 }
25064
25066 {
25067 return *reinterpret_cast<VkImageMemoryBarrier*>(this);
25068 }
25069
25070 bool operator==( ImageMemoryBarrier const& rhs ) const
25071 {
25072 return ( sType == rhs.sType )
25073 && ( pNext == rhs.pNext )
25074 && ( srcAccessMask == rhs.srcAccessMask )
25075 && ( dstAccessMask == rhs.dstAccessMask )
25076 && ( oldLayout == rhs.oldLayout )
25077 && ( newLayout == rhs.newLayout )
25080 && ( image == rhs.image )
25081 && ( subresourceRange == rhs.subresourceRange );
25082 }
25083
25084 bool operator!=( ImageMemoryBarrier const& rhs ) const
25085 {
25086 return !operator==( rhs );
25087 }
25088
25089 private:
25091
25092 public:
25093 const void* pNext = nullptr;
25102 };
25103 static_assert( sizeof( ImageMemoryBarrier ) == sizeof( VkImageMemoryBarrier ), "struct and wrapper have different size!" );
25104
25106 {
25108 Image image_ = Image(),
25110 Format format_ = Format::eUndefined,
25111 ComponentMapping components_ = ComponentMapping(),
25112 ImageSubresourceRange subresourceRange_ = ImageSubresourceRange() )
25113 : flags( flags_ )
25114 , image( image_ )
25115 , viewType( viewType_ )
25116 , format( format_ )
25117 , components( components_ )
25118 , subresourceRange( subresourceRange_ )
25119 {
25120 }
25121
25123 {
25124 memcpy( this, &rhs, sizeof( ImageViewCreateInfo ) );
25125 }
25126
25128 {
25129 memcpy( this, &rhs, sizeof( ImageViewCreateInfo ) );
25130 return *this;
25131 }
25132 ImageViewCreateInfo& setPNext( const void* pNext_ )
25133 {
25134 pNext = pNext_;
25135 return *this;
25136 }
25137
25139 {
25140 flags = flags_;
25141 return *this;
25142 }
25143
25145 {
25146 image = image_;
25147 return *this;
25148 }
25149
25151 {
25152 viewType = viewType_;
25153 return *this;
25154 }
25155
25157 {
25158 format = format_;
25159 return *this;
25160 }
25161
25163 {
25164 components = components_;
25165 return *this;
25166 }
25167
25169 {
25170 subresourceRange = subresourceRange_;
25171 return *this;
25172 }
25173
25174 operator VkImageViewCreateInfo const&() const
25175 {
25176 return *reinterpret_cast<const VkImageViewCreateInfo*>(this);
25177 }
25178
25180 {
25181 return *reinterpret_cast<VkImageViewCreateInfo*>(this);
25182 }
25183
25184 bool operator==( ImageViewCreateInfo const& rhs ) const
25185 {
25186 return ( sType == rhs.sType )
25187 && ( pNext == rhs.pNext )
25188 && ( flags == rhs.flags )
25189 && ( image == rhs.image )
25190 && ( viewType == rhs.viewType )
25191 && ( format == rhs.format )
25192 && ( components == rhs.components )
25193 && ( subresourceRange == rhs.subresourceRange );
25194 }
25195
25196 bool operator!=( ImageViewCreateInfo const& rhs ) const
25197 {
25198 return !operator==( rhs );
25199 }
25200
25201 private:
25203
25204 public:
25205 const void* pNext = nullptr;
25212 };
25213 static_assert( sizeof( ImageViewCreateInfo ) == sizeof( VkImageViewCreateInfo ), "struct and wrapper have different size!" );
25214
25216 {
25218 Offset3D srcOffset_ = Offset3D(),
25220 Offset3D dstOffset_ = Offset3D(),
25221 Extent3D extent_ = Extent3D() )
25222 : srcSubresource( srcSubresource_ )
25223 , srcOffset( srcOffset_ )
25224 , dstSubresource( dstSubresource_ )
25225 , dstOffset( dstOffset_ )
25226 , extent( extent_ )
25227 {
25228 }
25229
25230 ImageCopy( VkImageCopy const & rhs )
25231 {
25232 memcpy( this, &rhs, sizeof( ImageCopy ) );
25233 }
25234
25236 {
25237 memcpy( this, &rhs, sizeof( ImageCopy ) );
25238 return *this;
25239 }
25241 {
25242 srcSubresource = srcSubresource_;
25243 return *this;
25244 }
25245
25247 {
25248 srcOffset = srcOffset_;
25249 return *this;
25250 }
25251
25253 {
25254 dstSubresource = dstSubresource_;
25255 return *this;
25256 }
25257
25259 {
25260 dstOffset = dstOffset_;
25261 return *this;
25262 }
25263
25265 {
25266 extent = extent_;
25267 return *this;
25268 }
25269
25270 operator VkImageCopy const&() const
25271 {
25272 return *reinterpret_cast<const VkImageCopy*>(this);
25273 }
25274
25275 operator VkImageCopy &()
25276 {
25277 return *reinterpret_cast<VkImageCopy*>(this);
25278 }
25279
25280 bool operator==( ImageCopy const& rhs ) const
25281 {
25282 return ( srcSubresource == rhs.srcSubresource )
25283 && ( srcOffset == rhs.srcOffset )
25284 && ( dstSubresource == rhs.dstSubresource )
25285 && ( dstOffset == rhs.dstOffset )
25286 && ( extent == rhs.extent );
25287 }
25288
25289 bool operator!=( ImageCopy const& rhs ) const
25290 {
25291 return !operator==( rhs );
25292 }
25293
25299 };
25300 static_assert( sizeof( ImageCopy ) == sizeof( VkImageCopy ), "struct and wrapper have different size!" );
25301
25303 {
25305 std::array<Offset3D,2> const& srcOffsets_ = { { Offset3D(), Offset3D() } },
25307 std::array<Offset3D,2> const& dstOffsets_ = { { Offset3D(), Offset3D() } } )
25308 : srcSubresource( srcSubresource_ )
25309 , dstSubresource( dstSubresource_ )
25310 {
25311 memcpy( &srcOffsets, srcOffsets_.data(), 2 * sizeof( Offset3D ) );
25312 memcpy( &dstOffsets, dstOffsets_.data(), 2 * sizeof( Offset3D ) );
25313 }
25314
25315 ImageBlit( VkImageBlit const & rhs )
25316 {
25317 memcpy( this, &rhs, sizeof( ImageBlit ) );
25318 }
25319
25321 {
25322 memcpy( this, &rhs, sizeof( ImageBlit ) );
25323 return *this;
25324 }
25326 {
25327 srcSubresource = srcSubresource_;
25328 return *this;
25329 }
25330
25331 ImageBlit& setSrcOffsets( std::array<Offset3D,2> srcOffsets_ )
25332 {
25333 memcpy( &srcOffsets, srcOffsets_.data(), 2 * sizeof( Offset3D ) );
25334 return *this;
25335 }
25336
25338 {
25339 dstSubresource = dstSubresource_;
25340 return *this;
25341 }
25342
25343 ImageBlit& setDstOffsets( std::array<Offset3D,2> dstOffsets_ )
25344 {
25345 memcpy( &dstOffsets, dstOffsets_.data(), 2 * sizeof( Offset3D ) );
25346 return *this;
25347 }
25348
25349 operator VkImageBlit const&() const
25350 {
25351 return *reinterpret_cast<const VkImageBlit*>(this);
25352 }
25353
25354 operator VkImageBlit &()
25355 {
25356 return *reinterpret_cast<VkImageBlit*>(this);
25357 }
25358
25359 bool operator==( ImageBlit const& rhs ) const
25360 {
25361 return ( srcSubresource == rhs.srcSubresource )
25362 && ( memcmp( srcOffsets, rhs.srcOffsets, 2 * sizeof( Offset3D ) ) == 0 )
25363 && ( dstSubresource == rhs.dstSubresource )
25364 && ( memcmp( dstOffsets, rhs.dstOffsets, 2 * sizeof( Offset3D ) ) == 0 );
25365 }
25366
25367 bool operator!=( ImageBlit const& rhs ) const
25368 {
25369 return !operator==( rhs );
25370 }
25371
25376 };
25377 static_assert( sizeof( ImageBlit ) == sizeof( VkImageBlit ), "struct and wrapper have different size!" );
25378
25380 {
25381 BufferImageCopy( DeviceSize bufferOffset_ = 0,
25382 uint32_t bufferRowLength_ = 0,
25383 uint32_t bufferImageHeight_ = 0,
25384 ImageSubresourceLayers imageSubresource_ = ImageSubresourceLayers(),
25385 Offset3D imageOffset_ = Offset3D(),
25386 Extent3D imageExtent_ = Extent3D() )
25387 : bufferOffset( bufferOffset_ )
25388 , bufferRowLength( bufferRowLength_ )
25389 , bufferImageHeight( bufferImageHeight_ )
25390 , imageSubresource( imageSubresource_ )
25391 , imageOffset( imageOffset_ )
25392 , imageExtent( imageExtent_ )
25393 {
25394 }
25395
25397 {
25398 memcpy( this, &rhs, sizeof( BufferImageCopy ) );
25399 }
25400
25402 {
25403 memcpy( this, &rhs, sizeof( BufferImageCopy ) );
25404 return *this;
25405 }
25407 {
25408 bufferOffset = bufferOffset_;
25409 return *this;
25410 }
25411
25413 {
25414 bufferRowLength = bufferRowLength_;
25415 return *this;
25416 }
25417
25419 {
25420 bufferImageHeight = bufferImageHeight_;
25421 return *this;
25422 }
25423
25425 {
25426 imageSubresource = imageSubresource_;
25427 return *this;
25428 }
25429
25431 {
25432 imageOffset = imageOffset_;
25433 return *this;
25434 }
25435
25437 {
25438 imageExtent = imageExtent_;
25439 return *this;
25440 }
25441
25442 operator VkBufferImageCopy const&() const
25443 {
25444 return *reinterpret_cast<const VkBufferImageCopy*>(this);
25445 }
25446
25448 {
25449 return *reinterpret_cast<VkBufferImageCopy*>(this);
25450 }
25451
25452 bool operator==( BufferImageCopy const& rhs ) const
25453 {
25454 return ( bufferOffset == rhs.bufferOffset )
25455 && ( bufferRowLength == rhs.bufferRowLength )
25458 && ( imageOffset == rhs.imageOffset )
25459 && ( imageExtent == rhs.imageExtent );
25460 }
25461
25462 bool operator!=( BufferImageCopy const& rhs ) const
25463 {
25464 return !operator==( rhs );
25465 }
25466
25473 };
25474 static_assert( sizeof( BufferImageCopy ) == sizeof( VkBufferImageCopy ), "struct and wrapper have different size!" );
25475
25477 {
25479 Offset3D srcOffset_ = Offset3D(),
25481 Offset3D dstOffset_ = Offset3D(),
25482 Extent3D extent_ = Extent3D() )
25483 : srcSubresource( srcSubresource_ )
25484 , srcOffset( srcOffset_ )
25485 , dstSubresource( dstSubresource_ )
25486 , dstOffset( dstOffset_ )
25487 , extent( extent_ )
25488 {
25489 }
25490
25492 {
25493 memcpy( this, &rhs, sizeof( ImageResolve ) );
25494 }
25495
25497 {
25498 memcpy( this, &rhs, sizeof( ImageResolve ) );
25499 return *this;
25500 }
25502 {
25503 srcSubresource = srcSubresource_;
25504 return *this;
25505 }
25506
25508 {
25509 srcOffset = srcOffset_;
25510 return *this;
25511 }
25512
25514 {
25515 dstSubresource = dstSubresource_;
25516 return *this;
25517 }
25518
25520 {
25521 dstOffset = dstOffset_;
25522 return *this;
25523 }
25524
25526 {
25527 extent = extent_;
25528 return *this;
25529 }
25530
25531 operator VkImageResolve const&() const
25532 {
25533 return *reinterpret_cast<const VkImageResolve*>(this);
25534 }
25535
25536 operator VkImageResolve &()
25537 {
25538 return *reinterpret_cast<VkImageResolve*>(this);
25539 }
25540
25541 bool operator==( ImageResolve const& rhs ) const
25542 {
25543 return ( srcSubresource == rhs.srcSubresource )
25544 && ( srcOffset == rhs.srcOffset )
25545 && ( dstSubresource == rhs.dstSubresource )
25546 && ( dstOffset == rhs.dstOffset )
25547 && ( extent == rhs.extent );
25548 }
25549
25550 bool operator!=( ImageResolve const& rhs ) const
25551 {
25552 return !operator==( rhs );
25553 }
25554
25560 };
25561 static_assert( sizeof( ImageResolve ) == sizeof( VkImageResolve ), "struct and wrapper have different size!" );
25562
25564 {
25566 uint32_t colorAttachment_ = 0,
25567 ClearValue clearValue_ = ClearValue() )
25568 : aspectMask( aspectMask_ )
25569 , colorAttachment( colorAttachment_ )
25570 , clearValue( clearValue_ )
25571 {
25572 }
25573
25575 {
25576 memcpy( this, &rhs, sizeof( ClearAttachment ) );
25577 }
25578
25580 {
25581 memcpy( this, &rhs, sizeof( ClearAttachment ) );
25582 return *this;
25583 }
25585 {
25586 aspectMask = aspectMask_;
25587 return *this;
25588 }
25589
25591 {
25592 colorAttachment = colorAttachment_;
25593 return *this;
25594 }
25595
25597 {
25598 clearValue = clearValue_;
25599 return *this;
25600 }
25601
25602 operator VkClearAttachment const&() const
25603 {
25604 return *reinterpret_cast<const VkClearAttachment*>(this);
25605 }
25606
25608 {
25609 return *reinterpret_cast<VkClearAttachment*>(this);
25610 }
25611
25615 };
25616 static_assert( sizeof( ClearAttachment ) == sizeof( VkClearAttachment ), "struct and wrapper have different size!" );
25617
25619 {
25621 uint32_t inputAttachmentIndex_ = 0,
25622 ImageAspectFlags aspectMask_ = ImageAspectFlags() )
25623 : subpass( subpass_ )
25624 , inputAttachmentIndex( inputAttachmentIndex_ )
25625 , aspectMask( aspectMask_ )
25626 {
25627 }
25628
25630 {
25631 memcpy( this, &rhs, sizeof( InputAttachmentAspectReference ) );
25632 }
25633
25635 {
25636 memcpy( this, &rhs, sizeof( InputAttachmentAspectReference ) );
25637 return *this;
25638 }
25640 {
25641 subpass = subpass_;
25642 return *this;
25643 }
25644
25646 {
25647 inputAttachmentIndex = inputAttachmentIndex_;
25648 return *this;
25649 }
25650
25652 {
25653 aspectMask = aspectMask_;
25654 return *this;
25655 }
25656
25657 operator VkInputAttachmentAspectReference const&() const
25658 {
25659 return *reinterpret_cast<const VkInputAttachmentAspectReference*>(this);
25660 }
25661
25663 {
25664 return *reinterpret_cast<VkInputAttachmentAspectReference*>(this);
25665 }
25666
25668 {
25669 return ( subpass == rhs.subpass )
25671 && ( aspectMask == rhs.aspectMask );
25672 }
25673
25675 {
25676 return !operator==( rhs );
25677 }
25678
25682 };
25683 static_assert( sizeof( InputAttachmentAspectReference ) == sizeof( VkInputAttachmentAspectReference ), "struct and wrapper have different size!" );
25684
25686
25688 {
25690 const InputAttachmentAspectReference* pAspectReferences_ = nullptr )
25691 : aspectReferenceCount( aspectReferenceCount_ )
25692 , pAspectReferences( pAspectReferences_ )
25693 {
25694 }
25695
25697 {
25698 memcpy( this, &rhs, sizeof( RenderPassInputAttachmentAspectCreateInfo ) );
25699 }
25700
25702 {
25703 memcpy( this, &rhs, sizeof( RenderPassInputAttachmentAspectCreateInfo ) );
25704 return *this;
25705 }
25707 {
25708 pNext = pNext_;
25709 return *this;
25710 }
25711
25713 {
25714 aspectReferenceCount = aspectReferenceCount_;
25715 return *this;
25716 }
25717
25719 {
25720 pAspectReferences = pAspectReferences_;
25721 return *this;
25722 }
25723
25725 {
25726 return *reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfo*>(this);
25727 }
25728
25730 {
25731 return *reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo*>(this);
25732 }
25733
25735 {
25736 return ( sType == rhs.sType )
25737 && ( pNext == rhs.pNext )
25740 }
25741
25743 {
25744 return !operator==( rhs );
25745 }
25746
25747 private:
25749
25750 public:
25751 const void* pNext = nullptr;
25754 };
25755 static_assert( sizeof( RenderPassInputAttachmentAspectCreateInfo ) == sizeof( VkRenderPassInputAttachmentAspectCreateInfo ), "struct and wrapper have different size!" );
25756
25758
25760 {
25762 : planeAspect( planeAspect_ )
25763 {
25764 }
25765
25767 {
25768 memcpy( this, &rhs, sizeof( BindImagePlaneMemoryInfo ) );
25769 }
25770
25772 {
25773 memcpy( this, &rhs, sizeof( BindImagePlaneMemoryInfo ) );
25774 return *this;
25775 }
25776 BindImagePlaneMemoryInfo& setPNext( const void* pNext_ )
25777 {
25778 pNext = pNext_;
25779 return *this;
25780 }
25781
25783 {
25784 planeAspect = planeAspect_;
25785 return *this;
25786 }
25787
25788 operator VkBindImagePlaneMemoryInfo const&() const
25789 {
25790 return *reinterpret_cast<const VkBindImagePlaneMemoryInfo*>(this);
25791 }
25792
25794 {
25795 return *reinterpret_cast<VkBindImagePlaneMemoryInfo*>(this);
25796 }
25797
25798 bool operator==( BindImagePlaneMemoryInfo const& rhs ) const
25799 {
25800 return ( sType == rhs.sType )
25801 && ( pNext == rhs.pNext )
25802 && ( planeAspect == rhs.planeAspect );
25803 }
25804
25805 bool operator!=( BindImagePlaneMemoryInfo const& rhs ) const
25806 {
25807 return !operator==( rhs );
25808 }
25809
25810 private:
25812
25813 public:
25814 const void* pNext = nullptr;
25816 };
25817 static_assert( sizeof( BindImagePlaneMemoryInfo ) == sizeof( VkBindImagePlaneMemoryInfo ), "struct and wrapper have different size!" );
25818
25820
25822 {
25824 : planeAspect( planeAspect_ )
25825 {
25826 }
25827
25829 {
25830 memcpy( this, &rhs, sizeof( ImagePlaneMemoryRequirementsInfo ) );
25831 }
25832
25834 {
25835 memcpy( this, &rhs, sizeof( ImagePlaneMemoryRequirementsInfo ) );
25836 return *this;
25837 }
25839 {
25840 pNext = pNext_;
25841 return *this;
25842 }
25843
25845 {
25846 planeAspect = planeAspect_;
25847 return *this;
25848 }
25849
25851 {
25852 return *reinterpret_cast<const VkImagePlaneMemoryRequirementsInfo*>(this);
25853 }
25854
25856 {
25857 return *reinterpret_cast<VkImagePlaneMemoryRequirementsInfo*>(this);
25858 }
25859
25861 {
25862 return ( sType == rhs.sType )
25863 && ( pNext == rhs.pNext )
25864 && ( planeAspect == rhs.planeAspect );
25865 }
25866
25868 {
25869 return !operator==( rhs );
25870 }
25871
25872 private:
25874
25875 public:
25876 const void* pNext = nullptr;
25878 };
25879 static_assert( sizeof( ImagePlaneMemoryRequirementsInfo ) == sizeof( VkImagePlaneMemoryRequirementsInfo ), "struct and wrapper have different size!" );
25880
25882
25884 {
25887 ImageAspectFlags aspectMask_ = ImageAspectFlags() )
25888 : attachment( attachment_ )
25889 , layout( layout_ )
25890 , aspectMask( aspectMask_ )
25891 {
25892 }
25893
25895 {
25896 memcpy( this, &rhs, sizeof( AttachmentReference2KHR ) );
25897 }
25898
25900 {
25901 memcpy( this, &rhs, sizeof( AttachmentReference2KHR ) );
25902 return *this;
25903 }
25904 AttachmentReference2KHR& setPNext( const void* pNext_ )
25905 {
25906 pNext = pNext_;
25907 return *this;
25908 }
25909
25911 {
25912 attachment = attachment_;
25913 return *this;
25914 }
25915
25917 {
25918 layout = layout_;
25919 return *this;
25920 }
25921
25923 {
25924 aspectMask = aspectMask_;
25925 return *this;
25926 }
25927
25928 operator VkAttachmentReference2KHR const&() const
25929 {
25930 return *reinterpret_cast<const VkAttachmentReference2KHR*>(this);
25931 }
25932
25934 {
25935 return *reinterpret_cast<VkAttachmentReference2KHR*>(this);
25936 }
25937
25938 bool operator==( AttachmentReference2KHR const& rhs ) const
25939 {
25940 return ( sType == rhs.sType )
25941 && ( pNext == rhs.pNext )
25942 && ( attachment == rhs.attachment )
25943 && ( layout == rhs.layout )
25944 && ( aspectMask == rhs.aspectMask );
25945 }
25946
25947 bool operator!=( AttachmentReference2KHR const& rhs ) const
25948 {
25949 return !operator==( rhs );
25950 }
25951
25952 private:
25954
25955 public:
25956 const void* pNext = nullptr;
25960 };
25961 static_assert( sizeof( AttachmentReference2KHR ) == sizeof( VkAttachmentReference2KHR ), "struct and wrapper have different size!" );
25962
25964 {
25968 };
25969
25971
25973 {
25974 return SparseImageFormatFlags( bit0 ) | bit1;
25975 }
25976
25978 {
25979 return ~( SparseImageFormatFlags( bits ) );
25980 }
25981
25983 {
25984 enum
25985 {
25988 };
25989
25991 {
25992 operator VkSparseImageFormatProperties const&() const
25993 {
25994 return *reinterpret_cast<const VkSparseImageFormatProperties*>(this);
25995 }
25996
25998 {
25999 return *reinterpret_cast<VkSparseImageFormatProperties*>(this);
26000 }
26001
26003 {
26004 return ( aspectMask == rhs.aspectMask )
26006 && ( flags == rhs.flags );
26007 }
26008
26010 {
26011 return !operator==( rhs );
26012 }
26013
26017 };
26018 static_assert( sizeof( SparseImageFormatProperties ) == sizeof( VkSparseImageFormatProperties ), "struct and wrapper have different size!" );
26019
26021 {
26022 operator VkSparseImageMemoryRequirements const&() const
26023 {
26024 return *reinterpret_cast<const VkSparseImageMemoryRequirements*>(this);
26025 }
26026
26028 {
26029 return *reinterpret_cast<VkSparseImageMemoryRequirements*>(this);
26030 }
26031
26033 {
26034 return ( formatProperties == rhs.formatProperties )
26039 }
26040
26042 {
26043 return !operator==( rhs );
26044 }
26045
26051 };
26052 static_assert( sizeof( SparseImageMemoryRequirements ) == sizeof( VkSparseImageMemoryRequirements ), "struct and wrapper have different size!" );
26053
26055 {
26056 operator VkSparseImageFormatProperties2 const&() const
26057 {
26058 return *reinterpret_cast<const VkSparseImageFormatProperties2*>(this);
26059 }
26060
26062 {
26063 return *reinterpret_cast<VkSparseImageFormatProperties2*>(this);
26064 }
26065
26067 {
26068 return ( sType == rhs.sType )
26069 && ( pNext == rhs.pNext )
26070 && ( properties == rhs.properties );
26071 }
26072
26074 {
26075 return !operator==( rhs );
26076 }
26077
26078 private:
26080
26081 public:
26082 void* pNext = nullptr;
26084 };
26085 static_assert( sizeof( SparseImageFormatProperties2 ) == sizeof( VkSparseImageFormatProperties2 ), "struct and wrapper have different size!" );
26086
26088
26090 {
26091 operator VkSparseImageMemoryRequirements2 const&() const
26092 {
26093 return *reinterpret_cast<const VkSparseImageMemoryRequirements2*>(this);
26094 }
26095
26097 {
26098 return *reinterpret_cast<VkSparseImageMemoryRequirements2*>(this);
26099 }
26100
26102 {
26103 return ( sType == rhs.sType )
26104 && ( pNext == rhs.pNext )
26106 }
26107
26109 {
26110 return !operator==( rhs );
26111 }
26112
26113 private:
26115
26116 public:
26117 void* pNext = nullptr;
26119 };
26120 static_assert( sizeof( SparseImageMemoryRequirements2 ) == sizeof( VkSparseImageMemoryRequirements2 ), "struct and wrapper have different size!" );
26121
26123
26125 {
26127 };
26128
26130
26132 {
26133 return SparseMemoryBindFlags( bit0 ) | bit1;
26134 }
26135
26137 {
26138 return ~( SparseMemoryBindFlags( bits ) );
26139 }
26140
26142 {
26143 enum
26144 {
26147 };
26148
26150 {
26151 SparseMemoryBind( DeviceSize resourceOffset_ = 0,
26152 DeviceSize size_ = 0,
26153 DeviceMemory memory_ = DeviceMemory(),
26154 DeviceSize memoryOffset_ = 0,
26156 : resourceOffset( resourceOffset_ )
26157 , size( size_ )
26158 , memory( memory_ )
26159 , memoryOffset( memoryOffset_ )
26160 , flags( flags_ )
26161 {
26162 }
26163
26165 {
26166 memcpy( this, &rhs, sizeof( SparseMemoryBind ) );
26167 }
26168
26170 {
26171 memcpy( this, &rhs, sizeof( SparseMemoryBind ) );
26172 return *this;
26173 }
26175 {
26176 resourceOffset = resourceOffset_;
26177 return *this;
26178 }
26179
26181 {
26182 size = size_;
26183 return *this;
26184 }
26185
26187 {
26188 memory = memory_;
26189 return *this;
26190 }
26191
26193 {
26194 memoryOffset = memoryOffset_;
26195 return *this;
26196 }
26197
26199 {
26200 flags = flags_;
26201 return *this;
26202 }
26203
26204 operator VkSparseMemoryBind const&() const
26205 {
26206 return *reinterpret_cast<const VkSparseMemoryBind*>(this);
26207 }
26208
26210 {
26211 return *reinterpret_cast<VkSparseMemoryBind*>(this);
26212 }
26213
26214 bool operator==( SparseMemoryBind const& rhs ) const
26215 {
26216 return ( resourceOffset == rhs.resourceOffset )
26217 && ( size == rhs.size )
26218 && ( memory == rhs.memory )
26219 && ( memoryOffset == rhs.memoryOffset )
26220 && ( flags == rhs.flags );
26221 }
26222
26223 bool operator!=( SparseMemoryBind const& rhs ) const
26224 {
26225 return !operator==( rhs );
26226 }
26227
26233 };
26234 static_assert( sizeof( SparseMemoryBind ) == sizeof( VkSparseMemoryBind ), "struct and wrapper have different size!" );
26235
26237 {
26239 Offset3D offset_ = Offset3D(),
26240 Extent3D extent_ = Extent3D(),
26241 DeviceMemory memory_ = DeviceMemory(),
26242 DeviceSize memoryOffset_ = 0,
26244 : subresource( subresource_ )
26245 , offset( offset_ )
26246 , extent( extent_ )
26247 , memory( memory_ )
26248 , memoryOffset( memoryOffset_ )
26249 , flags( flags_ )
26250 {
26251 }
26252
26254 {
26255 memcpy( this, &rhs, sizeof( SparseImageMemoryBind ) );
26256 }
26257
26259 {
26260 memcpy( this, &rhs, sizeof( SparseImageMemoryBind ) );
26261 return *this;
26262 }
26264 {
26265 subresource = subresource_;
26266 return *this;
26267 }
26268
26270 {
26271 offset = offset_;
26272 return *this;
26273 }
26274
26276 {
26277 extent = extent_;
26278 return *this;
26279 }
26280
26282 {
26283 memory = memory_;
26284 return *this;
26285 }
26286
26288 {
26289 memoryOffset = memoryOffset_;
26290 return *this;
26291 }
26292
26294 {
26295 flags = flags_;
26296 return *this;
26297 }
26298
26299 operator VkSparseImageMemoryBind const&() const
26300 {
26301 return *reinterpret_cast<const VkSparseImageMemoryBind*>(this);
26302 }
26303
26305 {
26306 return *reinterpret_cast<VkSparseImageMemoryBind*>(this);
26307 }
26308
26309 bool operator==( SparseImageMemoryBind const& rhs ) const
26310 {
26311 return ( subresource == rhs.subresource )
26312 && ( offset == rhs.offset )
26313 && ( extent == rhs.extent )
26314 && ( memory == rhs.memory )
26315 && ( memoryOffset == rhs.memoryOffset )
26316 && ( flags == rhs.flags );
26317 }
26318
26319 bool operator!=( SparseImageMemoryBind const& rhs ) const
26320 {
26321 return !operator==( rhs );
26322 }
26323
26330 };
26331 static_assert( sizeof( SparseImageMemoryBind ) == sizeof( VkSparseImageMemoryBind ), "struct and wrapper have different size!" );
26332
26334 {
26336 uint32_t bindCount_ = 0,
26337 const SparseMemoryBind* pBinds_ = nullptr )
26338 : buffer( buffer_ )
26339 , bindCount( bindCount_ )
26340 , pBinds( pBinds_ )
26341 {
26342 }
26343
26345 {
26346 memcpy( this, &rhs, sizeof( SparseBufferMemoryBindInfo ) );
26347 }
26348
26350 {
26351 memcpy( this, &rhs, sizeof( SparseBufferMemoryBindInfo ) );
26352 return *this;
26353 }
26355 {
26356 buffer = buffer_;
26357 return *this;
26358 }
26359
26361 {
26362 bindCount = bindCount_;
26363 return *this;
26364 }
26365
26367 {
26368 pBinds = pBinds_;
26369 return *this;
26370 }
26371
26372 operator VkSparseBufferMemoryBindInfo const&() const
26373 {
26374 return *reinterpret_cast<const VkSparseBufferMemoryBindInfo*>(this);
26375 }
26376
26378 {
26379 return *reinterpret_cast<VkSparseBufferMemoryBindInfo*>(this);
26380 }
26381
26383 {
26384 return ( buffer == rhs.buffer )
26385 && ( bindCount == rhs.bindCount )
26386 && ( pBinds == rhs.pBinds );
26387 }
26388
26390 {
26391 return !operator==( rhs );
26392 }
26393
26397 };
26398 static_assert( sizeof( SparseBufferMemoryBindInfo ) == sizeof( VkSparseBufferMemoryBindInfo ), "struct and wrapper have different size!" );
26399
26401 {
26403 uint32_t bindCount_ = 0,
26404 const SparseMemoryBind* pBinds_ = nullptr )
26405 : image( image_ )
26406 , bindCount( bindCount_ )
26407 , pBinds( pBinds_ )
26408 {
26409 }
26410
26412 {
26413 memcpy( this, &rhs, sizeof( SparseImageOpaqueMemoryBindInfo ) );
26414 }
26415
26417 {
26418 memcpy( this, &rhs, sizeof( SparseImageOpaqueMemoryBindInfo ) );
26419 return *this;
26420 }
26422 {
26423 image = image_;
26424 return *this;
26425 }
26426
26428 {
26429 bindCount = bindCount_;
26430 return *this;
26431 }
26432
26434 {
26435 pBinds = pBinds_;
26436 return *this;
26437 }
26438
26440 {
26441 return *reinterpret_cast<const VkSparseImageOpaqueMemoryBindInfo*>(this);
26442 }
26443
26445 {
26446 return *reinterpret_cast<VkSparseImageOpaqueMemoryBindInfo*>(this);
26447 }
26448
26450 {
26451 return ( image == rhs.image )
26452 && ( bindCount == rhs.bindCount )
26453 && ( pBinds == rhs.pBinds );
26454 }
26455
26457 {
26458 return !operator==( rhs );
26459 }
26460
26464 };
26465 static_assert( sizeof( SparseImageOpaqueMemoryBindInfo ) == sizeof( VkSparseImageOpaqueMemoryBindInfo ), "struct and wrapper have different size!" );
26466
26468 {
26470 uint32_t bindCount_ = 0,
26471 const SparseImageMemoryBind* pBinds_ = nullptr )
26472 : image( image_ )
26473 , bindCount( bindCount_ )
26474 , pBinds( pBinds_ )
26475 {
26476 }
26477
26479 {
26480 memcpy( this, &rhs, sizeof( SparseImageMemoryBindInfo ) );
26481 }
26482
26484 {
26485 memcpy( this, &rhs, sizeof( SparseImageMemoryBindInfo ) );
26486 return *this;
26487 }
26489 {
26490 image = image_;
26491 return *this;
26492 }
26493
26495 {
26496 bindCount = bindCount_;
26497 return *this;
26498 }
26499
26501 {
26502 pBinds = pBinds_;
26503 return *this;
26504 }
26505
26506 operator VkSparseImageMemoryBindInfo const&() const
26507 {
26508 return *reinterpret_cast<const VkSparseImageMemoryBindInfo*>(this);
26509 }
26510
26512 {
26513 return *reinterpret_cast<VkSparseImageMemoryBindInfo*>(this);
26514 }
26515
26516 bool operator==( SparseImageMemoryBindInfo const& rhs ) const
26517 {
26518 return ( image == rhs.image )
26519 && ( bindCount == rhs.bindCount )
26520 && ( pBinds == rhs.pBinds );
26521 }
26522
26523 bool operator!=( SparseImageMemoryBindInfo const& rhs ) const
26524 {
26525 return !operator==( rhs );
26526 }
26527
26531 };
26532 static_assert( sizeof( SparseImageMemoryBindInfo ) == sizeof( VkSparseImageMemoryBindInfo ), "struct and wrapper have different size!" );
26533
26535 {
26536 BindSparseInfo( uint32_t waitSemaphoreCount_ = 0,
26537 const Semaphore* pWaitSemaphores_ = nullptr,
26538 uint32_t bufferBindCount_ = 0,
26539 const SparseBufferMemoryBindInfo* pBufferBinds_ = nullptr,
26540 uint32_t imageOpaqueBindCount_ = 0,
26541 const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds_ = nullptr,
26542 uint32_t imageBindCount_ = 0,
26543 const SparseImageMemoryBindInfo* pImageBinds_ = nullptr,
26544 uint32_t signalSemaphoreCount_ = 0,
26545 const Semaphore* pSignalSemaphores_ = nullptr )
26546 : waitSemaphoreCount( waitSemaphoreCount_ )
26547 , pWaitSemaphores( pWaitSemaphores_ )
26548 , bufferBindCount( bufferBindCount_ )
26549 , pBufferBinds( pBufferBinds_ )
26550 , imageOpaqueBindCount( imageOpaqueBindCount_ )
26551 , pImageOpaqueBinds( pImageOpaqueBinds_ )
26552 , imageBindCount( imageBindCount_ )
26553 , pImageBinds( pImageBinds_ )
26554 , signalSemaphoreCount( signalSemaphoreCount_ )
26555 , pSignalSemaphores( pSignalSemaphores_ )
26556 {
26557 }
26558
26560 {
26561 memcpy( this, &rhs, sizeof( BindSparseInfo ) );
26562 }
26563
26565 {
26566 memcpy( this, &rhs, sizeof( BindSparseInfo ) );
26567 return *this;
26568 }
26569 BindSparseInfo& setPNext( const void* pNext_ )
26570 {
26571 pNext = pNext_;
26572 return *this;
26573 }
26574
26576 {
26577 waitSemaphoreCount = waitSemaphoreCount_;
26578 return *this;
26579 }
26580
26581 BindSparseInfo& setPWaitSemaphores( const Semaphore* pWaitSemaphores_ )
26582 {
26583 pWaitSemaphores = pWaitSemaphores_;
26584 return *this;
26585 }
26586
26588 {
26589 bufferBindCount = bufferBindCount_;
26590 return *this;
26591 }
26592
26594 {
26595 pBufferBinds = pBufferBinds_;
26596 return *this;
26597 }
26598
26600 {
26601 imageOpaqueBindCount = imageOpaqueBindCount_;
26602 return *this;
26603 }
26604
26606 {
26607 pImageOpaqueBinds = pImageOpaqueBinds_;
26608 return *this;
26609 }
26610
26612 {
26613 imageBindCount = imageBindCount_;
26614 return *this;
26615 }
26616
26618 {
26619 pImageBinds = pImageBinds_;
26620 return *this;
26621 }
26622
26624 {
26625 signalSemaphoreCount = signalSemaphoreCount_;
26626 return *this;
26627 }
26628
26629 BindSparseInfo& setPSignalSemaphores( const Semaphore* pSignalSemaphores_ )
26630 {
26631 pSignalSemaphores = pSignalSemaphores_;
26632 return *this;
26633 }
26634
26635 operator VkBindSparseInfo const&() const
26636 {
26637 return *reinterpret_cast<const VkBindSparseInfo*>(this);
26638 }
26639
26640 operator VkBindSparseInfo &()
26641 {
26642 return *reinterpret_cast<VkBindSparseInfo*>(this);
26643 }
26644
26645 bool operator==( BindSparseInfo const& rhs ) const
26646 {
26647 return ( sType == rhs.sType )
26648 && ( pNext == rhs.pNext )
26650 && ( pWaitSemaphores == rhs.pWaitSemaphores )
26651 && ( bufferBindCount == rhs.bufferBindCount )
26652 && ( pBufferBinds == rhs.pBufferBinds )
26655 && ( imageBindCount == rhs.imageBindCount )
26656 && ( pImageBinds == rhs.pImageBinds )
26659 }
26660
26661 bool operator!=( BindSparseInfo const& rhs ) const
26662 {
26663 return !operator==( rhs );
26664 }
26665
26666 private:
26668
26669 public:
26670 const void* pNext = nullptr;
26681 };
26682 static_assert( sizeof( BindSparseInfo ) == sizeof( VkBindSparseInfo ), "struct and wrapper have different size!" );
26683
26685 {
26711 };
26712
26714
26716 {
26717 return PipelineStageFlags( bit0 ) | bit1;
26718 }
26719
26721 {
26722 return ~( PipelineStageFlags( bits ) );
26723 }
26724
26726 {
26727 enum
26728 {
26731 };
26732
26734 {
26736 {
26737 return *reinterpret_cast<const VkQueueFamilyCheckpointPropertiesNV*>(this);
26738 }
26739
26741 {
26742 return *reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV*>(this);
26743 }
26744
26746 {
26747 return ( sType == rhs.sType )
26748 && ( pNext == rhs.pNext )
26750 }
26751
26753 {
26754 return !operator==( rhs );
26755 }
26756
26757 private:
26759
26760 public:
26761 void* pNext = nullptr;
26763 };
26764 static_assert( sizeof( QueueFamilyCheckpointPropertiesNV ) == sizeof( VkQueueFamilyCheckpointPropertiesNV ), "struct and wrapper have different size!" );
26765
26767 {
26768 operator VkCheckpointDataNV const&() const
26769 {
26770 return *reinterpret_cast<const VkCheckpointDataNV*>(this);
26771 }
26772
26774 {
26775 return *reinterpret_cast<VkCheckpointDataNV*>(this);
26776 }
26777
26778 bool operator==( CheckpointDataNV const& rhs ) const
26779 {
26780 return ( sType == rhs.sType )
26781 && ( pNext == rhs.pNext )
26782 && ( stage == rhs.stage )
26784 }
26785
26786 bool operator!=( CheckpointDataNV const& rhs ) const
26787 {
26788 return !operator==( rhs );
26789 }
26790
26791 private:
26793
26794 public:
26795 void* pNext = nullptr;
26798 };
26799 static_assert( sizeof( CheckpointDataNV ) == sizeof( VkCheckpointDataNV ), "struct and wrapper have different size!" );
26800
26802 {
26806 };
26807
26809
26811 {
26812 return CommandPoolCreateFlags( bit0 ) | bit1;
26813 }
26814
26816 {
26817 return ~( CommandPoolCreateFlags( bits ) );
26818 }
26819
26821 {
26822 enum
26823 {
26826 };
26827
26829 {
26831 uint32_t queueFamilyIndex_ = 0 )
26832 : flags( flags_ )
26833 , queueFamilyIndex( queueFamilyIndex_ )
26834 {
26835 }
26836
26838 {
26839 memcpy( this, &rhs, sizeof( CommandPoolCreateInfo ) );
26840 }
26841
26843 {
26844 memcpy( this, &rhs, sizeof( CommandPoolCreateInfo ) );
26845 return *this;
26846 }
26847 CommandPoolCreateInfo& setPNext( const void* pNext_ )
26848 {
26849 pNext = pNext_;
26850 return *this;
26851 }
26852
26854 {
26855 flags = flags_;
26856 return *this;
26857 }
26858
26860 {
26861 queueFamilyIndex = queueFamilyIndex_;
26862 return *this;
26863 }
26864
26865 operator VkCommandPoolCreateInfo const&() const
26866 {
26867 return *reinterpret_cast<const VkCommandPoolCreateInfo*>(this);
26868 }
26869
26871 {
26872 return *reinterpret_cast<VkCommandPoolCreateInfo*>(this);
26873 }
26874
26875 bool operator==( CommandPoolCreateInfo const& rhs ) const
26876 {
26877 return ( sType == rhs.sType )
26878 && ( pNext == rhs.pNext )
26879 && ( flags == rhs.flags )
26880 && ( queueFamilyIndex == rhs.queueFamilyIndex );
26881 }
26882
26883 bool operator!=( CommandPoolCreateInfo const& rhs ) const
26884 {
26885 return !operator==( rhs );
26886 }
26887
26888 private:
26890
26891 public:
26892 const void* pNext = nullptr;
26895 };
26896 static_assert( sizeof( CommandPoolCreateInfo ) == sizeof( VkCommandPoolCreateInfo ), "struct and wrapper have different size!" );
26897
26899 {
26901 };
26902
26904
26906 {
26907 return CommandPoolResetFlags( bit0 ) | bit1;
26908 }
26909
26911 {
26912 return ~( CommandPoolResetFlags( bits ) );
26913 }
26914
26916 {
26917 enum
26918 {
26921 };
26922
26924 {
26926 };
26927
26929
26931 {
26932 return CommandBufferResetFlags( bit0 ) | bit1;
26933 }
26934
26936 {
26937 return ~( CommandBufferResetFlags( bits ) );
26938 }
26939
26941 {
26942 enum
26943 {
26946 };
26947
26949 {
26957 };
26958
26960
26962 {
26963 return SampleCountFlags( bit0 ) | bit1;
26964 }
26965
26967 {
26968 return ~( SampleCountFlags( bits ) );
26969 }
26970
26972 {
26973 enum
26974 {
26977 };
26978
26980 {
26981 operator VkImageFormatProperties const&() const
26982 {
26983 return *reinterpret_cast<const VkImageFormatProperties*>(this);
26984 }
26985
26987 {
26988 return *reinterpret_cast<VkImageFormatProperties*>(this);
26989 }
26990
26991 bool operator==( ImageFormatProperties const& rhs ) const
26992 {
26993 return ( maxExtent == rhs.maxExtent )
26994 && ( maxMipLevels == rhs.maxMipLevels )
26995 && ( maxArrayLayers == rhs.maxArrayLayers )
26996 && ( sampleCounts == rhs.sampleCounts )
26997 && ( maxResourceSize == rhs.maxResourceSize );
26998 }
26999
27000 bool operator!=( ImageFormatProperties const& rhs ) const
27001 {
27002 return !operator==( rhs );
27003 }
27004
27010 };
27011 static_assert( sizeof( ImageFormatProperties ) == sizeof( VkImageFormatProperties ), "struct and wrapper have different size!" );
27012
27014 {
27016 ImageType imageType_ = ImageType::e1D,
27017 Format format_ = Format::eUndefined,
27018 Extent3D extent_ = Extent3D(),
27019 uint32_t mipLevels_ = 0,
27020 uint32_t arrayLayers_ = 0,
27024 SharingMode sharingMode_ = SharingMode::eExclusive,
27025 uint32_t queueFamilyIndexCount_ = 0,
27026 const uint32_t* pQueueFamilyIndices_ = nullptr,
27027 ImageLayout initialLayout_ = ImageLayout::eUndefined )
27028 : flags( flags_ )
27029 , imageType( imageType_ )
27030 , format( format_ )
27031 , extent( extent_ )
27032 , mipLevels( mipLevels_ )
27033 , arrayLayers( arrayLayers_ )
27034 , samples( samples_ )
27035 , tiling( tiling_ )
27036 , usage( usage_ )
27037 , sharingMode( sharingMode_ )
27038 , queueFamilyIndexCount( queueFamilyIndexCount_ )
27039 , pQueueFamilyIndices( pQueueFamilyIndices_ )
27040 , initialLayout( initialLayout_ )
27041 {
27042 }
27043
27045 {
27046 memcpy( this, &rhs, sizeof( ImageCreateInfo ) );
27047 }
27048
27050 {
27051 memcpy( this, &rhs, sizeof( ImageCreateInfo ) );
27052 return *this;
27053 }
27054 ImageCreateInfo& setPNext( const void* pNext_ )
27055 {
27056 pNext = pNext_;
27057 return *this;
27058 }
27059
27061 {
27062 flags = flags_;
27063 return *this;
27064 }
27065
27067 {
27068 imageType = imageType_;
27069 return *this;
27070 }
27071
27073 {
27074 format = format_;
27075 return *this;
27076 }
27077
27079 {
27080 extent = extent_;
27081 return *this;
27082 }
27083
27085 {
27086 mipLevels = mipLevels_;
27087 return *this;
27088 }
27089
27091 {
27092 arrayLayers = arrayLayers_;
27093 return *this;
27094 }
27095
27097 {
27098 samples = samples_;
27099 return *this;
27100 }
27101
27103 {
27104 tiling = tiling_;
27105 return *this;
27106 }
27107
27109 {
27110 usage = usage_;
27111 return *this;
27112 }
27113
27115 {
27116 sharingMode = sharingMode_;
27117 return *this;
27118 }
27119
27121 {
27122 queueFamilyIndexCount = queueFamilyIndexCount_;
27123 return *this;
27124 }
27125
27126 ImageCreateInfo& setPQueueFamilyIndices( const uint32_t* pQueueFamilyIndices_ )
27127 {
27128 pQueueFamilyIndices = pQueueFamilyIndices_;
27129 return *this;
27130 }
27131
27133 {
27134 initialLayout = initialLayout_;
27135 return *this;
27136 }
27137
27138 operator VkImageCreateInfo const&() const
27139 {
27140 return *reinterpret_cast<const VkImageCreateInfo*>(this);
27141 }
27142
27144 {
27145 return *reinterpret_cast<VkImageCreateInfo*>(this);
27146 }
27147
27148 bool operator==( ImageCreateInfo const& rhs ) const
27149 {
27150 return ( sType == rhs.sType )
27151 && ( pNext == rhs.pNext )
27152 && ( flags == rhs.flags )
27153 && ( imageType == rhs.imageType )
27154 && ( format == rhs.format )
27155 && ( extent == rhs.extent )
27156 && ( mipLevels == rhs.mipLevels )
27157 && ( arrayLayers == rhs.arrayLayers )
27158 && ( samples == rhs.samples )
27159 && ( tiling == rhs.tiling )
27160 && ( usage == rhs.usage )
27161 && ( sharingMode == rhs.sharingMode )
27164 && ( initialLayout == rhs.initialLayout );
27165 }
27166
27167 bool operator!=( ImageCreateInfo const& rhs ) const
27168 {
27169 return !operator==( rhs );
27170 }
27171
27172 private:
27174
27175 public:
27176 const void* pNext = nullptr;
27190 };
27191 static_assert( sizeof( ImageCreateInfo ) == sizeof( VkImageCreateInfo ), "struct and wrapper have different size!" );
27192
27194 {
27196 SampleCountFlagBits rasterizationSamples_ = SampleCountFlagBits::e1,
27197 Bool32 sampleShadingEnable_ = 0,
27198 float minSampleShading_ = 0,
27199 const SampleMask* pSampleMask_ = nullptr,
27200 Bool32 alphaToCoverageEnable_ = 0,
27201 Bool32 alphaToOneEnable_ = 0 )
27202 : flags( flags_ )
27203 , rasterizationSamples( rasterizationSamples_ )
27204 , sampleShadingEnable( sampleShadingEnable_ )
27205 , minSampleShading( minSampleShading_ )
27206 , pSampleMask( pSampleMask_ )
27207 , alphaToCoverageEnable( alphaToCoverageEnable_ )
27208 , alphaToOneEnable( alphaToOneEnable_ )
27209 {
27210 }
27211
27213 {
27214 memcpy( this, &rhs, sizeof( PipelineMultisampleStateCreateInfo ) );
27215 }
27216
27218 {
27219 memcpy( this, &rhs, sizeof( PipelineMultisampleStateCreateInfo ) );
27220 return *this;
27221 }
27223 {
27224 pNext = pNext_;
27225 return *this;
27226 }
27227
27229 {
27230 flags = flags_;
27231 return *this;
27232 }
27233
27235 {
27236 rasterizationSamples = rasterizationSamples_;
27237 return *this;
27238 }
27239
27241 {
27242 sampleShadingEnable = sampleShadingEnable_;
27243 return *this;
27244 }
27245
27247 {
27248 minSampleShading = minSampleShading_;
27249 return *this;
27250 }
27251
27253 {
27254 pSampleMask = pSampleMask_;
27255 return *this;
27256 }
27257
27259 {
27260 alphaToCoverageEnable = alphaToCoverageEnable_;
27261 return *this;
27262 }
27263
27265 {
27266 alphaToOneEnable = alphaToOneEnable_;
27267 return *this;
27268 }
27269
27271 {
27272 return *reinterpret_cast<const VkPipelineMultisampleStateCreateInfo*>(this);
27273 }
27274
27276 {
27277 return *reinterpret_cast<VkPipelineMultisampleStateCreateInfo*>(this);
27278 }
27279
27281 {
27282 return ( sType == rhs.sType )
27283 && ( pNext == rhs.pNext )
27284 && ( flags == rhs.flags )
27288 && ( pSampleMask == rhs.pSampleMask )
27290 && ( alphaToOneEnable == rhs.alphaToOneEnable );
27291 }
27292
27294 {
27295 return !operator==( rhs );
27296 }
27297
27298 private:
27300
27301 public:
27302 const void* pNext = nullptr;
27310 };
27311 static_assert( sizeof( PipelineMultisampleStateCreateInfo ) == sizeof( VkPipelineMultisampleStateCreateInfo ), "struct and wrapper have different size!" );
27312
27314 {
27316 uint32_t stageCount_ = 0,
27317 const PipelineShaderStageCreateInfo* pStages_ = nullptr,
27318 const PipelineVertexInputStateCreateInfo* pVertexInputState_ = nullptr,
27319 const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState_ = nullptr,
27320 const PipelineTessellationStateCreateInfo* pTessellationState_ = nullptr,
27321 const PipelineViewportStateCreateInfo* pViewportState_ = nullptr,
27322 const PipelineRasterizationStateCreateInfo* pRasterizationState_ = nullptr,
27323 const PipelineMultisampleStateCreateInfo* pMultisampleState_ = nullptr,
27324 const PipelineDepthStencilStateCreateInfo* pDepthStencilState_ = nullptr,
27325 const PipelineColorBlendStateCreateInfo* pColorBlendState_ = nullptr,
27326 const PipelineDynamicStateCreateInfo* pDynamicState_ = nullptr,
27327 PipelineLayout layout_ = PipelineLayout(),
27328 RenderPass renderPass_ = RenderPass(),
27329 uint32_t subpass_ = 0,
27330 Pipeline basePipelineHandle_ = Pipeline(),
27331 int32_t basePipelineIndex_ = 0 )
27332 : flags( flags_ )
27333 , stageCount( stageCount_ )
27334 , pStages( pStages_ )
27335 , pVertexInputState( pVertexInputState_ )
27336 , pInputAssemblyState( pInputAssemblyState_ )
27337 , pTessellationState( pTessellationState_ )
27338 , pViewportState( pViewportState_ )
27339 , pRasterizationState( pRasterizationState_ )
27340 , pMultisampleState( pMultisampleState_ )
27341 , pDepthStencilState( pDepthStencilState_ )
27342 , pColorBlendState( pColorBlendState_ )
27343 , pDynamicState( pDynamicState_ )
27344 , layout( layout_ )
27345 , renderPass( renderPass_ )
27346 , subpass( subpass_ )
27347 , basePipelineHandle( basePipelineHandle_ )
27348 , basePipelineIndex( basePipelineIndex_ )
27349 {
27350 }
27351
27353 {
27354 memcpy( this, &rhs, sizeof( GraphicsPipelineCreateInfo ) );
27355 }
27356
27358 {
27359 memcpy( this, &rhs, sizeof( GraphicsPipelineCreateInfo ) );
27360 return *this;
27361 }
27363 {
27364 pNext = pNext_;
27365 return *this;
27366 }
27367
27369 {
27370 flags = flags_;
27371 return *this;
27372 }
27373
27375 {
27376 stageCount = stageCount_;
27377 return *this;
27378 }
27379
27381 {
27382 pStages = pStages_;
27383 return *this;
27384 }
27385
27387 {
27388 pVertexInputState = pVertexInputState_;
27389 return *this;
27390 }
27391
27393 {
27394 pInputAssemblyState = pInputAssemblyState_;
27395 return *this;
27396 }
27397
27399 {
27400 pTessellationState = pTessellationState_;
27401 return *this;
27402 }
27403
27405 {
27406 pViewportState = pViewportState_;
27407 return *this;
27408 }
27409
27411 {
27412 pRasterizationState = pRasterizationState_;
27413 return *this;
27414 }
27415
27417 {
27418 pMultisampleState = pMultisampleState_;
27419 return *this;
27420 }
27421
27423 {
27424 pDepthStencilState = pDepthStencilState_;
27425 return *this;
27426 }
27427
27429 {
27430 pColorBlendState = pColorBlendState_;
27431 return *this;
27432 }
27433
27435 {
27436 pDynamicState = pDynamicState_;
27437 return *this;
27438 }
27439
27441 {
27442 layout = layout_;
27443 return *this;
27444 }
27445
27447 {
27448 renderPass = renderPass_;
27449 return *this;
27450 }
27451
27453 {
27454 subpass = subpass_;
27455 return *this;
27456 }
27457
27459 {
27460 basePipelineHandle = basePipelineHandle_;
27461 return *this;
27462 }
27463
27465 {
27466 basePipelineIndex = basePipelineIndex_;
27467 return *this;
27468 }
27469
27470 operator VkGraphicsPipelineCreateInfo const&() const
27471 {
27472 return *reinterpret_cast<const VkGraphicsPipelineCreateInfo*>(this);
27473 }
27474
27476 {
27477 return *reinterpret_cast<VkGraphicsPipelineCreateInfo*>(this);
27478 }
27479
27481 {
27482 return ( sType == rhs.sType )
27483 && ( pNext == rhs.pNext )
27484 && ( flags == rhs.flags )
27485 && ( stageCount == rhs.stageCount )
27486 && ( pStages == rhs.pStages )
27490 && ( pViewportState == rhs.pViewportState )
27495 && ( pDynamicState == rhs.pDynamicState )
27496 && ( layout == rhs.layout )
27497 && ( renderPass == rhs.renderPass )
27498 && ( subpass == rhs.subpass )
27501 }
27502
27504 {
27505 return !operator==( rhs );
27506 }
27507
27508 private:
27510
27511 public:
27512 const void* pNext = nullptr;
27530 };
27531 static_assert( sizeof( GraphicsPipelineCreateInfo ) == sizeof( VkGraphicsPipelineCreateInfo ), "struct and wrapper have different size!" );
27532
27534 {
27535 operator VkPhysicalDeviceLimits const&() const
27536 {
27537 return *reinterpret_cast<const VkPhysicalDeviceLimits*>(this);
27538 }
27539
27541 {
27542 return *reinterpret_cast<VkPhysicalDeviceLimits*>(this);
27543 }
27544
27545 bool operator==( PhysicalDeviceLimits const& rhs ) const
27546 {
27599 && ( memcmp( maxComputeWorkGroupCount, rhs.maxComputeWorkGroupCount, 3 * sizeof( uint32_t ) ) == 0 )
27601 && ( memcmp( maxComputeWorkGroupSize, rhs.maxComputeWorkGroupSize, 3 * sizeof( uint32_t ) ) == 0 )
27609 && ( maxViewports == rhs.maxViewports )
27610 && ( memcmp( maxViewportDimensions, rhs.maxViewportDimensions, 2 * sizeof( uint32_t ) ) == 0 )
27611 && ( memcmp( viewportBoundsRange, rhs.viewportBoundsRange, 2 * sizeof( float ) ) == 0 )
27617 && ( minTexelOffset == rhs.minTexelOffset )
27618 && ( maxTexelOffset == rhs.maxTexelOffset )
27639 && ( timestampPeriod == rhs.timestampPeriod )
27644 && ( memcmp( pointSizeRange, rhs.pointSizeRange, 2 * sizeof( float ) ) == 0 )
27645 && ( memcmp( lineWidthRange, rhs.lineWidthRange, 2 * sizeof( float ) ) == 0 )
27648 && ( strictLines == rhs.strictLines )
27653 }
27654
27655 bool operator!=( PhysicalDeviceLimits const& rhs ) const
27656 {
27657 return !operator==( rhs );
27658 }
27659
27766 };
27767 static_assert( sizeof( PhysicalDeviceLimits ) == sizeof( VkPhysicalDeviceLimits ), "struct and wrapper have different size!" );
27768
27770 {
27771 operator VkPhysicalDeviceProperties const&() const
27772 {
27773 return *reinterpret_cast<const VkPhysicalDeviceProperties*>(this);
27774 }
27775
27777 {
27778 return *reinterpret_cast<VkPhysicalDeviceProperties*>(this);
27779 }
27780
27781 bool operator==( PhysicalDeviceProperties const& rhs ) const
27782 {
27783 return ( apiVersion == rhs.apiVersion )
27784 && ( driverVersion == rhs.driverVersion )
27785 && ( vendorID == rhs.vendorID )
27786 && ( deviceID == rhs.deviceID )
27787 && ( deviceType == rhs.deviceType )
27788 && ( memcmp( deviceName, rhs.deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE * sizeof( char ) ) == 0 )
27789 && ( memcmp( pipelineCacheUUID, rhs.pipelineCacheUUID, VK_UUID_SIZE * sizeof( uint8_t ) ) == 0 )
27790 && ( limits == rhs.limits )
27791 && ( sparseProperties == rhs.sparseProperties );
27792 }
27793
27794 bool operator!=( PhysicalDeviceProperties const& rhs ) const
27795 {
27796 return !operator==( rhs );
27797 }
27798
27808 };
27809 static_assert( sizeof( PhysicalDeviceProperties ) == sizeof( VkPhysicalDeviceProperties ), "struct and wrapper have different size!" );
27810
27812 {
27813 operator VkPhysicalDeviceProperties2 const&() const
27814 {
27815 return *reinterpret_cast<const VkPhysicalDeviceProperties2*>(this);
27816 }
27817
27819 {
27820 return *reinterpret_cast<VkPhysicalDeviceProperties2*>(this);
27821 }
27822
27823 bool operator==( PhysicalDeviceProperties2 const& rhs ) const
27824 {
27825 return ( sType == rhs.sType )
27826 && ( pNext == rhs.pNext )
27827 && ( properties == rhs.properties );
27828 }
27829
27830 bool operator!=( PhysicalDeviceProperties2 const& rhs ) const
27831 {
27832 return !operator==( rhs );
27833 }
27834
27835 private:
27837
27838 public:
27839 void* pNext = nullptr;
27841 };
27842 static_assert( sizeof( PhysicalDeviceProperties2 ) == sizeof( VkPhysicalDeviceProperties2 ), "struct and wrapper have different size!" );
27843
27845
27847 {
27848 operator VkImageFormatProperties2 const&() const
27849 {
27850 return *reinterpret_cast<const VkImageFormatProperties2*>(this);
27851 }
27852
27854 {
27855 return *reinterpret_cast<VkImageFormatProperties2*>(this);
27856 }
27857
27858 bool operator==( ImageFormatProperties2 const& rhs ) const
27859 {
27860 return ( sType == rhs.sType )
27861 && ( pNext == rhs.pNext )
27863 }
27864
27865 bool operator!=( ImageFormatProperties2 const& rhs ) const
27866 {
27867 return !operator==( rhs );
27868 }
27869
27870 private:
27872
27873 public:
27874 void* pNext = nullptr;
27876 };
27877 static_assert( sizeof( ImageFormatProperties2 ) == sizeof( VkImageFormatProperties2 ), "struct and wrapper have different size!" );
27878
27880
27882 {
27884 ImageType type_ = ImageType::e1D,
27888 : format( format_ )
27889 , type( type_ )
27890 , samples( samples_ )
27891 , usage( usage_ )
27892 , tiling( tiling_ )
27893 {
27894 }
27895
27897 {
27898 memcpy( this, &rhs, sizeof( PhysicalDeviceSparseImageFormatInfo2 ) );
27899 }
27900
27902 {
27903 memcpy( this, &rhs, sizeof( PhysicalDeviceSparseImageFormatInfo2 ) );
27904 return *this;
27905 }
27907 {
27908 pNext = pNext_;
27909 return *this;
27910 }
27911
27913 {
27914 format = format_;
27915 return *this;
27916 }
27917
27919 {
27920 type = type_;
27921 return *this;
27922 }
27923
27925 {
27926 samples = samples_;
27927 return *this;
27928 }
27929
27931 {
27932 usage = usage_;
27933 return *this;
27934 }
27935
27937 {
27938 tiling = tiling_;
27939 return *this;
27940 }
27941
27943 {
27944 return *reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>(this);
27945 }
27946
27948 {
27949 return *reinterpret_cast<VkPhysicalDeviceSparseImageFormatInfo2*>(this);
27950 }
27951
27953 {
27954 return ( sType == rhs.sType )
27955 && ( pNext == rhs.pNext )
27956 && ( format == rhs.format )
27957 && ( type == rhs.type )
27958 && ( samples == rhs.samples )
27959 && ( usage == rhs.usage )
27960 && ( tiling == rhs.tiling );
27961 }
27962
27964 {
27965 return !operator==( rhs );
27966 }
27967
27968 private:
27970
27971 public:
27972 const void* pNext = nullptr;
27978 };
27979 static_assert( sizeof( PhysicalDeviceSparseImageFormatInfo2 ) == sizeof( VkPhysicalDeviceSparseImageFormatInfo2 ), "struct and wrapper have different size!" );
27980
27982
27984 {
27986 Extent2D sampleLocationGridSize_ = Extent2D(),
27987 uint32_t sampleLocationsCount_ = 0,
27988 const SampleLocationEXT* pSampleLocations_ = nullptr )
27989 : sampleLocationsPerPixel( sampleLocationsPerPixel_ )
27990 , sampleLocationGridSize( sampleLocationGridSize_ )
27991 , sampleLocationsCount( sampleLocationsCount_ )
27992 , pSampleLocations( pSampleLocations_ )
27993 {
27994 }
27995
27997 {
27998 memcpy( this, &rhs, sizeof( SampleLocationsInfoEXT ) );
27999 }
28000
28002 {
28003 memcpy( this, &rhs, sizeof( SampleLocationsInfoEXT ) );
28004 return *this;
28005 }
28006 SampleLocationsInfoEXT& setPNext( const void* pNext_ )
28007 {
28008 pNext = pNext_;
28009 return *this;
28010 }
28011
28013 {
28014 sampleLocationsPerPixel = sampleLocationsPerPixel_;
28015 return *this;
28016 }
28017
28019 {
28020 sampleLocationGridSize = sampleLocationGridSize_;
28021 return *this;
28022 }
28023
28025 {
28026 sampleLocationsCount = sampleLocationsCount_;
28027 return *this;
28028 }
28029
28031 {
28032 pSampleLocations = pSampleLocations_;
28033 return *this;
28034 }
28035
28036 operator VkSampleLocationsInfoEXT const&() const
28037 {
28038 return *reinterpret_cast<const VkSampleLocationsInfoEXT*>(this);
28039 }
28040
28042 {
28043 return *reinterpret_cast<VkSampleLocationsInfoEXT*>(this);
28044 }
28045
28046 bool operator==( SampleLocationsInfoEXT const& rhs ) const
28047 {
28048 return ( sType == rhs.sType )
28049 && ( pNext == rhs.pNext )
28053 && ( pSampleLocations == rhs.pSampleLocations );
28054 }
28055
28056 bool operator!=( SampleLocationsInfoEXT const& rhs ) const
28057 {
28058 return !operator==( rhs );
28059 }
28060
28061 private:
28063
28064 public:
28065 const void* pNext = nullptr;
28070 };
28071 static_assert( sizeof( SampleLocationsInfoEXT ) == sizeof( VkSampleLocationsInfoEXT ), "struct and wrapper have different size!" );
28072
28074 {
28076 SampleLocationsInfoEXT sampleLocationsInfo_ = SampleLocationsInfoEXT() )
28077 : attachmentIndex( attachmentIndex_ )
28078 , sampleLocationsInfo( sampleLocationsInfo_ )
28079 {
28080 }
28081
28083 {
28084 memcpy( this, &rhs, sizeof( AttachmentSampleLocationsEXT ) );
28085 }
28086
28088 {
28089 memcpy( this, &rhs, sizeof( AttachmentSampleLocationsEXT ) );
28090 return *this;
28091 }
28093 {
28094 attachmentIndex = attachmentIndex_;
28095 return *this;
28096 }
28097
28099 {
28100 sampleLocationsInfo = sampleLocationsInfo_;
28101 return *this;
28102 }
28103
28104 operator VkAttachmentSampleLocationsEXT const&() const
28105 {
28106 return *reinterpret_cast<const VkAttachmentSampleLocationsEXT*>(this);
28107 }
28108
28110 {
28111 return *reinterpret_cast<VkAttachmentSampleLocationsEXT*>(this);
28112 }
28113
28115 {
28116 return ( attachmentIndex == rhs.attachmentIndex )
28118 }
28119
28121 {
28122 return !operator==( rhs );
28123 }
28124
28127 };
28128 static_assert( sizeof( AttachmentSampleLocationsEXT ) == sizeof( VkAttachmentSampleLocationsEXT ), "struct and wrapper have different size!" );
28129
28131 {
28133 SampleLocationsInfoEXT sampleLocationsInfo_ = SampleLocationsInfoEXT() )
28134 : subpassIndex( subpassIndex_ )
28135 , sampleLocationsInfo( sampleLocationsInfo_ )
28136 {
28137 }
28138
28140 {
28141 memcpy( this, &rhs, sizeof( SubpassSampleLocationsEXT ) );
28142 }
28143
28145 {
28146 memcpy( this, &rhs, sizeof( SubpassSampleLocationsEXT ) );
28147 return *this;
28148 }
28150 {
28151 subpassIndex = subpassIndex_;
28152 return *this;
28153 }
28154
28156 {
28157 sampleLocationsInfo = sampleLocationsInfo_;
28158 return *this;
28159 }
28160
28161 operator VkSubpassSampleLocationsEXT const&() const
28162 {
28163 return *reinterpret_cast<const VkSubpassSampleLocationsEXT*>(this);
28164 }
28165
28167 {
28168 return *reinterpret_cast<VkSubpassSampleLocationsEXT*>(this);
28169 }
28170
28171 bool operator==( SubpassSampleLocationsEXT const& rhs ) const
28172 {
28173 return ( subpassIndex == rhs.subpassIndex )
28175 }
28176
28177 bool operator!=( SubpassSampleLocationsEXT const& rhs ) const
28178 {
28179 return !operator==( rhs );
28180 }
28181
28184 };
28185 static_assert( sizeof( SubpassSampleLocationsEXT ) == sizeof( VkSubpassSampleLocationsEXT ), "struct and wrapper have different size!" );
28186
28188 {
28189 RenderPassSampleLocationsBeginInfoEXT( uint32_t attachmentInitialSampleLocationsCount_ = 0,
28190 const AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations_ = nullptr,
28191 uint32_t postSubpassSampleLocationsCount_ = 0,
28192 const SubpassSampleLocationsEXT* pPostSubpassSampleLocations_ = nullptr )
28193 : attachmentInitialSampleLocationsCount( attachmentInitialSampleLocationsCount_ )
28194 , pAttachmentInitialSampleLocations( pAttachmentInitialSampleLocations_ )
28195 , postSubpassSampleLocationsCount( postSubpassSampleLocationsCount_ )
28196 , pPostSubpassSampleLocations( pPostSubpassSampleLocations_ )
28197 {
28198 }
28199
28201 {
28202 memcpy( this, &rhs, sizeof( RenderPassSampleLocationsBeginInfoEXT ) );
28203 }
28204
28206 {
28207 memcpy( this, &rhs, sizeof( RenderPassSampleLocationsBeginInfoEXT ) );
28208 return *this;
28209 }
28211 {
28212 pNext = pNext_;
28213 return *this;
28214 }
28215
28217 {
28218 attachmentInitialSampleLocationsCount = attachmentInitialSampleLocationsCount_;
28219 return *this;
28220 }
28221
28223 {
28224 pAttachmentInitialSampleLocations = pAttachmentInitialSampleLocations_;
28225 return *this;
28226 }
28227
28229 {
28230 postSubpassSampleLocationsCount = postSubpassSampleLocationsCount_;
28231 return *this;
28232 }
28233
28235 {
28236 pPostSubpassSampleLocations = pPostSubpassSampleLocations_;
28237 return *this;
28238 }
28239
28241 {
28242 return *reinterpret_cast<const VkRenderPassSampleLocationsBeginInfoEXT*>(this);
28243 }
28244
28246 {
28247 return *reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT*>(this);
28248 }
28249
28251 {
28252 return ( sType == rhs.sType )
28253 && ( pNext == rhs.pNext )
28258 }
28259
28261 {
28262 return !operator==( rhs );
28263 }
28264
28265 private:
28267
28268 public:
28269 const void* pNext = nullptr;
28274 };
28275 static_assert( sizeof( RenderPassSampleLocationsBeginInfoEXT ) == sizeof( VkRenderPassSampleLocationsBeginInfoEXT ), "struct and wrapper have different size!" );
28276
28278 {
28280 SampleLocationsInfoEXT sampleLocationsInfo_ = SampleLocationsInfoEXT() )
28281 : sampleLocationsEnable( sampleLocationsEnable_ )
28282 , sampleLocationsInfo( sampleLocationsInfo_ )
28283 {
28284 }
28285
28287 {
28288 memcpy( this, &rhs, sizeof( PipelineSampleLocationsStateCreateInfoEXT ) );
28289 }
28290
28292 {
28293 memcpy( this, &rhs, sizeof( PipelineSampleLocationsStateCreateInfoEXT ) );
28294 return *this;
28295 }
28297 {
28298 pNext = pNext_;
28299 return *this;
28300 }
28301
28303 {
28304 sampleLocationsEnable = sampleLocationsEnable_;
28305 return *this;
28306 }
28307
28309 {
28310 sampleLocationsInfo = sampleLocationsInfo_;
28311 return *this;
28312 }
28313
28315 {
28316 return *reinterpret_cast<const VkPipelineSampleLocationsStateCreateInfoEXT*>(this);
28317 }
28318
28320 {
28321 return *reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT*>(this);
28322 }
28323
28325 {
28326 return ( sType == rhs.sType )
28327 && ( pNext == rhs.pNext )
28330 }
28331
28333 {
28334 return !operator==( rhs );
28335 }
28336
28337 private:
28339
28340 public:
28341 const void* pNext = nullptr;
28344 };
28345 static_assert( sizeof( PipelineSampleLocationsStateCreateInfoEXT ) == sizeof( VkPipelineSampleLocationsStateCreateInfoEXT ), "struct and wrapper have different size!" );
28346
28348 {
28350 {
28351 return *reinterpret_cast<const VkPhysicalDeviceSampleLocationsPropertiesEXT*>(this);
28352 }
28353
28355 {
28356 return *reinterpret_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT*>(this);
28357 }
28358
28360 {
28361 return ( sType == rhs.sType )
28362 && ( pNext == rhs.pNext )
28365 && ( memcmp( sampleLocationCoordinateRange, rhs.sampleLocationCoordinateRange, 2 * sizeof( float ) ) == 0 )
28368 }
28369
28371 {
28372 return !operator==( rhs );
28373 }
28374
28375 private:
28377
28378 public:
28379 void* pNext = nullptr;
28385 };
28386 static_assert( sizeof( PhysicalDeviceSampleLocationsPropertiesEXT ) == sizeof( VkPhysicalDeviceSampleLocationsPropertiesEXT ), "struct and wrapper have different size!" );
28387
28389 {
28391 };
28392
28394
28396 {
28397 return AttachmentDescriptionFlags( bit0 ) | bit1;
28398 }
28399
28401 {
28402 return ~( AttachmentDescriptionFlags( bits ) );
28403 }
28404
28406 {
28407 enum
28408 {
28411 };
28412
28414 {
28416 Format format_ = Format::eUndefined,
28422 ImageLayout initialLayout_ = ImageLayout::eUndefined,
28423 ImageLayout finalLayout_ = ImageLayout::eUndefined )
28424 : flags( flags_ )
28425 , format( format_ )
28426 , samples( samples_ )
28427 , loadOp( loadOp_ )
28428 , storeOp( storeOp_ )
28429 , stencilLoadOp( stencilLoadOp_ )
28430 , stencilStoreOp( stencilStoreOp_ )
28431 , initialLayout( initialLayout_ )
28432 , finalLayout( finalLayout_ )
28433 {
28434 }
28435
28437 {
28438 memcpy( this, &rhs, sizeof( AttachmentDescription ) );
28439 }
28440
28442 {
28443 memcpy( this, &rhs, sizeof( AttachmentDescription ) );
28444 return *this;
28445 }
28447 {
28448 flags = flags_;
28449 return *this;
28450 }
28451
28453 {
28454 format = format_;
28455 return *this;
28456 }
28457
28459 {
28460 samples = samples_;
28461 return *this;
28462 }
28463
28465 {
28466 loadOp = loadOp_;
28467 return *this;
28468 }
28469
28471 {
28472 storeOp = storeOp_;
28473 return *this;
28474 }
28475
28477 {
28478 stencilLoadOp = stencilLoadOp_;
28479 return *this;
28480 }
28481
28483 {
28484 stencilStoreOp = stencilStoreOp_;
28485 return *this;
28486 }
28487
28489 {
28490 initialLayout = initialLayout_;
28491 return *this;
28492 }
28493
28495 {
28496 finalLayout = finalLayout_;
28497 return *this;
28498 }
28499
28500 operator VkAttachmentDescription const&() const
28501 {
28502 return *reinterpret_cast<const VkAttachmentDescription*>(this);
28503 }
28504
28506 {
28507 return *reinterpret_cast<VkAttachmentDescription*>(this);
28508 }
28509
28510 bool operator==( AttachmentDescription const& rhs ) const
28511 {
28512 return ( flags == rhs.flags )
28513 && ( format == rhs.format )
28514 && ( samples == rhs.samples )
28515 && ( loadOp == rhs.loadOp )
28516 && ( storeOp == rhs.storeOp )
28517 && ( stencilLoadOp == rhs.stencilLoadOp )
28518 && ( stencilStoreOp == rhs.stencilStoreOp )
28519 && ( initialLayout == rhs.initialLayout )
28520 && ( finalLayout == rhs.finalLayout );
28521 }
28522
28523 bool operator!=( AttachmentDescription const& rhs ) const
28524 {
28525 return !operator==( rhs );
28526 }
28527
28537 };
28538 static_assert( sizeof( AttachmentDescription ) == sizeof( VkAttachmentDescription ), "struct and wrapper have different size!" );
28539
28541 {
28543 Format format_ = Format::eUndefined,
28549 ImageLayout initialLayout_ = ImageLayout::eUndefined,
28550 ImageLayout finalLayout_ = ImageLayout::eUndefined )
28551 : flags( flags_ )
28552 , format( format_ )
28553 , samples( samples_ )
28554 , loadOp( loadOp_ )
28555 , storeOp( storeOp_ )
28556 , stencilLoadOp( stencilLoadOp_ )
28557 , stencilStoreOp( stencilStoreOp_ )
28558 , initialLayout( initialLayout_ )
28559 , finalLayout( finalLayout_ )
28560 {
28561 }
28562
28564 {
28565 memcpy( this, &rhs, sizeof( AttachmentDescription2KHR ) );
28566 }
28567
28569 {
28570 memcpy( this, &rhs, sizeof( AttachmentDescription2KHR ) );
28571 return *this;
28572 }
28574 {
28575 pNext = pNext_;
28576 return *this;
28577 }
28578
28580 {
28581 flags = flags_;
28582 return *this;
28583 }
28584
28586 {
28587 format = format_;
28588 return *this;
28589 }
28590
28592 {
28593 samples = samples_;
28594 return *this;
28595 }
28596
28598 {
28599 loadOp = loadOp_;
28600 return *this;
28601 }
28602
28604 {
28605 storeOp = storeOp_;
28606 return *this;
28607 }
28608
28610 {
28611 stencilLoadOp = stencilLoadOp_;
28612 return *this;
28613 }
28614
28616 {
28617 stencilStoreOp = stencilStoreOp_;
28618 return *this;
28619 }
28620
28622 {
28623 initialLayout = initialLayout_;
28624 return *this;
28625 }
28626
28628 {
28629 finalLayout = finalLayout_;
28630 return *this;
28631 }
28632
28633 operator VkAttachmentDescription2KHR const&() const
28634 {
28635 return *reinterpret_cast<const VkAttachmentDescription2KHR*>(this);
28636 }
28637
28639 {
28640 return *reinterpret_cast<VkAttachmentDescription2KHR*>(this);
28641 }
28642
28643 bool operator==( AttachmentDescription2KHR const& rhs ) const
28644 {
28645 return ( sType == rhs.sType )
28646 && ( pNext == rhs.pNext )
28647 && ( flags == rhs.flags )
28648 && ( format == rhs.format )
28649 && ( samples == rhs.samples )
28650 && ( loadOp == rhs.loadOp )
28651 && ( storeOp == rhs.storeOp )
28652 && ( stencilLoadOp == rhs.stencilLoadOp )
28653 && ( stencilStoreOp == rhs.stencilStoreOp )
28654 && ( initialLayout == rhs.initialLayout )
28655 && ( finalLayout == rhs.finalLayout );
28656 }
28657
28658 bool operator!=( AttachmentDescription2KHR const& rhs ) const
28659 {
28660 return !operator==( rhs );
28661 }
28662
28663 private:
28665
28666 public:
28667 const void* pNext = nullptr;
28677 };
28678 static_assert( sizeof( AttachmentDescription2KHR ) == sizeof( VkAttachmentDescription2KHR ), "struct and wrapper have different size!" );
28679
28681 {
28685 };
28686
28688
28690 {
28691 return StencilFaceFlags( bit0 ) | bit1;
28692 }
28693
28695 {
28696 return ~( StencilFaceFlags( bits ) );
28697 }
28698
28700 {
28701 enum
28702 {
28705 };
28706
28708 {
28711 };
28712
28714
28716 {
28717 return DescriptorPoolCreateFlags( bit0 ) | bit1;
28718 }
28719
28721 {
28722 return ~( DescriptorPoolCreateFlags( bits ) );
28723 }
28724
28726 {
28727 enum
28728 {
28731 };
28732
28734 {
28736 uint32_t maxSets_ = 0,
28737 uint32_t poolSizeCount_ = 0,
28738 const DescriptorPoolSize* pPoolSizes_ = nullptr )
28739 : flags( flags_ )
28740 , maxSets( maxSets_ )
28741 , poolSizeCount( poolSizeCount_ )
28742 , pPoolSizes( pPoolSizes_ )
28743 {
28744 }
28745
28747 {
28748 memcpy( this, &rhs, sizeof( DescriptorPoolCreateInfo ) );
28749 }
28750
28752 {
28753 memcpy( this, &rhs, sizeof( DescriptorPoolCreateInfo ) );
28754 return *this;
28755 }
28756 DescriptorPoolCreateInfo& setPNext( const void* pNext_ )
28757 {
28758 pNext = pNext_;
28759 return *this;
28760 }
28761
28763 {
28764 flags = flags_;
28765 return *this;
28766 }
28767
28769 {
28770 maxSets = maxSets_;
28771 return *this;
28772 }
28773
28775 {
28776 poolSizeCount = poolSizeCount_;
28777 return *this;
28778 }
28779
28781 {
28782 pPoolSizes = pPoolSizes_;
28783 return *this;
28784 }
28785
28786 operator VkDescriptorPoolCreateInfo const&() const
28787 {
28788 return *reinterpret_cast<const VkDescriptorPoolCreateInfo*>(this);
28789 }
28790
28792 {
28793 return *reinterpret_cast<VkDescriptorPoolCreateInfo*>(this);
28794 }
28795
28796 bool operator==( DescriptorPoolCreateInfo const& rhs ) const
28797 {
28798 return ( sType == rhs.sType )
28799 && ( pNext == rhs.pNext )
28800 && ( flags == rhs.flags )
28801 && ( maxSets == rhs.maxSets )
28802 && ( poolSizeCount == rhs.poolSizeCount )
28803 && ( pPoolSizes == rhs.pPoolSizes );
28804 }
28805
28806 bool operator!=( DescriptorPoolCreateInfo const& rhs ) const
28807 {
28808 return !operator==( rhs );
28809 }
28810
28811 private:
28813
28814 public:
28815 const void* pNext = nullptr;
28820 };
28821 static_assert( sizeof( DescriptorPoolCreateInfo ) == sizeof( VkDescriptorPoolCreateInfo ), "struct and wrapper have different size!" );
28822
28824 {
28830 };
28831
28833
28835 {
28836 return DependencyFlags( bit0 ) | bit1;
28837 }
28838
28840 {
28841 return ~( DependencyFlags( bits ) );
28842 }
28843
28844 template <> struct FlagTraits<DependencyFlagBits>
28845 {
28846 enum
28847 {
28850 };
28851
28853 {
28854 SubpassDependency( uint32_t srcSubpass_ = 0,
28855 uint32_t dstSubpass_ = 0,
28856 PipelineStageFlags srcStageMask_ = PipelineStageFlags(),
28857 PipelineStageFlags dstStageMask_ = PipelineStageFlags(),
28858 AccessFlags srcAccessMask_ = AccessFlags(),
28859 AccessFlags dstAccessMask_ = AccessFlags(),
28860 DependencyFlags dependencyFlags_ = DependencyFlags() )
28861 : srcSubpass( srcSubpass_ )
28862 , dstSubpass( dstSubpass_ )
28863 , srcStageMask( srcStageMask_ )
28864 , dstStageMask( dstStageMask_ )
28865 , srcAccessMask( srcAccessMask_ )
28866 , dstAccessMask( dstAccessMask_ )
28867 , dependencyFlags( dependencyFlags_ )
28868 {
28869 }
28870
28872 {
28873 memcpy( this, &rhs, sizeof( SubpassDependency ) );
28874 }
28875
28877 {
28878 memcpy( this, &rhs, sizeof( SubpassDependency ) );
28879 return *this;
28880 }
28882 {
28883 srcSubpass = srcSubpass_;
28884 return *this;
28885 }
28886
28888 {
28889 dstSubpass = dstSubpass_;
28890 return *this;
28891 }
28892
28894 {
28895 srcStageMask = srcStageMask_;
28896 return *this;
28897 }
28898
28900 {
28901 dstStageMask = dstStageMask_;
28902 return *this;
28903 }
28904
28906 {
28907 srcAccessMask = srcAccessMask_;
28908 return *this;
28909 }
28910
28912 {
28913 dstAccessMask = dstAccessMask_;
28914 return *this;
28915 }
28916
28918 {
28919 dependencyFlags = dependencyFlags_;
28920 return *this;
28921 }
28922
28923 operator VkSubpassDependency const&() const
28924 {
28925 return *reinterpret_cast<const VkSubpassDependency*>(this);
28926 }
28927
28929 {
28930 return *reinterpret_cast<VkSubpassDependency*>(this);
28931 }
28932
28933 bool operator==( SubpassDependency const& rhs ) const
28934 {
28935 return ( srcSubpass == rhs.srcSubpass )
28936 && ( dstSubpass == rhs.dstSubpass )
28937 && ( srcStageMask == rhs.srcStageMask )
28938 && ( dstStageMask == rhs.dstStageMask )
28939 && ( srcAccessMask == rhs.srcAccessMask )
28940 && ( dstAccessMask == rhs.dstAccessMask )
28941 && ( dependencyFlags == rhs.dependencyFlags );
28942 }
28943
28944 bool operator!=( SubpassDependency const& rhs ) const
28945 {
28946 return !operator==( rhs );
28947 }
28948
28956 };
28957 static_assert( sizeof( SubpassDependency ) == sizeof( VkSubpassDependency ), "struct and wrapper have different size!" );
28958
28960 {
28962 uint32_t dstSubpass_ = 0,
28963 PipelineStageFlags srcStageMask_ = PipelineStageFlags(),
28964 PipelineStageFlags dstStageMask_ = PipelineStageFlags(),
28965 AccessFlags srcAccessMask_ = AccessFlags(),
28966 AccessFlags dstAccessMask_ = AccessFlags(),
28967 DependencyFlags dependencyFlags_ = DependencyFlags(),
28968 int32_t viewOffset_ = 0 )
28969 : srcSubpass( srcSubpass_ )
28970 , dstSubpass( dstSubpass_ )
28971 , srcStageMask( srcStageMask_ )
28972 , dstStageMask( dstStageMask_ )
28973 , srcAccessMask( srcAccessMask_ )
28974 , dstAccessMask( dstAccessMask_ )
28975 , dependencyFlags( dependencyFlags_ )
28976 , viewOffset( viewOffset_ )
28977 {
28978 }
28979
28981 {
28982 memcpy( this, &rhs, sizeof( SubpassDependency2KHR ) );
28983 }
28984
28986 {
28987 memcpy( this, &rhs, sizeof( SubpassDependency2KHR ) );
28988 return *this;
28989 }
28990 SubpassDependency2KHR& setPNext( const void* pNext_ )
28991 {
28992 pNext = pNext_;
28993 return *this;
28994 }
28995
28997 {
28998 srcSubpass = srcSubpass_;
28999 return *this;
29000 }
29001
29003 {
29004 dstSubpass = dstSubpass_;
29005 return *this;
29006 }
29007
29009 {
29010 srcStageMask = srcStageMask_;
29011 return *this;
29012 }
29013
29015 {
29016 dstStageMask = dstStageMask_;
29017 return *this;
29018 }
29019
29021 {
29022 srcAccessMask = srcAccessMask_;
29023 return *this;
29024 }
29025
29027 {
29028 dstAccessMask = dstAccessMask_;
29029 return *this;
29030 }
29031
29033 {
29034 dependencyFlags = dependencyFlags_;
29035 return *this;
29036 }
29037
29039 {
29040 viewOffset = viewOffset_;
29041 return *this;
29042 }
29043
29044 operator VkSubpassDependency2KHR const&() const
29045 {
29046 return *reinterpret_cast<const VkSubpassDependency2KHR*>(this);
29047 }
29048
29050 {
29051 return *reinterpret_cast<VkSubpassDependency2KHR*>(this);
29052 }
29053
29054 bool operator==( SubpassDependency2KHR const& rhs ) const
29055 {
29056 return ( sType == rhs.sType )
29057 && ( pNext == rhs.pNext )
29058 && ( srcSubpass == rhs.srcSubpass )
29059 && ( dstSubpass == rhs.dstSubpass )
29060 && ( srcStageMask == rhs.srcStageMask )
29061 && ( dstStageMask == rhs.dstStageMask )
29062 && ( srcAccessMask == rhs.srcAccessMask )
29063 && ( dstAccessMask == rhs.dstAccessMask )
29064 && ( dependencyFlags == rhs.dependencyFlags )
29065 && ( viewOffset == rhs.viewOffset );
29066 }
29067
29068 bool operator!=( SubpassDependency2KHR const& rhs ) const
29069 {
29070 return !operator==( rhs );
29071 }
29072
29073 private:
29075
29076 public:
29077 const void* pNext = nullptr;
29086 };
29087 static_assert( sizeof( SubpassDependency2KHR ) == sizeof( VkSubpassDependency2KHR ), "struct and wrapper have different size!" );
29088
29090 {
29097 };
29098
29099 enum class ColorSpaceKHR
29100 {
29117 };
29118
29120 {
29121 operator VkSurfaceFormatKHR const&() const
29122 {
29123 return *reinterpret_cast<const VkSurfaceFormatKHR*>(this);
29124 }
29125
29127 {
29128 return *reinterpret_cast<VkSurfaceFormatKHR*>(this);
29129 }
29130
29131 bool operator==( SurfaceFormatKHR const& rhs ) const
29132 {
29133 return ( format == rhs.format )
29134 && ( colorSpace == rhs.colorSpace );
29135 }
29136
29137 bool operator!=( SurfaceFormatKHR const& rhs ) const
29138 {
29139 return !operator==( rhs );
29140 }
29141
29144 };
29145 static_assert( sizeof( SurfaceFormatKHR ) == sizeof( VkSurfaceFormatKHR ), "struct and wrapper have different size!" );
29146
29148 {
29149 operator VkSurfaceFormat2KHR const&() const
29150 {
29151 return *reinterpret_cast<const VkSurfaceFormat2KHR*>(this);
29152 }
29153
29155 {
29156 return *reinterpret_cast<VkSurfaceFormat2KHR*>(this);
29157 }
29158
29159 bool operator==( SurfaceFormat2KHR const& rhs ) const
29160 {
29161 return ( sType == rhs.sType )
29162 && ( pNext == rhs.pNext )
29163 && ( surfaceFormat == rhs.surfaceFormat );
29164 }
29165
29166 bool operator!=( SurfaceFormat2KHR const& rhs ) const
29167 {
29168 return !operator==( rhs );
29169 }
29170
29171 private:
29173
29174 public:
29175 void* pNext = nullptr;
29177 };
29178 static_assert( sizeof( SurfaceFormat2KHR ) == sizeof( VkSurfaceFormat2KHR ), "struct and wrapper have different size!" );
29179
29181 {
29186 };
29187
29189
29191 {
29192 return DisplayPlaneAlphaFlagsKHR( bit0 ) | bit1;
29193 }
29194
29196 {
29197 return ~( DisplayPlaneAlphaFlagsKHR( bits ) );
29198 }
29199
29201 {
29202 enum
29203 {
29206 };
29207
29209 {
29210 operator VkDisplayPlaneCapabilitiesKHR const&() const
29211 {
29212 return *reinterpret_cast<const VkDisplayPlaneCapabilitiesKHR*>(this);
29213 }
29214
29216 {
29217 return *reinterpret_cast<VkDisplayPlaneCapabilitiesKHR*>(this);
29218 }
29219
29221 {
29222 return ( supportedAlpha == rhs.supportedAlpha )
29223 && ( minSrcPosition == rhs.minSrcPosition )
29224 && ( maxSrcPosition == rhs.maxSrcPosition )
29225 && ( minSrcExtent == rhs.minSrcExtent )
29226 && ( maxSrcExtent == rhs.maxSrcExtent )
29227 && ( minDstPosition == rhs.minDstPosition )
29228 && ( maxDstPosition == rhs.maxDstPosition )
29229 && ( minDstExtent == rhs.minDstExtent )
29230 && ( maxDstExtent == rhs.maxDstExtent );
29231 }
29232
29234 {
29235 return !operator==( rhs );
29236 }
29237
29247 };
29248 static_assert( sizeof( DisplayPlaneCapabilitiesKHR ) == sizeof( VkDisplayPlaneCapabilitiesKHR ), "struct and wrapper have different size!" );
29249
29251 {
29252 operator VkDisplayPlaneCapabilities2KHR const&() const
29253 {
29254 return *reinterpret_cast<const VkDisplayPlaneCapabilities2KHR*>(this);
29255 }
29256
29258 {
29259 return *reinterpret_cast<VkDisplayPlaneCapabilities2KHR*>(this);
29260 }
29261
29263 {
29264 return ( sType == rhs.sType )
29265 && ( pNext == rhs.pNext )
29266 && ( capabilities == rhs.capabilities );
29267 }
29268
29270 {
29271 return !operator==( rhs );
29272 }
29273
29274 private:
29276
29277 public:
29278 void* pNext = nullptr;
29280 };
29281 static_assert( sizeof( DisplayPlaneCapabilities2KHR ) == sizeof( VkDisplayPlaneCapabilities2KHR ), "struct and wrapper have different size!" );
29282
29284 {
29289 };
29290
29292
29294 {
29295 return CompositeAlphaFlagsKHR( bit0 ) | bit1;
29296 }
29297
29299 {
29300 return ~( CompositeAlphaFlagsKHR( bits ) );
29301 }
29302
29304 {
29305 enum
29306 {
29309 };
29310
29312 {
29322 };
29323
29325
29327 {
29328 return SurfaceTransformFlagsKHR( bit0 ) | bit1;
29329 }
29330
29332 {
29333 return ~( SurfaceTransformFlagsKHR( bits ) );
29334 }
29335
29337 {
29338 enum
29339 {
29342 };
29343
29345 {
29346 operator VkDisplayPropertiesKHR const&() const
29347 {
29348 return *reinterpret_cast<const VkDisplayPropertiesKHR*>(this);
29349 }
29350
29352 {
29353 return *reinterpret_cast<VkDisplayPropertiesKHR*>(this);
29354 }
29355
29356 bool operator==( DisplayPropertiesKHR const& rhs ) const
29357 {
29358 return ( display == rhs.display )
29359 && ( displayName == rhs.displayName )
29365 }
29366
29367 bool operator!=( DisplayPropertiesKHR const& rhs ) const
29368 {
29369 return !operator==( rhs );
29370 }
29371
29373 const char* displayName;
29379 };
29380 static_assert( sizeof( DisplayPropertiesKHR ) == sizeof( VkDisplayPropertiesKHR ), "struct and wrapper have different size!" );
29381
29383 {
29385 DisplayModeKHR displayMode_ = DisplayModeKHR(),
29386 uint32_t planeIndex_ = 0,
29387 uint32_t planeStackIndex_ = 0,
29389 float globalAlpha_ = 0,
29391 Extent2D imageExtent_ = Extent2D() )
29392 : flags( flags_ )
29393 , displayMode( displayMode_ )
29394 , planeIndex( planeIndex_ )
29395 , planeStackIndex( planeStackIndex_ )
29396 , transform( transform_ )
29397 , globalAlpha( globalAlpha_ )
29398 , alphaMode( alphaMode_ )
29399 , imageExtent( imageExtent_ )
29400 {
29401 }
29402
29404 {
29405 memcpy( this, &rhs, sizeof( DisplaySurfaceCreateInfoKHR ) );
29406 }
29407
29409 {
29410 memcpy( this, &rhs, sizeof( DisplaySurfaceCreateInfoKHR ) );
29411 return *this;
29412 }
29414 {
29415 pNext = pNext_;
29416 return *this;
29417 }
29418
29420 {
29421 flags = flags_;
29422 return *this;
29423 }
29424
29426 {
29427 displayMode = displayMode_;
29428 return *this;
29429 }
29430
29432 {
29433 planeIndex = planeIndex_;
29434 return *this;
29435 }
29436
29438 {
29439 planeStackIndex = planeStackIndex_;
29440 return *this;
29441 }
29442
29444 {
29445 transform = transform_;
29446 return *this;
29447 }
29448
29450 {
29451 globalAlpha = globalAlpha_;
29452 return *this;
29453 }
29454
29456 {
29457 alphaMode = alphaMode_;
29458 return *this;
29459 }
29460
29462 {
29463 imageExtent = imageExtent_;
29464 return *this;
29465 }
29466
29467 operator VkDisplaySurfaceCreateInfoKHR const&() const
29468 {
29469 return *reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR*>(this);
29470 }
29471
29473 {
29474 return *reinterpret_cast<VkDisplaySurfaceCreateInfoKHR*>(this);
29475 }
29476
29478 {
29479 return ( sType == rhs.sType )
29480 && ( pNext == rhs.pNext )
29481 && ( flags == rhs.flags )
29482 && ( displayMode == rhs.displayMode )
29483 && ( planeIndex == rhs.planeIndex )
29484 && ( planeStackIndex == rhs.planeStackIndex )
29485 && ( transform == rhs.transform )
29486 && ( globalAlpha == rhs.globalAlpha )
29487 && ( alphaMode == rhs.alphaMode )
29488 && ( imageExtent == rhs.imageExtent );
29489 }
29490
29492 {
29493 return !operator==( rhs );
29494 }
29495
29496 private:
29498
29499 public:
29500 const void* pNext = nullptr;
29509 };
29510 static_assert( sizeof( DisplaySurfaceCreateInfoKHR ) == sizeof( VkDisplaySurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
29511
29513 {
29514 operator VkSurfaceCapabilitiesKHR const&() const
29515 {
29516 return *reinterpret_cast<const VkSurfaceCapabilitiesKHR*>(this);
29517 }
29518
29520 {
29521 return *reinterpret_cast<VkSurfaceCapabilitiesKHR*>(this);
29522 }
29523
29524 bool operator==( SurfaceCapabilitiesKHR const& rhs ) const
29525 {
29526 return ( minImageCount == rhs.minImageCount )
29527 && ( maxImageCount == rhs.maxImageCount )
29528 && ( currentExtent == rhs.currentExtent )
29529 && ( minImageExtent == rhs.minImageExtent )
29530 && ( maxImageExtent == rhs.maxImageExtent )
29536 }
29537
29538 bool operator!=( SurfaceCapabilitiesKHR const& rhs ) const
29539 {
29540 return !operator==( rhs );
29541 }
29542
29553 };
29554 static_assert( sizeof( SurfaceCapabilitiesKHR ) == sizeof( VkSurfaceCapabilitiesKHR ), "struct and wrapper have different size!" );
29555
29557 {
29558 operator VkSurfaceCapabilities2KHR const&() const
29559 {
29560 return *reinterpret_cast<const VkSurfaceCapabilities2KHR*>(this);
29561 }
29562
29564 {
29565 return *reinterpret_cast<VkSurfaceCapabilities2KHR*>(this);
29566 }
29567
29568 bool operator==( SurfaceCapabilities2KHR const& rhs ) const
29569 {
29570 return ( sType == rhs.sType )
29571 && ( pNext == rhs.pNext )
29573 }
29574
29575 bool operator!=( SurfaceCapabilities2KHR const& rhs ) const
29576 {
29577 return !operator==( rhs );
29578 }
29579
29580 private:
29582
29583 public:
29584 void* pNext = nullptr;
29586 };
29587 static_assert( sizeof( SurfaceCapabilities2KHR ) == sizeof( VkSurfaceCapabilities2KHR ), "struct and wrapper have different size!" );
29588
29590 {
29591 operator VkDisplayProperties2KHR const&() const
29592 {
29593 return *reinterpret_cast<const VkDisplayProperties2KHR*>(this);
29594 }
29595
29597 {
29598 return *reinterpret_cast<VkDisplayProperties2KHR*>(this);
29599 }
29600
29601 bool operator==( DisplayProperties2KHR const& rhs ) const
29602 {
29603 return ( sType == rhs.sType )
29604 && ( pNext == rhs.pNext )
29606 }
29607
29608 bool operator!=( DisplayProperties2KHR const& rhs ) const
29609 {
29610 return !operator==( rhs );
29611 }
29612
29613 private:
29615
29616 public:
29617 void* pNext = nullptr;
29619 };
29620 static_assert( sizeof( DisplayProperties2KHR ) == sizeof( VkDisplayProperties2KHR ), "struct and wrapper have different size!" );
29621
29622 enum class TimeDomainEXT
29623 {
29628 };
29629
29631 {
29633 : timeDomain( timeDomain_ )
29634 {
29635 }
29636
29638 {
29639 memcpy( this, &rhs, sizeof( CalibratedTimestampInfoEXT ) );
29640 }
29641
29643 {
29644 memcpy( this, &rhs, sizeof( CalibratedTimestampInfoEXT ) );
29645 return *this;
29646 }
29648 {
29649 pNext = pNext_;
29650 return *this;
29651 }
29652
29654 {
29655 timeDomain = timeDomain_;
29656 return *this;
29657 }
29658
29659 operator VkCalibratedTimestampInfoEXT const&() const
29660 {
29661 return *reinterpret_cast<const VkCalibratedTimestampInfoEXT*>(this);
29662 }
29663
29665 {
29666 return *reinterpret_cast<VkCalibratedTimestampInfoEXT*>(this);
29667 }
29668
29670 {
29671 return ( sType == rhs.sType )
29672 && ( pNext == rhs.pNext )
29673 && ( timeDomain == rhs.timeDomain );
29674 }
29675
29677 {
29678 return !operator==( rhs );
29679 }
29680
29681 private:
29683
29684 public:
29685 const void* pNext = nullptr;
29687 };
29688 static_assert( sizeof( CalibratedTimestampInfoEXT ) == sizeof( VkCalibratedTimestampInfoEXT ), "struct and wrapper have different size!" );
29689
29691 {
29697 };
29698
29700
29702 {
29703 return DebugReportFlagsEXT( bit0 ) | bit1;
29704 }
29705
29707 {
29708 return ~( DebugReportFlagsEXT( bits ) );
29709 }
29710
29712 {
29713 enum
29714 {
29717 };
29718
29720 {
29722 PFN_vkDebugReportCallbackEXT pfnCallback_ = nullptr,
29723 void* pUserData_ = nullptr )
29724 : flags( flags_ )
29725 , pfnCallback( pfnCallback_ )
29726 , pUserData( pUserData_ )
29727 {
29728 }
29729
29731 {
29732 memcpy( this, &rhs, sizeof( DebugReportCallbackCreateInfoEXT ) );
29733 }
29734
29736 {
29737 memcpy( this, &rhs, sizeof( DebugReportCallbackCreateInfoEXT ) );
29738 return *this;
29739 }
29741 {
29742 pNext = pNext_;
29743 return *this;
29744 }
29745
29747 {
29748 flags = flags_;
29749 return *this;
29750 }
29751
29753 {
29754 pfnCallback = pfnCallback_;
29755 return *this;
29756 }
29757
29759 {
29760 pUserData = pUserData_;
29761 return *this;
29762 }
29763
29765 {
29766 return *reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>(this);
29767 }
29768
29770 {
29771 return *reinterpret_cast<VkDebugReportCallbackCreateInfoEXT*>(this);
29772 }
29773
29775 {
29776 return ( sType == rhs.sType )
29777 && ( pNext == rhs.pNext )
29778 && ( flags == rhs.flags )
29779 && ( pfnCallback == rhs.pfnCallback )
29780 && ( pUserData == rhs.pUserData );
29781 }
29782
29784 {
29785 return !operator==( rhs );
29786 }
29787
29788 private:
29790
29791 public:
29792 const void* pNext = nullptr;
29796 };
29797 static_assert( sizeof( DebugReportCallbackCreateInfoEXT ) == sizeof( VkDebugReportCallbackCreateInfoEXT ), "struct and wrapper have different size!" );
29798
29800 {
29842 };
29843
29845 {
29847 uint64_t object_ = 0,
29848 const char* pObjectName_ = nullptr )
29849 : objectType( objectType_ )
29850 , object( object_ )
29851 , pObjectName( pObjectName_ )
29852 {
29853 }
29854
29856 {
29857 memcpy( this, &rhs, sizeof( DebugMarkerObjectNameInfoEXT ) );
29858 }
29859
29861 {
29862 memcpy( this, &rhs, sizeof( DebugMarkerObjectNameInfoEXT ) );
29863 return *this;
29864 }
29866 {
29867 pNext = pNext_;
29868 return *this;
29869 }
29870
29872 {
29873 objectType = objectType_;
29874 return *this;
29875 }
29876
29878 {
29879 object = object_;
29880 return *this;
29881 }
29882
29884 {
29885 pObjectName = pObjectName_;
29886 return *this;
29887 }
29888
29889 operator VkDebugMarkerObjectNameInfoEXT const&() const
29890 {
29891 return *reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT*>(this);
29892 }
29893
29895 {
29896 return *reinterpret_cast<VkDebugMarkerObjectNameInfoEXT*>(this);
29897 }
29898
29900 {
29901 return ( sType == rhs.sType )
29902 && ( pNext == rhs.pNext )
29903 && ( objectType == rhs.objectType )
29904 && ( object == rhs.object )
29905 && ( pObjectName == rhs.pObjectName );
29906 }
29907
29909 {
29910 return !operator==( rhs );
29911 }
29912
29913 private:
29915
29916 public:
29917 const void* pNext = nullptr;
29920 const char* pObjectName;
29921 };
29922 static_assert( sizeof( DebugMarkerObjectNameInfoEXT ) == sizeof( VkDebugMarkerObjectNameInfoEXT ), "struct and wrapper have different size!" );
29923
29925 {
29927 uint64_t object_ = 0,
29928 uint64_t tagName_ = 0,
29929 size_t tagSize_ = 0,
29930 const void* pTag_ = nullptr )
29931 : objectType( objectType_ )
29932 , object( object_ )
29933 , tagName( tagName_ )
29934 , tagSize( tagSize_ )
29935 , pTag( pTag_ )
29936 {
29937 }
29938
29940 {
29941 memcpy( this, &rhs, sizeof( DebugMarkerObjectTagInfoEXT ) );
29942 }
29943
29945 {
29946 memcpy( this, &rhs, sizeof( DebugMarkerObjectTagInfoEXT ) );
29947 return *this;
29948 }
29950 {
29951 pNext = pNext_;
29952 return *this;
29953 }
29954
29956 {
29957 objectType = objectType_;
29958 return *this;
29959 }
29960
29962 {
29963 object = object_;
29964 return *this;
29965 }
29966
29968 {
29969 tagName = tagName_;
29970 return *this;
29971 }
29972
29974 {
29975 tagSize = tagSize_;
29976 return *this;
29977 }
29978
29980 {
29981 pTag = pTag_;
29982 return *this;
29983 }
29984
29985 operator VkDebugMarkerObjectTagInfoEXT const&() const
29986 {
29987 return *reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT*>(this);
29988 }
29989
29991 {
29992 return *reinterpret_cast<VkDebugMarkerObjectTagInfoEXT*>(this);
29993 }
29994
29996 {
29997 return ( sType == rhs.sType )
29998 && ( pNext == rhs.pNext )
29999 && ( objectType == rhs.objectType )
30000 && ( object == rhs.object )
30001 && ( tagName == rhs.tagName )
30002 && ( tagSize == rhs.tagSize )
30003 && ( pTag == rhs.pTag );
30004 }
30005
30007 {
30008 return !operator==( rhs );
30009 }
30010
30011 private:
30013
30014 public:
30015 const void* pNext = nullptr;
30019 size_t tagSize;
30020 const void* pTag;
30021 };
30022 static_assert( sizeof( DebugMarkerObjectTagInfoEXT ) == sizeof( VkDebugMarkerObjectTagInfoEXT ), "struct and wrapper have different size!" );
30023
30025 {
30028 };
30029
30031 {
30033 : rasterizationOrder( rasterizationOrder_ )
30034 {
30035 }
30036
30038 {
30040 }
30041
30043 {
30045 return *this;
30046 }
30048 {
30049 pNext = pNext_;
30050 return *this;
30051 }
30052
30054 {
30055 rasterizationOrder = rasterizationOrder_;
30056 return *this;
30057 }
30058
30060 {
30061 return *reinterpret_cast<const VkPipelineRasterizationStateRasterizationOrderAMD*>(this);
30062 }
30063
30065 {
30066 return *reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD*>(this);
30067 }
30068
30070 {
30071 return ( sType == rhs.sType )
30072 && ( pNext == rhs.pNext )
30074 }
30075
30077 {
30078 return !operator==( rhs );
30079 }
30080
30081 private:
30083
30084 public:
30085 const void* pNext = nullptr;
30087 };
30088 static_assert( sizeof( PipelineRasterizationStateRasterizationOrderAMD ) == sizeof( VkPipelineRasterizationStateRasterizationOrderAMD ), "struct and wrapper have different size!" );
30089
30091 {
30096 };
30097
30099
30101 {
30102 return ExternalMemoryHandleTypeFlagsNV( bit0 ) | bit1;
30103 }
30104
30106 {
30108 }
30109
30111 {
30112 enum
30113 {
30116 };
30117
30119 {
30121 : handleTypes( handleTypes_ )
30122 {
30123 }
30124
30126 {
30127 memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfoNV ) );
30128 }
30129
30131 {
30132 memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfoNV ) );
30133 return *this;
30134 }
30136 {
30137 pNext = pNext_;
30138 return *this;
30139 }
30140
30142 {
30143 handleTypes = handleTypes_;
30144 return *this;
30145 }
30146
30148 {
30149 return *reinterpret_cast<const VkExternalMemoryImageCreateInfoNV*>(this);
30150 }
30151
30153 {
30154 return *reinterpret_cast<VkExternalMemoryImageCreateInfoNV*>(this);
30155 }
30156
30158 {
30159 return ( sType == rhs.sType )
30160 && ( pNext == rhs.pNext )
30161 && ( handleTypes == rhs.handleTypes );
30162 }
30163
30165 {
30166 return !operator==( rhs );
30167 }
30168
30169 private:
30171
30172 public:
30173 const void* pNext = nullptr;
30175 };
30176 static_assert( sizeof( ExternalMemoryImageCreateInfoNV ) == sizeof( VkExternalMemoryImageCreateInfoNV ), "struct and wrapper have different size!" );
30177
30179 {
30181 : handleTypes( handleTypes_ )
30182 {
30183 }
30184
30186 {
30187 memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfoNV ) );
30188 }
30189
30191 {
30192 memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfoNV ) );
30193 return *this;
30194 }
30196 {
30197 pNext = pNext_;
30198 return *this;
30199 }
30200
30202 {
30203 handleTypes = handleTypes_;
30204 return *this;
30205 }
30206
30207 operator VkExportMemoryAllocateInfoNV const&() const
30208 {
30209 return *reinterpret_cast<const VkExportMemoryAllocateInfoNV*>(this);
30210 }
30211
30213 {
30214 return *reinterpret_cast<VkExportMemoryAllocateInfoNV*>(this);
30215 }
30216
30218 {
30219 return ( sType == rhs.sType )
30220 && ( pNext == rhs.pNext )
30221 && ( handleTypes == rhs.handleTypes );
30222 }
30223
30225 {
30226 return !operator==( rhs );
30227 }
30228
30229 private:
30231
30232 public:
30233 const void* pNext = nullptr;
30235 };
30236 static_assert( sizeof( ExportMemoryAllocateInfoNV ) == sizeof( VkExportMemoryAllocateInfoNV ), "struct and wrapper have different size!" );
30237
30238#ifdef VK_USE_PLATFORM_WIN32_NV
30239 struct ImportMemoryWin32HandleInfoNV
30240 {
30241 ImportMemoryWin32HandleInfoNV( ExternalMemoryHandleTypeFlagsNV handleType_ = ExternalMemoryHandleTypeFlagsNV(),
30242 HANDLE handle_ = 0 )
30243 : handleType( handleType_ )
30244 , handle( handle_ )
30245 {
30246 }
30247
30248 ImportMemoryWin32HandleInfoNV( VkImportMemoryWin32HandleInfoNV const & rhs )
30249 {
30250 memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoNV ) );
30251 }
30252
30253 ImportMemoryWin32HandleInfoNV& operator=( VkImportMemoryWin32HandleInfoNV const & rhs )
30254 {
30255 memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoNV ) );
30256 return *this;
30257 }
30258 ImportMemoryWin32HandleInfoNV& setPNext( const void* pNext_ )
30259 {
30260 pNext = pNext_;
30261 return *this;
30262 }
30263
30264 ImportMemoryWin32HandleInfoNV& setHandleType( ExternalMemoryHandleTypeFlagsNV handleType_ )
30265 {
30266 handleType = handleType_;
30267 return *this;
30268 }
30269
30270 ImportMemoryWin32HandleInfoNV& setHandle( HANDLE handle_ )
30271 {
30272 handle = handle_;
30273 return *this;
30274 }
30275
30276 operator VkImportMemoryWin32HandleInfoNV const&() const
30277 {
30278 return *reinterpret_cast<const VkImportMemoryWin32HandleInfoNV*>(this);
30279 }
30280
30282 {
30283 return *reinterpret_cast<VkImportMemoryWin32HandleInfoNV*>(this);
30284 }
30285
30286 bool operator==( ImportMemoryWin32HandleInfoNV const& rhs ) const
30287 {
30288 return ( sType == rhs.sType )
30289 && ( pNext == rhs.pNext )
30290 && ( handleType == rhs.handleType )
30291 && ( handle == rhs.handle );
30292 }
30293
30294 bool operator!=( ImportMemoryWin32HandleInfoNV const& rhs ) const
30295 {
30296 return !operator==( rhs );
30297 }
30298
30299 private:
30301
30302 public:
30303 const void* pNext = nullptr;
30305 HANDLE handle;
30306 };
30307 static_assert( sizeof( ImportMemoryWin32HandleInfoNV ) == sizeof( VkImportMemoryWin32HandleInfoNV ), "struct and wrapper have different size!" );
30308#endif /*VK_USE_PLATFORM_WIN32_NV*/
30309
30311 {
30315 };
30316
30318
30320 {
30321 return ExternalMemoryFeatureFlagsNV( bit0 ) | bit1;
30322 }
30323
30325 {
30326 return ~( ExternalMemoryFeatureFlagsNV( bits ) );
30327 }
30328
30330 {
30331 enum
30332 {
30335 };
30336
30338 {
30340 {
30341 return *reinterpret_cast<const VkExternalImageFormatPropertiesNV*>(this);
30342 }
30343
30345 {
30346 return *reinterpret_cast<VkExternalImageFormatPropertiesNV*>(this);
30347 }
30348
30350 {
30355 }
30356
30358 {
30359 return !operator==( rhs );
30360 }
30361
30366 };
30367 static_assert( sizeof( ExternalImageFormatPropertiesNV ) == sizeof( VkExternalImageFormatPropertiesNV ), "struct and wrapper have different size!" );
30368
30370 {
30373 };
30374
30376 {
30377 ValidationFlagsEXT( uint32_t disabledValidationCheckCount_ = 0,
30378 const ValidationCheckEXT* pDisabledValidationChecks_ = nullptr )
30379 : disabledValidationCheckCount( disabledValidationCheckCount_ )
30380 , pDisabledValidationChecks( pDisabledValidationChecks_ )
30381 {
30382 }
30383
30385 {
30386 memcpy( this, &rhs, sizeof( ValidationFlagsEXT ) );
30387 }
30388
30390 {
30391 memcpy( this, &rhs, sizeof( ValidationFlagsEXT ) );
30392 return *this;
30393 }
30394 ValidationFlagsEXT& setPNext( const void* pNext_ )
30395 {
30396 pNext = pNext_;
30397 return *this;
30398 }
30399
30401 {
30402 disabledValidationCheckCount = disabledValidationCheckCount_;
30403 return *this;
30404 }
30405
30407 {
30408 pDisabledValidationChecks = pDisabledValidationChecks_;
30409 return *this;
30410 }
30411
30412 operator VkValidationFlagsEXT const&() const
30413 {
30414 return *reinterpret_cast<const VkValidationFlagsEXT*>(this);
30415 }
30416
30418 {
30419 return *reinterpret_cast<VkValidationFlagsEXT*>(this);
30420 }
30421
30422 bool operator==( ValidationFlagsEXT const& rhs ) const
30423 {
30424 return ( sType == rhs.sType )
30425 && ( pNext == rhs.pNext )
30428 }
30429
30430 bool operator!=( ValidationFlagsEXT const& rhs ) const
30431 {
30432 return !operator==( rhs );
30433 }
30434
30435 private:
30437
30438 public:
30439 const void* pNext = nullptr;
30442 };
30443 static_assert( sizeof( ValidationFlagsEXT ) == sizeof( VkValidationFlagsEXT ), "struct and wrapper have different size!" );
30444
30446 {
30456 };
30457
30459
30461 {
30462 return SubgroupFeatureFlags( bit0 ) | bit1;
30463 }
30464
30466 {
30467 return ~( SubgroupFeatureFlags( bits ) );
30468 }
30469
30471 {
30472 enum
30473 {
30476 };
30477
30479 {
30481 {
30482 return *reinterpret_cast<const VkPhysicalDeviceSubgroupProperties*>(this);
30483 }
30484
30486 {
30487 return *reinterpret_cast<VkPhysicalDeviceSubgroupProperties*>(this);
30488 }
30489
30491 {
30492 return ( sType == rhs.sType )
30493 && ( pNext == rhs.pNext )
30494 && ( subgroupSize == rhs.subgroupSize )
30495 && ( supportedStages == rhs.supportedStages )
30498 }
30499
30501 {
30502 return !operator==( rhs );
30503 }
30504
30505 private:
30507
30508 public:
30509 void* pNext = nullptr;
30514 };
30515 static_assert( sizeof( PhysicalDeviceSubgroupProperties ) == sizeof( VkPhysicalDeviceSubgroupProperties ), "struct and wrapper have different size!" );
30516
30518 {
30523 };
30524
30526
30528 {
30529 return IndirectCommandsLayoutUsageFlagsNVX( bit0 ) | bit1;
30530 }
30531
30533 {
30535 }
30536
30538 {
30539 enum
30540 {
30543 };
30544
30546 {
30549 };
30550
30552
30554 {
30555 return ObjectEntryUsageFlagsNVX( bit0 ) | bit1;
30556 }
30557
30559 {
30560 return ~( ObjectEntryUsageFlagsNVX( bits ) );
30561 }
30562
30564 {
30565 enum
30566 {
30569 };
30570
30572 {
30581 };
30582
30584 {
30586 Buffer buffer_ = Buffer(),
30587 DeviceSize offset_ = 0 )
30588 : tokenType( tokenType_ )
30589 , buffer( buffer_ )
30590 , offset( offset_ )
30591 {
30592 }
30593
30595 {
30596 memcpy( this, &rhs, sizeof( IndirectCommandsTokenNVX ) );
30597 }
30598
30600 {
30601 memcpy( this, &rhs, sizeof( IndirectCommandsTokenNVX ) );
30602 return *this;
30603 }
30605 {
30606 tokenType = tokenType_;
30607 return *this;
30608 }
30609
30611 {
30612 buffer = buffer_;
30613 return *this;
30614 }
30615
30617 {
30618 offset = offset_;
30619 return *this;
30620 }
30621
30622 operator VkIndirectCommandsTokenNVX const&() const
30623 {
30624 return *reinterpret_cast<const VkIndirectCommandsTokenNVX*>(this);
30625 }
30626
30628 {
30629 return *reinterpret_cast<VkIndirectCommandsTokenNVX*>(this);
30630 }
30631
30632 bool operator==( IndirectCommandsTokenNVX const& rhs ) const
30633 {
30634 return ( tokenType == rhs.tokenType )
30635 && ( buffer == rhs.buffer )
30636 && ( offset == rhs.offset );
30637 }
30638
30639 bool operator!=( IndirectCommandsTokenNVX const& rhs ) const
30640 {
30641 return !operator==( rhs );
30642 }
30643
30647 };
30648 static_assert( sizeof( IndirectCommandsTokenNVX ) == sizeof( VkIndirectCommandsTokenNVX ), "struct and wrapper have different size!" );
30649
30651 {
30653 uint32_t bindingUnit_ = 0,
30654 uint32_t dynamicCount_ = 0,
30655 uint32_t divisor_ = 0 )
30656 : tokenType( tokenType_ )
30657 , bindingUnit( bindingUnit_ )
30658 , dynamicCount( dynamicCount_ )
30659 , divisor( divisor_ )
30660 {
30661 }
30662
30664 {
30665 memcpy( this, &rhs, sizeof( IndirectCommandsLayoutTokenNVX ) );
30666 }
30667
30669 {
30670 memcpy( this, &rhs, sizeof( IndirectCommandsLayoutTokenNVX ) );
30671 return *this;
30672 }
30674 {
30675 tokenType = tokenType_;
30676 return *this;
30677 }
30678
30680 {
30681 bindingUnit = bindingUnit_;
30682 return *this;
30683 }
30684
30686 {
30687 dynamicCount = dynamicCount_;
30688 return *this;
30689 }
30690
30692 {
30693 divisor = divisor_;
30694 return *this;
30695 }
30696
30697 operator VkIndirectCommandsLayoutTokenNVX const&() const
30698 {
30699 return *reinterpret_cast<const VkIndirectCommandsLayoutTokenNVX*>(this);
30700 }
30701
30703 {
30704 return *reinterpret_cast<VkIndirectCommandsLayoutTokenNVX*>(this);
30705 }
30706
30708 {
30709 return ( tokenType == rhs.tokenType )
30710 && ( bindingUnit == rhs.bindingUnit )
30711 && ( dynamicCount == rhs.dynamicCount )
30712 && ( divisor == rhs.divisor );
30713 }
30714
30716 {
30717 return !operator==( rhs );
30718 }
30719
30724 };
30725 static_assert( sizeof( IndirectCommandsLayoutTokenNVX ) == sizeof( VkIndirectCommandsLayoutTokenNVX ), "struct and wrapper have different size!" );
30726
30728 {
30731 uint32_t tokenCount_ = 0,
30732 const IndirectCommandsLayoutTokenNVX* pTokens_ = nullptr )
30733 : pipelineBindPoint( pipelineBindPoint_ )
30734 , flags( flags_ )
30735 , tokenCount( tokenCount_ )
30736 , pTokens( pTokens_ )
30737 {
30738 }
30739
30741 {
30742 memcpy( this, &rhs, sizeof( IndirectCommandsLayoutCreateInfoNVX ) );
30743 }
30744
30746 {
30747 memcpy( this, &rhs, sizeof( IndirectCommandsLayoutCreateInfoNVX ) );
30748 return *this;
30749 }
30751 {
30752 pNext = pNext_;
30753 return *this;
30754 }
30755
30757 {
30758 pipelineBindPoint = pipelineBindPoint_;
30759 return *this;
30760 }
30761
30763 {
30764 flags = flags_;
30765 return *this;
30766 }
30767
30769 {
30770 tokenCount = tokenCount_;
30771 return *this;
30772 }
30773
30775 {
30776 pTokens = pTokens_;
30777 return *this;
30778 }
30779
30781 {
30782 return *reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNVX*>(this);
30783 }
30784
30786 {
30787 return *reinterpret_cast<VkIndirectCommandsLayoutCreateInfoNVX*>(this);
30788 }
30789
30791 {
30792 return ( sType == rhs.sType )
30793 && ( pNext == rhs.pNext )
30795 && ( flags == rhs.flags )
30796 && ( tokenCount == rhs.tokenCount )
30797 && ( pTokens == rhs.pTokens );
30798 }
30799
30801 {
30802 return !operator==( rhs );
30803 }
30804
30805 private:
30807
30808 public:
30809 const void* pNext = nullptr;
30814 };
30815 static_assert( sizeof( IndirectCommandsLayoutCreateInfoNVX ) == sizeof( VkIndirectCommandsLayoutCreateInfoNVX ), "struct and wrapper have different size!" );
30816
30818 {
30824 };
30825
30827 {
30829 const ObjectEntryTypeNVX* pObjectEntryTypes_ = nullptr,
30830 const uint32_t* pObjectEntryCounts_ = nullptr,
30831 const ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags_ = nullptr,
30832 uint32_t maxUniformBuffersPerDescriptor_ = 0,
30833 uint32_t maxStorageBuffersPerDescriptor_ = 0,
30834 uint32_t maxStorageImagesPerDescriptor_ = 0,
30835 uint32_t maxSampledImagesPerDescriptor_ = 0,
30836 uint32_t maxPipelineLayouts_ = 0 )
30837 : objectCount( objectCount_ )
30838 , pObjectEntryTypes( pObjectEntryTypes_ )
30839 , pObjectEntryCounts( pObjectEntryCounts_ )
30840 , pObjectEntryUsageFlags( pObjectEntryUsageFlags_ )
30841 , maxUniformBuffersPerDescriptor( maxUniformBuffersPerDescriptor_ )
30842 , maxStorageBuffersPerDescriptor( maxStorageBuffersPerDescriptor_ )
30843 , maxStorageImagesPerDescriptor( maxStorageImagesPerDescriptor_ )
30844 , maxSampledImagesPerDescriptor( maxSampledImagesPerDescriptor_ )
30845 , maxPipelineLayouts( maxPipelineLayouts_ )
30846 {
30847 }
30848
30850 {
30851 memcpy( this, &rhs, sizeof( ObjectTableCreateInfoNVX ) );
30852 }
30853
30855 {
30856 memcpy( this, &rhs, sizeof( ObjectTableCreateInfoNVX ) );
30857 return *this;
30858 }
30859 ObjectTableCreateInfoNVX& setPNext( const void* pNext_ )
30860 {
30861 pNext = pNext_;
30862 return *this;
30863 }
30864
30866 {
30867 objectCount = objectCount_;
30868 return *this;
30869 }
30870
30872 {
30873 pObjectEntryTypes = pObjectEntryTypes_;
30874 return *this;
30875 }
30876
30878 {
30879 pObjectEntryCounts = pObjectEntryCounts_;
30880 return *this;
30881 }
30882
30884 {
30885 pObjectEntryUsageFlags = pObjectEntryUsageFlags_;
30886 return *this;
30887 }
30888
30890 {
30891 maxUniformBuffersPerDescriptor = maxUniformBuffersPerDescriptor_;
30892 return *this;
30893 }
30894
30896 {
30897 maxStorageBuffersPerDescriptor = maxStorageBuffersPerDescriptor_;
30898 return *this;
30899 }
30900
30902 {
30903 maxStorageImagesPerDescriptor = maxStorageImagesPerDescriptor_;
30904 return *this;
30905 }
30906
30908 {
30909 maxSampledImagesPerDescriptor = maxSampledImagesPerDescriptor_;
30910 return *this;
30911 }
30912
30914 {
30915 maxPipelineLayouts = maxPipelineLayouts_;
30916 return *this;
30917 }
30918
30919 operator VkObjectTableCreateInfoNVX const&() const
30920 {
30921 return *reinterpret_cast<const VkObjectTableCreateInfoNVX*>(this);
30922 }
30923
30925 {
30926 return *reinterpret_cast<VkObjectTableCreateInfoNVX*>(this);
30927 }
30928
30929 bool operator==( ObjectTableCreateInfoNVX const& rhs ) const
30930 {
30931 return ( sType == rhs.sType )
30932 && ( pNext == rhs.pNext )
30933 && ( objectCount == rhs.objectCount )
30942 }
30943
30944 bool operator!=( ObjectTableCreateInfoNVX const& rhs ) const
30945 {
30946 return !operator==( rhs );
30947 }
30948
30949 private:
30951
30952 public:
30953 const void* pNext = nullptr;
30963 };
30964 static_assert( sizeof( ObjectTableCreateInfoNVX ) == sizeof( VkObjectTableCreateInfoNVX ), "struct and wrapper have different size!" );
30965
30967 {
30970 : type( type_ )
30971 , flags( flags_ )
30972 {
30973 }
30974
30976 {
30977 memcpy( this, &rhs, sizeof( ObjectTableEntryNVX ) );
30978 }
30979
30981 {
30982 memcpy( this, &rhs, sizeof( ObjectTableEntryNVX ) );
30983 return *this;
30984 }
30986 {
30987 type = type_;
30988 return *this;
30989 }
30990
30992 {
30993 flags = flags_;
30994 return *this;
30995 }
30996
30997 operator VkObjectTableEntryNVX const&() const
30998 {
30999 return *reinterpret_cast<const VkObjectTableEntryNVX*>(this);
31000 }
31001
31003 {
31004 return *reinterpret_cast<VkObjectTableEntryNVX*>(this);
31005 }
31006
31007 bool operator==( ObjectTableEntryNVX const& rhs ) const
31008 {
31009 return ( type == rhs.type )
31010 && ( flags == rhs.flags );
31011 }
31012
31013 bool operator!=( ObjectTableEntryNVX const& rhs ) const
31014 {
31015 return !operator==( rhs );
31016 }
31017
31020 };
31021 static_assert( sizeof( ObjectTableEntryNVX ) == sizeof( VkObjectTableEntryNVX ), "struct and wrapper have different size!" );
31022
31024 {
31027 Pipeline pipeline_ = Pipeline() )
31028 : type( type_ )
31029 , flags( flags_ )
31030 , pipeline( pipeline_ )
31031 {
31032 }
31033
31034 explicit ObjectTablePipelineEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX,
31035 Pipeline pipeline_ = Pipeline() )
31036 : type( objectTableEntryNVX.type )
31037 , flags( objectTableEntryNVX.flags )
31038 , pipeline( pipeline_ )
31039 {}
31040
31042 {
31043 memcpy( this, &rhs, sizeof( ObjectTablePipelineEntryNVX ) );
31044 }
31045
31047 {
31048 memcpy( this, &rhs, sizeof( ObjectTablePipelineEntryNVX ) );
31049 return *this;
31050 }
31052 {
31053 type = type_;
31054 return *this;
31055 }
31056
31058 {
31059 flags = flags_;
31060 return *this;
31061 }
31062
31064 {
31065 pipeline = pipeline_;
31066 return *this;
31067 }
31068
31069 operator VkObjectTablePipelineEntryNVX const&() const
31070 {
31071 return *reinterpret_cast<const VkObjectTablePipelineEntryNVX*>(this);
31072 }
31073
31075 {
31076 return *reinterpret_cast<VkObjectTablePipelineEntryNVX*>(this);
31077 }
31078
31080 {
31081 return ( type == rhs.type )
31082 && ( flags == rhs.flags )
31083 && ( pipeline == rhs.pipeline );
31084 }
31085
31087 {
31088 return !operator==( rhs );
31089 }
31090
31094 };
31095 static_assert( sizeof( ObjectTablePipelineEntryNVX ) == sizeof( VkObjectTablePipelineEntryNVX ), "struct and wrapper have different size!" );
31096
31098 {
31101 PipelineLayout pipelineLayout_ = PipelineLayout(),
31102 DescriptorSet descriptorSet_ = DescriptorSet() )
31103 : type( type_ )
31104 , flags( flags_ )
31105 , pipelineLayout( pipelineLayout_ )
31106 , descriptorSet( descriptorSet_ )
31107 {
31108 }
31109
31110 explicit ObjectTableDescriptorSetEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX,
31111 PipelineLayout pipelineLayout_ = PipelineLayout(),
31112 DescriptorSet descriptorSet_ = DescriptorSet() )
31113 : type( objectTableEntryNVX.type )
31114 , flags( objectTableEntryNVX.flags )
31115 , pipelineLayout( pipelineLayout_ )
31116 , descriptorSet( descriptorSet_ )
31117 {}
31118
31120 {
31121 memcpy( this, &rhs, sizeof( ObjectTableDescriptorSetEntryNVX ) );
31122 }
31123
31125 {
31126 memcpy( this, &rhs, sizeof( ObjectTableDescriptorSetEntryNVX ) );
31127 return *this;
31128 }
31130 {
31131 type = type_;
31132 return *this;
31133 }
31134
31136 {
31137 flags = flags_;
31138 return *this;
31139 }
31140
31142 {
31143 pipelineLayout = pipelineLayout_;
31144 return *this;
31145 }
31146
31148 {
31149 descriptorSet = descriptorSet_;
31150 return *this;
31151 }
31152
31154 {
31155 return *reinterpret_cast<const VkObjectTableDescriptorSetEntryNVX*>(this);
31156 }
31157
31159 {
31160 return *reinterpret_cast<VkObjectTableDescriptorSetEntryNVX*>(this);
31161 }
31162
31164 {
31165 return ( type == rhs.type )
31166 && ( flags == rhs.flags )
31167 && ( pipelineLayout == rhs.pipelineLayout )
31168 && ( descriptorSet == rhs.descriptorSet );
31169 }
31170
31172 {
31173 return !operator==( rhs );
31174 }
31175
31180 };
31181 static_assert( sizeof( ObjectTableDescriptorSetEntryNVX ) == sizeof( VkObjectTableDescriptorSetEntryNVX ), "struct and wrapper have different size!" );
31182
31184 {
31187 Buffer buffer_ = Buffer() )
31188 : type( type_ )
31189 , flags( flags_ )
31190 , buffer( buffer_ )
31191 {
31192 }
31193
31194 explicit ObjectTableVertexBufferEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX,
31195 Buffer buffer_ = Buffer() )
31196 : type( objectTableEntryNVX.type )
31197 , flags( objectTableEntryNVX.flags )
31198 , buffer( buffer_ )
31199 {}
31200
31202 {
31203 memcpy( this, &rhs, sizeof( ObjectTableVertexBufferEntryNVX ) );
31204 }
31205
31207 {
31208 memcpy( this, &rhs, sizeof( ObjectTableVertexBufferEntryNVX ) );
31209 return *this;
31210 }
31212 {
31213 type = type_;
31214 return *this;
31215 }
31216
31218 {
31219 flags = flags_;
31220 return *this;
31221 }
31222
31224 {
31225 buffer = buffer_;
31226 return *this;
31227 }
31228
31230 {
31231 return *reinterpret_cast<const VkObjectTableVertexBufferEntryNVX*>(this);
31232 }
31233
31235 {
31236 return *reinterpret_cast<VkObjectTableVertexBufferEntryNVX*>(this);
31237 }
31238
31240 {
31241 return ( type == rhs.type )
31242 && ( flags == rhs.flags )
31243 && ( buffer == rhs.buffer );
31244 }
31245
31247 {
31248 return !operator==( rhs );
31249 }
31250
31254 };
31255 static_assert( sizeof( ObjectTableVertexBufferEntryNVX ) == sizeof( VkObjectTableVertexBufferEntryNVX ), "struct and wrapper have different size!" );
31256
31258 {
31261 Buffer buffer_ = Buffer(),
31262 IndexType indexType_ = IndexType::eUint16 )
31263 : type( type_ )
31264 , flags( flags_ )
31265 , buffer( buffer_ )
31266 , indexType( indexType_ )
31267 {
31268 }
31269
31270 explicit ObjectTableIndexBufferEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX,
31271 Buffer buffer_ = Buffer(),
31272 IndexType indexType_ = IndexType::eUint16 )
31273 : type( objectTableEntryNVX.type )
31274 , flags( objectTableEntryNVX.flags )
31275 , buffer( buffer_ )
31276 , indexType( indexType_ )
31277 {}
31278
31280 {
31281 memcpy( this, &rhs, sizeof( ObjectTableIndexBufferEntryNVX ) );
31282 }
31283
31285 {
31286 memcpy( this, &rhs, sizeof( ObjectTableIndexBufferEntryNVX ) );
31287 return *this;
31288 }
31290 {
31291 type = type_;
31292 return *this;
31293 }
31294
31296 {
31297 flags = flags_;
31298 return *this;
31299 }
31300
31302 {
31303 buffer = buffer_;
31304 return *this;
31305 }
31306
31308 {
31309 indexType = indexType_;
31310 return *this;
31311 }
31312
31313 operator VkObjectTableIndexBufferEntryNVX const&() const
31314 {
31315 return *reinterpret_cast<const VkObjectTableIndexBufferEntryNVX*>(this);
31316 }
31317
31319 {
31320 return *reinterpret_cast<VkObjectTableIndexBufferEntryNVX*>(this);
31321 }
31322
31324 {
31325 return ( type == rhs.type )
31326 && ( flags == rhs.flags )
31327 && ( buffer == rhs.buffer )
31328 && ( indexType == rhs.indexType );
31329 }
31330
31332 {
31333 return !operator==( rhs );
31334 }
31335
31340 };
31341 static_assert( sizeof( ObjectTableIndexBufferEntryNVX ) == sizeof( VkObjectTableIndexBufferEntryNVX ), "struct and wrapper have different size!" );
31342
31344 {
31347 PipelineLayout pipelineLayout_ = PipelineLayout(),
31348 ShaderStageFlags stageFlags_ = ShaderStageFlags() )
31349 : type( type_ )
31350 , flags( flags_ )
31351 , pipelineLayout( pipelineLayout_ )
31352 , stageFlags( stageFlags_ )
31353 {
31354 }
31355
31356 explicit ObjectTablePushConstantEntryNVX( ObjectTableEntryNVX const& objectTableEntryNVX,
31357 PipelineLayout pipelineLayout_ = PipelineLayout(),
31358 ShaderStageFlags stageFlags_ = ShaderStageFlags() )
31359 : type( objectTableEntryNVX.type )
31360 , flags( objectTableEntryNVX.flags )
31361 , pipelineLayout( pipelineLayout_ )
31362 , stageFlags( stageFlags_ )
31363 {}
31364
31366 {
31367 memcpy( this, &rhs, sizeof( ObjectTablePushConstantEntryNVX ) );
31368 }
31369
31371 {
31372 memcpy( this, &rhs, sizeof( ObjectTablePushConstantEntryNVX ) );
31373 return *this;
31374 }
31376 {
31377 type = type_;
31378 return *this;
31379 }
31380
31382 {
31383 flags = flags_;
31384 return *this;
31385 }
31386
31388 {
31389 pipelineLayout = pipelineLayout_;
31390 return *this;
31391 }
31392
31394 {
31395 stageFlags = stageFlags_;
31396 return *this;
31397 }
31398
31400 {
31401 return *reinterpret_cast<const VkObjectTablePushConstantEntryNVX*>(this);
31402 }
31403
31405 {
31406 return *reinterpret_cast<VkObjectTablePushConstantEntryNVX*>(this);
31407 }
31408
31410 {
31411 return ( type == rhs.type )
31412 && ( flags == rhs.flags )
31413 && ( pipelineLayout == rhs.pipelineLayout )
31414 && ( stageFlags == rhs.stageFlags );
31415 }
31416
31418 {
31419 return !operator==( rhs );
31420 }
31421
31426 };
31427 static_assert( sizeof( ObjectTablePushConstantEntryNVX ) == sizeof( VkObjectTablePushConstantEntryNVX ), "struct and wrapper have different size!" );
31428
31430 {
31433 };
31434
31436
31438 {
31439 return DescriptorSetLayoutCreateFlags( bit0 ) | bit1;
31440 }
31441
31443 {
31444 return ~( DescriptorSetLayoutCreateFlags( bits ) );
31445 }
31446
31448 {
31449 enum
31450 {
31453 };
31454
31456 {
31458 uint32_t bindingCount_ = 0,
31459 const DescriptorSetLayoutBinding* pBindings_ = nullptr )
31460 : flags( flags_ )
31461 , bindingCount( bindingCount_ )
31462 , pBindings( pBindings_ )
31463 {
31464 }
31465
31467 {
31468 memcpy( this, &rhs, sizeof( DescriptorSetLayoutCreateInfo ) );
31469 }
31470
31472 {
31473 memcpy( this, &rhs, sizeof( DescriptorSetLayoutCreateInfo ) );
31474 return *this;
31475 }
31477 {
31478 pNext = pNext_;
31479 return *this;
31480 }
31481
31483 {
31484 flags = flags_;
31485 return *this;
31486 }
31487
31489 {
31490 bindingCount = bindingCount_;
31491 return *this;
31492 }
31493
31495 {
31496 pBindings = pBindings_;
31497 return *this;
31498 }
31499
31500 operator VkDescriptorSetLayoutCreateInfo const&() const
31501 {
31502 return *reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>(this);
31503 }
31504
31506 {
31507 return *reinterpret_cast<VkDescriptorSetLayoutCreateInfo*>(this);
31508 }
31509
31511 {
31512 return ( sType == rhs.sType )
31513 && ( pNext == rhs.pNext )
31514 && ( flags == rhs.flags )
31515 && ( bindingCount == rhs.bindingCount )
31516 && ( pBindings == rhs.pBindings );
31517 }
31518
31520 {
31521 return !operator==( rhs );
31522 }
31523
31524 private:
31526
31527 public:
31528 const void* pNext = nullptr;
31532 };
31533 static_assert( sizeof( DescriptorSetLayoutCreateInfo ) == sizeof( VkDescriptorSetLayoutCreateInfo ), "struct and wrapper have different size!" );
31534
31536 {
31555 };
31556
31558
31560 {
31561 return ExternalMemoryHandleTypeFlags( bit0 ) | bit1;
31562 }
31563
31565 {
31566 return ~( ExternalMemoryHandleTypeFlags( bits ) );
31567 }
31568
31570 {
31571 enum
31572 {
31575 };
31576
31578
31580 {
31582 : handleType( handleType_ )
31583 {
31584 }
31585
31587 {
31588 memcpy( this, &rhs, sizeof( PhysicalDeviceExternalImageFormatInfo ) );
31589 }
31590
31592 {
31593 memcpy( this, &rhs, sizeof( PhysicalDeviceExternalImageFormatInfo ) );
31594 return *this;
31595 }
31597 {
31598 pNext = pNext_;
31599 return *this;
31600 }
31601
31603 {
31604 handleType = handleType_;
31605 return *this;
31606 }
31607
31609 {
31610 return *reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfo*>(this);
31611 }
31612
31614 {
31615 return *reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo*>(this);
31616 }
31617
31619 {
31620 return ( sType == rhs.sType )
31621 && ( pNext == rhs.pNext )
31622 && ( handleType == rhs.handleType );
31623 }
31624
31626 {
31627 return !operator==( rhs );
31628 }
31629
31630 private:
31632
31633 public:
31634 const void* pNext = nullptr;
31636 };
31637 static_assert( sizeof( PhysicalDeviceExternalImageFormatInfo ) == sizeof( VkPhysicalDeviceExternalImageFormatInfo ), "struct and wrapper have different size!" );
31638
31640
31642 {
31646 : flags( flags_ )
31647 , usage( usage_ )
31648 , handleType( handleType_ )
31649 {
31650 }
31651
31653 {
31654 memcpy( this, &rhs, sizeof( PhysicalDeviceExternalBufferInfo ) );
31655 }
31656
31658 {
31659 memcpy( this, &rhs, sizeof( PhysicalDeviceExternalBufferInfo ) );
31660 return *this;
31661 }
31663 {
31664 pNext = pNext_;
31665 return *this;
31666 }
31667
31669 {
31670 flags = flags_;
31671 return *this;
31672 }
31673
31675 {
31676 usage = usage_;
31677 return *this;
31678 }
31679
31681 {
31682 handleType = handleType_;
31683 return *this;
31684 }
31685
31687 {
31688 return *reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo*>(this);
31689 }
31690
31692 {
31693 return *reinterpret_cast<VkPhysicalDeviceExternalBufferInfo*>(this);
31694 }
31695
31697 {
31698 return ( sType == rhs.sType )
31699 && ( pNext == rhs.pNext )
31700 && ( flags == rhs.flags )
31701 && ( usage == rhs.usage )
31702 && ( handleType == rhs.handleType );
31703 }
31704
31706 {
31707 return !operator==( rhs );
31708 }
31709
31710 private:
31712
31713 public:
31714 const void* pNext = nullptr;
31718 };
31719 static_assert( sizeof( PhysicalDeviceExternalBufferInfo ) == sizeof( VkPhysicalDeviceExternalBufferInfo ), "struct and wrapper have different size!" );
31720
31722
31724 {
31726 : handleTypes( handleTypes_ )
31727 {
31728 }
31729
31731 {
31732 memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfo ) );
31733 }
31734
31736 {
31737 memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfo ) );
31738 return *this;
31739 }
31741 {
31742 pNext = pNext_;
31743 return *this;
31744 }
31745
31747 {
31748 handleTypes = handleTypes_;
31749 return *this;
31750 }
31751
31752 operator VkExternalMemoryImageCreateInfo const&() const
31753 {
31754 return *reinterpret_cast<const VkExternalMemoryImageCreateInfo*>(this);
31755 }
31756
31758 {
31759 return *reinterpret_cast<VkExternalMemoryImageCreateInfo*>(this);
31760 }
31761
31763 {
31764 return ( sType == rhs.sType )
31765 && ( pNext == rhs.pNext )
31766 && ( handleTypes == rhs.handleTypes );
31767 }
31768
31770 {
31771 return !operator==( rhs );
31772 }
31773
31774 private:
31776
31777 public:
31778 const void* pNext = nullptr;
31780 };
31781 static_assert( sizeof( ExternalMemoryImageCreateInfo ) == sizeof( VkExternalMemoryImageCreateInfo ), "struct and wrapper have different size!" );
31782
31784
31786 {
31788 : handleTypes( handleTypes_ )
31789 {
31790 }
31791
31793 {
31794 memcpy( this, &rhs, sizeof( ExternalMemoryBufferCreateInfo ) );
31795 }
31796
31798 {
31799 memcpy( this, &rhs, sizeof( ExternalMemoryBufferCreateInfo ) );
31800 return *this;
31801 }
31803 {
31804 pNext = pNext_;
31805 return *this;
31806 }
31807
31809 {
31810 handleTypes = handleTypes_;
31811 return *this;
31812 }
31813
31814 operator VkExternalMemoryBufferCreateInfo const&() const
31815 {
31816 return *reinterpret_cast<const VkExternalMemoryBufferCreateInfo*>(this);
31817 }
31818
31820 {
31821 return *reinterpret_cast<VkExternalMemoryBufferCreateInfo*>(this);
31822 }
31823
31825 {
31826 return ( sType == rhs.sType )
31827 && ( pNext == rhs.pNext )
31828 && ( handleTypes == rhs.handleTypes );
31829 }
31830
31832 {
31833 return !operator==( rhs );
31834 }
31835
31836 private:
31838
31839 public:
31840 const void* pNext = nullptr;
31842 };
31843 static_assert( sizeof( ExternalMemoryBufferCreateInfo ) == sizeof( VkExternalMemoryBufferCreateInfo ), "struct and wrapper have different size!" );
31844
31846
31848 {
31850 : handleTypes( handleTypes_ )
31851 {
31852 }
31853
31855 {
31856 memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfo ) );
31857 }
31858
31860 {
31861 memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfo ) );
31862 return *this;
31863 }
31864 ExportMemoryAllocateInfo& setPNext( const void* pNext_ )
31865 {
31866 pNext = pNext_;
31867 return *this;
31868 }
31869
31871 {
31872 handleTypes = handleTypes_;
31873 return *this;
31874 }
31875
31876 operator VkExportMemoryAllocateInfo const&() const
31877 {
31878 return *reinterpret_cast<const VkExportMemoryAllocateInfo*>(this);
31879 }
31880
31882 {
31883 return *reinterpret_cast<VkExportMemoryAllocateInfo*>(this);
31884 }
31885
31886 bool operator==( ExportMemoryAllocateInfo const& rhs ) const
31887 {
31888 return ( sType == rhs.sType )
31889 && ( pNext == rhs.pNext )
31890 && ( handleTypes == rhs.handleTypes );
31891 }
31892
31893 bool operator!=( ExportMemoryAllocateInfo const& rhs ) const
31894 {
31895 return !operator==( rhs );
31896 }
31897
31898 private:
31900
31901 public:
31902 const void* pNext = nullptr;
31904 };
31905 static_assert( sizeof( ExportMemoryAllocateInfo ) == sizeof( VkExportMemoryAllocateInfo ), "struct and wrapper have different size!" );
31906
31908
31909#ifdef VK_USE_PLATFORM_WIN32_KHR
31910 struct ImportMemoryWin32HandleInfoKHR
31911 {
31912 ImportMemoryWin32HandleInfoKHR( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd,
31913 HANDLE handle_ = 0,
31914 LPCWSTR name_ = 0 )
31915 : handleType( handleType_ )
31916 , handle( handle_ )
31917 , name( name_ )
31918 {
31919 }
31920
31921 ImportMemoryWin32HandleInfoKHR( VkImportMemoryWin32HandleInfoKHR const & rhs )
31922 {
31923 memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoKHR ) );
31924 }
31925
31926 ImportMemoryWin32HandleInfoKHR& operator=( VkImportMemoryWin32HandleInfoKHR const & rhs )
31927 {
31928 memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoKHR ) );
31929 return *this;
31930 }
31931 ImportMemoryWin32HandleInfoKHR& setPNext( const void* pNext_ )
31932 {
31933 pNext = pNext_;
31934 return *this;
31935 }
31936
31937 ImportMemoryWin32HandleInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ )
31938 {
31939 handleType = handleType_;
31940 return *this;
31941 }
31942
31943 ImportMemoryWin32HandleInfoKHR& setHandle( HANDLE handle_ )
31944 {
31945 handle = handle_;
31946 return *this;
31947 }
31948
31949 ImportMemoryWin32HandleInfoKHR& setName( LPCWSTR name_ )
31950 {
31951 name = name_;
31952 return *this;
31953 }
31954
31955 operator VkImportMemoryWin32HandleInfoKHR const&() const
31956 {
31957 return *reinterpret_cast<const VkImportMemoryWin32HandleInfoKHR*>(this);
31958 }
31959
31961 {
31962 return *reinterpret_cast<VkImportMemoryWin32HandleInfoKHR*>(this);
31963 }
31964
31965 bool operator==( ImportMemoryWin32HandleInfoKHR const& rhs ) const
31966 {
31967 return ( sType == rhs.sType )
31968 && ( pNext == rhs.pNext )
31969 && ( handleType == rhs.handleType )
31970 && ( handle == rhs.handle )
31971 && ( name == rhs.name );
31972 }
31973
31974 bool operator!=( ImportMemoryWin32HandleInfoKHR const& rhs ) const
31975 {
31976 return !operator==( rhs );
31977 }
31978
31979 private:
31981
31982 public:
31983 const void* pNext = nullptr;
31985 HANDLE handle;
31986 LPCWSTR name;
31987 };
31988 static_assert( sizeof( ImportMemoryWin32HandleInfoKHR ) == sizeof( VkImportMemoryWin32HandleInfoKHR ), "struct and wrapper have different size!" );
31989#endif /*VK_USE_PLATFORM_WIN32_KHR*/
31990
31991#ifdef VK_USE_PLATFORM_WIN32_KHR
31992 struct MemoryGetWin32HandleInfoKHR
31993 {
31994 MemoryGetWin32HandleInfoKHR( DeviceMemory memory_ = DeviceMemory(),
31996 : memory( memory_ )
31997 , handleType( handleType_ )
31998 {
31999 }
32000
32001 MemoryGetWin32HandleInfoKHR( VkMemoryGetWin32HandleInfoKHR const & rhs )
32002 {
32003 memcpy( this, &rhs, sizeof( MemoryGetWin32HandleInfoKHR ) );
32004 }
32005
32006 MemoryGetWin32HandleInfoKHR& operator=( VkMemoryGetWin32HandleInfoKHR const & rhs )
32007 {
32008 memcpy( this, &rhs, sizeof( MemoryGetWin32HandleInfoKHR ) );
32009 return *this;
32010 }
32011 MemoryGetWin32HandleInfoKHR& setPNext( const void* pNext_ )
32012 {
32013 pNext = pNext_;
32014 return *this;
32015 }
32016
32017 MemoryGetWin32HandleInfoKHR& setMemory( DeviceMemory memory_ )
32018 {
32019 memory = memory_;
32020 return *this;
32021 }
32022
32023 MemoryGetWin32HandleInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ )
32024 {
32025 handleType = handleType_;
32026 return *this;
32027 }
32028
32029 operator VkMemoryGetWin32HandleInfoKHR const&() const
32030 {
32031 return *reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR*>(this);
32032 }
32033
32035 {
32036 return *reinterpret_cast<VkMemoryGetWin32HandleInfoKHR*>(this);
32037 }
32038
32039 bool operator==( MemoryGetWin32HandleInfoKHR const& rhs ) const
32040 {
32041 return ( sType == rhs.sType )
32042 && ( pNext == rhs.pNext )
32043 && ( memory == rhs.memory )
32044 && ( handleType == rhs.handleType );
32045 }
32046
32047 bool operator!=( MemoryGetWin32HandleInfoKHR const& rhs ) const
32048 {
32049 return !operator==( rhs );
32050 }
32051
32052 private:
32054
32055 public:
32056 const void* pNext = nullptr;
32057 DeviceMemory memory;
32059 };
32060 static_assert( sizeof( MemoryGetWin32HandleInfoKHR ) == sizeof( VkMemoryGetWin32HandleInfoKHR ), "struct and wrapper have different size!" );
32061#endif /*VK_USE_PLATFORM_WIN32_KHR*/
32062
32064 {
32066 int fd_ = 0 )
32067 : handleType( handleType_ )
32068 , fd( fd_ )
32069 {
32070 }
32071
32073 {
32074 memcpy( this, &rhs, sizeof( ImportMemoryFdInfoKHR ) );
32075 }
32076
32078 {
32079 memcpy( this, &rhs, sizeof( ImportMemoryFdInfoKHR ) );
32080 return *this;
32081 }
32082 ImportMemoryFdInfoKHR& setPNext( const void* pNext_ )
32083 {
32084 pNext = pNext_;
32085 return *this;
32086 }
32087
32089 {
32090 handleType = handleType_;
32091 return *this;
32092 }
32093
32095 {
32096 fd = fd_;
32097 return *this;
32098 }
32099
32100 operator VkImportMemoryFdInfoKHR const&() const
32101 {
32102 return *reinterpret_cast<const VkImportMemoryFdInfoKHR*>(this);
32103 }
32104
32106 {
32107 return *reinterpret_cast<VkImportMemoryFdInfoKHR*>(this);
32108 }
32109
32110 bool operator==( ImportMemoryFdInfoKHR const& rhs ) const
32111 {
32112 return ( sType == rhs.sType )
32113 && ( pNext == rhs.pNext )
32114 && ( handleType == rhs.handleType )
32115 && ( fd == rhs.fd );
32116 }
32117
32118 bool operator!=( ImportMemoryFdInfoKHR const& rhs ) const
32119 {
32120 return !operator==( rhs );
32121 }
32122
32123 private:
32125
32126 public:
32127 const void* pNext = nullptr;
32129 int fd;
32130 };
32131 static_assert( sizeof( ImportMemoryFdInfoKHR ) == sizeof( VkImportMemoryFdInfoKHR ), "struct and wrapper have different size!" );
32132
32134 {
32137 : memory( memory_ )
32138 , handleType( handleType_ )
32139 {
32140 }
32141
32143 {
32144 memcpy( this, &rhs, sizeof( MemoryGetFdInfoKHR ) );
32145 }
32146
32148 {
32149 memcpy( this, &rhs, sizeof( MemoryGetFdInfoKHR ) );
32150 return *this;
32151 }
32152 MemoryGetFdInfoKHR& setPNext( const void* pNext_ )
32153 {
32154 pNext = pNext_;
32155 return *this;
32156 }
32157
32159 {
32160 memory = memory_;
32161 return *this;
32162 }
32163
32165 {
32166 handleType = handleType_;
32167 return *this;
32168 }
32169
32170 operator VkMemoryGetFdInfoKHR const&() const
32171 {
32172 return *reinterpret_cast<const VkMemoryGetFdInfoKHR*>(this);
32173 }
32174
32176 {
32177 return *reinterpret_cast<VkMemoryGetFdInfoKHR*>(this);
32178 }
32179
32180 bool operator==( MemoryGetFdInfoKHR const& rhs ) const
32181 {
32182 return ( sType == rhs.sType )
32183 && ( pNext == rhs.pNext )
32184 && ( memory == rhs.memory )
32185 && ( handleType == rhs.handleType );
32186 }
32187
32188 bool operator!=( MemoryGetFdInfoKHR const& rhs ) const
32189 {
32190 return !operator==( rhs );
32191 }
32192
32193 private:
32195
32196 public:
32197 const void* pNext = nullptr;
32200 };
32201 static_assert( sizeof( MemoryGetFdInfoKHR ) == sizeof( VkMemoryGetFdInfoKHR ), "struct and wrapper have different size!" );
32202
32204 {
32206 void* pHostPointer_ = nullptr )
32207 : handleType( handleType_ )
32208 , pHostPointer( pHostPointer_ )
32209 {
32210 }
32211
32213 {
32214 memcpy( this, &rhs, sizeof( ImportMemoryHostPointerInfoEXT ) );
32215 }
32216
32218 {
32219 memcpy( this, &rhs, sizeof( ImportMemoryHostPointerInfoEXT ) );
32220 return *this;
32221 }
32223 {
32224 pNext = pNext_;
32225 return *this;
32226 }
32227
32229 {
32230 handleType = handleType_;
32231 return *this;
32232 }
32233
32235 {
32236 pHostPointer = pHostPointer_;
32237 return *this;
32238 }
32239
32240 operator VkImportMemoryHostPointerInfoEXT const&() const
32241 {
32242 return *reinterpret_cast<const VkImportMemoryHostPointerInfoEXT*>(this);
32243 }
32244
32246 {
32247 return *reinterpret_cast<VkImportMemoryHostPointerInfoEXT*>(this);
32248 }
32249
32251 {
32252 return ( sType == rhs.sType )
32253 && ( pNext == rhs.pNext )
32254 && ( handleType == rhs.handleType )
32255 && ( pHostPointer == rhs.pHostPointer );
32256 }
32257
32259 {
32260 return !operator==( rhs );
32261 }
32262
32263 private:
32265
32266 public:
32267 const void* pNext = nullptr;
32270 };
32271 static_assert( sizeof( ImportMemoryHostPointerInfoEXT ) == sizeof( VkImportMemoryHostPointerInfoEXT ), "struct and wrapper have different size!" );
32272
32274 {
32281 };
32282
32284
32286 {
32287 return ExternalMemoryFeatureFlags( bit0 ) | bit1;
32288 }
32289
32291 {
32292 return ~( ExternalMemoryFeatureFlags( bits ) );
32293 }
32294
32296 {
32297 enum
32298 {
32301 };
32302
32304
32306 {
32307 operator VkExternalMemoryProperties const&() const
32308 {
32309 return *reinterpret_cast<const VkExternalMemoryProperties*>(this);
32310 }
32311
32313 {
32314 return *reinterpret_cast<VkExternalMemoryProperties*>(this);
32315 }
32316
32317 bool operator==( ExternalMemoryProperties const& rhs ) const
32318 {
32322 }
32323
32324 bool operator!=( ExternalMemoryProperties const& rhs ) const
32325 {
32326 return !operator==( rhs );
32327 }
32328
32332 };
32333 static_assert( sizeof( ExternalMemoryProperties ) == sizeof( VkExternalMemoryProperties ), "struct and wrapper have different size!" );
32334
32336
32338 {
32339 operator VkExternalImageFormatProperties const&() const
32340 {
32341 return *reinterpret_cast<const VkExternalImageFormatProperties*>(this);
32342 }
32343
32345 {
32346 return *reinterpret_cast<VkExternalImageFormatProperties*>(this);
32347 }
32348
32350 {
32351 return ( sType == rhs.sType )
32352 && ( pNext == rhs.pNext )
32354 }
32355
32357 {
32358 return !operator==( rhs );
32359 }
32360
32361 private:
32363
32364 public:
32365 void* pNext = nullptr;
32367 };
32368 static_assert( sizeof( ExternalImageFormatProperties ) == sizeof( VkExternalImageFormatProperties ), "struct and wrapper have different size!" );
32369
32371
32373 {
32374 operator VkExternalBufferProperties const&() const
32375 {
32376 return *reinterpret_cast<const VkExternalBufferProperties*>(this);
32377 }
32378
32380 {
32381 return *reinterpret_cast<VkExternalBufferProperties*>(this);
32382 }
32383
32384 bool operator==( ExternalBufferProperties const& rhs ) const
32385 {
32386 return ( sType == rhs.sType )
32387 && ( pNext == rhs.pNext )
32389 }
32390
32391 bool operator!=( ExternalBufferProperties const& rhs ) const
32392 {
32393 return !operator==( rhs );
32394 }
32395
32396 private:
32398
32399 public:
32400 void* pNext = nullptr;
32402 };
32403 static_assert( sizeof( ExternalBufferProperties ) == sizeof( VkExternalBufferProperties ), "struct and wrapper have different size!" );
32404
32406
32408 {
32419 };
32420
32422
32424 {
32425 return ExternalSemaphoreHandleTypeFlags( bit0 ) | bit1;
32426 }
32427
32429 {
32431 }
32432
32434 {
32435 enum
32436 {
32439 };
32440
32442
32444 {
32446 : handleType( handleType_ )
32447 {
32448 }
32449
32451 {
32452 memcpy( this, &rhs, sizeof( PhysicalDeviceExternalSemaphoreInfo ) );
32453 }
32454
32456 {
32457 memcpy( this, &rhs, sizeof( PhysicalDeviceExternalSemaphoreInfo ) );
32458 return *this;
32459 }
32461 {
32462 pNext = pNext_;
32463 return *this;
32464 }
32465
32467 {
32468 handleType = handleType_;
32469 return *this;
32470 }
32471
32473 {
32474 return *reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo*>(this);
32475 }
32476
32478 {
32479 return *reinterpret_cast<VkPhysicalDeviceExternalSemaphoreInfo*>(this);
32480 }
32481
32483 {
32484 return ( sType == rhs.sType )
32485 && ( pNext == rhs.pNext )
32486 && ( handleType == rhs.handleType );
32487 }
32488
32490 {
32491 return !operator==( rhs );
32492 }
32493
32494 private:
32496
32497 public:
32498 const void* pNext = nullptr;
32500 };
32501 static_assert( sizeof( PhysicalDeviceExternalSemaphoreInfo ) == sizeof( VkPhysicalDeviceExternalSemaphoreInfo ), "struct and wrapper have different size!" );
32502
32504
32506 {
32508 : handleTypes( handleTypes_ )
32509 {
32510 }
32511
32513 {
32514 memcpy( this, &rhs, sizeof( ExportSemaphoreCreateInfo ) );
32515 }
32516
32518 {
32519 memcpy( this, &rhs, sizeof( ExportSemaphoreCreateInfo ) );
32520 return *this;
32521 }
32523 {
32524 pNext = pNext_;
32525 return *this;
32526 }
32527
32529 {
32530 handleTypes = handleTypes_;
32531 return *this;
32532 }
32533
32534 operator VkExportSemaphoreCreateInfo const&() const
32535 {
32536 return *reinterpret_cast<const VkExportSemaphoreCreateInfo*>(this);
32537 }
32538
32540 {
32541 return *reinterpret_cast<VkExportSemaphoreCreateInfo*>(this);
32542 }
32543
32544 bool operator==( ExportSemaphoreCreateInfo const& rhs ) const
32545 {
32546 return ( sType == rhs.sType )
32547 && ( pNext == rhs.pNext )
32548 && ( handleTypes == rhs.handleTypes );
32549 }
32550
32551 bool operator!=( ExportSemaphoreCreateInfo const& rhs ) const
32552 {
32553 return !operator==( rhs );
32554 }
32555
32556 private:
32558
32559 public:
32560 const void* pNext = nullptr;
32562 };
32563 static_assert( sizeof( ExportSemaphoreCreateInfo ) == sizeof( VkExportSemaphoreCreateInfo ), "struct and wrapper have different size!" );
32564
32566
32567#ifdef VK_USE_PLATFORM_WIN32_KHR
32568 struct SemaphoreGetWin32HandleInfoKHR
32569 {
32570 SemaphoreGetWin32HandleInfoKHR( Semaphore semaphore_ = Semaphore(),
32572 : semaphore( semaphore_ )
32573 , handleType( handleType_ )
32574 {
32575 }
32576
32577 SemaphoreGetWin32HandleInfoKHR( VkSemaphoreGetWin32HandleInfoKHR const & rhs )
32578 {
32579 memcpy( this, &rhs, sizeof( SemaphoreGetWin32HandleInfoKHR ) );
32580 }
32581
32582 SemaphoreGetWin32HandleInfoKHR& operator=( VkSemaphoreGetWin32HandleInfoKHR const & rhs )
32583 {
32584 memcpy( this, &rhs, sizeof( SemaphoreGetWin32HandleInfoKHR ) );
32585 return *this;
32586 }
32587 SemaphoreGetWin32HandleInfoKHR& setPNext( const void* pNext_ )
32588 {
32589 pNext = pNext_;
32590 return *this;
32591 }
32592
32593 SemaphoreGetWin32HandleInfoKHR& setSemaphore( Semaphore semaphore_ )
32594 {
32595 semaphore = semaphore_;
32596 return *this;
32597 }
32598
32599 SemaphoreGetWin32HandleInfoKHR& setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ )
32600 {
32601 handleType = handleType_;
32602 return *this;
32603 }
32604
32605 operator VkSemaphoreGetWin32HandleInfoKHR const&() const
32606 {
32607 return *reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR*>(this);
32608 }
32609
32611 {
32612 return *reinterpret_cast<VkSemaphoreGetWin32HandleInfoKHR*>(this);
32613 }
32614
32615 bool operator==( SemaphoreGetWin32HandleInfoKHR const& rhs ) const
32616 {
32617 return ( sType == rhs.sType )
32618 && ( pNext == rhs.pNext )
32619 && ( semaphore == rhs.semaphore )
32620 && ( handleType == rhs.handleType );
32621 }
32622
32623 bool operator!=( SemaphoreGetWin32HandleInfoKHR const& rhs ) const
32624 {
32625 return !operator==( rhs );
32626 }
32627
32628 private:
32630
32631 public:
32632 const void* pNext = nullptr;
32633 Semaphore semaphore;
32635 };
32636 static_assert( sizeof( SemaphoreGetWin32HandleInfoKHR ) == sizeof( VkSemaphoreGetWin32HandleInfoKHR ), "struct and wrapper have different size!" );
32637#endif /*VK_USE_PLATFORM_WIN32_KHR*/
32638
32640 {
32643 : semaphore( semaphore_ )
32644 , handleType( handleType_ )
32645 {
32646 }
32647
32649 {
32650 memcpy( this, &rhs, sizeof( SemaphoreGetFdInfoKHR ) );
32651 }
32652
32654 {
32655 memcpy( this, &rhs, sizeof( SemaphoreGetFdInfoKHR ) );
32656 return *this;
32657 }
32658 SemaphoreGetFdInfoKHR& setPNext( const void* pNext_ )
32659 {
32660 pNext = pNext_;
32661 return *this;
32662 }
32663
32665 {
32666 semaphore = semaphore_;
32667 return *this;
32668 }
32669
32671 {
32672 handleType = handleType_;
32673 return *this;
32674 }
32675
32676 operator VkSemaphoreGetFdInfoKHR const&() const
32677 {
32678 return *reinterpret_cast<const VkSemaphoreGetFdInfoKHR*>(this);
32679 }
32680
32682 {
32683 return *reinterpret_cast<VkSemaphoreGetFdInfoKHR*>(this);
32684 }
32685
32686 bool operator==( SemaphoreGetFdInfoKHR const& rhs ) const
32687 {
32688 return ( sType == rhs.sType )
32689 && ( pNext == rhs.pNext )
32690 && ( semaphore == rhs.semaphore )
32691 && ( handleType == rhs.handleType );
32692 }
32693
32694 bool operator!=( SemaphoreGetFdInfoKHR const& rhs ) const
32695 {
32696 return !operator==( rhs );
32697 }
32698
32699 private:
32701
32702 public:
32703 const void* pNext = nullptr;
32706 };
32707 static_assert( sizeof( SemaphoreGetFdInfoKHR ) == sizeof( VkSemaphoreGetFdInfoKHR ), "struct and wrapper have different size!" );
32708
32710 {
32715 };
32716
32718
32720 {
32721 return ExternalSemaphoreFeatureFlags( bit0 ) | bit1;
32722 }
32723
32725 {
32726 return ~( ExternalSemaphoreFeatureFlags( bits ) );
32727 }
32728
32730 {
32731 enum
32732 {
32735 };
32736
32738
32740 {
32741 operator VkExternalSemaphoreProperties const&() const
32742 {
32743 return *reinterpret_cast<const VkExternalSemaphoreProperties*>(this);
32744 }
32745
32747 {
32748 return *reinterpret_cast<VkExternalSemaphoreProperties*>(this);
32749 }
32750
32752 {
32753 return ( sType == rhs.sType )
32754 && ( pNext == rhs.pNext )
32758 }
32759
32761 {
32762 return !operator==( rhs );
32763 }
32764
32765 private:
32767
32768 public:
32769 void* pNext = nullptr;
32773 };
32774 static_assert( sizeof( ExternalSemaphoreProperties ) == sizeof( VkExternalSemaphoreProperties ), "struct and wrapper have different size!" );
32775
32777
32779 {
32782 };
32783
32785
32787 {
32788 return SemaphoreImportFlags( bit0 ) | bit1;
32789 }
32790
32792 {
32793 return ~( SemaphoreImportFlags( bits ) );
32794 }
32795
32797 {
32798 enum
32799 {
32802 };
32803
32805
32806#ifdef VK_USE_PLATFORM_WIN32_KHR
32807 struct ImportSemaphoreWin32HandleInfoKHR
32808 {
32809 ImportSemaphoreWin32HandleInfoKHR( Semaphore semaphore_ = Semaphore(),
32812 HANDLE handle_ = 0,
32813 LPCWSTR name_ = 0 )
32814 : semaphore( semaphore_ )
32815 , flags( flags_ )
32816 , handleType( handleType_ )
32817 , handle( handle_ )
32818 , name( name_ )
32819 {
32820 }
32821
32822 ImportSemaphoreWin32HandleInfoKHR( VkImportSemaphoreWin32HandleInfoKHR const & rhs )
32823 {
32824 memcpy( this, &rhs, sizeof( ImportSemaphoreWin32HandleInfoKHR ) );
32825 }
32826
32827 ImportSemaphoreWin32HandleInfoKHR& operator=( VkImportSemaphoreWin32HandleInfoKHR const & rhs )
32828 {
32829 memcpy( this, &rhs, sizeof( ImportSemaphoreWin32HandleInfoKHR ) );
32830 return *this;
32831 }
32832 ImportSemaphoreWin32HandleInfoKHR& setPNext( const void* pNext_ )
32833 {
32834 pNext = pNext_;
32835 return *this;
32836 }
32837
32838 ImportSemaphoreWin32HandleInfoKHR& setSemaphore( Semaphore semaphore_ )
32839 {
32840 semaphore = semaphore_;
32841 return *this;
32842 }
32843
32844 ImportSemaphoreWin32HandleInfoKHR& setFlags( SemaphoreImportFlags flags_ )
32845 {
32846 flags = flags_;
32847 return *this;
32848 }
32849
32850 ImportSemaphoreWin32HandleInfoKHR& setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ )
32851 {
32852 handleType = handleType_;
32853 return *this;
32854 }
32855
32856 ImportSemaphoreWin32HandleInfoKHR& setHandle( HANDLE handle_ )
32857 {
32858 handle = handle_;
32859 return *this;
32860 }
32861
32862 ImportSemaphoreWin32HandleInfoKHR& setName( LPCWSTR name_ )
32863 {
32864 name = name_;
32865 return *this;
32866 }
32867
32868 operator VkImportSemaphoreWin32HandleInfoKHR const&() const
32869 {
32870 return *reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR*>(this);
32871 }
32872
32874 {
32875 return *reinterpret_cast<VkImportSemaphoreWin32HandleInfoKHR*>(this);
32876 }
32877
32878 bool operator==( ImportSemaphoreWin32HandleInfoKHR const& rhs ) const
32879 {
32880 return ( sType == rhs.sType )
32881 && ( pNext == rhs.pNext )
32882 && ( semaphore == rhs.semaphore )
32883 && ( flags == rhs.flags )
32884 && ( handleType == rhs.handleType )
32885 && ( handle == rhs.handle )
32886 && ( name == rhs.name );
32887 }
32888
32889 bool operator!=( ImportSemaphoreWin32HandleInfoKHR const& rhs ) const
32890 {
32891 return !operator==( rhs );
32892 }
32893
32894 private:
32896
32897 public:
32898 const void* pNext = nullptr;
32899 Semaphore semaphore;
32902 HANDLE handle;
32903 LPCWSTR name;
32904 };
32905 static_assert( sizeof( ImportSemaphoreWin32HandleInfoKHR ) == sizeof( VkImportSemaphoreWin32HandleInfoKHR ), "struct and wrapper have different size!" );
32906#endif /*VK_USE_PLATFORM_WIN32_KHR*/
32907
32909 {
32913 int fd_ = 0 )
32914 : semaphore( semaphore_ )
32915 , flags( flags_ )
32916 , handleType( handleType_ )
32917 , fd( fd_ )
32918 {
32919 }
32920
32922 {
32923 memcpy( this, &rhs, sizeof( ImportSemaphoreFdInfoKHR ) );
32924 }
32925
32927 {
32928 memcpy( this, &rhs, sizeof( ImportSemaphoreFdInfoKHR ) );
32929 return *this;
32930 }
32931 ImportSemaphoreFdInfoKHR& setPNext( const void* pNext_ )
32932 {
32933 pNext = pNext_;
32934 return *this;
32935 }
32936
32938 {
32939 semaphore = semaphore_;
32940 return *this;
32941 }
32942
32944 {
32945 flags = flags_;
32946 return *this;
32947 }
32948
32950 {
32951 handleType = handleType_;
32952 return *this;
32953 }
32954
32956 {
32957 fd = fd_;
32958 return *this;
32959 }
32960
32961 operator VkImportSemaphoreFdInfoKHR const&() const
32962 {
32963 return *reinterpret_cast<const VkImportSemaphoreFdInfoKHR*>(this);
32964 }
32965
32967 {
32968 return *reinterpret_cast<VkImportSemaphoreFdInfoKHR*>(this);
32969 }
32970
32971 bool operator==( ImportSemaphoreFdInfoKHR const& rhs ) const
32972 {
32973 return ( sType == rhs.sType )
32974 && ( pNext == rhs.pNext )
32975 && ( semaphore == rhs.semaphore )
32976 && ( flags == rhs.flags )
32977 && ( handleType == rhs.handleType )
32978 && ( fd == rhs.fd );
32979 }
32980
32981 bool operator!=( ImportSemaphoreFdInfoKHR const& rhs ) const
32982 {
32983 return !operator==( rhs );
32984 }
32985
32986 private:
32988
32989 public:
32990 const void* pNext = nullptr;
32994 int fd;
32995 };
32996 static_assert( sizeof( ImportSemaphoreFdInfoKHR ) == sizeof( VkImportSemaphoreFdInfoKHR ), "struct and wrapper have different size!" );
32997
32999 {
33008 };
33009
33011
33013 {
33014 return ExternalFenceHandleTypeFlags( bit0 ) | bit1;
33015 }
33016
33018 {
33019 return ~( ExternalFenceHandleTypeFlags( bits ) );
33020 }
33021
33023 {
33024 enum
33025 {
33028 };
33029
33031
33033 {
33035 : handleType( handleType_ )
33036 {
33037 }
33038
33040 {
33041 memcpy( this, &rhs, sizeof( PhysicalDeviceExternalFenceInfo ) );
33042 }
33043
33045 {
33046 memcpy( this, &rhs, sizeof( PhysicalDeviceExternalFenceInfo ) );
33047 return *this;
33048 }
33050 {
33051 pNext = pNext_;
33052 return *this;
33053 }
33054
33056 {
33057 handleType = handleType_;
33058 return *this;
33059 }
33060
33062 {
33063 return *reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo*>(this);
33064 }
33065
33067 {
33068 return *reinterpret_cast<VkPhysicalDeviceExternalFenceInfo*>(this);
33069 }
33070
33072 {
33073 return ( sType == rhs.sType )
33074 && ( pNext == rhs.pNext )
33075 && ( handleType == rhs.handleType );
33076 }
33077
33079 {
33080 return !operator==( rhs );
33081 }
33082
33083 private:
33085
33086 public:
33087 const void* pNext = nullptr;
33089 };
33090 static_assert( sizeof( PhysicalDeviceExternalFenceInfo ) == sizeof( VkPhysicalDeviceExternalFenceInfo ), "struct and wrapper have different size!" );
33091
33093
33095 {
33097 : handleTypes( handleTypes_ )
33098 {
33099 }
33100
33102 {
33103 memcpy( this, &rhs, sizeof( ExportFenceCreateInfo ) );
33104 }
33105
33107 {
33108 memcpy( this, &rhs, sizeof( ExportFenceCreateInfo ) );
33109 return *this;
33110 }
33111 ExportFenceCreateInfo& setPNext( const void* pNext_ )
33112 {
33113 pNext = pNext_;
33114 return *this;
33115 }
33116
33118 {
33119 handleTypes = handleTypes_;
33120 return *this;
33121 }
33122
33123 operator VkExportFenceCreateInfo const&() const
33124 {
33125 return *reinterpret_cast<const VkExportFenceCreateInfo*>(this);
33126 }
33127
33129 {
33130 return *reinterpret_cast<VkExportFenceCreateInfo*>(this);
33131 }
33132
33133 bool operator==( ExportFenceCreateInfo const& rhs ) const
33134 {
33135 return ( sType == rhs.sType )
33136 && ( pNext == rhs.pNext )
33137 && ( handleTypes == rhs.handleTypes );
33138 }
33139
33140 bool operator!=( ExportFenceCreateInfo const& rhs ) const
33141 {
33142 return !operator==( rhs );
33143 }
33144
33145 private:
33147
33148 public:
33149 const void* pNext = nullptr;
33151 };
33152 static_assert( sizeof( ExportFenceCreateInfo ) == sizeof( VkExportFenceCreateInfo ), "struct and wrapper have different size!" );
33153
33155
33156#ifdef VK_USE_PLATFORM_WIN32_KHR
33157 struct FenceGetWin32HandleInfoKHR
33158 {
33159 FenceGetWin32HandleInfoKHR( Fence fence_ = Fence(),
33161 : fence( fence_ )
33162 , handleType( handleType_ )
33163 {
33164 }
33165
33166 FenceGetWin32HandleInfoKHR( VkFenceGetWin32HandleInfoKHR const & rhs )
33167 {
33168 memcpy( this, &rhs, sizeof( FenceGetWin32HandleInfoKHR ) );
33169 }
33170
33171 FenceGetWin32HandleInfoKHR& operator=( VkFenceGetWin32HandleInfoKHR const & rhs )
33172 {
33173 memcpy( this, &rhs, sizeof( FenceGetWin32HandleInfoKHR ) );
33174 return *this;
33175 }
33176 FenceGetWin32HandleInfoKHR& setPNext( const void* pNext_ )
33177 {
33178 pNext = pNext_;
33179 return *this;
33180 }
33181
33182 FenceGetWin32HandleInfoKHR& setFence( Fence fence_ )
33183 {
33184 fence = fence_;
33185 return *this;
33186 }
33187
33188 FenceGetWin32HandleInfoKHR& setHandleType( ExternalFenceHandleTypeFlagBits handleType_ )
33189 {
33190 handleType = handleType_;
33191 return *this;
33192 }
33193
33194 operator VkFenceGetWin32HandleInfoKHR const&() const
33195 {
33196 return *reinterpret_cast<const VkFenceGetWin32HandleInfoKHR*>(this);
33197 }
33198
33199 operator VkFenceGetWin32HandleInfoKHR &()
33200 {
33201 return *reinterpret_cast<VkFenceGetWin32HandleInfoKHR*>(this);
33202 }
33203
33204 bool operator==( FenceGetWin32HandleInfoKHR const& rhs ) const
33205 {
33206 return ( sType == rhs.sType )
33207 && ( pNext == rhs.pNext )
33208 && ( fence == rhs.fence )
33209 && ( handleType == rhs.handleType );
33210 }
33211
33212 bool operator!=( FenceGetWin32HandleInfoKHR const& rhs ) const
33213 {
33214 return !operator==( rhs );
33215 }
33216
33217 private:
33219
33220 public:
33221 const void* pNext = nullptr;
33222 Fence fence;
33224 };
33225 static_assert( sizeof( FenceGetWin32HandleInfoKHR ) == sizeof( VkFenceGetWin32HandleInfoKHR ), "struct and wrapper have different size!" );
33226#endif /*VK_USE_PLATFORM_WIN32_KHR*/
33227
33229 {
33232 : fence( fence_ )
33233 , handleType( handleType_ )
33234 {
33235 }
33236
33238 {
33239 memcpy( this, &rhs, sizeof( FenceGetFdInfoKHR ) );
33240 }
33241
33243 {
33244 memcpy( this, &rhs, sizeof( FenceGetFdInfoKHR ) );
33245 return *this;
33246 }
33247 FenceGetFdInfoKHR& setPNext( const void* pNext_ )
33248 {
33249 pNext = pNext_;
33250 return *this;
33251 }
33252
33254 {
33255 fence = fence_;
33256 return *this;
33257 }
33258
33260 {
33261 handleType = handleType_;
33262 return *this;
33263 }
33264
33265 operator VkFenceGetFdInfoKHR const&() const
33266 {
33267 return *reinterpret_cast<const VkFenceGetFdInfoKHR*>(this);
33268 }
33269
33271 {
33272 return *reinterpret_cast<VkFenceGetFdInfoKHR*>(this);
33273 }
33274
33275 bool operator==( FenceGetFdInfoKHR const& rhs ) const
33276 {
33277 return ( sType == rhs.sType )
33278 && ( pNext == rhs.pNext )
33279 && ( fence == rhs.fence )
33280 && ( handleType == rhs.handleType );
33281 }
33282
33283 bool operator!=( FenceGetFdInfoKHR const& rhs ) const
33284 {
33285 return !operator==( rhs );
33286 }
33287
33288 private:
33290
33291 public:
33292 const void* pNext = nullptr;
33295 };
33296 static_assert( sizeof( FenceGetFdInfoKHR ) == sizeof( VkFenceGetFdInfoKHR ), "struct and wrapper have different size!" );
33297
33299 {
33304 };
33305
33307
33309 {
33310 return ExternalFenceFeatureFlags( bit0 ) | bit1;
33311 }
33312
33314 {
33315 return ~( ExternalFenceFeatureFlags( bits ) );
33316 }
33317
33319 {
33320 enum
33321 {
33324 };
33325
33327
33329 {
33330 operator VkExternalFenceProperties const&() const
33331 {
33332 return *reinterpret_cast<const VkExternalFenceProperties*>(this);
33333 }
33334
33336 {
33337 return *reinterpret_cast<VkExternalFenceProperties*>(this);
33338 }
33339
33340 bool operator==( ExternalFenceProperties const& rhs ) const
33341 {
33342 return ( sType == rhs.sType )
33343 && ( pNext == rhs.pNext )
33347 }
33348
33349 bool operator!=( ExternalFenceProperties const& rhs ) const
33350 {
33351 return !operator==( rhs );
33352 }
33353
33354 private:
33356
33357 public:
33358 void* pNext = nullptr;
33362 };
33363 static_assert( sizeof( ExternalFenceProperties ) == sizeof( VkExternalFenceProperties ), "struct and wrapper have different size!" );
33364
33366
33368 {
33371 };
33372
33374
33376 {
33377 return FenceImportFlags( bit0 ) | bit1;
33378 }
33379
33381 {
33382 return ~( FenceImportFlags( bits ) );
33383 }
33384
33386 {
33387 enum
33388 {
33391 };
33392
33394
33395#ifdef VK_USE_PLATFORM_WIN32_KHR
33396 struct ImportFenceWin32HandleInfoKHR
33397 {
33398 ImportFenceWin32HandleInfoKHR( Fence fence_ = Fence(),
33401 HANDLE handle_ = 0,
33402 LPCWSTR name_ = 0 )
33403 : fence( fence_ )
33404 , flags( flags_ )
33405 , handleType( handleType_ )
33406 , handle( handle_ )
33407 , name( name_ )
33408 {
33409 }
33410
33411 ImportFenceWin32HandleInfoKHR( VkImportFenceWin32HandleInfoKHR const & rhs )
33412 {
33413 memcpy( this, &rhs, sizeof( ImportFenceWin32HandleInfoKHR ) );
33414 }
33415
33416 ImportFenceWin32HandleInfoKHR& operator=( VkImportFenceWin32HandleInfoKHR const & rhs )
33417 {
33418 memcpy( this, &rhs, sizeof( ImportFenceWin32HandleInfoKHR ) );
33419 return *this;
33420 }
33421 ImportFenceWin32HandleInfoKHR& setPNext( const void* pNext_ )
33422 {
33423 pNext = pNext_;
33424 return *this;
33425 }
33426
33427 ImportFenceWin32HandleInfoKHR& setFence( Fence fence_ )
33428 {
33429 fence = fence_;
33430 return *this;
33431 }
33432
33433 ImportFenceWin32HandleInfoKHR& setFlags( FenceImportFlags flags_ )
33434 {
33435 flags = flags_;
33436 return *this;
33437 }
33438
33439 ImportFenceWin32HandleInfoKHR& setHandleType( ExternalFenceHandleTypeFlagBits handleType_ )
33440 {
33441 handleType = handleType_;
33442 return *this;
33443 }
33444
33445 ImportFenceWin32HandleInfoKHR& setHandle( HANDLE handle_ )
33446 {
33447 handle = handle_;
33448 return *this;
33449 }
33450
33451 ImportFenceWin32HandleInfoKHR& setName( LPCWSTR name_ )
33452 {
33453 name = name_;
33454 return *this;
33455 }
33456
33457 operator VkImportFenceWin32HandleInfoKHR const&() const
33458 {
33459 return *reinterpret_cast<const VkImportFenceWin32HandleInfoKHR*>(this);
33460 }
33461
33463 {
33464 return *reinterpret_cast<VkImportFenceWin32HandleInfoKHR*>(this);
33465 }
33466
33467 bool operator==( ImportFenceWin32HandleInfoKHR const& rhs ) const
33468 {
33469 return ( sType == rhs.sType )
33470 && ( pNext == rhs.pNext )
33471 && ( fence == rhs.fence )
33472 && ( flags == rhs.flags )
33473 && ( handleType == rhs.handleType )
33474 && ( handle == rhs.handle )
33475 && ( name == rhs.name );
33476 }
33477
33478 bool operator!=( ImportFenceWin32HandleInfoKHR const& rhs ) const
33479 {
33480 return !operator==( rhs );
33481 }
33482
33483 private:
33485
33486 public:
33487 const void* pNext = nullptr;
33488 Fence fence;
33491 HANDLE handle;
33492 LPCWSTR name;
33493 };
33494 static_assert( sizeof( ImportFenceWin32HandleInfoKHR ) == sizeof( VkImportFenceWin32HandleInfoKHR ), "struct and wrapper have different size!" );
33495#endif /*VK_USE_PLATFORM_WIN32_KHR*/
33496
33498 {
33502 int fd_ = 0 )
33503 : fence( fence_ )
33504 , flags( flags_ )
33505 , handleType( handleType_ )
33506 , fd( fd_ )
33507 {
33508 }
33509
33511 {
33512 memcpy( this, &rhs, sizeof( ImportFenceFdInfoKHR ) );
33513 }
33514
33516 {
33517 memcpy( this, &rhs, sizeof( ImportFenceFdInfoKHR ) );
33518 return *this;
33519 }
33520 ImportFenceFdInfoKHR& setPNext( const void* pNext_ )
33521 {
33522 pNext = pNext_;
33523 return *this;
33524 }
33525
33527 {
33528 fence = fence_;
33529 return *this;
33530 }
33531
33533 {
33534 flags = flags_;
33535 return *this;
33536 }
33537
33539 {
33540 handleType = handleType_;
33541 return *this;
33542 }
33543
33545 {
33546 fd = fd_;
33547 return *this;
33548 }
33549
33550 operator VkImportFenceFdInfoKHR const&() const
33551 {
33552 return *reinterpret_cast<const VkImportFenceFdInfoKHR*>(this);
33553 }
33554
33556 {
33557 return *reinterpret_cast<VkImportFenceFdInfoKHR*>(this);
33558 }
33559
33560 bool operator==( ImportFenceFdInfoKHR const& rhs ) const
33561 {
33562 return ( sType == rhs.sType )
33563 && ( pNext == rhs.pNext )
33564 && ( fence == rhs.fence )
33565 && ( flags == rhs.flags )
33566 && ( handleType == rhs.handleType )
33567 && ( fd == rhs.fd );
33568 }
33569
33570 bool operator!=( ImportFenceFdInfoKHR const& rhs ) const
33571 {
33572 return !operator==( rhs );
33573 }
33574
33575 private:
33577
33578 public:
33579 const void* pNext = nullptr;
33583 int fd;
33584 };
33585 static_assert( sizeof( ImportFenceFdInfoKHR ) == sizeof( VkImportFenceFdInfoKHR ), "struct and wrapper have different size!" );
33586
33588 {
33590 };
33591
33593
33595 {
33596 return SurfaceCounterFlagsEXT( bit0 ) | bit1;
33597 }
33598
33600 {
33601 return ~( SurfaceCounterFlagsEXT( bits ) );
33602 }
33603
33605 {
33606 enum
33607 {
33610 };
33611
33613 {
33614 operator VkSurfaceCapabilities2EXT const&() const
33615 {
33616 return *reinterpret_cast<const VkSurfaceCapabilities2EXT*>(this);
33617 }
33618
33620 {
33621 return *reinterpret_cast<VkSurfaceCapabilities2EXT*>(this);
33622 }
33623
33624 bool operator==( SurfaceCapabilities2EXT const& rhs ) const
33625 {
33626 return ( sType == rhs.sType )
33627 && ( pNext == rhs.pNext )
33628 && ( minImageCount == rhs.minImageCount )
33629 && ( maxImageCount == rhs.maxImageCount )
33630 && ( currentExtent == rhs.currentExtent )
33631 && ( minImageExtent == rhs.minImageExtent )
33632 && ( maxImageExtent == rhs.maxImageExtent )
33639 }
33640
33641 bool operator!=( SurfaceCapabilities2EXT const& rhs ) const
33642 {
33643 return !operator==( rhs );
33644 }
33645
33646 private:
33648
33649 public:
33650 void* pNext = nullptr;
33662 };
33663 static_assert( sizeof( SurfaceCapabilities2EXT ) == sizeof( VkSurfaceCapabilities2EXT ), "struct and wrapper have different size!" );
33664
33666 {
33668 : surfaceCounters( surfaceCounters_ )
33669 {
33670 }
33671
33673 {
33674 memcpy( this, &rhs, sizeof( SwapchainCounterCreateInfoEXT ) );
33675 }
33676
33678 {
33679 memcpy( this, &rhs, sizeof( SwapchainCounterCreateInfoEXT ) );
33680 return *this;
33681 }
33683 {
33684 pNext = pNext_;
33685 return *this;
33686 }
33687
33689 {
33690 surfaceCounters = surfaceCounters_;
33691 return *this;
33692 }
33693
33694 operator VkSwapchainCounterCreateInfoEXT const&() const
33695 {
33696 return *reinterpret_cast<const VkSwapchainCounterCreateInfoEXT*>(this);
33697 }
33698
33700 {
33701 return *reinterpret_cast<VkSwapchainCounterCreateInfoEXT*>(this);
33702 }
33703
33705 {
33706 return ( sType == rhs.sType )
33707 && ( pNext == rhs.pNext )
33708 && ( surfaceCounters == rhs.surfaceCounters );
33709 }
33710
33712 {
33713 return !operator==( rhs );
33714 }
33715
33716 private:
33718
33719 public:
33720 const void* pNext = nullptr;
33722 };
33723 static_assert( sizeof( SwapchainCounterCreateInfoEXT ) == sizeof( VkSwapchainCounterCreateInfoEXT ), "struct and wrapper have different size!" );
33724
33726 {
33730 };
33731
33733 {
33735 : powerState( powerState_ )
33736 {
33737 }
33738
33740 {
33741 memcpy( this, &rhs, sizeof( DisplayPowerInfoEXT ) );
33742 }
33743
33745 {
33746 memcpy( this, &rhs, sizeof( DisplayPowerInfoEXT ) );
33747 return *this;
33748 }
33749 DisplayPowerInfoEXT& setPNext( const void* pNext_ )
33750 {
33751 pNext = pNext_;
33752 return *this;
33753 }
33754
33756 {
33757 powerState = powerState_;
33758 return *this;
33759 }
33760
33761 operator VkDisplayPowerInfoEXT const&() const
33762 {
33763 return *reinterpret_cast<const VkDisplayPowerInfoEXT*>(this);
33764 }
33765
33767 {
33768 return *reinterpret_cast<VkDisplayPowerInfoEXT*>(this);
33769 }
33770
33771 bool operator==( DisplayPowerInfoEXT const& rhs ) const
33772 {
33773 return ( sType == rhs.sType )
33774 && ( pNext == rhs.pNext )
33775 && ( powerState == rhs.powerState );
33776 }
33777
33778 bool operator!=( DisplayPowerInfoEXT const& rhs ) const
33779 {
33780 return !operator==( rhs );
33781 }
33782
33783 private:
33785
33786 public:
33787 const void* pNext = nullptr;
33789 };
33790 static_assert( sizeof( DisplayPowerInfoEXT ) == sizeof( VkDisplayPowerInfoEXT ), "struct and wrapper have different size!" );
33791
33793 {
33795 };
33796
33798 {
33800 : deviceEvent( deviceEvent_ )
33801 {
33802 }
33803
33805 {
33806 memcpy( this, &rhs, sizeof( DeviceEventInfoEXT ) );
33807 }
33808
33810 {
33811 memcpy( this, &rhs, sizeof( DeviceEventInfoEXT ) );
33812 return *this;
33813 }
33814 DeviceEventInfoEXT& setPNext( const void* pNext_ )
33815 {
33816 pNext = pNext_;
33817 return *this;
33818 }
33819
33821 {
33822 deviceEvent = deviceEvent_;
33823 return *this;
33824 }
33825
33826 operator VkDeviceEventInfoEXT const&() const
33827 {
33828 return *reinterpret_cast<const VkDeviceEventInfoEXT*>(this);
33829 }
33830
33832 {
33833 return *reinterpret_cast<VkDeviceEventInfoEXT*>(this);
33834 }
33835
33836 bool operator==( DeviceEventInfoEXT const& rhs ) const
33837 {
33838 return ( sType == rhs.sType )
33839 && ( pNext == rhs.pNext )
33840 && ( deviceEvent == rhs.deviceEvent );
33841 }
33842
33843 bool operator!=( DeviceEventInfoEXT const& rhs ) const
33844 {
33845 return !operator==( rhs );
33846 }
33847
33848 private:
33850
33851 public:
33852 const void* pNext = nullptr;
33854 };
33855 static_assert( sizeof( DeviceEventInfoEXT ) == sizeof( VkDeviceEventInfoEXT ), "struct and wrapper have different size!" );
33856
33858 {
33860 };
33861
33863 {
33865 : displayEvent( displayEvent_ )
33866 {
33867 }
33868
33870 {
33871 memcpy( this, &rhs, sizeof( DisplayEventInfoEXT ) );
33872 }
33873
33875 {
33876 memcpy( this, &rhs, sizeof( DisplayEventInfoEXT ) );
33877 return *this;
33878 }
33879 DisplayEventInfoEXT& setPNext( const void* pNext_ )
33880 {
33881 pNext = pNext_;
33882 return *this;
33883 }
33884
33886 {
33887 displayEvent = displayEvent_;
33888 return *this;
33889 }
33890
33891 operator VkDisplayEventInfoEXT const&() const
33892 {
33893 return *reinterpret_cast<const VkDisplayEventInfoEXT*>(this);
33894 }
33895
33897 {
33898 return *reinterpret_cast<VkDisplayEventInfoEXT*>(this);
33899 }
33900
33901 bool operator==( DisplayEventInfoEXT const& rhs ) const
33902 {
33903 return ( sType == rhs.sType )
33904 && ( pNext == rhs.pNext )
33905 && ( displayEvent == rhs.displayEvent );
33906 }
33907
33908 bool operator!=( DisplayEventInfoEXT const& rhs ) const
33909 {
33910 return !operator==( rhs );
33911 }
33912
33913 private:
33915
33916 public:
33917 const void* pNext = nullptr;
33919 };
33920 static_assert( sizeof( DisplayEventInfoEXT ) == sizeof( VkDisplayEventInfoEXT ), "struct and wrapper have different size!" );
33921
33923 {
33932 };
33933
33935
33937 {
33938 return PeerMemoryFeatureFlags( bit0 ) | bit1;
33939 }
33940
33942 {
33943 return ~( PeerMemoryFeatureFlags( bits ) );
33944 }
33945
33947 {
33948 enum
33949 {
33952 };
33953
33955
33957 {
33960 };
33961
33963
33965 {
33966 return MemoryAllocateFlags( bit0 ) | bit1;
33967 }
33968
33970 {
33971 return ~( MemoryAllocateFlags( bits ) );
33972 }
33973
33975 {
33976 enum
33977 {
33980 };
33981
33983
33985 {
33987 uint32_t deviceMask_ = 0 )
33988 : flags( flags_ )
33989 , deviceMask( deviceMask_ )
33990 {
33991 }
33992
33994 {
33995 memcpy( this, &rhs, sizeof( MemoryAllocateFlagsInfo ) );
33996 }
33997
33999 {
34000 memcpy( this, &rhs, sizeof( MemoryAllocateFlagsInfo ) );
34001 return *this;
34002 }
34003 MemoryAllocateFlagsInfo& setPNext( const void* pNext_ )
34004 {
34005 pNext = pNext_;
34006 return *this;
34007 }
34008
34010 {
34011 flags = flags_;
34012 return *this;
34013 }
34014
34016 {
34017 deviceMask = deviceMask_;
34018 return *this;
34019 }
34020
34021 operator VkMemoryAllocateFlagsInfo const&() const
34022 {
34023 return *reinterpret_cast<const VkMemoryAllocateFlagsInfo*>(this);
34024 }
34025
34027 {
34028 return *reinterpret_cast<VkMemoryAllocateFlagsInfo*>(this);
34029 }
34030
34031 bool operator==( MemoryAllocateFlagsInfo const& rhs ) const
34032 {
34033 return ( sType == rhs.sType )
34034 && ( pNext == rhs.pNext )
34035 && ( flags == rhs.flags )
34036 && ( deviceMask == rhs.deviceMask );
34037 }
34038
34039 bool operator!=( MemoryAllocateFlagsInfo const& rhs ) const
34040 {
34041 return !operator==( rhs );
34042 }
34043
34044 private:
34046
34047 public:
34048 const void* pNext = nullptr;
34051 };
34052 static_assert( sizeof( MemoryAllocateFlagsInfo ) == sizeof( VkMemoryAllocateFlagsInfo ), "struct and wrapper have different size!" );
34053
34055
34057 {
34062 };
34063
34065
34067 {
34068 return DeviceGroupPresentModeFlagsKHR( bit0 ) | bit1;
34069 }
34070
34072 {
34073 return ~( DeviceGroupPresentModeFlagsKHR( bits ) );
34074 }
34075
34077 {
34078 enum
34079 {
34082 };
34083
34085 {
34087 {
34088 return *reinterpret_cast<const VkDeviceGroupPresentCapabilitiesKHR*>(this);
34089 }
34090
34092 {
34093 return *reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR*>(this);
34094 }
34095
34097 {
34098 return ( sType == rhs.sType )
34099 && ( pNext == rhs.pNext )
34100 && ( memcmp( presentMask, rhs.presentMask, VK_MAX_DEVICE_GROUP_SIZE * sizeof( uint32_t ) ) == 0 )
34101 && ( modes == rhs.modes );
34102 }
34103
34105 {
34106 return !operator==( rhs );
34107 }
34108
34109 private:
34111
34112 public:
34113 const void* pNext = nullptr;
34116 };
34117 static_assert( sizeof( DeviceGroupPresentCapabilitiesKHR ) == sizeof( VkDeviceGroupPresentCapabilitiesKHR ), "struct and wrapper have different size!" );
34118
34120 {
34122 const uint32_t* pDeviceMasks_ = nullptr,
34124 : swapchainCount( swapchainCount_ )
34125 , pDeviceMasks( pDeviceMasks_ )
34126 , mode( mode_ )
34127 {
34128 }
34129
34131 {
34132 memcpy( this, &rhs, sizeof( DeviceGroupPresentInfoKHR ) );
34133 }
34134
34136 {
34137 memcpy( this, &rhs, sizeof( DeviceGroupPresentInfoKHR ) );
34138 return *this;
34139 }
34141 {
34142 pNext = pNext_;
34143 return *this;
34144 }
34145
34147 {
34148 swapchainCount = swapchainCount_;
34149 return *this;
34150 }
34151
34153 {
34154 pDeviceMasks = pDeviceMasks_;
34155 return *this;
34156 }
34157
34159 {
34160 mode = mode_;
34161 return *this;
34162 }
34163
34164 operator VkDeviceGroupPresentInfoKHR const&() const
34165 {
34166 return *reinterpret_cast<const VkDeviceGroupPresentInfoKHR*>(this);
34167 }
34168
34170 {
34171 return *reinterpret_cast<VkDeviceGroupPresentInfoKHR*>(this);
34172 }
34173
34174 bool operator==( DeviceGroupPresentInfoKHR const& rhs ) const
34175 {
34176 return ( sType == rhs.sType )
34177 && ( pNext == rhs.pNext )
34178 && ( swapchainCount == rhs.swapchainCount )
34179 && ( pDeviceMasks == rhs.pDeviceMasks )
34180 && ( mode == rhs.mode );
34181 }
34182
34183 bool operator!=( DeviceGroupPresentInfoKHR const& rhs ) const
34184 {
34185 return !operator==( rhs );
34186 }
34187
34188 private:
34190
34191 public:
34192 const void* pNext = nullptr;
34196 };
34197 static_assert( sizeof( DeviceGroupPresentInfoKHR ) == sizeof( VkDeviceGroupPresentInfoKHR ), "struct and wrapper have different size!" );
34198
34200 {
34202 : modes( modes_ )
34203 {
34204 }
34205
34207 {
34208 memcpy( this, &rhs, sizeof( DeviceGroupSwapchainCreateInfoKHR ) );
34209 }
34210
34212 {
34213 memcpy( this, &rhs, sizeof( DeviceGroupSwapchainCreateInfoKHR ) );
34214 return *this;
34215 }
34217 {
34218 pNext = pNext_;
34219 return *this;
34220 }
34221
34223 {
34224 modes = modes_;
34225 return *this;
34226 }
34227
34229 {
34230 return *reinterpret_cast<const VkDeviceGroupSwapchainCreateInfoKHR*>(this);
34231 }
34232
34234 {
34235 return *reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR*>(this);
34236 }
34237
34239 {
34240 return ( sType == rhs.sType )
34241 && ( pNext == rhs.pNext )
34242 && ( modes == rhs.modes );
34243 }
34244
34246 {
34247 return !operator==( rhs );
34248 }
34249
34250 private:
34252
34253 public:
34254 const void* pNext = nullptr;
34256 };
34257 static_assert( sizeof( DeviceGroupSwapchainCreateInfoKHR ) == sizeof( VkDeviceGroupSwapchainCreateInfoKHR ), "struct and wrapper have different size!" );
34258
34260 {
34263 };
34264
34266
34268 {
34269 return SwapchainCreateFlagsKHR( bit0 ) | bit1;
34270 }
34271
34273 {
34274 return ~( SwapchainCreateFlagsKHR( bits ) );
34275 }
34276
34278 {
34279 enum
34280 {
34283 };
34284
34286 {
34288 SurfaceKHR surface_ = SurfaceKHR(),
34289 uint32_t minImageCount_ = 0,
34290 Format imageFormat_ = Format::eUndefined,
34292 Extent2D imageExtent_ = Extent2D(),
34293 uint32_t imageArrayLayers_ = 0,
34294 ImageUsageFlags imageUsage_ = ImageUsageFlags(),
34295 SharingMode imageSharingMode_ = SharingMode::eExclusive,
34296 uint32_t queueFamilyIndexCount_ = 0,
34297 const uint32_t* pQueueFamilyIndices_ = nullptr,
34301 Bool32 clipped_ = 0,
34302 SwapchainKHR oldSwapchain_ = SwapchainKHR() )
34303 : flags( flags_ )
34304 , surface( surface_ )
34305 , minImageCount( minImageCount_ )
34306 , imageFormat( imageFormat_ )
34307 , imageColorSpace( imageColorSpace_ )
34308 , imageExtent( imageExtent_ )
34309 , imageArrayLayers( imageArrayLayers_ )
34310 , imageUsage( imageUsage_ )
34311 , imageSharingMode( imageSharingMode_ )
34312 , queueFamilyIndexCount( queueFamilyIndexCount_ )
34313 , pQueueFamilyIndices( pQueueFamilyIndices_ )
34314 , preTransform( preTransform_ )
34315 , compositeAlpha( compositeAlpha_ )
34316 , presentMode( presentMode_ )
34317 , clipped( clipped_ )
34318 , oldSwapchain( oldSwapchain_ )
34319 {
34320 }
34321
34323 {
34324 memcpy( this, &rhs, sizeof( SwapchainCreateInfoKHR ) );
34325 }
34326
34328 {
34329 memcpy( this, &rhs, sizeof( SwapchainCreateInfoKHR ) );
34330 return *this;
34331 }
34332 SwapchainCreateInfoKHR& setPNext( const void* pNext_ )
34333 {
34334 pNext = pNext_;
34335 return *this;
34336 }
34337
34339 {
34340 flags = flags_;
34341 return *this;
34342 }
34343
34345 {
34346 surface = surface_;
34347 return *this;
34348 }
34349
34351 {
34352 minImageCount = minImageCount_;
34353 return *this;
34354 }
34355
34357 {
34358 imageFormat = imageFormat_;
34359 return *this;
34360 }
34361
34363 {
34364 imageColorSpace = imageColorSpace_;
34365 return *this;
34366 }
34367
34369 {
34370 imageExtent = imageExtent_;
34371 return *this;
34372 }
34373
34375 {
34376 imageArrayLayers = imageArrayLayers_;
34377 return *this;
34378 }
34379
34381 {
34382 imageUsage = imageUsage_;
34383 return *this;
34384 }
34385
34387 {
34388 imageSharingMode = imageSharingMode_;
34389 return *this;
34390 }
34391
34393 {
34394 queueFamilyIndexCount = queueFamilyIndexCount_;
34395 return *this;
34396 }
34397
34399 {
34400 pQueueFamilyIndices = pQueueFamilyIndices_;
34401 return *this;
34402 }
34403
34405 {
34406 preTransform = preTransform_;
34407 return *this;
34408 }
34409
34411 {
34412 compositeAlpha = compositeAlpha_;
34413 return *this;
34414 }
34415
34417 {
34418 presentMode = presentMode_;
34419 return *this;
34420 }
34421
34423 {
34424 clipped = clipped_;
34425 return *this;
34426 }
34427
34429 {
34430 oldSwapchain = oldSwapchain_;
34431 return *this;
34432 }
34433
34434 operator VkSwapchainCreateInfoKHR const&() const
34435 {
34436 return *reinterpret_cast<const VkSwapchainCreateInfoKHR*>(this);
34437 }
34438
34440 {
34441 return *reinterpret_cast<VkSwapchainCreateInfoKHR*>(this);
34442 }
34443
34444 bool operator==( SwapchainCreateInfoKHR const& rhs ) const
34445 {
34446 return ( sType == rhs.sType )
34447 && ( pNext == rhs.pNext )
34448 && ( flags == rhs.flags )
34449 && ( surface == rhs.surface )
34450 && ( minImageCount == rhs.minImageCount )
34451 && ( imageFormat == rhs.imageFormat )
34452 && ( imageColorSpace == rhs.imageColorSpace )
34453 && ( imageExtent == rhs.imageExtent )
34455 && ( imageUsage == rhs.imageUsage )
34459 && ( preTransform == rhs.preTransform )
34460 && ( compositeAlpha == rhs.compositeAlpha )
34461 && ( presentMode == rhs.presentMode )
34462 && ( clipped == rhs.clipped )
34463 && ( oldSwapchain == rhs.oldSwapchain );
34464 }
34465
34466 bool operator!=( SwapchainCreateInfoKHR const& rhs ) const
34467 {
34468 return !operator==( rhs );
34469 }
34470
34471 private:
34473
34474 public:
34475 const void* pNext = nullptr;
34492 };
34493 static_assert( sizeof( SwapchainCreateInfoKHR ) == sizeof( VkSwapchainCreateInfoKHR ), "struct and wrapper have different size!" );
34494
34496 {
34505 };
34506
34508 {
34513 : x( x_ )
34514 , y( y_ )
34515 , z( z_ )
34516 , w( w_ )
34517 {
34518 }
34519
34521 {
34522 memcpy( this, &rhs, sizeof( ViewportSwizzleNV ) );
34523 }
34524
34526 {
34527 memcpy( this, &rhs, sizeof( ViewportSwizzleNV ) );
34528 return *this;
34529 }
34531 {
34532 x = x_;
34533 return *this;
34534 }
34535
34537 {
34538 y = y_;
34539 return *this;
34540 }
34541
34543 {
34544 z = z_;
34545 return *this;
34546 }
34547
34549 {
34550 w = w_;
34551 return *this;
34552 }
34553
34554 operator VkViewportSwizzleNV const&() const
34555 {
34556 return *reinterpret_cast<const VkViewportSwizzleNV*>(this);
34557 }
34558
34560 {
34561 return *reinterpret_cast<VkViewportSwizzleNV*>(this);
34562 }
34563
34564 bool operator==( ViewportSwizzleNV const& rhs ) const
34565 {
34566 return ( x == rhs.x )
34567 && ( y == rhs.y )
34568 && ( z == rhs.z )
34569 && ( w == rhs.w );
34570 }
34571
34572 bool operator!=( ViewportSwizzleNV const& rhs ) const
34573 {
34574 return !operator==( rhs );
34575 }
34576
34581 };
34582 static_assert( sizeof( ViewportSwizzleNV ) == sizeof( VkViewportSwizzleNV ), "struct and wrapper have different size!" );
34583
34585 {
34587 uint32_t viewportCount_ = 0,
34588 const ViewportSwizzleNV* pViewportSwizzles_ = nullptr )
34589 : flags( flags_ )
34590 , viewportCount( viewportCount_ )
34591 , pViewportSwizzles( pViewportSwizzles_ )
34592 {
34593 }
34594
34596 {
34597 memcpy( this, &rhs, sizeof( PipelineViewportSwizzleStateCreateInfoNV ) );
34598 }
34599
34601 {
34602 memcpy( this, &rhs, sizeof( PipelineViewportSwizzleStateCreateInfoNV ) );
34603 return *this;
34604 }
34606 {
34607 pNext = pNext_;
34608 return *this;
34609 }
34610
34612 {
34613 flags = flags_;
34614 return *this;
34615 }
34616
34618 {
34619 viewportCount = viewportCount_;
34620 return *this;
34621 }
34622
34624 {
34625 pViewportSwizzles = pViewportSwizzles_;
34626 return *this;
34627 }
34628
34630 {
34631 return *reinterpret_cast<const VkPipelineViewportSwizzleStateCreateInfoNV*>(this);
34632 }
34633
34635 {
34636 return *reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV*>(this);
34637 }
34638
34640 {
34641 return ( sType == rhs.sType )
34642 && ( pNext == rhs.pNext )
34643 && ( flags == rhs.flags )
34644 && ( viewportCount == rhs.viewportCount )
34646 }
34647
34649 {
34650 return !operator==( rhs );
34651 }
34652
34653 private:
34655
34656 public:
34657 const void* pNext = nullptr;
34661 };
34662 static_assert( sizeof( PipelineViewportSwizzleStateCreateInfoNV ) == sizeof( VkPipelineViewportSwizzleStateCreateInfoNV ), "struct and wrapper have different size!" );
34663
34665 {
34668 };
34669
34671 {
34674 uint32_t discardRectangleCount_ = 0,
34675 const Rect2D* pDiscardRectangles_ = nullptr )
34676 : flags( flags_ )
34677 , discardRectangleMode( discardRectangleMode_ )
34678 , discardRectangleCount( discardRectangleCount_ )
34679 , pDiscardRectangles( pDiscardRectangles_ )
34680 {
34681 }
34682
34684 {
34685 memcpy( this, &rhs, sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) );
34686 }
34687
34689 {
34690 memcpy( this, &rhs, sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) );
34691 return *this;
34692 }
34694 {
34695 pNext = pNext_;
34696 return *this;
34697 }
34698
34700 {
34701 flags = flags_;
34702 return *this;
34703 }
34704
34706 {
34707 discardRectangleMode = discardRectangleMode_;
34708 return *this;
34709 }
34710
34712 {
34713 discardRectangleCount = discardRectangleCount_;
34714 return *this;
34715 }
34716
34718 {
34719 pDiscardRectangles = pDiscardRectangles_;
34720 return *this;
34721 }
34722
34724 {
34725 return *reinterpret_cast<const VkPipelineDiscardRectangleStateCreateInfoEXT*>(this);
34726 }
34727
34729 {
34730 return *reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT*>(this);
34731 }
34732
34734 {
34735 return ( sType == rhs.sType )
34736 && ( pNext == rhs.pNext )
34737 && ( flags == rhs.flags )
34741 }
34742
34744 {
34745 return !operator==( rhs );
34746 }
34747
34748 private:
34750
34751 public:
34752 const void* pNext = nullptr;
34757 };
34758 static_assert( sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) == sizeof( VkPipelineDiscardRectangleStateCreateInfoEXT ), "struct and wrapper have different size!" );
34759
34761 {
34764 };
34765
34767
34769 {
34770 return SubpassDescriptionFlags( bit0 ) | bit1;
34771 }
34772
34774 {
34775 return ~( SubpassDescriptionFlags( bits ) );
34776 }
34777
34779 {
34780 enum
34781 {
34784 };
34785
34787 {
34790 uint32_t inputAttachmentCount_ = 0,
34791 const AttachmentReference* pInputAttachments_ = nullptr,
34792 uint32_t colorAttachmentCount_ = 0,
34793 const AttachmentReference* pColorAttachments_ = nullptr,
34794 const AttachmentReference* pResolveAttachments_ = nullptr,
34795 const AttachmentReference* pDepthStencilAttachment_ = nullptr,
34796 uint32_t preserveAttachmentCount_ = 0,
34797 const uint32_t* pPreserveAttachments_ = nullptr )
34798 : flags( flags_ )
34799 , pipelineBindPoint( pipelineBindPoint_ )
34800 , inputAttachmentCount( inputAttachmentCount_ )
34801 , pInputAttachments( pInputAttachments_ )
34802 , colorAttachmentCount( colorAttachmentCount_ )
34803 , pColorAttachments( pColorAttachments_ )
34804 , pResolveAttachments( pResolveAttachments_ )
34805 , pDepthStencilAttachment( pDepthStencilAttachment_ )
34806 , preserveAttachmentCount( preserveAttachmentCount_ )
34807 , pPreserveAttachments( pPreserveAttachments_ )
34808 {
34809 }
34810
34812 {
34813 memcpy( this, &rhs, sizeof( SubpassDescription ) );
34814 }
34815
34817 {
34818 memcpy( this, &rhs, sizeof( SubpassDescription ) );
34819 return *this;
34820 }
34822 {
34823 flags = flags_;
34824 return *this;
34825 }
34826
34828 {
34829 pipelineBindPoint = pipelineBindPoint_;
34830 return *this;
34831 }
34832
34834 {
34835 inputAttachmentCount = inputAttachmentCount_;
34836 return *this;
34837 }
34838
34840 {
34841 pInputAttachments = pInputAttachments_;
34842 return *this;
34843 }
34844
34846 {
34847 colorAttachmentCount = colorAttachmentCount_;
34848 return *this;
34849 }
34850
34852 {
34853 pColorAttachments = pColorAttachments_;
34854 return *this;
34855 }
34856
34858 {
34859 pResolveAttachments = pResolveAttachments_;
34860 return *this;
34861 }
34862
34864 {
34865 pDepthStencilAttachment = pDepthStencilAttachment_;
34866 return *this;
34867 }
34868
34870 {
34871 preserveAttachmentCount = preserveAttachmentCount_;
34872 return *this;
34873 }
34874
34875 SubpassDescription& setPPreserveAttachments( const uint32_t* pPreserveAttachments_ )
34876 {
34877 pPreserveAttachments = pPreserveAttachments_;
34878 return *this;
34879 }
34880
34881 operator VkSubpassDescription const&() const
34882 {
34883 return *reinterpret_cast<const VkSubpassDescription*>(this);
34884 }
34885
34887 {
34888 return *reinterpret_cast<VkSubpassDescription*>(this);
34889 }
34890
34891 bool operator==( SubpassDescription const& rhs ) const
34892 {
34893 return ( flags == rhs.flags )
34903 }
34904
34905 bool operator!=( SubpassDescription const& rhs ) const
34906 {
34907 return !operator==( rhs );
34908 }
34909
34920 };
34921 static_assert( sizeof( SubpassDescription ) == sizeof( VkSubpassDescription ), "struct and wrapper have different size!" );
34922
34924 {
34926 uint32_t attachmentCount_ = 0,
34927 const AttachmentDescription* pAttachments_ = nullptr,
34928 uint32_t subpassCount_ = 0,
34929 const SubpassDescription* pSubpasses_ = nullptr,
34930 uint32_t dependencyCount_ = 0,
34931 const SubpassDependency* pDependencies_ = nullptr )
34932 : flags( flags_ )
34933 , attachmentCount( attachmentCount_ )
34934 , pAttachments( pAttachments_ )
34935 , subpassCount( subpassCount_ )
34936 , pSubpasses( pSubpasses_ )
34937 , dependencyCount( dependencyCount_ )
34938 , pDependencies( pDependencies_ )
34939 {
34940 }
34941
34943 {
34944 memcpy( this, &rhs, sizeof( RenderPassCreateInfo ) );
34945 }
34946
34948 {
34949 memcpy( this, &rhs, sizeof( RenderPassCreateInfo ) );
34950 return *this;
34951 }
34952 RenderPassCreateInfo& setPNext( const void* pNext_ )
34953 {
34954 pNext = pNext_;
34955 return *this;
34956 }
34957
34959 {
34960 flags = flags_;
34961 return *this;
34962 }
34963
34965 {
34966 attachmentCount = attachmentCount_;
34967 return *this;
34968 }
34969
34971 {
34972 pAttachments = pAttachments_;
34973 return *this;
34974 }
34975
34977 {
34978 subpassCount = subpassCount_;
34979 return *this;
34980 }
34981
34983 {
34984 pSubpasses = pSubpasses_;
34985 return *this;
34986 }
34987
34989 {
34990 dependencyCount = dependencyCount_;
34991 return *this;
34992 }
34993
34995 {
34996 pDependencies = pDependencies_;
34997 return *this;
34998 }
34999
35000 operator VkRenderPassCreateInfo const&() const
35001 {
35002 return *reinterpret_cast<const VkRenderPassCreateInfo*>(this);
35003 }
35004
35006 {
35007 return *reinterpret_cast<VkRenderPassCreateInfo*>(this);
35008 }
35009
35010 bool operator==( RenderPassCreateInfo const& rhs ) const
35011 {
35012 return ( sType == rhs.sType )
35013 && ( pNext == rhs.pNext )
35014 && ( flags == rhs.flags )
35015 && ( attachmentCount == rhs.attachmentCount )
35016 && ( pAttachments == rhs.pAttachments )
35017 && ( subpassCount == rhs.subpassCount )
35018 && ( pSubpasses == rhs.pSubpasses )
35019 && ( dependencyCount == rhs.dependencyCount )
35020 && ( pDependencies == rhs.pDependencies );
35021 }
35022
35023 bool operator!=( RenderPassCreateInfo const& rhs ) const
35024 {
35025 return !operator==( rhs );
35026 }
35027
35028 private:
35030
35031 public:
35032 const void* pNext = nullptr;
35040 };
35041 static_assert( sizeof( RenderPassCreateInfo ) == sizeof( VkRenderPassCreateInfo ), "struct and wrapper have different size!" );
35042
35044 {
35047 uint32_t viewMask_ = 0,
35048 uint32_t inputAttachmentCount_ = 0,
35049 const AttachmentReference2KHR* pInputAttachments_ = nullptr,
35050 uint32_t colorAttachmentCount_ = 0,
35051 const AttachmentReference2KHR* pColorAttachments_ = nullptr,
35052 const AttachmentReference2KHR* pResolveAttachments_ = nullptr,
35053 const AttachmentReference2KHR* pDepthStencilAttachment_ = nullptr,
35054 uint32_t preserveAttachmentCount_ = 0,
35055 const uint32_t* pPreserveAttachments_ = nullptr )
35056 : flags( flags_ )
35057 , pipelineBindPoint( pipelineBindPoint_ )
35058 , viewMask( viewMask_ )
35059 , inputAttachmentCount( inputAttachmentCount_ )
35060 , pInputAttachments( pInputAttachments_ )
35061 , colorAttachmentCount( colorAttachmentCount_ )
35062 , pColorAttachments( pColorAttachments_ )
35063 , pResolveAttachments( pResolveAttachments_ )
35064 , pDepthStencilAttachment( pDepthStencilAttachment_ )
35065 , preserveAttachmentCount( preserveAttachmentCount_ )
35066 , pPreserveAttachments( pPreserveAttachments_ )
35067 {
35068 }
35069
35071 {
35072 memcpy( this, &rhs, sizeof( SubpassDescription2KHR ) );
35073 }
35074
35076 {
35077 memcpy( this, &rhs, sizeof( SubpassDescription2KHR ) );
35078 return *this;
35079 }
35080 SubpassDescription2KHR& setPNext( const void* pNext_ )
35081 {
35082 pNext = pNext_;
35083 return *this;
35084 }
35085
35087 {
35088 flags = flags_;
35089 return *this;
35090 }
35091
35093 {
35094 pipelineBindPoint = pipelineBindPoint_;
35095 return *this;
35096 }
35097
35099 {
35100 viewMask = viewMask_;
35101 return *this;
35102 }
35103
35105 {
35106 inputAttachmentCount = inputAttachmentCount_;
35107 return *this;
35108 }
35109
35111 {
35112 pInputAttachments = pInputAttachments_;
35113 return *this;
35114 }
35115
35117 {
35118 colorAttachmentCount = colorAttachmentCount_;
35119 return *this;
35120 }
35121
35123 {
35124 pColorAttachments = pColorAttachments_;
35125 return *this;
35126 }
35127
35129 {
35130 pResolveAttachments = pResolveAttachments_;
35131 return *this;
35132 }
35133
35135 {
35136 pDepthStencilAttachment = pDepthStencilAttachment_;
35137 return *this;
35138 }
35139
35141 {
35142 preserveAttachmentCount = preserveAttachmentCount_;
35143 return *this;
35144 }
35145
35147 {
35148 pPreserveAttachments = pPreserveAttachments_;
35149 return *this;
35150 }
35151
35152 operator VkSubpassDescription2KHR const&() const
35153 {
35154 return *reinterpret_cast<const VkSubpassDescription2KHR*>(this);
35155 }
35156
35158 {
35159 return *reinterpret_cast<VkSubpassDescription2KHR*>(this);
35160 }
35161
35162 bool operator==( SubpassDescription2KHR const& rhs ) const
35163 {
35164 return ( sType == rhs.sType )
35165 && ( pNext == rhs.pNext )
35166 && ( flags == rhs.flags )
35168 && ( viewMask == rhs.viewMask )
35177 }
35178
35179 bool operator!=( SubpassDescription2KHR const& rhs ) const
35180 {
35181 return !operator==( rhs );
35182 }
35183
35184 private:
35186
35187 public:
35188 const void* pNext = nullptr;
35200 };
35201 static_assert( sizeof( SubpassDescription2KHR ) == sizeof( VkSubpassDescription2KHR ), "struct and wrapper have different size!" );
35202
35204 {
35206 uint32_t attachmentCount_ = 0,
35207 const AttachmentDescription2KHR* pAttachments_ = nullptr,
35208 uint32_t subpassCount_ = 0,
35209 const SubpassDescription2KHR* pSubpasses_ = nullptr,
35210 uint32_t dependencyCount_ = 0,
35211 const SubpassDependency2KHR* pDependencies_ = nullptr,
35212 uint32_t correlatedViewMaskCount_ = 0,
35213 const uint32_t* pCorrelatedViewMasks_ = nullptr )
35214 : flags( flags_ )
35215 , attachmentCount( attachmentCount_ )
35216 , pAttachments( pAttachments_ )
35217 , subpassCount( subpassCount_ )
35218 , pSubpasses( pSubpasses_ )
35219 , dependencyCount( dependencyCount_ )
35220 , pDependencies( pDependencies_ )
35221 , correlatedViewMaskCount( correlatedViewMaskCount_ )
35222 , pCorrelatedViewMasks( pCorrelatedViewMasks_ )
35223 {
35224 }
35225
35227 {
35228 memcpy( this, &rhs, sizeof( RenderPassCreateInfo2KHR ) );
35229 }
35230
35232 {
35233 memcpy( this, &rhs, sizeof( RenderPassCreateInfo2KHR ) );
35234 return *this;
35235 }
35236 RenderPassCreateInfo2KHR& setPNext( const void* pNext_ )
35237 {
35238 pNext = pNext_;
35239 return *this;
35240 }
35241
35243 {
35244 flags = flags_;
35245 return *this;
35246 }
35247
35249 {
35250 attachmentCount = attachmentCount_;
35251 return *this;
35252 }
35253
35255 {
35256 pAttachments = pAttachments_;
35257 return *this;
35258 }
35259
35261 {
35262 subpassCount = subpassCount_;
35263 return *this;
35264 }
35265
35267 {
35268 pSubpasses = pSubpasses_;
35269 return *this;
35270 }
35271
35273 {
35274 dependencyCount = dependencyCount_;
35275 return *this;
35276 }
35277
35279 {
35280 pDependencies = pDependencies_;
35281 return *this;
35282 }
35283
35285 {
35286 correlatedViewMaskCount = correlatedViewMaskCount_;
35287 return *this;
35288 }
35289
35291 {
35292 pCorrelatedViewMasks = pCorrelatedViewMasks_;
35293 return *this;
35294 }
35295
35296 operator VkRenderPassCreateInfo2KHR const&() const
35297 {
35298 return *reinterpret_cast<const VkRenderPassCreateInfo2KHR*>(this);
35299 }
35300
35302 {
35303 return *reinterpret_cast<VkRenderPassCreateInfo2KHR*>(this);
35304 }
35305
35306 bool operator==( RenderPassCreateInfo2KHR const& rhs ) const
35307 {
35308 return ( sType == rhs.sType )
35309 && ( pNext == rhs.pNext )
35310 && ( flags == rhs.flags )
35311 && ( attachmentCount == rhs.attachmentCount )
35312 && ( pAttachments == rhs.pAttachments )
35313 && ( subpassCount == rhs.subpassCount )
35314 && ( pSubpasses == rhs.pSubpasses )
35315 && ( dependencyCount == rhs.dependencyCount )
35316 && ( pDependencies == rhs.pDependencies )
35319 }
35320
35321 bool operator!=( RenderPassCreateInfo2KHR const& rhs ) const
35322 {
35323 return !operator==( rhs );
35324 }
35325
35326 private:
35328
35329 public:
35330 const void* pNext = nullptr;
35340 };
35341 static_assert( sizeof( RenderPassCreateInfo2KHR ) == sizeof( VkRenderPassCreateInfo2KHR ), "struct and wrapper have different size!" );
35342
35344 {
35349 };
35350
35352 {
35354 {
35355 return *reinterpret_cast<const VkPhysicalDevicePointClippingProperties*>(this);
35356 }
35357
35359 {
35360 return *reinterpret_cast<VkPhysicalDevicePointClippingProperties*>(this);
35361 }
35362
35364 {
35365 return ( sType == rhs.sType )
35366 && ( pNext == rhs.pNext )
35368 }
35369
35371 {
35372 return !operator==( rhs );
35373 }
35374
35375 private:
35377
35378 public:
35379 void* pNext = nullptr;
35381 };
35382 static_assert( sizeof( PhysicalDevicePointClippingProperties ) == sizeof( VkPhysicalDevicePointClippingProperties ), "struct and wrapper have different size!" );
35383
35385
35387 {
35391 };
35392
35394 {
35396 : reductionMode( reductionMode_ )
35397 {
35398 }
35399
35401 {
35402 memcpy( this, &rhs, sizeof( SamplerReductionModeCreateInfoEXT ) );
35403 }
35404
35406 {
35407 memcpy( this, &rhs, sizeof( SamplerReductionModeCreateInfoEXT ) );
35408 return *this;
35409 }
35411 {
35412 pNext = pNext_;
35413 return *this;
35414 }
35415
35417 {
35418 reductionMode = reductionMode_;
35419 return *this;
35420 }
35421
35423 {
35424 return *reinterpret_cast<const VkSamplerReductionModeCreateInfoEXT*>(this);
35425 }
35426
35428 {
35429 return *reinterpret_cast<VkSamplerReductionModeCreateInfoEXT*>(this);
35430 }
35431
35433 {
35434 return ( sType == rhs.sType )
35435 && ( pNext == rhs.pNext )
35436 && ( reductionMode == rhs.reductionMode );
35437 }
35438
35440 {
35441 return !operator==( rhs );
35442 }
35443
35444 private:
35446
35447 public:
35448 const void* pNext = nullptr;
35450 };
35451 static_assert( sizeof( SamplerReductionModeCreateInfoEXT ) == sizeof( VkSamplerReductionModeCreateInfoEXT ), "struct and wrapper have different size!" );
35452
35454 {
35459 };
35460
35462 {
35464 : domainOrigin( domainOrigin_ )
35465 {
35466 }
35467
35469 {
35471 }
35472
35474 {
35476 return *this;
35477 }
35479 {
35480 pNext = pNext_;
35481 return *this;
35482 }
35483
35485 {
35486 domainOrigin = domainOrigin_;
35487 return *this;
35488 }
35489
35491 {
35492 return *reinterpret_cast<const VkPipelineTessellationDomainOriginStateCreateInfo*>(this);
35493 }
35494
35496 {
35497 return *reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo*>(this);
35498 }
35499
35501 {
35502 return ( sType == rhs.sType )
35503 && ( pNext == rhs.pNext )
35504 && ( domainOrigin == rhs.domainOrigin );
35505 }
35506
35508 {
35509 return !operator==( rhs );
35510 }
35511
35512 private:
35514
35515 public:
35516 const void* pNext = nullptr;
35518 };
35519 static_assert( sizeof( PipelineTessellationDomainOriginStateCreateInfo ) == sizeof( VkPipelineTessellationDomainOriginStateCreateInfo ), "struct and wrapper have different size!" );
35520
35522
35524 {
35535 };
35536
35538 {
35543 };
35544
35546 {
35551 };
35552
35554 {
35558 ComponentMapping components_ = ComponentMapping(),
35561 Filter chromaFilter_ = Filter::eNearest,
35562 Bool32 forceExplicitReconstruction_ = 0 )
35563 : format( format_ )
35564 , ycbcrModel( ycbcrModel_ )
35565 , ycbcrRange( ycbcrRange_ )
35566 , components( components_ )
35567 , xChromaOffset( xChromaOffset_ )
35568 , yChromaOffset( yChromaOffset_ )
35569 , chromaFilter( chromaFilter_ )
35570 , forceExplicitReconstruction( forceExplicitReconstruction_ )
35571 {
35572 }
35573
35575 {
35576 memcpy( this, &rhs, sizeof( SamplerYcbcrConversionCreateInfo ) );
35577 }
35578
35580 {
35581 memcpy( this, &rhs, sizeof( SamplerYcbcrConversionCreateInfo ) );
35582 return *this;
35583 }
35585 {
35586 pNext = pNext_;
35587 return *this;
35588 }
35589
35591 {
35592 format = format_;
35593 return *this;
35594 }
35595
35597 {
35598 ycbcrModel = ycbcrModel_;
35599 return *this;
35600 }
35601
35603 {
35604 ycbcrRange = ycbcrRange_;
35605 return *this;
35606 }
35607
35609 {
35610 components = components_;
35611 return *this;
35612 }
35613
35615 {
35616 xChromaOffset = xChromaOffset_;
35617 return *this;
35618 }
35619
35621 {
35622 yChromaOffset = yChromaOffset_;
35623 return *this;
35624 }
35625
35627 {
35628 chromaFilter = chromaFilter_;
35629 return *this;
35630 }
35631
35633 {
35634 forceExplicitReconstruction = forceExplicitReconstruction_;
35635 return *this;
35636 }
35637
35639 {
35640 return *reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo*>(this);
35641 }
35642
35644 {
35645 return *reinterpret_cast<VkSamplerYcbcrConversionCreateInfo*>(this);
35646 }
35647
35649 {
35650 return ( sType == rhs.sType )
35651 && ( pNext == rhs.pNext )
35652 && ( format == rhs.format )
35653 && ( ycbcrModel == rhs.ycbcrModel )
35654 && ( ycbcrRange == rhs.ycbcrRange )
35655 && ( components == rhs.components )
35656 && ( xChromaOffset == rhs.xChromaOffset )
35657 && ( yChromaOffset == rhs.yChromaOffset )
35658 && ( chromaFilter == rhs.chromaFilter )
35660 }
35661
35663 {
35664 return !operator==( rhs );
35665 }
35666
35667 private:
35669
35670 public:
35671 const void* pNext = nullptr;
35680 };
35681 static_assert( sizeof( SamplerYcbcrConversionCreateInfo ) == sizeof( VkSamplerYcbcrConversionCreateInfo ), "struct and wrapper have different size!" );
35682
35684
35685#ifdef VK_USE_PLATFORM_ANDROID_ANDROID
35686 struct AndroidHardwareBufferFormatPropertiesANDROID
35687 {
35689 {
35690 return *reinterpret_cast<const VkAndroidHardwareBufferFormatPropertiesANDROID*>(this);
35691 }
35692
35694 {
35695 return *reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID*>(this);
35696 }
35697
35698 bool operator==( AndroidHardwareBufferFormatPropertiesANDROID const& rhs ) const
35699 {
35700 return ( sType == rhs.sType )
35701 && ( pNext == rhs.pNext )
35702 && ( format == rhs.format )
35703 && ( externalFormat == rhs.externalFormat )
35704 && ( formatFeatures == rhs.formatFeatures )
35705 && ( samplerYcbcrConversionComponents == rhs.samplerYcbcrConversionComponents )
35706 && ( suggestedYcbcrModel == rhs.suggestedYcbcrModel )
35707 && ( suggestedYcbcrRange == rhs.suggestedYcbcrRange )
35708 && ( suggestedXChromaOffset == rhs.suggestedXChromaOffset )
35709 && ( suggestedYChromaOffset == rhs.suggestedYChromaOffset );
35710 }
35711
35712 bool operator!=( AndroidHardwareBufferFormatPropertiesANDROID const& rhs ) const
35713 {
35714 return !operator==( rhs );
35715 }
35716
35717 private:
35719
35720 public:
35721 void* pNext = nullptr;
35722 Format format;
35723 uint64_t externalFormat;
35724 FormatFeatureFlags formatFeatures;
35725 ComponentMapping samplerYcbcrConversionComponents;
35726 SamplerYcbcrModelConversion suggestedYcbcrModel;
35727 SamplerYcbcrRange suggestedYcbcrRange;
35728 ChromaLocation suggestedXChromaOffset;
35729 ChromaLocation suggestedYChromaOffset;
35730 };
35731 static_assert( sizeof( AndroidHardwareBufferFormatPropertiesANDROID ) == sizeof( VkAndroidHardwareBufferFormatPropertiesANDROID ), "struct and wrapper have different size!" );
35732#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/
35733
35735 {
35739 };
35740
35742 {
35744 Bool32 dstPremultiplied_ = 0,
35746 : srcPremultiplied( srcPremultiplied_ )
35747 , dstPremultiplied( dstPremultiplied_ )
35748 , blendOverlap( blendOverlap_ )
35749 {
35750 }
35751
35753 {
35755 }
35756
35758 {
35760 return *this;
35761 }
35763 {
35764 pNext = pNext_;
35765 return *this;
35766 }
35767
35769 {
35770 srcPremultiplied = srcPremultiplied_;
35771 return *this;
35772 }
35773
35775 {
35776 dstPremultiplied = dstPremultiplied_;
35777 return *this;
35778 }
35779
35781 {
35782 blendOverlap = blendOverlap_;
35783 return *this;
35784 }
35785
35787 {
35788 return *reinterpret_cast<const VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(this);
35789 }
35790
35792 {
35793 return *reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(this);
35794 }
35795
35797 {
35798 return ( sType == rhs.sType )
35799 && ( pNext == rhs.pNext )
35802 && ( blendOverlap == rhs.blendOverlap );
35803 }
35804
35806 {
35807 return !operator==( rhs );
35808 }
35809
35810 private:
35812
35813 public:
35814 const void* pNext = nullptr;
35818 };
35819 static_assert( sizeof( PipelineColorBlendAdvancedStateCreateInfoEXT ) == sizeof( VkPipelineColorBlendAdvancedStateCreateInfoEXT ), "struct and wrapper have different size!" );
35820
35822 {
35827 };
35828
35830 {
35833 Bool32 coverageModulationTableEnable_ = 0,
35834 uint32_t coverageModulationTableCount_ = 0,
35835 const float* pCoverageModulationTable_ = nullptr )
35836 : flags( flags_ )
35837 , coverageModulationMode( coverageModulationMode_ )
35838 , coverageModulationTableEnable( coverageModulationTableEnable_ )
35839 , coverageModulationTableCount( coverageModulationTableCount_ )
35840 , pCoverageModulationTable( pCoverageModulationTable_ )
35841 {
35842 }
35843
35845 {
35846 memcpy( this, &rhs, sizeof( PipelineCoverageModulationStateCreateInfoNV ) );
35847 }
35848
35850 {
35851 memcpy( this, &rhs, sizeof( PipelineCoverageModulationStateCreateInfoNV ) );
35852 return *this;
35853 }
35855 {
35856 pNext = pNext_;
35857 return *this;
35858 }
35859
35861 {
35862 flags = flags_;
35863 return *this;
35864 }
35865
35867 {
35868 coverageModulationMode = coverageModulationMode_;
35869 return *this;
35870 }
35871
35873 {
35874 coverageModulationTableEnable = coverageModulationTableEnable_;
35875 return *this;
35876 }
35877
35879 {
35880 coverageModulationTableCount = coverageModulationTableCount_;
35881 return *this;
35882 }
35883
35885 {
35886 pCoverageModulationTable = pCoverageModulationTable_;
35887 return *this;
35888 }
35889
35891 {
35892 return *reinterpret_cast<const VkPipelineCoverageModulationStateCreateInfoNV*>(this);
35893 }
35894
35896 {
35897 return *reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV*>(this);
35898 }
35899
35901 {
35902 return ( sType == rhs.sType )
35903 && ( pNext == rhs.pNext )
35904 && ( flags == rhs.flags )
35909 }
35910
35912 {
35913 return !operator==( rhs );
35914 }
35915
35916 private:
35918
35919 public:
35920 const void* pNext = nullptr;
35926 };
35927 static_assert( sizeof( PipelineCoverageModulationStateCreateInfoNV ) == sizeof( VkPipelineCoverageModulationStateCreateInfoNV ), "struct and wrapper have different size!" );
35928
35930 {
35932 };
35933
35935 {
35939 };
35940
35942 {
35947 };
35948
35950 {
35952 : globalPriority( globalPriority_ )
35953 {
35954 }
35955
35957 {
35958 memcpy( this, &rhs, sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) );
35959 }
35960
35962 {
35963 memcpy( this, &rhs, sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) );
35964 return *this;
35965 }
35967 {
35968 pNext = pNext_;
35969 return *this;
35970 }
35971
35973 {
35974 globalPriority = globalPriority_;
35975 return *this;
35976 }
35977
35979 {
35980 return *reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfoEXT*>(this);
35981 }
35982
35984 {
35985 return *reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT*>(this);
35986 }
35987
35989 {
35990 return ( sType == rhs.sType )
35991 && ( pNext == rhs.pNext )
35992 && ( globalPriority == rhs.globalPriority );
35993 }
35994
35996 {
35997 return !operator==( rhs );
35998 }
35999
36000 private:
36002
36003 public:
36004 const void* pNext = nullptr;
36006 };
36007 static_assert( sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) == sizeof( VkDeviceQueueGlobalPriorityCreateInfoEXT ), "struct and wrapper have different size!" );
36008
36010 {
36015 };
36016
36018
36020 {
36021 return DebugUtilsMessageSeverityFlagsEXT( bit0 ) | bit1;
36022 }
36023
36025 {
36027 }
36028
36030 {
36031 enum
36032 {
36035 };
36036
36038 {
36042 };
36043
36045
36047 {
36048 return DebugUtilsMessageTypeFlagsEXT( bit0 ) | bit1;
36049 }
36050
36052 {
36053 return ~( DebugUtilsMessageTypeFlagsEXT( bits ) );
36054 }
36055
36057 {
36058 enum
36059 {
36062 };
36063
36065 {
36069 PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback_ = nullptr,
36070 void* pUserData_ = nullptr )
36071 : flags( flags_ )
36072 , messageSeverity( messageSeverity_ )
36073 , messageType( messageType_ )
36074 , pfnUserCallback( pfnUserCallback_ )
36075 , pUserData( pUserData_ )
36076 {
36077 }
36078
36080 {
36081 memcpy( this, &rhs, sizeof( DebugUtilsMessengerCreateInfoEXT ) );
36082 }
36083
36085 {
36086 memcpy( this, &rhs, sizeof( DebugUtilsMessengerCreateInfoEXT ) );
36087 return *this;
36088 }
36090 {
36091 pNext = pNext_;
36092 return *this;
36093 }
36094
36096 {
36097 flags = flags_;
36098 return *this;
36099 }
36100
36102 {
36103 messageSeverity = messageSeverity_;
36104 return *this;
36105 }
36106
36108 {
36109 messageType = messageType_;
36110 return *this;
36111 }
36112
36114 {
36115 pfnUserCallback = pfnUserCallback_;
36116 return *this;
36117 }
36118
36120 {
36121 pUserData = pUserData_;
36122 return *this;
36123 }
36124
36126 {
36127 return *reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>(this);
36128 }
36129
36131 {
36132 return *reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT*>(this);
36133 }
36134
36136 {
36137 return ( sType == rhs.sType )
36138 && ( pNext == rhs.pNext )
36139 && ( flags == rhs.flags )
36140 && ( messageSeverity == rhs.messageSeverity )
36141 && ( messageType == rhs.messageType )
36142 && ( pfnUserCallback == rhs.pfnUserCallback )
36143 && ( pUserData == rhs.pUserData );
36144 }
36145
36147 {
36148 return !operator==( rhs );
36149 }
36150
36151 private:
36153
36154 public:
36155 const void* pNext = nullptr;
36161 };
36162 static_assert( sizeof( DebugUtilsMessengerCreateInfoEXT ) == sizeof( VkDebugUtilsMessengerCreateInfoEXT ), "struct and wrapper have different size!" );
36163
36165 {
36169 };
36170
36172 {
36175 float extraPrimitiveOverestimationSize_ = 0 )
36176 : flags( flags_ )
36177 , conservativeRasterizationMode( conservativeRasterizationMode_ )
36178 , extraPrimitiveOverestimationSize( extraPrimitiveOverestimationSize_ )
36179 {
36180 }
36181
36183 {
36185 }
36186
36188 {
36190 return *this;
36191 }
36193 {
36194 pNext = pNext_;
36195 return *this;
36196 }
36197
36199 {
36200 flags = flags_;
36201 return *this;
36202 }
36203
36205 {
36206 conservativeRasterizationMode = conservativeRasterizationMode_;
36207 return *this;
36208 }
36209
36211 {
36212 extraPrimitiveOverestimationSize = extraPrimitiveOverestimationSize_;
36213 return *this;
36214 }
36215
36217 {
36218 return *reinterpret_cast<const VkPipelineRasterizationConservativeStateCreateInfoEXT*>(this);
36219 }
36220
36222 {
36223 return *reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT*>(this);
36224 }
36225
36227 {
36228 return ( sType == rhs.sType )
36229 && ( pNext == rhs.pNext )
36230 && ( flags == rhs.flags )
36233 }
36234
36236 {
36237 return !operator==( rhs );
36238 }
36239
36240 private:
36242
36243 public:
36244 const void* pNext = nullptr;
36248 };
36249 static_assert( sizeof( PipelineRasterizationConservativeStateCreateInfoEXT ) == sizeof( VkPipelineRasterizationConservativeStateCreateInfoEXT ), "struct and wrapper have different size!" );
36250
36252 {
36257 };
36258
36260
36262 {
36263 return DescriptorBindingFlagsEXT( bit0 ) | bit1;
36264 }
36265
36267 {
36268 return ~( DescriptorBindingFlagsEXT( bits ) );
36269 }
36270
36272 {
36273 enum
36274 {
36277 };
36278
36280 {
36282 const DescriptorBindingFlagsEXT* pBindingFlags_ = nullptr )
36283 : bindingCount( bindingCount_ )
36284 , pBindingFlags( pBindingFlags_ )
36285 {
36286 }
36287
36289 {
36291 }
36292
36294 {
36296 return *this;
36297 }
36299 {
36300 pNext = pNext_;
36301 return *this;
36302 }
36303
36305 {
36306 bindingCount = bindingCount_;
36307 return *this;
36308 }
36309
36311 {
36312 pBindingFlags = pBindingFlags_;
36313 return *this;
36314 }
36315
36317 {
36318 return *reinterpret_cast<const VkDescriptorSetLayoutBindingFlagsCreateInfoEXT*>(this);
36319 }
36320
36322 {
36323 return *reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfoEXT*>(this);
36324 }
36325
36327 {
36328 return ( sType == rhs.sType )
36329 && ( pNext == rhs.pNext )
36330 && ( bindingCount == rhs.bindingCount )
36331 && ( pBindingFlags == rhs.pBindingFlags );
36332 }
36333
36335 {
36336 return !operator==( rhs );
36337 }
36338
36339 private:
36341
36342 public:
36343 const void* pNext = nullptr;
36346 };
36347 static_assert( sizeof( DescriptorSetLayoutBindingFlagsCreateInfoEXT ) == sizeof( VkDescriptorSetLayoutBindingFlagsCreateInfoEXT ), "struct and wrapper have different size!" );
36348
36349 enum class VendorId
36350 {
36354 };
36355
36356 enum class DriverIdKHR
36357 {
36367 };
36368
36370 {
36372 {
36373 return *reinterpret_cast<const VkPhysicalDeviceDriverPropertiesKHR*>(this);
36374 }
36375
36377 {
36378 return *reinterpret_cast<VkPhysicalDeviceDriverPropertiesKHR*>(this);
36379 }
36380
36382 {
36383 return ( sType == rhs.sType )
36384 && ( pNext == rhs.pNext )
36385 && ( driverID == rhs.driverID )
36386 && ( memcmp( driverName, rhs.driverName, VK_MAX_DRIVER_NAME_SIZE_KHR * sizeof( char ) ) == 0 )
36387 && ( memcmp( driverInfo, rhs.driverInfo, VK_MAX_DRIVER_INFO_SIZE_KHR * sizeof( char ) ) == 0 )
36389 }
36390
36392 {
36393 return !operator==( rhs );
36394 }
36395
36396 private:
36398
36399 public:
36400 void* pNext = nullptr;
36405 };
36406 static_assert( sizeof( PhysicalDeviceDriverPropertiesKHR ) == sizeof( VkPhysicalDeviceDriverPropertiesKHR ), "struct and wrapper have different size!" );
36407
36409 {
36411 };
36412
36414
36416 {
36417 return ConditionalRenderingFlagsEXT( bit0 ) | bit1;
36418 }
36419
36421 {
36422 return ~( ConditionalRenderingFlagsEXT( bits ) );
36423 }
36424
36426 {
36427 enum
36428 {
36431 };
36432
36434 {
36436 DeviceSize offset_ = 0,
36438 : buffer( buffer_ )
36439 , offset( offset_ )
36440 , flags( flags_ )
36441 {
36442 }
36443
36445 {
36446 memcpy( this, &rhs, sizeof( ConditionalRenderingBeginInfoEXT ) );
36447 }
36448
36450 {
36451 memcpy( this, &rhs, sizeof( ConditionalRenderingBeginInfoEXT ) );
36452 return *this;
36453 }
36455 {
36456 pNext = pNext_;
36457 return *this;
36458 }
36459
36461 {
36462 buffer = buffer_;
36463 return *this;
36464 }
36465
36467 {
36468 offset = offset_;
36469 return *this;
36470 }
36471
36473 {
36474 flags = flags_;
36475 return *this;
36476 }
36477
36479 {
36480 return *reinterpret_cast<const VkConditionalRenderingBeginInfoEXT*>(this);
36481 }
36482
36484 {
36485 return *reinterpret_cast<VkConditionalRenderingBeginInfoEXT*>(this);
36486 }
36487
36489 {
36490 return ( sType == rhs.sType )
36491 && ( pNext == rhs.pNext )
36492 && ( buffer == rhs.buffer )
36493 && ( offset == rhs.offset )
36494 && ( flags == rhs.flags );
36495 }
36496
36498 {
36499 return !operator==( rhs );
36500 }
36501
36502 private:
36504
36505 public:
36506 const void* pNext = nullptr;
36510 };
36511 static_assert( sizeof( ConditionalRenderingBeginInfoEXT ) == sizeof( VkConditionalRenderingBeginInfoEXT ), "struct and wrapper have different size!" );
36512
36514 {
36527 };
36528
36530 {
36531 ShadingRatePaletteNV( uint32_t shadingRatePaletteEntryCount_ = 0,
36532 const ShadingRatePaletteEntryNV* pShadingRatePaletteEntries_ = nullptr )
36533 : shadingRatePaletteEntryCount( shadingRatePaletteEntryCount_ )
36534 , pShadingRatePaletteEntries( pShadingRatePaletteEntries_ )
36535 {
36536 }
36537
36539 {
36540 memcpy( this, &rhs, sizeof( ShadingRatePaletteNV ) );
36541 }
36542
36544 {
36545 memcpy( this, &rhs, sizeof( ShadingRatePaletteNV ) );
36546 return *this;
36547 }
36549 {
36550 shadingRatePaletteEntryCount = shadingRatePaletteEntryCount_;
36551 return *this;
36552 }
36553
36555 {
36556 pShadingRatePaletteEntries = pShadingRatePaletteEntries_;
36557 return *this;
36558 }
36559
36560 operator VkShadingRatePaletteNV const&() const
36561 {
36562 return *reinterpret_cast<const VkShadingRatePaletteNV*>(this);
36563 }
36564
36566 {
36567 return *reinterpret_cast<VkShadingRatePaletteNV*>(this);
36568 }
36569
36570 bool operator==( ShadingRatePaletteNV const& rhs ) const
36571 {
36574 }
36575
36576 bool operator!=( ShadingRatePaletteNV const& rhs ) const
36577 {
36578 return !operator==( rhs );
36579 }
36580
36583 };
36584 static_assert( sizeof( ShadingRatePaletteNV ) == sizeof( VkShadingRatePaletteNV ), "struct and wrapper have different size!" );
36585
36587 {
36589 uint32_t viewportCount_ = 0,
36590 const ShadingRatePaletteNV* pShadingRatePalettes_ = nullptr )
36591 : shadingRateImageEnable( shadingRateImageEnable_ )
36592 , viewportCount( viewportCount_ )
36593 , pShadingRatePalettes( pShadingRatePalettes_ )
36594 {
36595 }
36596
36598 {
36600 }
36601
36603 {
36605 return *this;
36606 }
36608 {
36609 pNext = pNext_;
36610 return *this;
36611 }
36612
36614 {
36615 shadingRateImageEnable = shadingRateImageEnable_;
36616 return *this;
36617 }
36618
36620 {
36621 viewportCount = viewportCount_;
36622 return *this;
36623 }
36624
36626 {
36627 pShadingRatePalettes = pShadingRatePalettes_;
36628 return *this;
36629 }
36630
36632 {
36633 return *reinterpret_cast<const VkPipelineViewportShadingRateImageStateCreateInfoNV*>(this);
36634 }
36635
36637 {
36638 return *reinterpret_cast<VkPipelineViewportShadingRateImageStateCreateInfoNV*>(this);
36639 }
36640
36642 {
36643 return ( sType == rhs.sType )
36644 && ( pNext == rhs.pNext )
36646 && ( viewportCount == rhs.viewportCount )
36648 }
36649
36651 {
36652 return !operator==( rhs );
36653 }
36654
36655 private:
36657
36658 public:
36659 const void* pNext = nullptr;
36663 };
36664 static_assert( sizeof( PipelineViewportShadingRateImageStateCreateInfoNV ) == sizeof( VkPipelineViewportShadingRateImageStateCreateInfoNV ), "struct and wrapper have different size!" );
36665
36667 {
36669 uint32_t sampleCount_ = 0,
36670 uint32_t sampleLocationCount_ = 0,
36671 const CoarseSampleLocationNV* pSampleLocations_ = nullptr )
36672 : shadingRate( shadingRate_ )
36673 , sampleCount( sampleCount_ )
36674 , sampleLocationCount( sampleLocationCount_ )
36675 , pSampleLocations( pSampleLocations_ )
36676 {
36677 }
36678
36680 {
36681 memcpy( this, &rhs, sizeof( CoarseSampleOrderCustomNV ) );
36682 }
36683
36685 {
36686 memcpy( this, &rhs, sizeof( CoarseSampleOrderCustomNV ) );
36687 return *this;
36688 }
36690 {
36691 shadingRate = shadingRate_;
36692 return *this;
36693 }
36694
36696 {
36697 sampleCount = sampleCount_;
36698 return *this;
36699 }
36700
36702 {
36703 sampleLocationCount = sampleLocationCount_;
36704 return *this;
36705 }
36706
36708 {
36709 pSampleLocations = pSampleLocations_;
36710 return *this;
36711 }
36712
36713 operator VkCoarseSampleOrderCustomNV const&() const
36714 {
36715 return *reinterpret_cast<const VkCoarseSampleOrderCustomNV*>(this);
36716 }
36717
36719 {
36720 return *reinterpret_cast<VkCoarseSampleOrderCustomNV*>(this);
36721 }
36722
36723 bool operator==( CoarseSampleOrderCustomNV const& rhs ) const
36724 {
36725 return ( shadingRate == rhs.shadingRate )
36726 && ( sampleCount == rhs.sampleCount )
36728 && ( pSampleLocations == rhs.pSampleLocations );
36729 }
36730
36731 bool operator!=( CoarseSampleOrderCustomNV const& rhs ) const
36732 {
36733 return !operator==( rhs );
36734 }
36735
36740 };
36741 static_assert( sizeof( CoarseSampleOrderCustomNV ) == sizeof( VkCoarseSampleOrderCustomNV ), "struct and wrapper have different size!" );
36742
36744 {
36749 };
36750
36752 {
36754 uint32_t customSampleOrderCount_ = 0,
36755 const CoarseSampleOrderCustomNV* pCustomSampleOrders_ = nullptr )
36756 : sampleOrderType( sampleOrderType_ )
36757 , customSampleOrderCount( customSampleOrderCount_ )
36758 , pCustomSampleOrders( pCustomSampleOrders_ )
36759 {
36760 }
36761
36763 {
36765 }
36766
36768 {
36770 return *this;
36771 }
36773 {
36774 pNext = pNext_;
36775 return *this;
36776 }
36777
36779 {
36780 sampleOrderType = sampleOrderType_;
36781 return *this;
36782 }
36783
36785 {
36786 customSampleOrderCount = customSampleOrderCount_;
36787 return *this;
36788 }
36789
36791 {
36792 pCustomSampleOrders = pCustomSampleOrders_;
36793 return *this;
36794 }
36795
36797 {
36798 return *reinterpret_cast<const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(this);
36799 }
36800
36802 {
36803 return *reinterpret_cast<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV*>(this);
36804 }
36805
36807 {
36808 return ( sType == rhs.sType )
36809 && ( pNext == rhs.pNext )
36810 && ( sampleOrderType == rhs.sampleOrderType )
36813 }
36814
36816 {
36817 return !operator==( rhs );
36818 }
36819
36820 private:
36822
36823 public:
36824 const void* pNext = nullptr;
36828 };
36829 static_assert( sizeof( PipelineViewportCoarseSampleOrderStateCreateInfoNV ) == sizeof( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV ), "struct and wrapper have different size!" );
36830
36832 {
36837 };
36838
36840
36842 {
36843 return GeometryInstanceFlagsNV( bit0 ) | bit1;
36844 }
36845
36847 {
36848 return ~( GeometryInstanceFlagsNV( bits ) );
36849 }
36850
36852 {
36853 enum
36854 {
36857 };
36858
36860 {
36863 };
36864
36866
36868 {
36869 return GeometryFlagsNV( bit0 ) | bit1;
36870 }
36871
36873 {
36874 return ~( GeometryFlagsNV( bits ) );
36875 }
36876
36877 template <> struct FlagTraits<GeometryFlagBitsNV>
36878 {
36879 enum
36880 {
36883 };
36884
36886 {
36892 };
36893
36895
36897 {
36898 return BuildAccelerationStructureFlagsNV( bit0 ) | bit1;
36899 }
36900
36902 {
36904 }
36905
36907 {
36908 enum
36909 {
36912 };
36913
36915 {
36918 };
36919
36921 {
36924 };
36925
36927 {
36930 };
36931
36933 {
36935 GeometryDataNV geometry_ = GeometryDataNV(),
36936 GeometryFlagsNV flags_ = GeometryFlagsNV() )
36937 : geometryType( geometryType_ )
36938 , geometry( geometry_ )
36939 , flags( flags_ )
36940 {
36941 }
36942
36944 {
36945 memcpy( this, &rhs, sizeof( GeometryNV ) );
36946 }
36947
36949 {
36950 memcpy( this, &rhs, sizeof( GeometryNV ) );
36951 return *this;
36952 }
36953 GeometryNV& setPNext( const void* pNext_ )
36954 {
36955 pNext = pNext_;
36956 return *this;
36957 }
36958
36960 {
36961 geometryType = geometryType_;
36962 return *this;
36963 }
36964
36966 {
36967 geometry = geometry_;
36968 return *this;
36969 }
36970
36972 {
36973 flags = flags_;
36974 return *this;
36975 }
36976
36977 operator VkGeometryNV const&() const
36978 {
36979 return *reinterpret_cast<const VkGeometryNV*>(this);
36980 }
36981
36982 operator VkGeometryNV &()
36983 {
36984 return *reinterpret_cast<VkGeometryNV*>(this);
36985 }
36986
36987 bool operator==( GeometryNV const& rhs ) const
36988 {
36989 return ( sType == rhs.sType )
36990 && ( pNext == rhs.pNext )
36991 && ( geometryType == rhs.geometryType )
36992 && ( geometry == rhs.geometry )
36993 && ( flags == rhs.flags );
36994 }
36995
36996 bool operator!=( GeometryNV const& rhs ) const
36997 {
36998 return !operator==( rhs );
36999 }
37000
37001 private:
37003
37004 public:
37005 const void* pNext = nullptr;
37009 };
37010 static_assert( sizeof( GeometryNV ) == sizeof( VkGeometryNV ), "struct and wrapper have different size!" );
37011
37013 {
37016 uint32_t instanceCount_ = 0,
37017 uint32_t geometryCount_ = 0,
37018 const GeometryNV* pGeometries_ = nullptr )
37019 : type( type_ )
37020 , flags( flags_ )
37021 , instanceCount( instanceCount_ )
37022 , geometryCount( geometryCount_ )
37023 , pGeometries( pGeometries_ )
37024 {
37025 }
37026
37028 {
37029 memcpy( this, &rhs, sizeof( AccelerationStructureInfoNV ) );
37030 }
37031
37033 {
37034 memcpy( this, &rhs, sizeof( AccelerationStructureInfoNV ) );
37035 return *this;
37036 }
37038 {
37039 pNext = pNext_;
37040 return *this;
37041 }
37042
37044 {
37045 type = type_;
37046 return *this;
37047 }
37048
37050 {
37051 flags = flags_;
37052 return *this;
37053 }
37054
37056 {
37057 instanceCount = instanceCount_;
37058 return *this;
37059 }
37060
37062 {
37063 geometryCount = geometryCount_;
37064 return *this;
37065 }
37066
37068 {
37069 pGeometries = pGeometries_;
37070 return *this;
37071 }
37072
37073 operator VkAccelerationStructureInfoNV const&() const
37074 {
37075 return *reinterpret_cast<const VkAccelerationStructureInfoNV*>(this);
37076 }
37077
37079 {
37080 return *reinterpret_cast<VkAccelerationStructureInfoNV*>(this);
37081 }
37082
37084 {
37085 return ( sType == rhs.sType )
37086 && ( pNext == rhs.pNext )
37087 && ( type == rhs.type )
37088 && ( flags == rhs.flags )
37089 && ( instanceCount == rhs.instanceCount )
37090 && ( geometryCount == rhs.geometryCount )
37091 && ( pGeometries == rhs.pGeometries );
37092 }
37093
37095 {
37096 return !operator==( rhs );
37097 }
37098
37099 private:
37101
37102 public:
37103 const void* pNext = nullptr;
37109 };
37110 static_assert( sizeof( AccelerationStructureInfoNV ) == sizeof( VkAccelerationStructureInfoNV ), "struct and wrapper have different size!" );
37111
37113 {
37116 : compactedSize( compactedSize_ )
37117 , info( info_ )
37118 {
37119 }
37120
37122 {
37123 memcpy( this, &rhs, sizeof( AccelerationStructureCreateInfoNV ) );
37124 }
37125
37127 {
37128 memcpy( this, &rhs, sizeof( AccelerationStructureCreateInfoNV ) );
37129 return *this;
37130 }
37132 {
37133 pNext = pNext_;
37134 return *this;
37135 }
37136
37138 {
37139 compactedSize = compactedSize_;
37140 return *this;
37141 }
37142
37144 {
37145 info = info_;
37146 return *this;
37147 }
37148
37150 {
37151 return *reinterpret_cast<const VkAccelerationStructureCreateInfoNV*>(this);
37152 }
37153
37155 {
37156 return *reinterpret_cast<VkAccelerationStructureCreateInfoNV*>(this);
37157 }
37158
37160 {
37161 return ( sType == rhs.sType )
37162 && ( pNext == rhs.pNext )
37163 && ( compactedSize == rhs.compactedSize )
37164 && ( info == rhs.info );
37165 }
37166
37168 {
37169 return !operator==( rhs );
37170 }
37171
37172 private:
37174
37175 public:
37176 const void* pNext = nullptr;
37179 };
37180 static_assert( sizeof( AccelerationStructureCreateInfoNV ) == sizeof( VkAccelerationStructureCreateInfoNV ), "struct and wrapper have different size!" );
37181
37183 {
37187 };
37188
37190 {
37192 AccelerationStructureNV accelerationStructure_ = AccelerationStructureNV() )
37193 : type( type_ )
37194 , accelerationStructure( accelerationStructure_ )
37195 {
37196 }
37197
37199 {
37201 }
37202
37204 {
37206 return *this;
37207 }
37209 {
37210 pNext = pNext_;
37211 return *this;
37212 }
37213
37215 {
37216 type = type_;
37217 return *this;
37218 }
37219
37221 {
37222 accelerationStructure = accelerationStructure_;
37223 return *this;
37224 }
37225
37227 {
37228 return *reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV*>(this);
37229 }
37230
37232 {
37233 return *reinterpret_cast<VkAccelerationStructureMemoryRequirementsInfoNV*>(this);
37234 }
37235
37237 {
37238 return ( sType == rhs.sType )
37239 && ( pNext == rhs.pNext )
37240 && ( type == rhs.type )
37242 }
37243
37245 {
37246 return !operator==( rhs );
37247 }
37248
37249 private:
37251
37252 public:
37253 const void* pNext = nullptr;
37256 };
37257 static_assert( sizeof( AccelerationStructureMemoryRequirementsInfoNV ) == sizeof( VkAccelerationStructureMemoryRequirementsInfoNV ), "struct and wrapper have different size!" );
37258
37260 {
37264 };
37265
37267 {
37269 uint32_t generalShader_ = 0,
37270 uint32_t closestHitShader_ = 0,
37271 uint32_t anyHitShader_ = 0,
37272 uint32_t intersectionShader_ = 0 )
37273 : type( type_ )
37274 , generalShader( generalShader_ )
37275 , closestHitShader( closestHitShader_ )
37276 , anyHitShader( anyHitShader_ )
37277 , intersectionShader( intersectionShader_ )
37278 {
37279 }
37280
37282 {
37283 memcpy( this, &rhs, sizeof( RayTracingShaderGroupCreateInfoNV ) );
37284 }
37285
37287 {
37288 memcpy( this, &rhs, sizeof( RayTracingShaderGroupCreateInfoNV ) );
37289 return *this;
37290 }
37292 {
37293 pNext = pNext_;
37294 return *this;
37295 }
37296
37298 {
37299 type = type_;
37300 return *this;
37301 }
37302
37304 {
37305 generalShader = generalShader_;
37306 return *this;
37307 }
37308
37310 {
37311 closestHitShader = closestHitShader_;
37312 return *this;
37313 }
37314
37316 {
37317 anyHitShader = anyHitShader_;
37318 return *this;
37319 }
37320
37322 {
37323 intersectionShader = intersectionShader_;
37324 return *this;
37325 }
37326
37328 {
37329 return *reinterpret_cast<const VkRayTracingShaderGroupCreateInfoNV*>(this);
37330 }
37331
37333 {
37334 return *reinterpret_cast<VkRayTracingShaderGroupCreateInfoNV*>(this);
37335 }
37336
37338 {
37339 return ( sType == rhs.sType )
37340 && ( pNext == rhs.pNext )
37341 && ( type == rhs.type )
37342 && ( generalShader == rhs.generalShader )
37344 && ( anyHitShader == rhs.anyHitShader )
37346 }
37347
37349 {
37350 return !operator==( rhs );
37351 }
37352
37353 private:
37355
37356 public:
37357 const void* pNext = nullptr;
37363 };
37364 static_assert( sizeof( RayTracingShaderGroupCreateInfoNV ) == sizeof( VkRayTracingShaderGroupCreateInfoNV ), "struct and wrapper have different size!" );
37365
37367 {
37369 uint32_t stageCount_ = 0,
37370 const PipelineShaderStageCreateInfo* pStages_ = nullptr,
37371 uint32_t groupCount_ = 0,
37372 const RayTracingShaderGroupCreateInfoNV* pGroups_ = nullptr,
37373 uint32_t maxRecursionDepth_ = 0,
37374 PipelineLayout layout_ = PipelineLayout(),
37375 Pipeline basePipelineHandle_ = Pipeline(),
37376 int32_t basePipelineIndex_ = 0 )
37377 : flags( flags_ )
37378 , stageCount( stageCount_ )
37379 , pStages( pStages_ )
37380 , groupCount( groupCount_ )
37381 , pGroups( pGroups_ )
37382 , maxRecursionDepth( maxRecursionDepth_ )
37383 , layout( layout_ )
37384 , basePipelineHandle( basePipelineHandle_ )
37385 , basePipelineIndex( basePipelineIndex_ )
37386 {
37387 }
37388
37390 {
37391 memcpy( this, &rhs, sizeof( RayTracingPipelineCreateInfoNV ) );
37392 }
37393
37395 {
37396 memcpy( this, &rhs, sizeof( RayTracingPipelineCreateInfoNV ) );
37397 return *this;
37398 }
37400 {
37401 pNext = pNext_;
37402 return *this;
37403 }
37404
37406 {
37407 flags = flags_;
37408 return *this;
37409 }
37410
37412 {
37413 stageCount = stageCount_;
37414 return *this;
37415 }
37416
37418 {
37419 pStages = pStages_;
37420 return *this;
37421 }
37422
37424 {
37425 groupCount = groupCount_;
37426 return *this;
37427 }
37428
37430 {
37431 pGroups = pGroups_;
37432 return *this;
37433 }
37434
37436 {
37437 maxRecursionDepth = maxRecursionDepth_;
37438 return *this;
37439 }
37440
37442 {
37443 layout = layout_;
37444 return *this;
37445 }
37446
37448 {
37449 basePipelineHandle = basePipelineHandle_;
37450 return *this;
37451 }
37452
37454 {
37455 basePipelineIndex = basePipelineIndex_;
37456 return *this;
37457 }
37458
37459 operator VkRayTracingPipelineCreateInfoNV const&() const
37460 {
37461 return *reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>(this);
37462 }
37463
37465 {
37466 return *reinterpret_cast<VkRayTracingPipelineCreateInfoNV*>(this);
37467 }
37468
37470 {
37471 return ( sType == rhs.sType )
37472 && ( pNext == rhs.pNext )
37473 && ( flags == rhs.flags )
37474 && ( stageCount == rhs.stageCount )
37475 && ( pStages == rhs.pStages )
37476 && ( groupCount == rhs.groupCount )
37477 && ( pGroups == rhs.pGroups )
37479 && ( layout == rhs.layout )
37482 }
37483
37485 {
37486 return !operator==( rhs );
37487 }
37488
37489 private:
37491
37492 public:
37493 const void* pNext = nullptr;
37503 };
37504 static_assert( sizeof( RayTracingPipelineCreateInfoNV ) == sizeof( VkRayTracingPipelineCreateInfoNV ), "struct and wrapper have different size!" );
37505
37507 {
37511 };
37512
37514 {
37516 : overallocationBehavior( overallocationBehavior_ )
37517 {
37518 }
37519
37521 {
37522 memcpy( this, &rhs, sizeof( DeviceMemoryOverallocationCreateInfoAMD ) );
37523 }
37524
37526 {
37527 memcpy( this, &rhs, sizeof( DeviceMemoryOverallocationCreateInfoAMD ) );
37528 return *this;
37529 }
37531 {
37532 pNext = pNext_;
37533 return *this;
37534 }
37535
37537 {
37538 overallocationBehavior = overallocationBehavior_;
37539 return *this;
37540 }
37541
37543 {
37544 return *reinterpret_cast<const VkDeviceMemoryOverallocationCreateInfoAMD*>(this);
37545 }
37546
37548 {
37549 return *reinterpret_cast<VkDeviceMemoryOverallocationCreateInfoAMD*>(this);
37550 }
37551
37553 {
37554 return ( sType == rhs.sType )
37555 && ( pNext == rhs.pNext )
37557 }
37558
37560 {
37561 return !operator==( rhs );
37562 }
37563
37564 private:
37566
37567 public:
37568 const void* pNext = nullptr;
37570 };
37571 static_assert( sizeof( DeviceMemoryOverallocationCreateInfoAMD ) == sizeof( VkDeviceMemoryOverallocationCreateInfoAMD ), "struct and wrapper have different size!" );
37572
37573 template<typename Dispatch = DispatchLoaderStatic>
37574 Result enumerateInstanceVersion( uint32_t* pApiVersion, Dispatch const &d = Dispatch() );
37575#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
37576 template<typename Dispatch = DispatchLoaderStatic>
37577 ResultValueType<uint32_t>::type enumerateInstanceVersion(Dispatch const &d = Dispatch() );
37578#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
37579
37580 template<typename Dispatch>
37582 {
37583 return static_cast<Result>( d.vkEnumerateInstanceVersion( pApiVersion ) );
37584 }
37585#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
37586 template<typename Dispatch>
37588 {
37589 uint32_t apiVersion;
37590 Result result = static_cast<Result>( d.vkEnumerateInstanceVersion( &apiVersion ) );
37591 return createResultValue( result, apiVersion, VULKAN_HPP_NAMESPACE_STRING"::enumerateInstanceVersion" );
37592 }
37593#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
37594
37595
37596 template<typename Dispatch = DispatchLoaderStatic>
37597 Result enumerateInstanceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties, Dispatch const &d = Dispatch() );
37598#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
37599 template <typename Allocator = std::allocator<LayerProperties>, typename Dispatch = DispatchLoaderStatic>
37600 typename ResultValueType<std::vector<LayerProperties,Allocator>>::type enumerateInstanceLayerProperties(Dispatch const &d = Dispatch() );
37601 template <typename Allocator = std::allocator<LayerProperties>, typename Dispatch = DispatchLoaderStatic>
37602 typename ResultValueType<std::vector<LayerProperties,Allocator>>::type enumerateInstanceLayerProperties(Allocator const& vectorAllocator, Dispatch const &d );
37603#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
37604
37605 template<typename Dispatch>
37607 {
37608 return static_cast<Result>( d.vkEnumerateInstanceLayerProperties( pPropertyCount, reinterpret_cast<VkLayerProperties*>( pProperties ) ) );
37609 }
37610#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
37611 template <typename Allocator, typename Dispatch>
37613 {
37614 std::vector<LayerProperties,Allocator> properties;
37615 uint32_t propertyCount;
37616 Result result;
37617 do
37618 {
37619 result = static_cast<Result>( d.vkEnumerateInstanceLayerProperties( &propertyCount, nullptr ) );
37620 if ( ( result == Result::eSuccess ) && propertyCount )
37621 {
37622 properties.resize( propertyCount );
37623 result = static_cast<Result>( d.vkEnumerateInstanceLayerProperties( &propertyCount, reinterpret_cast<VkLayerProperties*>( properties.data() ) ) );
37624 }
37625 } while ( result == Result::eIncomplete );
37626 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
37627 properties.resize( propertyCount );
37628 return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::enumerateInstanceLayerProperties" );
37629 }
37630 template <typename Allocator, typename Dispatch>
37632 {
37633 std::vector<LayerProperties,Allocator> properties( vectorAllocator );
37634 uint32_t propertyCount;
37635 Result result;
37636 do
37637 {
37638 result = static_cast<Result>( d.vkEnumerateInstanceLayerProperties( &propertyCount, nullptr ) );
37639 if ( ( result == Result::eSuccess ) && propertyCount )
37640 {
37641 properties.resize( propertyCount );
37642 result = static_cast<Result>( d.vkEnumerateInstanceLayerProperties( &propertyCount, reinterpret_cast<VkLayerProperties*>( properties.data() ) ) );
37643 }
37644 } while ( result == Result::eIncomplete );
37645 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
37646 properties.resize( propertyCount );
37647 return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::enumerateInstanceLayerProperties" );
37648 }
37649#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
37650
37651
37652 template<typename Dispatch = DispatchLoaderStatic>
37653 Result enumerateInstanceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties, Dispatch const &d = Dispatch() );
37654#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
37655 template <typename Allocator = std::allocator<ExtensionProperties>, typename Dispatch = DispatchLoaderStatic>
37656 typename ResultValueType<std::vector<ExtensionProperties,Allocator>>::type enumerateInstanceExtensionProperties( Optional<const std::string> layerName = nullptr, Dispatch const &d = Dispatch() );
37657 template <typename Allocator = std::allocator<ExtensionProperties>, typename Dispatch = DispatchLoaderStatic>
37658 typename ResultValueType<std::vector<ExtensionProperties,Allocator>>::type enumerateInstanceExtensionProperties( Optional<const std::string> layerName, Allocator const& vectorAllocator, Dispatch const &d );
37659#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
37660
37661 template<typename Dispatch>
37662 VULKAN_HPP_INLINE Result enumerateInstanceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties, Dispatch const &d)
37663 {
37664 return static_cast<Result>( d.vkEnumerateInstanceExtensionProperties( pLayerName, pPropertyCount, reinterpret_cast<VkExtensionProperties*>( pProperties ) ) );
37665 }
37666#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
37667 template <typename Allocator, typename Dispatch>
37669 {
37670 std::vector<ExtensionProperties,Allocator> properties;
37671 uint32_t propertyCount;
37672 Result result;
37673 do
37674 {
37675 result = static_cast<Result>( d.vkEnumerateInstanceExtensionProperties( layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) );
37676 if ( ( result == Result::eSuccess ) && propertyCount )
37677 {
37678 properties.resize( propertyCount );
37679 result = static_cast<Result>( d.vkEnumerateInstanceExtensionProperties( layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast<VkExtensionProperties*>( properties.data() ) ) );
37680 }
37681 } while ( result == Result::eIncomplete );
37682 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
37683 properties.resize( propertyCount );
37684 return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::enumerateInstanceExtensionProperties" );
37685 }
37686 template <typename Allocator, typename Dispatch>
37688 {
37689 std::vector<ExtensionProperties,Allocator> properties( vectorAllocator );
37690 uint32_t propertyCount;
37691 Result result;
37692 do
37693 {
37694 result = static_cast<Result>( d.vkEnumerateInstanceExtensionProperties( layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) );
37695 if ( ( result == Result::eSuccess ) && propertyCount )
37696 {
37697 properties.resize( propertyCount );
37698 result = static_cast<Result>( d.vkEnumerateInstanceExtensionProperties( layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast<VkExtensionProperties*>( properties.data() ) ) );
37699 }
37700 } while ( result == Result::eIncomplete );
37701 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
37702 properties.resize( propertyCount );
37703 return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::enumerateInstanceExtensionProperties" );
37704 }
37705#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
37706
37707
37708 // forward declarations
37709 struct CmdProcessCommandsInfoNVX;
37710
37712 {
37713 public:
37716 {}
37717
37720 {}
37721
37722 VULKAN_HPP_TYPESAFE_EXPLICIT CommandBuffer( VkCommandBuffer commandBuffer )
37723 : m_commandBuffer( commandBuffer )
37724 {}
37725
37726#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
37727 CommandBuffer & operator=(VkCommandBuffer commandBuffer)
37728 {
37729 m_commandBuffer = commandBuffer;
37730 return *this;
37731 }
37732#endif
37733
37734 CommandBuffer & operator=( std::nullptr_t )
37735 {
37737 return *this;
37738 }
37739
37740 bool operator==( CommandBuffer const & rhs ) const
37741 {
37742 return m_commandBuffer == rhs.m_commandBuffer;
37743 }
37744
37745 bool operator!=(CommandBuffer const & rhs ) const
37746 {
37747 return m_commandBuffer != rhs.m_commandBuffer;
37748 }
37749
37750 bool operator<(CommandBuffer const & rhs ) const
37751 {
37752 return m_commandBuffer < rhs.m_commandBuffer;
37753 }
37754
37755 template<typename Dispatch = DispatchLoaderStatic>
37756 Result begin( const CommandBufferBeginInfo* pBeginInfo, Dispatch const &d = Dispatch() ) const;
37757#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
37758 template<typename Dispatch = DispatchLoaderStatic>
37759 ResultValueType<void>::type begin( const CommandBufferBeginInfo & beginInfo, Dispatch const &d = Dispatch() ) const;
37760#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
37761
37762#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
37763 template<typename Dispatch = DispatchLoaderStatic>
37764 Result end(Dispatch const &d = Dispatch() ) const;
37765#else
37766 template<typename Dispatch = DispatchLoaderStatic>
37767 ResultValueType<void>::type end(Dispatch const &d = Dispatch() ) const;
37768#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
37769
37770#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
37771 template<typename Dispatch = DispatchLoaderStatic>
37772 Result reset( CommandBufferResetFlags flags, Dispatch const &d = Dispatch() ) const;
37773#else
37774 template<typename Dispatch = DispatchLoaderStatic>
37775 ResultValueType<void>::type reset( CommandBufferResetFlags flags, Dispatch const &d = Dispatch() ) const;
37776#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
37777
37778 template<typename Dispatch = DispatchLoaderStatic>
37779 void bindPipeline( PipelineBindPoint pipelineBindPoint, Pipeline pipeline, Dispatch const &d = Dispatch() ) const;
37780
37781 template<typename Dispatch = DispatchLoaderStatic>
37782 void setViewport( uint32_t firstViewport, uint32_t viewportCount, const Viewport* pViewports, Dispatch const &d = Dispatch() ) const;
37783#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
37784 template<typename Dispatch = DispatchLoaderStatic>
37785 void setViewport( uint32_t firstViewport, ArrayProxy<const Viewport> viewports, Dispatch const &d = Dispatch() ) const;
37786#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
37787
37788 template<typename Dispatch = DispatchLoaderStatic>
37789 void setScissor( uint32_t firstScissor, uint32_t scissorCount, const Rect2D* pScissors, Dispatch const &d = Dispatch() ) const;
37790#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
37791 template<typename Dispatch = DispatchLoaderStatic>
37792 void setScissor( uint32_t firstScissor, ArrayProxy<const Rect2D> scissors, Dispatch const &d = Dispatch() ) const;
37793#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
37794
37795 template<typename Dispatch = DispatchLoaderStatic>
37796 void setLineWidth( float lineWidth, Dispatch const &d = Dispatch() ) const;
37797
37798 template<typename Dispatch = DispatchLoaderStatic>
37799 void setDepthBias( float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor, Dispatch const &d = Dispatch() ) const;
37800
37801 template<typename Dispatch = DispatchLoaderStatic>
37802 void setBlendConstants( const float blendConstants[4], Dispatch const &d = Dispatch() ) const;
37803
37804 template<typename Dispatch = DispatchLoaderStatic>
37805 void setDepthBounds( float minDepthBounds, float maxDepthBounds, Dispatch const &d = Dispatch() ) const;
37806
37807 template<typename Dispatch = DispatchLoaderStatic>
37808 void setStencilCompareMask( StencilFaceFlags faceMask, uint32_t compareMask, Dispatch const &d = Dispatch() ) const;
37809
37810 template<typename Dispatch = DispatchLoaderStatic>
37811 void setStencilWriteMask( StencilFaceFlags faceMask, uint32_t writeMask, Dispatch const &d = Dispatch() ) const;
37812
37813 template<typename Dispatch = DispatchLoaderStatic>
37814 void setStencilReference( StencilFaceFlags faceMask, uint32_t reference, Dispatch const &d = Dispatch() ) const;
37815
37816 template<typename Dispatch = DispatchLoaderStatic>
37817 void bindDescriptorSets( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets, Dispatch const &d = Dispatch() ) const;
37818#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
37819 template<typename Dispatch = DispatchLoaderStatic>
37820 void bindDescriptorSets( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t firstSet, ArrayProxy<const DescriptorSet> descriptorSets, ArrayProxy<const uint32_t> dynamicOffsets, Dispatch const &d = Dispatch() ) const;
37821#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
37822
37823 template<typename Dispatch = DispatchLoaderStatic>
37824 void bindIndexBuffer( Buffer buffer, DeviceSize offset, IndexType indexType, Dispatch const &d = Dispatch() ) const;
37825
37826 template<typename Dispatch = DispatchLoaderStatic>
37827 void bindVertexBuffers( uint32_t firstBinding, uint32_t bindingCount, const Buffer* pBuffers, const DeviceSize* pOffsets, Dispatch const &d = Dispatch() ) const;
37828#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
37829 template<typename Dispatch = DispatchLoaderStatic>
37830 void bindVertexBuffers( uint32_t firstBinding, ArrayProxy<const Buffer> buffers, ArrayProxy<const DeviceSize> offsets, Dispatch const &d = Dispatch() ) const;
37831#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
37832
37833 template<typename Dispatch = DispatchLoaderStatic>
37834 void draw( uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance, Dispatch const &d = Dispatch() ) const;
37835
37836 template<typename Dispatch = DispatchLoaderStatic>
37837 void drawIndexed( uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance, Dispatch const &d = Dispatch() ) const;
37838
37839 template<typename Dispatch = DispatchLoaderStatic>
37840 void drawIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
37841
37842 template<typename Dispatch = DispatchLoaderStatic>
37843 void drawIndexedIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
37844
37845 template<typename Dispatch = DispatchLoaderStatic>
37846 void dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d = Dispatch() ) const;
37847
37848 template<typename Dispatch = DispatchLoaderStatic>
37849 void dispatchIndirect( Buffer buffer, DeviceSize offset, Dispatch const &d = Dispatch() ) const;
37850
37851 template<typename Dispatch = DispatchLoaderStatic>
37852 void copyBuffer( Buffer srcBuffer, Buffer dstBuffer, uint32_t regionCount, const BufferCopy* pRegions, Dispatch const &d = Dispatch() ) const;
37853#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
37854 template<typename Dispatch = DispatchLoaderStatic>
37855 void copyBuffer( Buffer srcBuffer, Buffer dstBuffer, ArrayProxy<const BufferCopy> regions, Dispatch const &d = Dispatch() ) const;
37856#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
37857
37858 template<typename Dispatch = DispatchLoaderStatic>
37859 void copyImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageCopy* pRegions, Dispatch const &d = Dispatch() ) const;
37860#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
37861 template<typename Dispatch = DispatchLoaderStatic>
37862 void copyImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const ImageCopy> regions, Dispatch const &d = Dispatch() ) const;
37863#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
37864
37865 template<typename Dispatch = DispatchLoaderStatic>
37866 void blitImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageBlit* pRegions, Filter filter, Dispatch const &d = Dispatch() ) const;
37867#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
37868 template<typename Dispatch = DispatchLoaderStatic>
37869 void blitImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const ImageBlit> regions, Filter filter, Dispatch const &d = Dispatch() ) const;
37870#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
37871
37872 template<typename Dispatch = DispatchLoaderStatic>
37873 void copyBufferToImage( Buffer srcBuffer, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const BufferImageCopy* pRegions, Dispatch const &d = Dispatch() ) const;
37874#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
37875 template<typename Dispatch = DispatchLoaderStatic>
37876 void copyBufferToImage( Buffer srcBuffer, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const BufferImageCopy> regions, Dispatch const &d = Dispatch() ) const;
37877#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
37878
37879 template<typename Dispatch = DispatchLoaderStatic>
37880 void copyImageToBuffer( Image srcImage, ImageLayout srcImageLayout, Buffer dstBuffer, uint32_t regionCount, const BufferImageCopy* pRegions, Dispatch const &d = Dispatch() ) const;
37881#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
37882 template<typename Dispatch = DispatchLoaderStatic>
37883 void copyImageToBuffer( Image srcImage, ImageLayout srcImageLayout, Buffer dstBuffer, ArrayProxy<const BufferImageCopy> regions, Dispatch const &d = Dispatch() ) const;
37884#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
37885
37886 template<typename Dispatch = DispatchLoaderStatic>
37887 void updateBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize dataSize, const void* pData, Dispatch const &d = Dispatch() ) const;
37888#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
37889 template <typename T, typename Dispatch = DispatchLoaderStatic>
37890 void updateBuffer( Buffer dstBuffer, DeviceSize dstOffset, ArrayProxy<const T> data, Dispatch const &d = Dispatch() ) const;
37891#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
37892
37893 template<typename Dispatch = DispatchLoaderStatic>
37894 void fillBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize size, uint32_t data, Dispatch const &d = Dispatch() ) const;
37895
37896 template<typename Dispatch = DispatchLoaderStatic>
37897 void clearColorImage( Image image, ImageLayout imageLayout, const ClearColorValue* pColor, uint32_t rangeCount, const ImageSubresourceRange* pRanges, Dispatch const &d = Dispatch() ) const;
37898#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
37899 template<typename Dispatch = DispatchLoaderStatic>
37900 void clearColorImage( Image image, ImageLayout imageLayout, const ClearColorValue & color, ArrayProxy<const ImageSubresourceRange> ranges, Dispatch const &d = Dispatch() ) const;
37901#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
37902
37903 template<typename Dispatch = DispatchLoaderStatic>
37904 void clearDepthStencilImage( Image image, ImageLayout imageLayout, const ClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const ImageSubresourceRange* pRanges, Dispatch const &d = Dispatch() ) const;
37905#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
37906 template<typename Dispatch = DispatchLoaderStatic>
37907 void clearDepthStencilImage( Image image, ImageLayout imageLayout, const ClearDepthStencilValue & depthStencil, ArrayProxy<const ImageSubresourceRange> ranges, Dispatch const &d = Dispatch() ) const;
37908#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
37909
37910 template<typename Dispatch = DispatchLoaderStatic>
37911 void clearAttachments( uint32_t attachmentCount, const ClearAttachment* pAttachments, uint32_t rectCount, const ClearRect* pRects, Dispatch const &d = Dispatch() ) const;
37912#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
37913 template<typename Dispatch = DispatchLoaderStatic>
37915#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
37916
37917 template<typename Dispatch = DispatchLoaderStatic>
37918 void resolveImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageResolve* pRegions, Dispatch const &d = Dispatch() ) const;
37919#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
37920 template<typename Dispatch = DispatchLoaderStatic>
37921 void resolveImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const ImageResolve> regions, Dispatch const &d = Dispatch() ) const;
37922#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
37923
37924 template<typename Dispatch = DispatchLoaderStatic>
37925 void setEvent( Event event, PipelineStageFlags stageMask, Dispatch const &d = Dispatch() ) const;
37926
37927 template<typename Dispatch = DispatchLoaderStatic>
37928 void resetEvent( Event event, PipelineStageFlags stageMask, Dispatch const &d = Dispatch() ) const;
37929
37930 template<typename Dispatch = DispatchLoaderStatic>
37931 void waitEvents( uint32_t eventCount, const Event* pEvents, PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const MemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const BufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const ImageMemoryBarrier* pImageMemoryBarriers, Dispatch const &d = Dispatch() ) const;
37932#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
37933 template<typename Dispatch = DispatchLoaderStatic>
37934 void waitEvents( ArrayProxy<const Event> events, PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, ArrayProxy<const MemoryBarrier> memoryBarriers, ArrayProxy<const BufferMemoryBarrier> bufferMemoryBarriers, ArrayProxy<const ImageMemoryBarrier> imageMemoryBarriers, Dispatch const &d = Dispatch() ) const;
37935#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
37936
37937 template<typename Dispatch = DispatchLoaderStatic>
37938 void pipelineBarrier( PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, DependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const MemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const BufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const ImageMemoryBarrier* pImageMemoryBarriers, Dispatch const &d = Dispatch() ) const;
37939#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
37940 template<typename Dispatch = DispatchLoaderStatic>
37941 void pipelineBarrier( PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, DependencyFlags dependencyFlags, ArrayProxy<const MemoryBarrier> memoryBarriers, ArrayProxy<const BufferMemoryBarrier> bufferMemoryBarriers, ArrayProxy<const ImageMemoryBarrier> imageMemoryBarriers, Dispatch const &d = Dispatch() ) const;
37942#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
37943
37944 template<typename Dispatch = DispatchLoaderStatic>
37945 void beginQuery( QueryPool queryPool, uint32_t query, QueryControlFlags flags, Dispatch const &d = Dispatch() ) const;
37946
37947 template<typename Dispatch = DispatchLoaderStatic>
37948 void endQuery( QueryPool queryPool, uint32_t query, Dispatch const &d = Dispatch() ) const;
37949
37950 template<typename Dispatch = DispatchLoaderStatic>
37951 void beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin, Dispatch const &d = Dispatch() ) const;
37952#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
37953 template<typename Dispatch = DispatchLoaderStatic>
37954 void beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin, Dispatch const &d = Dispatch() ) const;
37955#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
37956
37957 template<typename Dispatch = DispatchLoaderStatic>
37958 void endConditionalRenderingEXT(Dispatch const &d = Dispatch() ) const;
37959
37960 template<typename Dispatch = DispatchLoaderStatic>
37961 void resetQueryPool( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d = Dispatch() ) const;
37962
37963 template<typename Dispatch = DispatchLoaderStatic>
37964 void writeTimestamp( PipelineStageFlagBits pipelineStage, QueryPool queryPool, uint32_t query, Dispatch const &d = Dispatch() ) const;
37965
37966 template<typename Dispatch = DispatchLoaderStatic>
37967 void copyQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Buffer dstBuffer, DeviceSize dstOffset, DeviceSize stride, QueryResultFlags flags, Dispatch const &d = Dispatch() ) const;
37968
37969 template<typename Dispatch = DispatchLoaderStatic>
37970 void pushConstants( PipelineLayout layout, ShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues, Dispatch const &d = Dispatch() ) const;
37971#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
37972 template <typename T, typename Dispatch = DispatchLoaderStatic>
37973 void pushConstants( PipelineLayout layout, ShaderStageFlags stageFlags, uint32_t offset, ArrayProxy<const T> values, Dispatch const &d = Dispatch() ) const;
37974#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
37975
37976 template<typename Dispatch = DispatchLoaderStatic>
37977 void beginRenderPass( const RenderPassBeginInfo* pRenderPassBegin, SubpassContents contents, Dispatch const &d = Dispatch() ) const;
37978#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
37979 template<typename Dispatch = DispatchLoaderStatic>
37980 void beginRenderPass( const RenderPassBeginInfo & renderPassBegin, SubpassContents contents, Dispatch const &d = Dispatch() ) const;
37981#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
37982
37983 template<typename Dispatch = DispatchLoaderStatic>
37984 void nextSubpass( SubpassContents contents, Dispatch const &d = Dispatch() ) const;
37985
37986 template<typename Dispatch = DispatchLoaderStatic>
37987 void endRenderPass(Dispatch const &d = Dispatch() ) const;
37988
37989 template<typename Dispatch = DispatchLoaderStatic>
37990 void executeCommands( uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers, Dispatch const &d = Dispatch() ) const;
37991#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
37992 template<typename Dispatch = DispatchLoaderStatic>
37993 void executeCommands( ArrayProxy<const CommandBuffer> commandBuffers, Dispatch const &d = Dispatch() ) const;
37994#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
37995
37996 template<typename Dispatch = DispatchLoaderStatic>
37997 void debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT* pMarkerInfo, Dispatch const &d = Dispatch() ) const;
37998#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
37999 template<typename Dispatch = DispatchLoaderStatic>
38000 void debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT & markerInfo, Dispatch const &d = Dispatch() ) const;
38001#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38002
38003 template<typename Dispatch = DispatchLoaderStatic>
38004 void debugMarkerEndEXT(Dispatch const &d = Dispatch() ) const;
38005
38006 template<typename Dispatch = DispatchLoaderStatic>
38007 void debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT* pMarkerInfo, Dispatch const &d = Dispatch() ) const;
38008#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38009 template<typename Dispatch = DispatchLoaderStatic>
38010 void debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT & markerInfo, Dispatch const &d = Dispatch() ) const;
38011#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38012
38013 template<typename Dispatch = DispatchLoaderStatic>
38014 void drawIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
38015
38016 template<typename Dispatch = DispatchLoaderStatic>
38017 void drawIndexedIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
38018
38019 template<typename Dispatch = DispatchLoaderStatic>
38020 void processCommandsNVX( const CmdProcessCommandsInfoNVX* pProcessCommandsInfo, Dispatch const &d = Dispatch() ) const;
38021#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38022 template<typename Dispatch = DispatchLoaderStatic>
38023 void processCommandsNVX( const CmdProcessCommandsInfoNVX & processCommandsInfo, Dispatch const &d = Dispatch() ) const;
38024#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38025
38026 template<typename Dispatch = DispatchLoaderStatic>
38027 void reserveSpaceForCommandsNVX( const CmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo, Dispatch const &d = Dispatch() ) const;
38028#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38029 template<typename Dispatch = DispatchLoaderStatic>
38030 void reserveSpaceForCommandsNVX( const CmdReserveSpaceForCommandsInfoNVX & reserveSpaceInfo, Dispatch const &d = Dispatch() ) const;
38031#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38032
38033 template<typename Dispatch = DispatchLoaderStatic>
38034 void pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const WriteDescriptorSet* pDescriptorWrites, Dispatch const &d = Dispatch() ) const;
38035#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38036 template<typename Dispatch = DispatchLoaderStatic>
38037 void pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t set, ArrayProxy<const WriteDescriptorSet> descriptorWrites, Dispatch const &d = Dispatch() ) const;
38038#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38039
38040 template<typename Dispatch = DispatchLoaderStatic>
38041 void setDeviceMask( uint32_t deviceMask, Dispatch const &d = Dispatch() ) const;
38042
38043 template<typename Dispatch = DispatchLoaderStatic>
38044 void setDeviceMaskKHR( uint32_t deviceMask, Dispatch const &d = Dispatch() ) const;
38045
38046 template<typename Dispatch = DispatchLoaderStatic>
38047 void dispatchBase( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d = Dispatch() ) const;
38048
38049 template<typename Dispatch = DispatchLoaderStatic>
38050 void dispatchBaseKHR( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d = Dispatch() ) const;
38051
38052 template<typename Dispatch = DispatchLoaderStatic>
38053 void pushDescriptorSetWithTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, PipelineLayout layout, uint32_t set, const void* pData, Dispatch const &d = Dispatch() ) const;
38054
38055 template<typename Dispatch = DispatchLoaderStatic>
38056 void setViewportWScalingNV( uint32_t firstViewport, uint32_t viewportCount, const ViewportWScalingNV* pViewportWScalings, Dispatch const &d = Dispatch() ) const;
38057#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38058 template<typename Dispatch = DispatchLoaderStatic>
38059 void setViewportWScalingNV( uint32_t firstViewport, ArrayProxy<const ViewportWScalingNV> viewportWScalings, Dispatch const &d = Dispatch() ) const;
38060#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38061
38062 template<typename Dispatch = DispatchLoaderStatic>
38063 void setDiscardRectangleEXT( uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const Rect2D* pDiscardRectangles, Dispatch const &d = Dispatch() ) const;
38064#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38065 template<typename Dispatch = DispatchLoaderStatic>
38066 void setDiscardRectangleEXT( uint32_t firstDiscardRectangle, ArrayProxy<const Rect2D> discardRectangles, Dispatch const &d = Dispatch() ) const;
38067#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38068
38069 template<typename Dispatch = DispatchLoaderStatic>
38070 void setSampleLocationsEXT( const SampleLocationsInfoEXT* pSampleLocationsInfo, Dispatch const &d = Dispatch() ) const;
38071#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38072 template<typename Dispatch = DispatchLoaderStatic>
38073 void setSampleLocationsEXT( const SampleLocationsInfoEXT & sampleLocationsInfo, Dispatch const &d = Dispatch() ) const;
38074#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38075
38076 template<typename Dispatch = DispatchLoaderStatic>
38077 void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d = Dispatch() ) const;
38078#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38079 template<typename Dispatch = DispatchLoaderStatic>
38080 void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d = Dispatch() ) const;
38081#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38082
38083 template<typename Dispatch = DispatchLoaderStatic>
38084 void endDebugUtilsLabelEXT(Dispatch const &d = Dispatch() ) const;
38085
38086 template<typename Dispatch = DispatchLoaderStatic>
38087 void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d = Dispatch() ) const;
38088#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38089 template<typename Dispatch = DispatchLoaderStatic>
38090 void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d = Dispatch() ) const;
38091#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38092
38093 template<typename Dispatch = DispatchLoaderStatic>
38094 void writeBufferMarkerAMD( PipelineStageFlagBits pipelineStage, Buffer dstBuffer, DeviceSize dstOffset, uint32_t marker, Dispatch const &d = Dispatch() ) const;
38095
38096 template<typename Dispatch = DispatchLoaderStatic>
38097 void beginRenderPass2KHR( const RenderPassBeginInfo* pRenderPassBegin, const SubpassBeginInfoKHR* pSubpassBeginInfo, Dispatch const &d = Dispatch() ) const;
38098#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38099 template<typename Dispatch = DispatchLoaderStatic>
38100 void beginRenderPass2KHR( const RenderPassBeginInfo & renderPassBegin, const SubpassBeginInfoKHR & subpassBeginInfo, Dispatch const &d = Dispatch() ) const;
38101#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38102
38103 template<typename Dispatch = DispatchLoaderStatic>
38104 void nextSubpass2KHR( const SubpassBeginInfoKHR* pSubpassBeginInfo, const SubpassEndInfoKHR* pSubpassEndInfo, Dispatch const &d = Dispatch() ) const;
38105#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38106 template<typename Dispatch = DispatchLoaderStatic>
38107 void nextSubpass2KHR( const SubpassBeginInfoKHR & subpassBeginInfo, const SubpassEndInfoKHR & subpassEndInfo, Dispatch const &d = Dispatch() ) const;
38108#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38109
38110 template<typename Dispatch = DispatchLoaderStatic>
38111 void endRenderPass2KHR( const SubpassEndInfoKHR* pSubpassEndInfo, Dispatch const &d = Dispatch() ) const;
38112#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38113 template<typename Dispatch = DispatchLoaderStatic>
38114 void endRenderPass2KHR( const SubpassEndInfoKHR & subpassEndInfo, Dispatch const &d = Dispatch() ) const;
38115#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38116
38117 template<typename Dispatch = DispatchLoaderStatic>
38118 void drawIndirectCountKHR( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
38119
38120 template<typename Dispatch = DispatchLoaderStatic>
38121 void drawIndexedIndirectCountKHR( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
38122
38123 template<typename Dispatch = DispatchLoaderStatic>
38124 void setCheckpointNV( const void* pCheckpointMarker, Dispatch const &d = Dispatch() ) const;
38125
38126 template<typename Dispatch = DispatchLoaderStatic>
38127 void bindTransformFeedbackBuffersEXT( uint32_t firstBinding, uint32_t bindingCount, const Buffer* pBuffers, const DeviceSize* pOffsets, const DeviceSize* pSizes, Dispatch const &d = Dispatch() ) const;
38128#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38129 template<typename Dispatch = DispatchLoaderStatic>
38131#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38132
38133 template<typename Dispatch = DispatchLoaderStatic>
38134 void beginTransformFeedbackEXT( uint32_t firstCounterBuffer, uint32_t counterBufferCount, const Buffer* pCounterBuffers, const DeviceSize* pCounterBufferOffsets, Dispatch const &d = Dispatch() ) const;
38135#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38136 template<typename Dispatch = DispatchLoaderStatic>
38137 void beginTransformFeedbackEXT( uint32_t firstCounterBuffer, ArrayProxy<const Buffer> counterBuffers, ArrayProxy<const DeviceSize> counterBufferOffsets, Dispatch const &d = Dispatch() ) const;
38138#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38139
38140 template<typename Dispatch = DispatchLoaderStatic>
38141 void endTransformFeedbackEXT( uint32_t firstCounterBuffer, uint32_t counterBufferCount, const Buffer* pCounterBuffers, const DeviceSize* pCounterBufferOffsets, Dispatch const &d = Dispatch() ) const;
38142#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38143 template<typename Dispatch = DispatchLoaderStatic>
38144 void endTransformFeedbackEXT( uint32_t firstCounterBuffer, ArrayProxy<const Buffer> counterBuffers, ArrayProxy<const DeviceSize> counterBufferOffsets, Dispatch const &d = Dispatch() ) const;
38145#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38146
38147 template<typename Dispatch = DispatchLoaderStatic>
38148 void beginQueryIndexedEXT( QueryPool queryPool, uint32_t query, QueryControlFlags flags, uint32_t index, Dispatch const &d = Dispatch() ) const;
38149
38150 template<typename Dispatch = DispatchLoaderStatic>
38151 void endQueryIndexedEXT( QueryPool queryPool, uint32_t query, uint32_t index, Dispatch const &d = Dispatch() ) const;
38152
38153 template<typename Dispatch = DispatchLoaderStatic>
38154 void drawIndirectByteCountEXT( uint32_t instanceCount, uint32_t firstInstance, Buffer counterBuffer, DeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride, Dispatch const &d = Dispatch() ) const;
38155
38156 template<typename Dispatch = DispatchLoaderStatic>
38157 void setExclusiveScissorNV( uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const Rect2D* pExclusiveScissors, Dispatch const &d = Dispatch() ) const;
38158#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38159 template<typename Dispatch = DispatchLoaderStatic>
38160 void setExclusiveScissorNV( uint32_t firstExclusiveScissor, ArrayProxy<const Rect2D> exclusiveScissors, Dispatch const &d = Dispatch() ) const;
38161#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38162
38163 template<typename Dispatch = DispatchLoaderStatic>
38164 void bindShadingRateImageNV( ImageView imageView, ImageLayout imageLayout, Dispatch const &d = Dispatch() ) const;
38165
38166 template<typename Dispatch = DispatchLoaderStatic>
38167 void setViewportShadingRatePaletteNV( uint32_t firstViewport, uint32_t viewportCount, const ShadingRatePaletteNV* pShadingRatePalettes, Dispatch const &d = Dispatch() ) const;
38168#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38169 template<typename Dispatch = DispatchLoaderStatic>
38170 void setViewportShadingRatePaletteNV( uint32_t firstViewport, ArrayProxy<const ShadingRatePaletteNV> shadingRatePalettes, Dispatch const &d = Dispatch() ) const;
38171#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38172
38173 template<typename Dispatch = DispatchLoaderStatic>
38174 void setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const CoarseSampleOrderCustomNV* pCustomSampleOrders, Dispatch const &d = Dispatch() ) const;
38175#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38176 template<typename Dispatch = DispatchLoaderStatic>
38177 void setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType, ArrayProxy<const CoarseSampleOrderCustomNV> customSampleOrders, Dispatch const &d = Dispatch() ) const;
38178#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38179
38180 template<typename Dispatch = DispatchLoaderStatic>
38181 void drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask, Dispatch const &d = Dispatch() ) const;
38182
38183 template<typename Dispatch = DispatchLoaderStatic>
38185
38186 template<typename Dispatch = DispatchLoaderStatic>
38187 void drawMeshTasksIndirectCountNV( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d = Dispatch() ) const;
38188
38189 template<typename Dispatch = DispatchLoaderStatic>
38191
38192 template<typename Dispatch = DispatchLoaderStatic>
38193 void writeAccelerationStructuresPropertiesNV( uint32_t accelerationStructureCount, const AccelerationStructureNV* pAccelerationStructures, QueryType queryType, QueryPool queryPool, uint32_t firstQuery, Dispatch const &d = Dispatch() ) const;
38194#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38195 template<typename Dispatch = DispatchLoaderStatic>
38196 void writeAccelerationStructuresPropertiesNV( ArrayProxy<const AccelerationStructureNV> accelerationStructures, QueryType queryType, QueryPool queryPool, uint32_t firstQuery, Dispatch const &d = Dispatch() ) const;
38197#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38198
38199 template<typename Dispatch = DispatchLoaderStatic>
38200 void buildAccelerationStructureNV( const AccelerationStructureInfoNV* pInfo, Buffer instanceData, DeviceSize instanceOffset, Bool32 update, AccelerationStructureNV dst, AccelerationStructureNV src, Buffer scratch, DeviceSize scratchOffset, Dispatch const &d = Dispatch() ) const;
38201#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38202 template<typename Dispatch = DispatchLoaderStatic>
38203 void buildAccelerationStructureNV( const AccelerationStructureInfoNV & info, Buffer instanceData, DeviceSize instanceOffset, Bool32 update, AccelerationStructureNV dst, AccelerationStructureNV src, Buffer scratch, DeviceSize scratchOffset, Dispatch const &d = Dispatch() ) const;
38204#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38205
38206 template<typename Dispatch = DispatchLoaderStatic>
38207 void traceRaysNV( Buffer raygenShaderBindingTableBuffer, DeviceSize raygenShaderBindingOffset, Buffer missShaderBindingTableBuffer, DeviceSize missShaderBindingOffset, DeviceSize missShaderBindingStride, Buffer hitShaderBindingTableBuffer, DeviceSize hitShaderBindingOffset, DeviceSize hitShaderBindingStride, Buffer callableShaderBindingTableBuffer, DeviceSize callableShaderBindingOffset, DeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth, Dispatch const &d = Dispatch() ) const;
38208
38209
38210
38211 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandBuffer() const
38212 {
38213 return m_commandBuffer;
38214 }
38215
38216 explicit operator bool() const
38217 {
38219 }
38220
38221 bool operator!() const
38222 {
38224 }
38225
38226 private:
38227 VkCommandBuffer m_commandBuffer;
38228 };
38229
38230 static_assert( sizeof( CommandBuffer ) == sizeof( VkCommandBuffer ), "handle and wrapper have different size!" );
38231
38232 template<typename Dispatch>
38233 VULKAN_HPP_INLINE Result CommandBuffer::begin( const CommandBufferBeginInfo* pBeginInfo, Dispatch const &d) const
38234 {
38235 return static_cast<Result>( d.vkBeginCommandBuffer( m_commandBuffer, reinterpret_cast<const VkCommandBufferBeginInfo*>( pBeginInfo ) ) );
38236 }
38237#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38238 template<typename Dispatch>
38240 {
38241 Result result = static_cast<Result>( d.vkBeginCommandBuffer( m_commandBuffer, reinterpret_cast<const VkCommandBufferBeginInfo*>( &beginInfo ) ) );
38242 return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::CommandBuffer::begin" );
38243 }
38244#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38245
38246#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
38247 template<typename Dispatch>
38248 VULKAN_HPP_INLINE Result CommandBuffer::end(Dispatch const &d) const
38249 {
38250 return static_cast<Result>( d.vkEndCommandBuffer( m_commandBuffer ) );
38251 }
38252#else
38253 template<typename Dispatch>
38255 {
38256 Result result = static_cast<Result>( d.vkEndCommandBuffer( m_commandBuffer ) );
38257 return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::CommandBuffer::end" );
38258 }
38259#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38260
38261#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
38262 template<typename Dispatch>
38264 {
38265 return static_cast<Result>( d.vkResetCommandBuffer( m_commandBuffer, static_cast<VkCommandBufferResetFlags>( flags ) ) );
38266 }
38267#else
38268 template<typename Dispatch>
38270 {
38271 Result result = static_cast<Result>( d.vkResetCommandBuffer( m_commandBuffer, static_cast<VkCommandBufferResetFlags>( flags ) ) );
38272 return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::CommandBuffer::reset" );
38273 }
38274#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38275
38276#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
38277 template<typename Dispatch>
38278 VULKAN_HPP_INLINE void CommandBuffer::bindPipeline( PipelineBindPoint pipelineBindPoint, Pipeline pipeline, Dispatch const &d) const
38279 {
38280 d.vkCmdBindPipeline( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipeline>( pipeline ) );
38281 }
38282#else
38283 template<typename Dispatch>
38284 VULKAN_HPP_INLINE void CommandBuffer::bindPipeline( PipelineBindPoint pipelineBindPoint, Pipeline pipeline, Dispatch const &d ) const
38285 {
38286 d.vkCmdBindPipeline( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipeline>( pipeline ) );
38287 }
38288#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38289
38290 template<typename Dispatch>
38291 VULKAN_HPP_INLINE void CommandBuffer::setViewport( uint32_t firstViewport, uint32_t viewportCount, const Viewport* pViewports, Dispatch const &d) const
38292 {
38293 d.vkCmdSetViewport( m_commandBuffer, firstViewport, viewportCount, reinterpret_cast<const VkViewport*>( pViewports ) );
38294 }
38295#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38296 template<typename Dispatch>
38297 VULKAN_HPP_INLINE void CommandBuffer::setViewport( uint32_t firstViewport, ArrayProxy<const Viewport> viewports, Dispatch const &d ) const
38298 {
38299 d.vkCmdSetViewport( m_commandBuffer, firstViewport, viewports.size() , reinterpret_cast<const VkViewport*>( viewports.data() ) );
38300 }
38301#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38302
38303 template<typename Dispatch>
38304 VULKAN_HPP_INLINE void CommandBuffer::setScissor( uint32_t firstScissor, uint32_t scissorCount, const Rect2D* pScissors, Dispatch const &d) const
38305 {
38306 d.vkCmdSetScissor( m_commandBuffer, firstScissor, scissorCount, reinterpret_cast<const VkRect2D*>( pScissors ) );
38307 }
38308#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38309 template<typename Dispatch>
38310 VULKAN_HPP_INLINE void CommandBuffer::setScissor( uint32_t firstScissor, ArrayProxy<const Rect2D> scissors, Dispatch const &d ) const
38311 {
38312 d.vkCmdSetScissor( m_commandBuffer, firstScissor, scissors.size() , reinterpret_cast<const VkRect2D*>( scissors.data() ) );
38313 }
38314#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38315
38316#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
38317 template<typename Dispatch>
38318 VULKAN_HPP_INLINE void CommandBuffer::setLineWidth( float lineWidth, Dispatch const &d) const
38319 {
38320 d.vkCmdSetLineWidth( m_commandBuffer, lineWidth );
38321 }
38322#else
38323 template<typename Dispatch>
38324 VULKAN_HPP_INLINE void CommandBuffer::setLineWidth( float lineWidth, Dispatch const &d ) const
38325 {
38326 d.vkCmdSetLineWidth( m_commandBuffer, lineWidth );
38327 }
38328#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38329
38330#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
38331 template<typename Dispatch>
38332 VULKAN_HPP_INLINE void CommandBuffer::setDepthBias( float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor, Dispatch const &d) const
38333 {
38334 d.vkCmdSetDepthBias( m_commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor );
38335 }
38336#else
38337 template<typename Dispatch>
38338 VULKAN_HPP_INLINE void CommandBuffer::setDepthBias( float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor, Dispatch const &d ) const
38339 {
38340 d.vkCmdSetDepthBias( m_commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor );
38341 }
38342#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38343
38344#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
38345 template<typename Dispatch>
38346 VULKAN_HPP_INLINE void CommandBuffer::setBlendConstants( const float blendConstants[4], Dispatch const &d) const
38347 {
38348 d.vkCmdSetBlendConstants( m_commandBuffer, blendConstants );
38349 }
38350#else
38351 template<typename Dispatch>
38352 VULKAN_HPP_INLINE void CommandBuffer::setBlendConstants( const float blendConstants[4], Dispatch const &d ) const
38353 {
38354 d.vkCmdSetBlendConstants( m_commandBuffer, blendConstants );
38355 }
38356#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38357
38358#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
38359 template<typename Dispatch>
38360 VULKAN_HPP_INLINE void CommandBuffer::setDepthBounds( float minDepthBounds, float maxDepthBounds, Dispatch const &d) const
38361 {
38362 d.vkCmdSetDepthBounds( m_commandBuffer, minDepthBounds, maxDepthBounds );
38363 }
38364#else
38365 template<typename Dispatch>
38366 VULKAN_HPP_INLINE void CommandBuffer::setDepthBounds( float minDepthBounds, float maxDepthBounds, Dispatch const &d ) const
38367 {
38368 d.vkCmdSetDepthBounds( m_commandBuffer, minDepthBounds, maxDepthBounds );
38369 }
38370#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38371
38372#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
38373 template<typename Dispatch>
38374 VULKAN_HPP_INLINE void CommandBuffer::setStencilCompareMask( StencilFaceFlags faceMask, uint32_t compareMask, Dispatch const &d) const
38375 {
38376 d.vkCmdSetStencilCompareMask( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), compareMask );
38377 }
38378#else
38379 template<typename Dispatch>
38380 VULKAN_HPP_INLINE void CommandBuffer::setStencilCompareMask( StencilFaceFlags faceMask, uint32_t compareMask, Dispatch const &d ) const
38381 {
38382 d.vkCmdSetStencilCompareMask( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), compareMask );
38383 }
38384#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38385
38386#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
38387 template<typename Dispatch>
38388 VULKAN_HPP_INLINE void CommandBuffer::setStencilWriteMask( StencilFaceFlags faceMask, uint32_t writeMask, Dispatch const &d) const
38389 {
38390 d.vkCmdSetStencilWriteMask( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), writeMask );
38391 }
38392#else
38393 template<typename Dispatch>
38394 VULKAN_HPP_INLINE void CommandBuffer::setStencilWriteMask( StencilFaceFlags faceMask, uint32_t writeMask, Dispatch const &d ) const
38395 {
38396 d.vkCmdSetStencilWriteMask( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), writeMask );
38397 }
38398#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38399
38400#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
38401 template<typename Dispatch>
38403 {
38404 d.vkCmdSetStencilReference( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), reference );
38405 }
38406#else
38407 template<typename Dispatch>
38409 {
38410 d.vkCmdSetStencilReference( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), reference );
38411 }
38412#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38413
38414 template<typename Dispatch>
38415 VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets, Dispatch const &d) const
38416 {
38417 d.vkCmdBindDescriptorSets( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipelineLayout>( layout ), firstSet, descriptorSetCount, reinterpret_cast<const VkDescriptorSet*>( pDescriptorSets ), dynamicOffsetCount, pDynamicOffsets );
38418 }
38419#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38420 template<typename Dispatch>
38421 VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t firstSet, ArrayProxy<const DescriptorSet> descriptorSets, ArrayProxy<const uint32_t> dynamicOffsets, Dispatch const &d ) const
38422 {
38423 d.vkCmdBindDescriptorSets( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipelineLayout>( layout ), firstSet, descriptorSets.size() , reinterpret_cast<const VkDescriptorSet*>( descriptorSets.data() ), dynamicOffsets.size() , dynamicOffsets.data() );
38424 }
38425#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38426
38427#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
38428 template<typename Dispatch>
38430 {
38431 d.vkCmdBindIndexBuffer( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, static_cast<VkIndexType>( indexType ) );
38432 }
38433#else
38434 template<typename Dispatch>
38436 {
38437 d.vkCmdBindIndexBuffer( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, static_cast<VkIndexType>( indexType ) );
38438 }
38439#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38440
38441 template<typename Dispatch>
38442 VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers( uint32_t firstBinding, uint32_t bindingCount, const Buffer* pBuffers, const DeviceSize* pOffsets, Dispatch const &d) const
38443 {
38444 d.vkCmdBindVertexBuffers( m_commandBuffer, firstBinding, bindingCount, reinterpret_cast<const VkBuffer*>( pBuffers ), pOffsets );
38445 }
38446#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38447 template<typename Dispatch>
38449 {
38450#ifdef VULKAN_HPP_NO_EXCEPTIONS
38451 VULKAN_HPP_ASSERT( buffers.size() == offsets.size() );
38452#else
38453 if ( buffers.size() != offsets.size() )
38454 {
38455 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers: buffers.size() != offsets.size()" );
38456 }
38457#endif // VULKAN_HPP_NO_EXCEPTIONS
38458 d.vkCmdBindVertexBuffers( m_commandBuffer, firstBinding, buffers.size() , reinterpret_cast<const VkBuffer*>( buffers.data() ), offsets.data() );
38459 }
38460#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38461
38462#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
38463 template<typename Dispatch>
38464 VULKAN_HPP_INLINE void CommandBuffer::draw( uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance, Dispatch const &d) const
38465 {
38466 d.vkCmdDraw( m_commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance );
38467 }
38468#else
38469 template<typename Dispatch>
38470 VULKAN_HPP_INLINE void CommandBuffer::draw( uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance, Dispatch const &d ) const
38471 {
38472 d.vkCmdDraw( m_commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance );
38473 }
38474#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38475
38476#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
38477 template<typename Dispatch>
38478 VULKAN_HPP_INLINE void CommandBuffer::drawIndexed( uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance, Dispatch const &d) const
38479 {
38480 d.vkCmdDrawIndexed( m_commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance );
38481 }
38482#else
38483 template<typename Dispatch>
38484 VULKAN_HPP_INLINE void CommandBuffer::drawIndexed( uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance, Dispatch const &d ) const
38485 {
38486 d.vkCmdDrawIndexed( m_commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance );
38487 }
38488#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38489
38490#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
38491 template<typename Dispatch>
38493 {
38494 d.vkCmdDrawIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, drawCount, stride );
38495 }
38496#else
38497 template<typename Dispatch>
38499 {
38500 d.vkCmdDrawIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, drawCount, stride );
38501 }
38502#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38503
38504#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
38505 template<typename Dispatch>
38507 {
38508 d.vkCmdDrawIndexedIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, drawCount, stride );
38509 }
38510#else
38511 template<typename Dispatch>
38513 {
38514 d.vkCmdDrawIndexedIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, drawCount, stride );
38515 }
38516#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38517
38518#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
38519 template<typename Dispatch>
38520 VULKAN_HPP_INLINE void CommandBuffer::dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d) const
38521 {
38522 d.vkCmdDispatch( m_commandBuffer, groupCountX, groupCountY, groupCountZ );
38523 }
38524#else
38525 template<typename Dispatch>
38526 VULKAN_HPP_INLINE void CommandBuffer::dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d ) const
38527 {
38528 d.vkCmdDispatch( m_commandBuffer, groupCountX, groupCountY, groupCountZ );
38529 }
38530#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38531
38532#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
38533 template<typename Dispatch>
38535 {
38536 d.vkCmdDispatchIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset );
38537 }
38538#else
38539 template<typename Dispatch>
38541 {
38542 d.vkCmdDispatchIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset );
38543 }
38544#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38545
38546 template<typename Dispatch>
38547 VULKAN_HPP_INLINE void CommandBuffer::copyBuffer( Buffer srcBuffer, Buffer dstBuffer, uint32_t regionCount, const BufferCopy* pRegions, Dispatch const &d) const
38548 {
38549 d.vkCmdCopyBuffer( m_commandBuffer, static_cast<VkBuffer>( srcBuffer ), static_cast<VkBuffer>( dstBuffer ), regionCount, reinterpret_cast<const VkBufferCopy*>( pRegions ) );
38550 }
38551#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38552 template<typename Dispatch>
38553 VULKAN_HPP_INLINE void CommandBuffer::copyBuffer( Buffer srcBuffer, Buffer dstBuffer, ArrayProxy<const BufferCopy> regions, Dispatch const &d ) const
38554 {
38555 d.vkCmdCopyBuffer( m_commandBuffer, static_cast<VkBuffer>( srcBuffer ), static_cast<VkBuffer>( dstBuffer ), regions.size() , reinterpret_cast<const VkBufferCopy*>( regions.data() ) );
38556 }
38557#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38558
38559 template<typename Dispatch>
38560 VULKAN_HPP_INLINE void CommandBuffer::copyImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageCopy* pRegions, Dispatch const &d) const
38561 {
38562 d.vkCmdCopyImage( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regionCount, reinterpret_cast<const VkImageCopy*>( pRegions ) );
38563 }
38564#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38565 template<typename Dispatch>
38566 VULKAN_HPP_INLINE void CommandBuffer::copyImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const ImageCopy> regions, Dispatch const &d ) const
38567 {
38568 d.vkCmdCopyImage( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regions.size() , reinterpret_cast<const VkImageCopy*>( regions.data() ) );
38569 }
38570#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38571
38572 template<typename Dispatch>
38573 VULKAN_HPP_INLINE void CommandBuffer::blitImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageBlit* pRegions, Filter filter, Dispatch const &d) const
38574 {
38575 d.vkCmdBlitImage( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regionCount, reinterpret_cast<const VkImageBlit*>( pRegions ), static_cast<VkFilter>( filter ) );
38576 }
38577#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38578 template<typename Dispatch>
38579 VULKAN_HPP_INLINE void CommandBuffer::blitImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const ImageBlit> regions, Filter filter, Dispatch const &d ) const
38580 {
38581 d.vkCmdBlitImage( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regions.size() , reinterpret_cast<const VkImageBlit*>( regions.data() ), static_cast<VkFilter>( filter ) );
38582 }
38583#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38584
38585 template<typename Dispatch>
38586 VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage( Buffer srcBuffer, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const BufferImageCopy* pRegions, Dispatch const &d) const
38587 {
38588 d.vkCmdCopyBufferToImage( m_commandBuffer, static_cast<VkBuffer>( srcBuffer ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regionCount, reinterpret_cast<const VkBufferImageCopy*>( pRegions ) );
38589 }
38590#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38591 template<typename Dispatch>
38592 VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage( Buffer srcBuffer, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const BufferImageCopy> regions, Dispatch const &d ) const
38593 {
38594 d.vkCmdCopyBufferToImage( m_commandBuffer, static_cast<VkBuffer>( srcBuffer ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regions.size() , reinterpret_cast<const VkBufferImageCopy*>( regions.data() ) );
38595 }
38596#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38597
38598 template<typename Dispatch>
38599 VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer( Image srcImage, ImageLayout srcImageLayout, Buffer dstBuffer, uint32_t regionCount, const BufferImageCopy* pRegions, Dispatch const &d) const
38600 {
38601 d.vkCmdCopyImageToBuffer( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkBuffer>( dstBuffer ), regionCount, reinterpret_cast<const VkBufferImageCopy*>( pRegions ) );
38602 }
38603#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38604 template<typename Dispatch>
38605 VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer( Image srcImage, ImageLayout srcImageLayout, Buffer dstBuffer, ArrayProxy<const BufferImageCopy> regions, Dispatch const &d ) const
38606 {
38607 d.vkCmdCopyImageToBuffer( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkBuffer>( dstBuffer ), regions.size() , reinterpret_cast<const VkBufferImageCopy*>( regions.data() ) );
38608 }
38609#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38610
38611 template<typename Dispatch>
38612 VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize dataSize, const void* pData, Dispatch const &d) const
38613 {
38614 d.vkCmdUpdateBuffer( m_commandBuffer, static_cast<VkBuffer>( dstBuffer ), dstOffset, dataSize, pData );
38615 }
38616#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38617 template <typename T, typename Dispatch>
38618 VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( Buffer dstBuffer, DeviceSize dstOffset, ArrayProxy<const T> data, Dispatch const &d ) const
38619 {
38620 d.vkCmdUpdateBuffer( m_commandBuffer, static_cast<VkBuffer>( dstBuffer ), dstOffset, data.size() * sizeof( T ) , reinterpret_cast<const void*>( data.data() ) );
38621 }
38622#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38623
38624#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
38625 template<typename Dispatch>
38626 VULKAN_HPP_INLINE void CommandBuffer::fillBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize size, uint32_t data, Dispatch const &d) const
38627 {
38628 d.vkCmdFillBuffer( m_commandBuffer, static_cast<VkBuffer>( dstBuffer ), dstOffset, size, data );
38629 }
38630#else
38631 template<typename Dispatch>
38632 VULKAN_HPP_INLINE void CommandBuffer::fillBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize size, uint32_t data, Dispatch const &d ) const
38633 {
38634 d.vkCmdFillBuffer( m_commandBuffer, static_cast<VkBuffer>( dstBuffer ), dstOffset, size, data );
38635 }
38636#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38637
38638 template<typename Dispatch>
38639 VULKAN_HPP_INLINE void CommandBuffer::clearColorImage( Image image, ImageLayout imageLayout, const ClearColorValue* pColor, uint32_t rangeCount, const ImageSubresourceRange* pRanges, Dispatch const &d) const
38640 {
38641 d.vkCmdClearColorImage( m_commandBuffer, static_cast<VkImage>( image ), static_cast<VkImageLayout>( imageLayout ), reinterpret_cast<const VkClearColorValue*>( pColor ), rangeCount, reinterpret_cast<const VkImageSubresourceRange*>( pRanges ) );
38642 }
38643#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38644 template<typename Dispatch>
38646 {
38647 d.vkCmdClearColorImage( m_commandBuffer, static_cast<VkImage>( image ), static_cast<VkImageLayout>( imageLayout ), reinterpret_cast<const VkClearColorValue*>( &color ), ranges.size() , reinterpret_cast<const VkImageSubresourceRange*>( ranges.data() ) );
38648 }
38649#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38650
38651 template<typename Dispatch>
38652 VULKAN_HPP_INLINE void CommandBuffer::clearDepthStencilImage( Image image, ImageLayout imageLayout, const ClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const ImageSubresourceRange* pRanges, Dispatch const &d) const
38653 {
38654 d.vkCmdClearDepthStencilImage( m_commandBuffer, static_cast<VkImage>( image ), static_cast<VkImageLayout>( imageLayout ), reinterpret_cast<const VkClearDepthStencilValue*>( pDepthStencil ), rangeCount, reinterpret_cast<const VkImageSubresourceRange*>( pRanges ) );
38655 }
38656#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38657 template<typename Dispatch>
38659 {
38660 d.vkCmdClearDepthStencilImage( m_commandBuffer, static_cast<VkImage>( image ), static_cast<VkImageLayout>( imageLayout ), reinterpret_cast<const VkClearDepthStencilValue*>( &depthStencil ), ranges.size() , reinterpret_cast<const VkImageSubresourceRange*>( ranges.data() ) );
38661 }
38662#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38663
38664 template<typename Dispatch>
38665 VULKAN_HPP_INLINE void CommandBuffer::clearAttachments( uint32_t attachmentCount, const ClearAttachment* pAttachments, uint32_t rectCount, const ClearRect* pRects, Dispatch const &d) const
38666 {
38667 d.vkCmdClearAttachments( m_commandBuffer, attachmentCount, reinterpret_cast<const VkClearAttachment*>( pAttachments ), rectCount, reinterpret_cast<const VkClearRect*>( pRects ) );
38668 }
38669#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38670 template<typename Dispatch>
38672 {
38673 d.vkCmdClearAttachments( m_commandBuffer, attachments.size() , reinterpret_cast<const VkClearAttachment*>( attachments.data() ), rects.size() , reinterpret_cast<const VkClearRect*>( rects.data() ) );
38674 }
38675#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38676
38677 template<typename Dispatch>
38678 VULKAN_HPP_INLINE void CommandBuffer::resolveImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageResolve* pRegions, Dispatch const &d) const
38679 {
38680 d.vkCmdResolveImage( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regionCount, reinterpret_cast<const VkImageResolve*>( pRegions ) );
38681 }
38682#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38683 template<typename Dispatch>
38684 VULKAN_HPP_INLINE void CommandBuffer::resolveImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const ImageResolve> regions, Dispatch const &d ) const
38685 {
38686 d.vkCmdResolveImage( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regions.size() , reinterpret_cast<const VkImageResolve*>( regions.data() ) );
38687 }
38688#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38689
38690#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
38691 template<typename Dispatch>
38692 VULKAN_HPP_INLINE void CommandBuffer::setEvent( Event event, PipelineStageFlags stageMask, Dispatch const &d) const
38693 {
38694 d.vkCmdSetEvent( m_commandBuffer, static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags>( stageMask ) );
38695 }
38696#else
38697 template<typename Dispatch>
38699 {
38700 d.vkCmdSetEvent( m_commandBuffer, static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags>( stageMask ) );
38701 }
38702#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38703
38704#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
38705 template<typename Dispatch>
38706 VULKAN_HPP_INLINE void CommandBuffer::resetEvent( Event event, PipelineStageFlags stageMask, Dispatch const &d) const
38707 {
38708 d.vkCmdResetEvent( m_commandBuffer, static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags>( stageMask ) );
38709 }
38710#else
38711 template<typename Dispatch>
38713 {
38714 d.vkCmdResetEvent( m_commandBuffer, static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags>( stageMask ) );
38715 }
38716#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38717
38718 template<typename Dispatch>
38719 VULKAN_HPP_INLINE void CommandBuffer::waitEvents( uint32_t eventCount, const Event* pEvents, PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const MemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const BufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const ImageMemoryBarrier* pImageMemoryBarriers, Dispatch const &d) const
38720 {
38721 d.vkCmdWaitEvents( m_commandBuffer, eventCount, reinterpret_cast<const VkEvent*>( pEvents ), static_cast<VkPipelineStageFlags>( srcStageMask ), static_cast<VkPipelineStageFlags>( dstStageMask ), memoryBarrierCount, reinterpret_cast<const VkMemoryBarrier*>( pMemoryBarriers ), bufferMemoryBarrierCount, reinterpret_cast<const VkBufferMemoryBarrier*>( pBufferMemoryBarriers ), imageMemoryBarrierCount, reinterpret_cast<const VkImageMemoryBarrier*>( pImageMemoryBarriers ) );
38722 }
38723#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38724 template<typename Dispatch>
38726 {
38727 d.vkCmdWaitEvents( m_commandBuffer, events.size() , reinterpret_cast<const VkEvent*>( events.data() ), static_cast<VkPipelineStageFlags>( srcStageMask ), static_cast<VkPipelineStageFlags>( dstStageMask ), memoryBarriers.size() , reinterpret_cast<const VkMemoryBarrier*>( memoryBarriers.data() ), bufferMemoryBarriers.size() , reinterpret_cast<const VkBufferMemoryBarrier*>( bufferMemoryBarriers.data() ), imageMemoryBarriers.size() , reinterpret_cast<const VkImageMemoryBarrier*>( imageMemoryBarriers.data() ) );
38728 }
38729#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38730
38731 template<typename Dispatch>
38732 VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier( PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, DependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const MemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const BufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const ImageMemoryBarrier* pImageMemoryBarriers, Dispatch const &d) const
38733 {
38734 d.vkCmdPipelineBarrier( m_commandBuffer, static_cast<VkPipelineStageFlags>( srcStageMask ), static_cast<VkPipelineStageFlags>( dstStageMask ), static_cast<VkDependencyFlags>( dependencyFlags ), memoryBarrierCount, reinterpret_cast<const VkMemoryBarrier*>( pMemoryBarriers ), bufferMemoryBarrierCount, reinterpret_cast<const VkBufferMemoryBarrier*>( pBufferMemoryBarriers ), imageMemoryBarrierCount, reinterpret_cast<const VkImageMemoryBarrier*>( pImageMemoryBarriers ) );
38735 }
38736#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38737 template<typename Dispatch>
38738 VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier( PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, DependencyFlags dependencyFlags, ArrayProxy<const MemoryBarrier> memoryBarriers, ArrayProxy<const BufferMemoryBarrier> bufferMemoryBarriers, ArrayProxy<const ImageMemoryBarrier> imageMemoryBarriers, Dispatch const &d ) const
38739 {
38740 d.vkCmdPipelineBarrier( m_commandBuffer, static_cast<VkPipelineStageFlags>( srcStageMask ), static_cast<VkPipelineStageFlags>( dstStageMask ), static_cast<VkDependencyFlags>( dependencyFlags ), memoryBarriers.size() , reinterpret_cast<const VkMemoryBarrier*>( memoryBarriers.data() ), bufferMemoryBarriers.size() , reinterpret_cast<const VkBufferMemoryBarrier*>( bufferMemoryBarriers.data() ), imageMemoryBarriers.size() , reinterpret_cast<const VkImageMemoryBarrier*>( imageMemoryBarriers.data() ) );
38741 }
38742#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38743
38744#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
38745 template<typename Dispatch>
38747 {
38748 d.vkCmdBeginQuery( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, static_cast<VkQueryControlFlags>( flags ) );
38749 }
38750#else
38751 template<typename Dispatch>
38753 {
38754 d.vkCmdBeginQuery( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, static_cast<VkQueryControlFlags>( flags ) );
38755 }
38756#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38757
38758#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
38759 template<typename Dispatch>
38760 VULKAN_HPP_INLINE void CommandBuffer::endQuery( QueryPool queryPool, uint32_t query, Dispatch const &d) const
38761 {
38762 d.vkCmdEndQuery( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query );
38763 }
38764#else
38765 template<typename Dispatch>
38766 VULKAN_HPP_INLINE void CommandBuffer::endQuery( QueryPool queryPool, uint32_t query, Dispatch const &d ) const
38767 {
38768 d.vkCmdEndQuery( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query );
38769 }
38770#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38771
38772 template<typename Dispatch>
38773 VULKAN_HPP_INLINE void CommandBuffer::beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin, Dispatch const &d) const
38774 {
38775 d.vkCmdBeginConditionalRenderingEXT( m_commandBuffer, reinterpret_cast<const VkConditionalRenderingBeginInfoEXT*>( pConditionalRenderingBegin ) );
38776 }
38777#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38778 template<typename Dispatch>
38779 VULKAN_HPP_INLINE void CommandBuffer::beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin, Dispatch const &d ) const
38780 {
38781 d.vkCmdBeginConditionalRenderingEXT( m_commandBuffer, reinterpret_cast<const VkConditionalRenderingBeginInfoEXT*>( &conditionalRenderingBegin ) );
38782 }
38783#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38784
38785#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
38786 template<typename Dispatch>
38788 {
38789 d.vkCmdEndConditionalRenderingEXT( m_commandBuffer );
38790 }
38791#else
38792 template<typename Dispatch>
38794 {
38795 d.vkCmdEndConditionalRenderingEXT( m_commandBuffer );
38796 }
38797#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38798
38799#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
38800 template<typename Dispatch>
38801 VULKAN_HPP_INLINE void CommandBuffer::resetQueryPool( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d) const
38802 {
38803 d.vkCmdResetQueryPool( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount );
38804 }
38805#else
38806 template<typename Dispatch>
38807 VULKAN_HPP_INLINE void CommandBuffer::resetQueryPool( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d ) const
38808 {
38809 d.vkCmdResetQueryPool( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount );
38810 }
38811#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38812
38813#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
38814 template<typename Dispatch>
38815 VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp( PipelineStageFlagBits pipelineStage, QueryPool queryPool, uint32_t query, Dispatch const &d) const
38816 {
38817 d.vkCmdWriteTimestamp( m_commandBuffer, static_cast<VkPipelineStageFlagBits>( pipelineStage ), static_cast<VkQueryPool>( queryPool ), query );
38818 }
38819#else
38820 template<typename Dispatch>
38821 VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp( PipelineStageFlagBits pipelineStage, QueryPool queryPool, uint32_t query, Dispatch const &d ) const
38822 {
38823 d.vkCmdWriteTimestamp( m_commandBuffer, static_cast<VkPipelineStageFlagBits>( pipelineStage ), static_cast<VkQueryPool>( queryPool ), query );
38824 }
38825#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38826
38827#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
38828 template<typename Dispatch>
38829 VULKAN_HPP_INLINE void CommandBuffer::copyQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Buffer dstBuffer, DeviceSize dstOffset, DeviceSize stride, QueryResultFlags flags, Dispatch const &d) const
38830 {
38831 d.vkCmdCopyQueryPoolResults( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount, static_cast<VkBuffer>( dstBuffer ), dstOffset, stride, static_cast<VkQueryResultFlags>( flags ) );
38832 }
38833#else
38834 template<typename Dispatch>
38835 VULKAN_HPP_INLINE void CommandBuffer::copyQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Buffer dstBuffer, DeviceSize dstOffset, DeviceSize stride, QueryResultFlags flags, Dispatch const &d ) const
38836 {
38837 d.vkCmdCopyQueryPoolResults( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount, static_cast<VkBuffer>( dstBuffer ), dstOffset, stride, static_cast<VkQueryResultFlags>( flags ) );
38838 }
38839#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38840
38841 template<typename Dispatch>
38842 VULKAN_HPP_INLINE void CommandBuffer::pushConstants( PipelineLayout layout, ShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues, Dispatch const &d) const
38843 {
38844 d.vkCmdPushConstants( m_commandBuffer, static_cast<VkPipelineLayout>( layout ), static_cast<VkShaderStageFlags>( stageFlags ), offset, size, pValues );
38845 }
38846#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38847 template <typename T, typename Dispatch>
38849 {
38850 d.vkCmdPushConstants( m_commandBuffer, static_cast<VkPipelineLayout>( layout ), static_cast<VkShaderStageFlags>( stageFlags ), offset, values.size() * sizeof( T ) , reinterpret_cast<const void*>( values.data() ) );
38851 }
38852#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38853
38854 template<typename Dispatch>
38855 VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass( const RenderPassBeginInfo* pRenderPassBegin, SubpassContents contents, Dispatch const &d) const
38856 {
38857 d.vkCmdBeginRenderPass( m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo*>( pRenderPassBegin ), static_cast<VkSubpassContents>( contents ) );
38858 }
38859#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38860 template<typename Dispatch>
38861 VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass( const RenderPassBeginInfo & renderPassBegin, SubpassContents contents, Dispatch const &d ) const
38862 {
38863 d.vkCmdBeginRenderPass( m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo*>( &renderPassBegin ), static_cast<VkSubpassContents>( contents ) );
38864 }
38865#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38866
38867#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
38868 template<typename Dispatch>
38869 VULKAN_HPP_INLINE void CommandBuffer::nextSubpass( SubpassContents contents, Dispatch const &d) const
38870 {
38871 d.vkCmdNextSubpass( m_commandBuffer, static_cast<VkSubpassContents>( contents ) );
38872 }
38873#else
38874 template<typename Dispatch>
38875 VULKAN_HPP_INLINE void CommandBuffer::nextSubpass( SubpassContents contents, Dispatch const &d ) const
38876 {
38877 d.vkCmdNextSubpass( m_commandBuffer, static_cast<VkSubpassContents>( contents ) );
38878 }
38879#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38880
38881#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
38882 template<typename Dispatch>
38883 VULKAN_HPP_INLINE void CommandBuffer::endRenderPass(Dispatch const &d) const
38884 {
38885 d.vkCmdEndRenderPass( m_commandBuffer );
38886 }
38887#else
38888 template<typename Dispatch>
38890 {
38891 d.vkCmdEndRenderPass( m_commandBuffer );
38892 }
38893#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38894
38895 template<typename Dispatch>
38896 VULKAN_HPP_INLINE void CommandBuffer::executeCommands( uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers, Dispatch const &d) const
38897 {
38898 d.vkCmdExecuteCommands( m_commandBuffer, commandBufferCount, reinterpret_cast<const VkCommandBuffer*>( pCommandBuffers ) );
38899 }
38900#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38901 template<typename Dispatch>
38903 {
38904 d.vkCmdExecuteCommands( m_commandBuffer, commandBuffers.size() , reinterpret_cast<const VkCommandBuffer*>( commandBuffers.data() ) );
38905 }
38906#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38907
38908 template<typename Dispatch>
38910 {
38911 d.vkCmdDebugMarkerBeginEXT( m_commandBuffer, reinterpret_cast<const VkDebugMarkerMarkerInfoEXT*>( pMarkerInfo ) );
38912 }
38913#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38914 template<typename Dispatch>
38915 VULKAN_HPP_INLINE void CommandBuffer::debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT & markerInfo, Dispatch const &d ) const
38916 {
38917 d.vkCmdDebugMarkerBeginEXT( m_commandBuffer, reinterpret_cast<const VkDebugMarkerMarkerInfoEXT*>( &markerInfo ) );
38918 }
38919#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38920
38921#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
38922 template<typename Dispatch>
38923 VULKAN_HPP_INLINE void CommandBuffer::debugMarkerEndEXT(Dispatch const &d) const
38924 {
38925 d.vkCmdDebugMarkerEndEXT( m_commandBuffer );
38926 }
38927#else
38928 template<typename Dispatch>
38930 {
38931 d.vkCmdDebugMarkerEndEXT( m_commandBuffer );
38932 }
38933#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38934
38935 template<typename Dispatch>
38937 {
38938 d.vkCmdDebugMarkerInsertEXT( m_commandBuffer, reinterpret_cast<const VkDebugMarkerMarkerInfoEXT*>( pMarkerInfo ) );
38939 }
38940#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38941 template<typename Dispatch>
38943 {
38944 d.vkCmdDebugMarkerInsertEXT( m_commandBuffer, reinterpret_cast<const VkDebugMarkerMarkerInfoEXT*>( &markerInfo ) );
38945 }
38946#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38947
38948#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
38949 template<typename Dispatch>
38950 VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const
38951 {
38952 d.vkCmdDrawIndirectCountAMD( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, static_cast<VkBuffer>( countBuffer ), countBufferOffset, maxDrawCount, stride );
38953 }
38954#else
38955 template<typename Dispatch>
38956 VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const
38957 {
38958 d.vkCmdDrawIndirectCountAMD( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, static_cast<VkBuffer>( countBuffer ), countBufferOffset, maxDrawCount, stride );
38959 }
38960#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38961
38962#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
38963 template<typename Dispatch>
38964 VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const
38965 {
38966 d.vkCmdDrawIndexedIndirectCountAMD( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, static_cast<VkBuffer>( countBuffer ), countBufferOffset, maxDrawCount, stride );
38967 }
38968#else
38969 template<typename Dispatch>
38970 VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const
38971 {
38972 d.vkCmdDrawIndexedIndirectCountAMD( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, static_cast<VkBuffer>( countBuffer ), countBufferOffset, maxDrawCount, stride );
38973 }
38974#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38975
38976 template<typename Dispatch>
38977 VULKAN_HPP_INLINE void CommandBuffer::processCommandsNVX( const CmdProcessCommandsInfoNVX* pProcessCommandsInfo, Dispatch const &d) const
38978 {
38979 d.vkCmdProcessCommandsNVX( m_commandBuffer, reinterpret_cast<const VkCmdProcessCommandsInfoNVX*>( pProcessCommandsInfo ) );
38980 }
38981#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38982 template<typename Dispatch>
38983 VULKAN_HPP_INLINE void CommandBuffer::processCommandsNVX( const CmdProcessCommandsInfoNVX & processCommandsInfo, Dispatch const &d ) const
38984 {
38985 d.vkCmdProcessCommandsNVX( m_commandBuffer, reinterpret_cast<const VkCmdProcessCommandsInfoNVX*>( &processCommandsInfo ) );
38986 }
38987#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
38988
38989 template<typename Dispatch>
38991 {
38992 d.vkCmdReserveSpaceForCommandsNVX( m_commandBuffer, reinterpret_cast<const VkCmdReserveSpaceForCommandsInfoNVX*>( pReserveSpaceInfo ) );
38993 }
38994#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
38995 template<typename Dispatch>
38997 {
38998 d.vkCmdReserveSpaceForCommandsNVX( m_commandBuffer, reinterpret_cast<const VkCmdReserveSpaceForCommandsInfoNVX*>( &reserveSpaceInfo ) );
38999 }
39000#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39001
39002 template<typename Dispatch>
39003 VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const WriteDescriptorSet* pDescriptorWrites, Dispatch const &d) const
39004 {
39005 d.vkCmdPushDescriptorSetKHR( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipelineLayout>( layout ), set, descriptorWriteCount, reinterpret_cast<const VkWriteDescriptorSet*>( pDescriptorWrites ) );
39006 }
39007#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
39008 template<typename Dispatch>
39010 {
39011 d.vkCmdPushDescriptorSetKHR( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipelineLayout>( layout ), set, descriptorWrites.size() , reinterpret_cast<const VkWriteDescriptorSet*>( descriptorWrites.data() ) );
39012 }
39013#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39014
39015#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
39016 template<typename Dispatch>
39017 VULKAN_HPP_INLINE void CommandBuffer::setDeviceMask( uint32_t deviceMask, Dispatch const &d) const
39018 {
39019 d.vkCmdSetDeviceMask( m_commandBuffer, deviceMask );
39020 }
39021#else
39022 template<typename Dispatch>
39023 VULKAN_HPP_INLINE void CommandBuffer::setDeviceMask( uint32_t deviceMask, Dispatch const &d ) const
39024 {
39025 d.vkCmdSetDeviceMask( m_commandBuffer, deviceMask );
39026 }
39027#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39028
39029#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
39030 template<typename Dispatch>
39031 VULKAN_HPP_INLINE void CommandBuffer::setDeviceMaskKHR( uint32_t deviceMask, Dispatch const &d) const
39032 {
39033 d.vkCmdSetDeviceMaskKHR( m_commandBuffer, deviceMask );
39034 }
39035#else
39036 template<typename Dispatch>
39037 VULKAN_HPP_INLINE void CommandBuffer::setDeviceMaskKHR( uint32_t deviceMask, Dispatch const &d ) const
39038 {
39039 d.vkCmdSetDeviceMaskKHR( m_commandBuffer, deviceMask );
39040 }
39041#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39042
39043#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
39044 template<typename Dispatch>
39045 VULKAN_HPP_INLINE void CommandBuffer::dispatchBase( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d) const
39046 {
39047 d.vkCmdDispatchBase( m_commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
39048 }
39049#else
39050 template<typename Dispatch>
39051 VULKAN_HPP_INLINE void CommandBuffer::dispatchBase( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d ) const
39052 {
39053 d.vkCmdDispatchBase( m_commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
39054 }
39055#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39056
39057#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
39058 template<typename Dispatch>
39059 VULKAN_HPP_INLINE void CommandBuffer::dispatchBaseKHR( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d) const
39060 {
39061 d.vkCmdDispatchBaseKHR( m_commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
39062 }
39063#else
39064 template<typename Dispatch>
39065 VULKAN_HPP_INLINE void CommandBuffer::dispatchBaseKHR( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d ) const
39066 {
39067 d.vkCmdDispatchBaseKHR( m_commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
39068 }
39069#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39070
39071#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
39072 template<typename Dispatch>
39073 VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, PipelineLayout layout, uint32_t set, const void* pData, Dispatch const &d) const
39074 {
39075 d.vkCmdPushDescriptorSetWithTemplateKHR( m_commandBuffer, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), static_cast<VkPipelineLayout>( layout ), set, pData );
39076 }
39077#else
39078 template<typename Dispatch>
39079 VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, PipelineLayout layout, uint32_t set, const void* pData, Dispatch const &d ) const
39080 {
39081 d.vkCmdPushDescriptorSetWithTemplateKHR( m_commandBuffer, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), static_cast<VkPipelineLayout>( layout ), set, pData );
39082 }
39083#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39084
39085 template<typename Dispatch>
39086 VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV( uint32_t firstViewport, uint32_t viewportCount, const ViewportWScalingNV* pViewportWScalings, Dispatch const &d) const
39087 {
39088 d.vkCmdSetViewportWScalingNV( m_commandBuffer, firstViewport, viewportCount, reinterpret_cast<const VkViewportWScalingNV*>( pViewportWScalings ) );
39089 }
39090#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
39091 template<typename Dispatch>
39092 VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV( uint32_t firstViewport, ArrayProxy<const ViewportWScalingNV> viewportWScalings, Dispatch const &d ) const
39093 {
39094 d.vkCmdSetViewportWScalingNV( m_commandBuffer, firstViewport, viewportWScalings.size() , reinterpret_cast<const VkViewportWScalingNV*>( viewportWScalings.data() ) );
39095 }
39096#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39097
39098 template<typename Dispatch>
39099 VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEXT( uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const Rect2D* pDiscardRectangles, Dispatch const &d) const
39100 {
39101 d.vkCmdSetDiscardRectangleEXT( m_commandBuffer, firstDiscardRectangle, discardRectangleCount, reinterpret_cast<const VkRect2D*>( pDiscardRectangles ) );
39102 }
39103#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
39104 template<typename Dispatch>
39105 VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEXT( uint32_t firstDiscardRectangle, ArrayProxy<const Rect2D> discardRectangles, Dispatch const &d ) const
39106 {
39107 d.vkCmdSetDiscardRectangleEXT( m_commandBuffer, firstDiscardRectangle, discardRectangles.size() , reinterpret_cast<const VkRect2D*>( discardRectangles.data() ) );
39108 }
39109#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39110
39111 template<typename Dispatch>
39112 VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEXT( const SampleLocationsInfoEXT* pSampleLocationsInfo, Dispatch const &d) const
39113 {
39114 d.vkCmdSetSampleLocationsEXT( m_commandBuffer, reinterpret_cast<const VkSampleLocationsInfoEXT*>( pSampleLocationsInfo ) );
39115 }
39116#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
39117 template<typename Dispatch>
39118 VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEXT( const SampleLocationsInfoEXT & sampleLocationsInfo, Dispatch const &d ) const
39119 {
39120 d.vkCmdSetSampleLocationsEXT( m_commandBuffer, reinterpret_cast<const VkSampleLocationsInfoEXT*>( &sampleLocationsInfo ) );
39121 }
39122#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39123
39124 template<typename Dispatch>
39126 {
39127 d.vkCmdBeginDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast<const VkDebugUtilsLabelEXT*>( pLabelInfo ) );
39128 }
39129#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
39130 template<typename Dispatch>
39131 VULKAN_HPP_INLINE void CommandBuffer::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d ) const
39132 {
39133 d.vkCmdBeginDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast<const VkDebugUtilsLabelEXT*>( &labelInfo ) );
39134 }
39135#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39136
39137#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
39138 template<typename Dispatch>
39139 VULKAN_HPP_INLINE void CommandBuffer::endDebugUtilsLabelEXT(Dispatch const &d) const
39140 {
39141 d.vkCmdEndDebugUtilsLabelEXT( m_commandBuffer );
39142 }
39143#else
39144 template<typename Dispatch>
39146 {
39147 d.vkCmdEndDebugUtilsLabelEXT( m_commandBuffer );
39148 }
39149#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39150
39151 template<typename Dispatch>
39153 {
39154 d.vkCmdInsertDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast<const VkDebugUtilsLabelEXT*>( pLabelInfo ) );
39155 }
39156#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
39157 template<typename Dispatch>
39159 {
39160 d.vkCmdInsertDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast<const VkDebugUtilsLabelEXT*>( &labelInfo ) );
39161 }
39162#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39163
39164#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
39165 template<typename Dispatch>
39166 VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarkerAMD( PipelineStageFlagBits pipelineStage, Buffer dstBuffer, DeviceSize dstOffset, uint32_t marker, Dispatch const &d) const
39167 {
39168 d.vkCmdWriteBufferMarkerAMD( m_commandBuffer, static_cast<VkPipelineStageFlagBits>( pipelineStage ), static_cast<VkBuffer>( dstBuffer ), dstOffset, marker );
39169 }
39170#else
39171 template<typename Dispatch>
39172 VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarkerAMD( PipelineStageFlagBits pipelineStage, Buffer dstBuffer, DeviceSize dstOffset, uint32_t marker, Dispatch const &d ) const
39173 {
39174 d.vkCmdWriteBufferMarkerAMD( m_commandBuffer, static_cast<VkPipelineStageFlagBits>( pipelineStage ), static_cast<VkBuffer>( dstBuffer ), dstOffset, marker );
39175 }
39176#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39177
39178 template<typename Dispatch>
39179 VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2KHR( const RenderPassBeginInfo* pRenderPassBegin, const SubpassBeginInfoKHR* pSubpassBeginInfo, Dispatch const &d) const
39180 {
39181 d.vkCmdBeginRenderPass2KHR( m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo*>( pRenderPassBegin ), reinterpret_cast<const VkSubpassBeginInfoKHR*>( pSubpassBeginInfo ) );
39182 }
39183#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
39184 template<typename Dispatch>
39185 VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2KHR( const RenderPassBeginInfo & renderPassBegin, const SubpassBeginInfoKHR & subpassBeginInfo, Dispatch const &d ) const
39186 {
39187 d.vkCmdBeginRenderPass2KHR( m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo*>( &renderPassBegin ), reinterpret_cast<const VkSubpassBeginInfoKHR*>( &subpassBeginInfo ) );
39188 }
39189#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39190
39191 template<typename Dispatch>
39192 VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2KHR( const SubpassBeginInfoKHR* pSubpassBeginInfo, const SubpassEndInfoKHR* pSubpassEndInfo, Dispatch const &d) const
39193 {
39194 d.vkCmdNextSubpass2KHR( m_commandBuffer, reinterpret_cast<const VkSubpassBeginInfoKHR*>( pSubpassBeginInfo ), reinterpret_cast<const VkSubpassEndInfoKHR*>( pSubpassEndInfo ) );
39195 }
39196#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
39197 template<typename Dispatch>
39198 VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2KHR( const SubpassBeginInfoKHR & subpassBeginInfo, const SubpassEndInfoKHR & subpassEndInfo, Dispatch const &d ) const
39199 {
39200 d.vkCmdNextSubpass2KHR( m_commandBuffer, reinterpret_cast<const VkSubpassBeginInfoKHR*>( &subpassBeginInfo ), reinterpret_cast<const VkSubpassEndInfoKHR*>( &subpassEndInfo ) );
39201 }
39202#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39203
39204 template<typename Dispatch>
39205 VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2KHR( const SubpassEndInfoKHR* pSubpassEndInfo, Dispatch const &d) const
39206 {
39207 d.vkCmdEndRenderPass2KHR( m_commandBuffer, reinterpret_cast<const VkSubpassEndInfoKHR*>( pSubpassEndInfo ) );
39208 }
39209#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
39210 template<typename Dispatch>
39211 VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2KHR( const SubpassEndInfoKHR & subpassEndInfo, Dispatch const &d ) const
39212 {
39213 d.vkCmdEndRenderPass2KHR( m_commandBuffer, reinterpret_cast<const VkSubpassEndInfoKHR*>( &subpassEndInfo ) );
39214 }
39215#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39216
39217#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
39218 template<typename Dispatch>
39219 VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountKHR( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const
39220 {
39221 d.vkCmdDrawIndirectCountKHR( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, static_cast<VkBuffer>( countBuffer ), countBufferOffset, maxDrawCount, stride );
39222 }
39223#else
39224 template<typename Dispatch>
39225 VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountKHR( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const
39226 {
39227 d.vkCmdDrawIndirectCountKHR( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, static_cast<VkBuffer>( countBuffer ), countBufferOffset, maxDrawCount, stride );
39228 }
39229#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39230
39231#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
39232 template<typename Dispatch>
39233 VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountKHR( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const
39234 {
39235 d.vkCmdDrawIndexedIndirectCountKHR( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, static_cast<VkBuffer>( countBuffer ), countBufferOffset, maxDrawCount, stride );
39236 }
39237#else
39238 template<typename Dispatch>
39239 VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountKHR( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const
39240 {
39241 d.vkCmdDrawIndexedIndirectCountKHR( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, static_cast<VkBuffer>( countBuffer ), countBufferOffset, maxDrawCount, stride );
39242 }
39243#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39244
39245#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
39246 template<typename Dispatch>
39247 VULKAN_HPP_INLINE void CommandBuffer::setCheckpointNV( const void* pCheckpointMarker, Dispatch const &d) const
39248 {
39249 d.vkCmdSetCheckpointNV( m_commandBuffer, pCheckpointMarker );
39250 }
39251#else
39252 template<typename Dispatch>
39253 VULKAN_HPP_INLINE void CommandBuffer::setCheckpointNV( const void* pCheckpointMarker, Dispatch const &d ) const
39254 {
39255 d.vkCmdSetCheckpointNV( m_commandBuffer, pCheckpointMarker );
39256 }
39257#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39258
39259 template<typename Dispatch>
39260 VULKAN_HPP_INLINE void CommandBuffer::bindTransformFeedbackBuffersEXT( uint32_t firstBinding, uint32_t bindingCount, const Buffer* pBuffers, const DeviceSize* pOffsets, const DeviceSize* pSizes, Dispatch const &d) const
39261 {
39262 d.vkCmdBindTransformFeedbackBuffersEXT( m_commandBuffer, firstBinding, bindingCount, reinterpret_cast<const VkBuffer*>( pBuffers ), pOffsets, pSizes );
39263 }
39264#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
39265 template<typename Dispatch>
39267 {
39268#ifdef VULKAN_HPP_NO_EXCEPTIONS
39269 VULKAN_HPP_ASSERT( buffers.size() == offsets.size() );
39270#else
39271 if ( buffers.size() != offsets.size() )
39272 {
39273 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != offsets.size()" );
39274 }
39275#endif // VULKAN_HPP_NO_EXCEPTIONS
39276#ifdef VULKAN_HPP_NO_EXCEPTIONS
39277 VULKAN_HPP_ASSERT( buffers.size() == sizes.size() );
39278#else
39279 if ( buffers.size() != sizes.size() )
39280 {
39281 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != sizes.size()" );
39282 }
39283#endif // VULKAN_HPP_NO_EXCEPTIONS
39284#ifdef VULKAN_HPP_NO_EXCEPTIONS
39285 VULKAN_HPP_ASSERT( offsets.size() == sizes.size() );
39286#else
39287 if ( offsets.size() != sizes.size() )
39288 {
39289 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindTransformFeedbackBuffersEXT: offsets.size() != sizes.size()" );
39290 }
39291#endif // VULKAN_HPP_NO_EXCEPTIONS
39292 d.vkCmdBindTransformFeedbackBuffersEXT( m_commandBuffer, firstBinding, buffers.size() , reinterpret_cast<const VkBuffer*>( buffers.data() ), offsets.data(), sizes.data() );
39293 }
39294#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39295
39296 template<typename Dispatch>
39297 VULKAN_HPP_INLINE void CommandBuffer::beginTransformFeedbackEXT( uint32_t firstCounterBuffer, uint32_t counterBufferCount, const Buffer* pCounterBuffers, const DeviceSize* pCounterBufferOffsets, Dispatch const &d) const
39298 {
39299 d.vkCmdBeginTransformFeedbackEXT( m_commandBuffer, firstCounterBuffer, counterBufferCount, reinterpret_cast<const VkBuffer*>( pCounterBuffers ), pCounterBufferOffsets );
39300 }
39301#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
39302 template<typename Dispatch>
39303 VULKAN_HPP_INLINE void CommandBuffer::beginTransformFeedbackEXT( uint32_t firstCounterBuffer, ArrayProxy<const Buffer> counterBuffers, ArrayProxy<const DeviceSize> counterBufferOffsets, Dispatch const &d ) const
39304 {
39305#ifdef VULKAN_HPP_NO_EXCEPTIONS
39306 VULKAN_HPP_ASSERT( counterBuffers.size() == counterBufferOffsets.size() );
39307#else
39308 if ( counterBuffers.size() != counterBufferOffsets.size() )
39309 {
39310 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::beginTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" );
39311 }
39312#endif // VULKAN_HPP_NO_EXCEPTIONS
39313 d.vkCmdBeginTransformFeedbackEXT( m_commandBuffer, firstCounterBuffer, counterBuffers.size() , reinterpret_cast<const VkBuffer*>( counterBuffers.data() ), counterBufferOffsets.data() );
39314 }
39315#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39316
39317 template<typename Dispatch>
39318 VULKAN_HPP_INLINE void CommandBuffer::endTransformFeedbackEXT( uint32_t firstCounterBuffer, uint32_t counterBufferCount, const Buffer* pCounterBuffers, const DeviceSize* pCounterBufferOffsets, Dispatch const &d) const
39319 {
39320 d.vkCmdEndTransformFeedbackEXT( m_commandBuffer, firstCounterBuffer, counterBufferCount, reinterpret_cast<const VkBuffer*>( pCounterBuffers ), pCounterBufferOffsets );
39321 }
39322#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
39323 template<typename Dispatch>
39324 VULKAN_HPP_INLINE void CommandBuffer::endTransformFeedbackEXT( uint32_t firstCounterBuffer, ArrayProxy<const Buffer> counterBuffers, ArrayProxy<const DeviceSize> counterBufferOffsets, Dispatch const &d ) const
39325 {
39326#ifdef VULKAN_HPP_NO_EXCEPTIONS
39327 VULKAN_HPP_ASSERT( counterBuffers.size() == counterBufferOffsets.size() );
39328#else
39329 if ( counterBuffers.size() != counterBufferOffsets.size() )
39330 {
39331 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::endTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" );
39332 }
39333#endif // VULKAN_HPP_NO_EXCEPTIONS
39334 d.vkCmdEndTransformFeedbackEXT( m_commandBuffer, firstCounterBuffer, counterBuffers.size() , reinterpret_cast<const VkBuffer*>( counterBuffers.data() ), counterBufferOffsets.data() );
39335 }
39336#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39337
39338#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
39339 template<typename Dispatch>
39341 {
39342 d.vkCmdBeginQueryIndexedEXT( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, static_cast<VkQueryControlFlags>( flags ), index );
39343 }
39344#else
39345 template<typename Dispatch>
39347 {
39348 d.vkCmdBeginQueryIndexedEXT( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, static_cast<VkQueryControlFlags>( flags ), index );
39349 }
39350#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39351
39352#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
39353 template<typename Dispatch>
39355 {
39356 d.vkCmdEndQueryIndexedEXT( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, index );
39357 }
39358#else
39359 template<typename Dispatch>
39361 {
39362 d.vkCmdEndQueryIndexedEXT( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, index );
39363 }
39364#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39365
39366#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
39367 template<typename Dispatch>
39368 VULKAN_HPP_INLINE void CommandBuffer::drawIndirectByteCountEXT( uint32_t instanceCount, uint32_t firstInstance, Buffer counterBuffer, DeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride, Dispatch const &d) const
39369 {
39370 d.vkCmdDrawIndirectByteCountEXT( m_commandBuffer, instanceCount, firstInstance, static_cast<VkBuffer>( counterBuffer ), counterBufferOffset, counterOffset, vertexStride );
39371 }
39372#else
39373 template<typename Dispatch>
39374 VULKAN_HPP_INLINE void CommandBuffer::drawIndirectByteCountEXT( uint32_t instanceCount, uint32_t firstInstance, Buffer counterBuffer, DeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride, Dispatch const &d ) const
39375 {
39376 d.vkCmdDrawIndirectByteCountEXT( m_commandBuffer, instanceCount, firstInstance, static_cast<VkBuffer>( counterBuffer ), counterBufferOffset, counterOffset, vertexStride );
39377 }
39378#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39379
39380 template<typename Dispatch>
39381 VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorNV( uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const Rect2D* pExclusiveScissors, Dispatch const &d) const
39382 {
39383 d.vkCmdSetExclusiveScissorNV( m_commandBuffer, firstExclusiveScissor, exclusiveScissorCount, reinterpret_cast<const VkRect2D*>( pExclusiveScissors ) );
39384 }
39385#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
39386 template<typename Dispatch>
39387 VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorNV( uint32_t firstExclusiveScissor, ArrayProxy<const Rect2D> exclusiveScissors, Dispatch const &d ) const
39388 {
39389 d.vkCmdSetExclusiveScissorNV( m_commandBuffer, firstExclusiveScissor, exclusiveScissors.size() , reinterpret_cast<const VkRect2D*>( exclusiveScissors.data() ) );
39390 }
39391#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39392
39393#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
39394 template<typename Dispatch>
39395 VULKAN_HPP_INLINE void CommandBuffer::bindShadingRateImageNV( ImageView imageView, ImageLayout imageLayout, Dispatch const &d) const
39396 {
39397 d.vkCmdBindShadingRateImageNV( m_commandBuffer, static_cast<VkImageView>( imageView ), static_cast<VkImageLayout>( imageLayout ) );
39398 }
39399#else
39400 template<typename Dispatch>
39401 VULKAN_HPP_INLINE void CommandBuffer::bindShadingRateImageNV( ImageView imageView, ImageLayout imageLayout, Dispatch const &d ) const
39402 {
39403 d.vkCmdBindShadingRateImageNV( m_commandBuffer, static_cast<VkImageView>( imageView ), static_cast<VkImageLayout>( imageLayout ) );
39404 }
39405#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39406
39407 template<typename Dispatch>
39408 VULKAN_HPP_INLINE void CommandBuffer::setViewportShadingRatePaletteNV( uint32_t firstViewport, uint32_t viewportCount, const ShadingRatePaletteNV* pShadingRatePalettes, Dispatch const &d) const
39409 {
39410 d.vkCmdSetViewportShadingRatePaletteNV( m_commandBuffer, firstViewport, viewportCount, reinterpret_cast<const VkShadingRatePaletteNV*>( pShadingRatePalettes ) );
39411 }
39412#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
39413 template<typename Dispatch>
39415 {
39416 d.vkCmdSetViewportShadingRatePaletteNV( m_commandBuffer, firstViewport, shadingRatePalettes.size() , reinterpret_cast<const VkShadingRatePaletteNV*>( shadingRatePalettes.data() ) );
39417 }
39418#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39419
39420 template<typename Dispatch>
39421 VULKAN_HPP_INLINE void CommandBuffer::setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const CoarseSampleOrderCustomNV* pCustomSampleOrders, Dispatch const &d) const
39422 {
39423 d.vkCmdSetCoarseSampleOrderNV( m_commandBuffer, static_cast<VkCoarseSampleOrderTypeNV>( sampleOrderType ), customSampleOrderCount, reinterpret_cast<const VkCoarseSampleOrderCustomNV*>( pCustomSampleOrders ) );
39424 }
39425#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
39426 template<typename Dispatch>
39428 {
39429 d.vkCmdSetCoarseSampleOrderNV( m_commandBuffer, static_cast<VkCoarseSampleOrderTypeNV>( sampleOrderType ), customSampleOrders.size() , reinterpret_cast<const VkCoarseSampleOrderCustomNV*>( customSampleOrders.data() ) );
39430 }
39431#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39432
39433#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
39434 template<typename Dispatch>
39435 VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask, Dispatch const &d) const
39436 {
39437 d.vkCmdDrawMeshTasksNV( m_commandBuffer, taskCount, firstTask );
39438 }
39439#else
39440 template<typename Dispatch>
39441 VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask, Dispatch const &d ) const
39442 {
39443 d.vkCmdDrawMeshTasksNV( m_commandBuffer, taskCount, firstTask );
39444 }
39445#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39446
39447#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
39448 template<typename Dispatch>
39450 {
39451 d.vkCmdDrawMeshTasksIndirectNV( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, drawCount, stride );
39452 }
39453#else
39454 template<typename Dispatch>
39456 {
39457 d.vkCmdDrawMeshTasksIndirectNV( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, drawCount, stride );
39458 }
39459#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39460
39461#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
39462 template<typename Dispatch>
39463 VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectCountNV( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d) const
39464 {
39465 d.vkCmdDrawMeshTasksIndirectCountNV( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, static_cast<VkBuffer>( countBuffer ), countBufferOffset, maxDrawCount, stride );
39466 }
39467#else
39468 template<typename Dispatch>
39469 VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectCountNV( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d ) const
39470 {
39471 d.vkCmdDrawMeshTasksIndirectCountNV( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, static_cast<VkBuffer>( countBuffer ), countBufferOffset, maxDrawCount, stride );
39472 }
39473#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39474
39475#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
39476 template<typename Dispatch>
39478 {
39479 d.vkCmdCopyAccelerationStructureNV( m_commandBuffer, static_cast<VkAccelerationStructureNV>( dst ), static_cast<VkAccelerationStructureNV>( src ), static_cast<VkCopyAccelerationStructureModeNV>( mode ) );
39480 }
39481#else
39482 template<typename Dispatch>
39484 {
39485 d.vkCmdCopyAccelerationStructureNV( m_commandBuffer, static_cast<VkAccelerationStructureNV>( dst ), static_cast<VkAccelerationStructureNV>( src ), static_cast<VkCopyAccelerationStructureModeNV>( mode ) );
39486 }
39487#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39488
39489 template<typename Dispatch>
39490 VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesNV( uint32_t accelerationStructureCount, const AccelerationStructureNV* pAccelerationStructures, QueryType queryType, QueryPool queryPool, uint32_t firstQuery, Dispatch const &d) const
39491 {
39492 d.vkCmdWriteAccelerationStructuresPropertiesNV( m_commandBuffer, accelerationStructureCount, reinterpret_cast<const VkAccelerationStructureNV*>( pAccelerationStructures ), static_cast<VkQueryType>( queryType ), static_cast<VkQueryPool>( queryPool ), firstQuery );
39493 }
39494#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
39495 template<typename Dispatch>
39497 {
39498 d.vkCmdWriteAccelerationStructuresPropertiesNV( m_commandBuffer, accelerationStructures.size() , reinterpret_cast<const VkAccelerationStructureNV*>( accelerationStructures.data() ), static_cast<VkQueryType>( queryType ), static_cast<VkQueryPool>( queryPool ), firstQuery );
39499 }
39500#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39501
39502 template<typename Dispatch>
39504 {
39505 d.vkCmdBuildAccelerationStructureNV( m_commandBuffer, reinterpret_cast<const VkAccelerationStructureInfoNV*>( pInfo ), static_cast<VkBuffer>( instanceData ), instanceOffset, update, static_cast<VkAccelerationStructureNV>( dst ), static_cast<VkAccelerationStructureNV>( src ), static_cast<VkBuffer>( scratch ), scratchOffset );
39506 }
39507#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
39508 template<typename Dispatch>
39510 {
39511 d.vkCmdBuildAccelerationStructureNV( m_commandBuffer, reinterpret_cast<const VkAccelerationStructureInfoNV*>( &info ), static_cast<VkBuffer>( instanceData ), instanceOffset, update, static_cast<VkAccelerationStructureNV>( dst ), static_cast<VkAccelerationStructureNV>( src ), static_cast<VkBuffer>( scratch ), scratchOffset );
39512 }
39513#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39514
39515#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
39516 template<typename Dispatch>
39517 VULKAN_HPP_INLINE void CommandBuffer::traceRaysNV( Buffer raygenShaderBindingTableBuffer, DeviceSize raygenShaderBindingOffset, Buffer missShaderBindingTableBuffer, DeviceSize missShaderBindingOffset, DeviceSize missShaderBindingStride, Buffer hitShaderBindingTableBuffer, DeviceSize hitShaderBindingOffset, DeviceSize hitShaderBindingStride, Buffer callableShaderBindingTableBuffer, DeviceSize callableShaderBindingOffset, DeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth, Dispatch const &d) const
39518 {
39519 d.vkCmdTraceRaysNV( m_commandBuffer, static_cast<VkBuffer>( raygenShaderBindingTableBuffer ), raygenShaderBindingOffset, static_cast<VkBuffer>( missShaderBindingTableBuffer ), missShaderBindingOffset, missShaderBindingStride, static_cast<VkBuffer>( hitShaderBindingTableBuffer ), hitShaderBindingOffset, hitShaderBindingStride, static_cast<VkBuffer>( callableShaderBindingTableBuffer ), callableShaderBindingOffset, callableShaderBindingStride, width, height, depth );
39520 }
39521#else
39522 template<typename Dispatch>
39523 VULKAN_HPP_INLINE void CommandBuffer::traceRaysNV( Buffer raygenShaderBindingTableBuffer, DeviceSize raygenShaderBindingOffset, Buffer missShaderBindingTableBuffer, DeviceSize missShaderBindingOffset, DeviceSize missShaderBindingStride, Buffer hitShaderBindingTableBuffer, DeviceSize hitShaderBindingOffset, DeviceSize hitShaderBindingStride, Buffer callableShaderBindingTableBuffer, DeviceSize callableShaderBindingOffset, DeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth, Dispatch const &d ) const
39524 {
39525 d.vkCmdTraceRaysNV( m_commandBuffer, static_cast<VkBuffer>( raygenShaderBindingTableBuffer ), raygenShaderBindingOffset, static_cast<VkBuffer>( missShaderBindingTableBuffer ), missShaderBindingOffset, missShaderBindingStride, static_cast<VkBuffer>( hitShaderBindingTableBuffer ), hitShaderBindingOffset, hitShaderBindingStride, static_cast<VkBuffer>( callableShaderBindingTableBuffer ), callableShaderBindingOffset, callableShaderBindingStride, width, height, depth );
39526 }
39527#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39528
39530 {
39531 SubmitInfo( uint32_t waitSemaphoreCount_ = 0,
39532 const Semaphore* pWaitSemaphores_ = nullptr,
39533 const PipelineStageFlags* pWaitDstStageMask_ = nullptr,
39534 uint32_t commandBufferCount_ = 0,
39535 const CommandBuffer* pCommandBuffers_ = nullptr,
39536 uint32_t signalSemaphoreCount_ = 0,
39537 const Semaphore* pSignalSemaphores_ = nullptr )
39538 : waitSemaphoreCount( waitSemaphoreCount_ )
39539 , pWaitSemaphores( pWaitSemaphores_ )
39540 , pWaitDstStageMask( pWaitDstStageMask_ )
39541 , commandBufferCount( commandBufferCount_ )
39542 , pCommandBuffers( pCommandBuffers_ )
39543 , signalSemaphoreCount( signalSemaphoreCount_ )
39544 , pSignalSemaphores( pSignalSemaphores_ )
39545 {
39546 }
39547
39549 {
39550 memcpy( this, &rhs, sizeof( SubmitInfo ) );
39551 }
39552
39554 {
39555 memcpy( this, &rhs, sizeof( SubmitInfo ) );
39556 return *this;
39557 }
39558 SubmitInfo& setPNext( const void* pNext_ )
39559 {
39560 pNext = pNext_;
39561 return *this;
39562 }
39563
39565 {
39566 waitSemaphoreCount = waitSemaphoreCount_;
39567 return *this;
39568 }
39569
39570 SubmitInfo& setPWaitSemaphores( const Semaphore* pWaitSemaphores_ )
39571 {
39572 pWaitSemaphores = pWaitSemaphores_;
39573 return *this;
39574 }
39575
39577 {
39578 pWaitDstStageMask = pWaitDstStageMask_;
39579 return *this;
39580 }
39581
39583 {
39584 commandBufferCount = commandBufferCount_;
39585 return *this;
39586 }
39587
39588 SubmitInfo& setPCommandBuffers( const CommandBuffer* pCommandBuffers_ )
39589 {
39590 pCommandBuffers = pCommandBuffers_;
39591 return *this;
39592 }
39593
39595 {
39596 signalSemaphoreCount = signalSemaphoreCount_;
39597 return *this;
39598 }
39599
39600 SubmitInfo& setPSignalSemaphores( const Semaphore* pSignalSemaphores_ )
39601 {
39602 pSignalSemaphores = pSignalSemaphores_;
39603 return *this;
39604 }
39605
39606 operator VkSubmitInfo const&() const
39607 {
39608 return *reinterpret_cast<const VkSubmitInfo*>(this);
39609 }
39610
39611 operator VkSubmitInfo &()
39612 {
39613 return *reinterpret_cast<VkSubmitInfo*>(this);
39614 }
39615
39616 bool operator==( SubmitInfo const& rhs ) const
39617 {
39618 return ( sType == rhs.sType )
39619 && ( pNext == rhs.pNext )
39621 && ( pWaitSemaphores == rhs.pWaitSemaphores )
39624 && ( pCommandBuffers == rhs.pCommandBuffers )
39627 }
39628
39629 bool operator!=( SubmitInfo const& rhs ) const
39630 {
39631 return !operator==( rhs );
39632 }
39633
39634 private:
39636
39637 public:
39638 const void* pNext = nullptr;
39646 };
39647 static_assert( sizeof( SubmitInfo ) == sizeof( VkSubmitInfo ), "struct and wrapper have different size!" );
39648
39649 class Queue
39650 {
39651 public:
39654 {}
39655
39656 VULKAN_HPP_CONSTEXPR Queue( std::nullptr_t )
39658 {}
39659
39661 : m_queue( queue )
39662 {}
39663
39664#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
39665 Queue & operator=(VkQueue queue)
39666 {
39667 m_queue = queue;
39668 return *this;
39669 }
39670#endif
39671
39672 Queue & operator=( std::nullptr_t )
39673 {
39675 return *this;
39676 }
39677
39678 bool operator==( Queue const & rhs ) const
39679 {
39680 return m_queue == rhs.m_queue;
39681 }
39682
39683 bool operator!=(Queue const & rhs ) const
39684 {
39685 return m_queue != rhs.m_queue;
39686 }
39687
39688 bool operator<(Queue const & rhs ) const
39689 {
39690 return m_queue < rhs.m_queue;
39691 }
39692
39693 template<typename Dispatch = DispatchLoaderStatic>
39694 Result submit( uint32_t submitCount, const SubmitInfo* pSubmits, Fence fence, Dispatch const &d = Dispatch() ) const;
39695#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
39696 template<typename Dispatch = DispatchLoaderStatic>
39697 ResultValueType<void>::type submit( ArrayProxy<const SubmitInfo> submits, Fence fence, Dispatch const &d = Dispatch() ) const;
39698#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39699
39700#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
39701 template<typename Dispatch = DispatchLoaderStatic>
39702 Result waitIdle(Dispatch const &d = Dispatch() ) const;
39703#else
39704 template<typename Dispatch = DispatchLoaderStatic>
39705 ResultValueType<void>::type waitIdle(Dispatch const &d = Dispatch() ) const;
39706#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39707
39708 template<typename Dispatch = DispatchLoaderStatic>
39709 Result bindSparse( uint32_t bindInfoCount, const BindSparseInfo* pBindInfo, Fence fence, Dispatch const &d = Dispatch() ) const;
39710#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
39711 template<typename Dispatch = DispatchLoaderStatic>
39712 ResultValueType<void>::type bindSparse( ArrayProxy<const BindSparseInfo> bindInfo, Fence fence, Dispatch const &d = Dispatch() ) const;
39713#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39714
39715 template<typename Dispatch = DispatchLoaderStatic>
39716 Result presentKHR( const PresentInfoKHR* pPresentInfo, Dispatch const &d = Dispatch() ) const;
39717#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
39718 template<typename Dispatch = DispatchLoaderStatic>
39719 Result presentKHR( const PresentInfoKHR & presentInfo, Dispatch const &d = Dispatch() ) const;
39720#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39721
39722 template<typename Dispatch = DispatchLoaderStatic>
39723 void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d = Dispatch() ) const;
39724#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
39725 template<typename Dispatch = DispatchLoaderStatic>
39726 void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d = Dispatch() ) const;
39727#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39728
39729 template<typename Dispatch = DispatchLoaderStatic>
39730 void endDebugUtilsLabelEXT(Dispatch const &d = Dispatch() ) const;
39731
39732 template<typename Dispatch = DispatchLoaderStatic>
39733 void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d = Dispatch() ) const;
39734#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
39735 template<typename Dispatch = DispatchLoaderStatic>
39736 void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d = Dispatch() ) const;
39737#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39738
39739 template<typename Dispatch = DispatchLoaderStatic>
39740 void getCheckpointDataNV( uint32_t* pCheckpointDataCount, CheckpointDataNV* pCheckpointData, Dispatch const &d = Dispatch() ) const;
39741#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
39742 template <typename Allocator = std::allocator<CheckpointDataNV>, typename Dispatch = DispatchLoaderStatic>
39743 std::vector<CheckpointDataNV,Allocator> getCheckpointDataNV(Dispatch const &d = Dispatch() ) const;
39744 template <typename Allocator = std::allocator<CheckpointDataNV>, typename Dispatch = DispatchLoaderStatic>
39745 std::vector<CheckpointDataNV,Allocator> getCheckpointDataNV(Allocator const& vectorAllocator, Dispatch const &d ) const;
39746#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39747
39748
39749
39750 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueue() const
39751 {
39752 return m_queue;
39753 }
39754
39755 explicit operator bool() const
39756 {
39757 return m_queue != VK_NULL_HANDLE;
39758 }
39759
39760 bool operator!() const
39761 {
39762 return m_queue == VK_NULL_HANDLE;
39763 }
39764
39765 private:
39766 VkQueue m_queue;
39767 };
39768
39769 static_assert( sizeof( Queue ) == sizeof( VkQueue ), "handle and wrapper have different size!" );
39770
39771 template<typename Dispatch>
39772 VULKAN_HPP_INLINE Result Queue::submit( uint32_t submitCount, const SubmitInfo* pSubmits, Fence fence, Dispatch const &d) const
39773 {
39774 return static_cast<Result>( d.vkQueueSubmit( m_queue, submitCount, reinterpret_cast<const VkSubmitInfo*>( pSubmits ), static_cast<VkFence>( fence ) ) );
39775 }
39776#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
39777 template<typename Dispatch>
39779 {
39780 Result result = static_cast<Result>( d.vkQueueSubmit( m_queue, submits.size() , reinterpret_cast<const VkSubmitInfo*>( submits.data() ), static_cast<VkFence>( fence ) ) );
39781 return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Queue::submit" );
39782 }
39783#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39784
39785#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
39786 template<typename Dispatch>
39787 VULKAN_HPP_INLINE Result Queue::waitIdle(Dispatch const &d) const
39788 {
39789 return static_cast<Result>( d.vkQueueWaitIdle( m_queue ) );
39790 }
39791#else
39792 template<typename Dispatch>
39794 {
39795 Result result = static_cast<Result>( d.vkQueueWaitIdle( m_queue ) );
39796 return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Queue::waitIdle" );
39797 }
39798#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39799
39800 template<typename Dispatch>
39801 VULKAN_HPP_INLINE Result Queue::bindSparse( uint32_t bindInfoCount, const BindSparseInfo* pBindInfo, Fence fence, Dispatch const &d) const
39802 {
39803 return static_cast<Result>( d.vkQueueBindSparse( m_queue, bindInfoCount, reinterpret_cast<const VkBindSparseInfo*>( pBindInfo ), static_cast<VkFence>( fence ) ) );
39804 }
39805#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
39806 template<typename Dispatch>
39808 {
39809 Result result = static_cast<Result>( d.vkQueueBindSparse( m_queue, bindInfo.size() , reinterpret_cast<const VkBindSparseInfo*>( bindInfo.data() ), static_cast<VkFence>( fence ) ) );
39810 return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Queue::bindSparse" );
39811 }
39812#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39813
39814 template<typename Dispatch>
39815 VULKAN_HPP_INLINE Result Queue::presentKHR( const PresentInfoKHR* pPresentInfo, Dispatch const &d) const
39816 {
39817 return static_cast<Result>( d.vkQueuePresentKHR( m_queue, reinterpret_cast<const VkPresentInfoKHR*>( pPresentInfo ) ) );
39818 }
39819#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
39820 template<typename Dispatch>
39821 VULKAN_HPP_INLINE Result Queue::presentKHR( const PresentInfoKHR & presentInfo, Dispatch const &d ) const
39822 {
39823 Result result = static_cast<Result>( d.vkQueuePresentKHR( m_queue, reinterpret_cast<const VkPresentInfoKHR*>( &presentInfo ) ) );
39825 }
39826#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39827
39828 template<typename Dispatch>
39829 VULKAN_HPP_INLINE void Queue::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d) const
39830 {
39831 d.vkQueueBeginDebugUtilsLabelEXT( m_queue, reinterpret_cast<const VkDebugUtilsLabelEXT*>( pLabelInfo ) );
39832 }
39833#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
39834 template<typename Dispatch>
39835 VULKAN_HPP_INLINE void Queue::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d ) const
39836 {
39837 d.vkQueueBeginDebugUtilsLabelEXT( m_queue, reinterpret_cast<const VkDebugUtilsLabelEXT*>( &labelInfo ) );
39838 }
39839#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39840
39841#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
39842 template<typename Dispatch>
39843 VULKAN_HPP_INLINE void Queue::endDebugUtilsLabelEXT(Dispatch const &d) const
39844 {
39845 d.vkQueueEndDebugUtilsLabelEXT( m_queue );
39846 }
39847#else
39848 template<typename Dispatch>
39850 {
39851 d.vkQueueEndDebugUtilsLabelEXT( m_queue );
39852 }
39853#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39854
39855 template<typename Dispatch>
39856 VULKAN_HPP_INLINE void Queue::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT* pLabelInfo, Dispatch const &d) const
39857 {
39858 d.vkQueueInsertDebugUtilsLabelEXT( m_queue, reinterpret_cast<const VkDebugUtilsLabelEXT*>( pLabelInfo ) );
39859 }
39860#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
39861 template<typename Dispatch>
39862 VULKAN_HPP_INLINE void Queue::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const &d ) const
39863 {
39864 d.vkQueueInsertDebugUtilsLabelEXT( m_queue, reinterpret_cast<const VkDebugUtilsLabelEXT*>( &labelInfo ) );
39865 }
39866#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39867
39868 template<typename Dispatch>
39869 VULKAN_HPP_INLINE void Queue::getCheckpointDataNV( uint32_t* pCheckpointDataCount, CheckpointDataNV* pCheckpointData, Dispatch const &d) const
39870 {
39871 d.vkGetQueueCheckpointDataNV( m_queue, pCheckpointDataCount, reinterpret_cast<VkCheckpointDataNV*>( pCheckpointData ) );
39872 }
39873#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
39874 template <typename Allocator, typename Dispatch>
39875 VULKAN_HPP_INLINE std::vector<CheckpointDataNV,Allocator> Queue::getCheckpointDataNV(Dispatch const &d ) const
39876 {
39877 std::vector<CheckpointDataNV,Allocator> checkpointData;
39878 uint32_t checkpointDataCount;
39879 d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, nullptr );
39880 checkpointData.resize( checkpointDataCount );
39881 d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, reinterpret_cast<VkCheckpointDataNV*>( checkpointData.data() ) );
39882 return checkpointData;
39883 }
39884 template <typename Allocator, typename Dispatch>
39885 VULKAN_HPP_INLINE std::vector<CheckpointDataNV,Allocator> Queue::getCheckpointDataNV(Allocator const& vectorAllocator, Dispatch const &d ) const
39886 {
39887 std::vector<CheckpointDataNV,Allocator> checkpointData( vectorAllocator );
39888 uint32_t checkpointDataCount;
39889 d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, nullptr );
39890 checkpointData.resize( checkpointDataCount );
39891 d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, reinterpret_cast<VkCheckpointDataNV*>( checkpointData.data() ) );
39892 return checkpointData;
39893 }
39894#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
39895
39896#ifndef VULKAN_HPP_NO_SMART_HANDLE
39897 class Device;
39898
39899 template <typename Dispatch> class UniqueHandleTraits<AccelerationStructureNV,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
39901 template <typename Dispatch> class UniqueHandleTraits<Buffer,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
39903 template <typename Dispatch> class UniqueHandleTraits<BufferView,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
39905 template <typename Dispatch> class UniqueHandleTraits<CommandBuffer,Dispatch> {public: using deleter = PoolFree<Device, CommandPool,Dispatch>; };
39907 template <typename Dispatch> class UniqueHandleTraits<CommandPool,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
39909 template <typename Dispatch> class UniqueHandleTraits<DescriptorPool,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
39911 template <typename Dispatch> class UniqueHandleTraits<DescriptorSet,Dispatch> {public: using deleter = PoolFree<Device, DescriptorPool,Dispatch>; };
39913 template <typename Dispatch> class UniqueHandleTraits<DescriptorSetLayout,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
39915 template <typename Dispatch> class UniqueHandleTraits<DescriptorUpdateTemplate,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
39917 template <typename Dispatch> class UniqueHandleTraits<DeviceMemory,Dispatch> {public: using deleter = ObjectFree<Device,Dispatch>; };
39919 template <typename Dispatch> class UniqueHandleTraits<Event,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
39921 template <typename Dispatch> class UniqueHandleTraits<Fence,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
39923 template <typename Dispatch> class UniqueHandleTraits<Framebuffer,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
39925 template <typename Dispatch> class UniqueHandleTraits<Image,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
39927 template <typename Dispatch> class UniqueHandleTraits<ImageView,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
39929 template <typename Dispatch> class UniqueHandleTraits<IndirectCommandsLayoutNVX,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
39931 template <typename Dispatch> class UniqueHandleTraits<ObjectTableNVX,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
39933 template <typename Dispatch> class UniqueHandleTraits<Pipeline,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
39935 template <typename Dispatch> class UniqueHandleTraits<PipelineCache,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
39937 template <typename Dispatch> class UniqueHandleTraits<PipelineLayout,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
39939 template <typename Dispatch> class UniqueHandleTraits<QueryPool,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
39941 template <typename Dispatch> class UniqueHandleTraits<RenderPass,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
39943 template <typename Dispatch> class UniqueHandleTraits<Sampler,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
39945 template <typename Dispatch> class UniqueHandleTraits<SamplerYcbcrConversion,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
39947 template <typename Dispatch> class UniqueHandleTraits<Semaphore,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
39949 template <typename Dispatch> class UniqueHandleTraits<ShaderModule,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
39951 template <typename Dispatch> class UniqueHandleTraits<SwapchainKHR,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
39953 template <typename Dispatch> class UniqueHandleTraits<ValidationCacheEXT,Dispatch> {public: using deleter = ObjectDestroy<Device,Dispatch>; };
39955#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
39956
39958 {
39959 public:
39962 {}
39963
39966 {}
39967
39969 : m_device( device )
39970 {}
39971
39972#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
39973 Device & operator=(VkDevice device)
39974 {
39975 m_device = device;
39976 return *this;
39977 }
39978#endif
39979
39980 Device & operator=( std::nullptr_t )
39981 {
39983 return *this;
39984 }
39985
39986 bool operator==( Device const & rhs ) const
39987 {
39988 return m_device == rhs.m_device;
39989 }
39990
39991 bool operator!=(Device const & rhs ) const
39992 {
39993 return m_device != rhs.m_device;
39994 }
39995
39996 bool operator<(Device const & rhs ) const
39997 {
39998 return m_device < rhs.m_device;
39999 }
40000
40001 template<typename Dispatch = DispatchLoaderStatic>
40002 PFN_vkVoidFunction getProcAddr( const char* pName, Dispatch const &d = Dispatch() ) const;
40003#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40004 template<typename Dispatch = DispatchLoaderStatic>
40005 PFN_vkVoidFunction getProcAddr( const std::string & name, Dispatch const &d = Dispatch() ) const;
40006#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40007
40008 template<typename Dispatch = DispatchLoaderStatic>
40009 void destroy( const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40010#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40011 template<typename Dispatch = DispatchLoaderStatic>
40012 void destroy( Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40013#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40014
40015 template<typename Dispatch = DispatchLoaderStatic>
40016 void getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Queue* pQueue, Dispatch const &d = Dispatch() ) const;
40017#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40018 template<typename Dispatch = DispatchLoaderStatic>
40019 Queue getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Dispatch const &d = Dispatch() ) const;
40020#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40021
40022#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
40023 template<typename Dispatch = DispatchLoaderStatic>
40024 Result waitIdle(Dispatch const &d = Dispatch() ) const;
40025#else
40026 template<typename Dispatch = DispatchLoaderStatic>
40027 ResultValueType<void>::type waitIdle(Dispatch const &d = Dispatch() ) const;
40028#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40029
40030 template<typename Dispatch = DispatchLoaderStatic>
40031 Result allocateMemory( const MemoryAllocateInfo* pAllocateInfo, const AllocationCallbacks* pAllocator, DeviceMemory* pMemory, Dispatch const &d = Dispatch() ) const;
40032#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40033 template<typename Dispatch = DispatchLoaderStatic>
40034 ResultValueType<DeviceMemory>::type allocateMemory( const MemoryAllocateInfo & allocateInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40035#ifndef VULKAN_HPP_NO_SMART_HANDLE
40036 template<typename Dispatch = DispatchLoaderStatic>
40037 typename ResultValueType<UniqueHandle<DeviceMemory,Dispatch>>::type allocateMemoryUnique( const MemoryAllocateInfo & allocateInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40038#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
40039#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40040
40041 template<typename Dispatch = DispatchLoaderStatic>
40042 void freeMemory( DeviceMemory memory, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40043#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40044 template<typename Dispatch = DispatchLoaderStatic>
40045 void freeMemory( DeviceMemory memory, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40046#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40047
40048 template<typename Dispatch = DispatchLoaderStatic>
40049 void free( DeviceMemory memory, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40050#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40051 template<typename Dispatch = DispatchLoaderStatic>
40052 void free( DeviceMemory memory, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40053#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40054
40055 template<typename Dispatch = DispatchLoaderStatic>
40056 Result mapMemory( DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags, void** ppData, Dispatch const &d = Dispatch() ) const;
40057#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40058 template<typename Dispatch = DispatchLoaderStatic>
40060#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40061
40062 template<typename Dispatch = DispatchLoaderStatic>
40063 void unmapMemory( DeviceMemory memory, Dispatch const &d = Dispatch() ) const;
40064
40065 template<typename Dispatch = DispatchLoaderStatic>
40066 Result flushMappedMemoryRanges( uint32_t memoryRangeCount, const MappedMemoryRange* pMemoryRanges, Dispatch const &d = Dispatch() ) const;
40067#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40068 template<typename Dispatch = DispatchLoaderStatic>
40070#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40071
40072 template<typename Dispatch = DispatchLoaderStatic>
40073 Result invalidateMappedMemoryRanges( uint32_t memoryRangeCount, const MappedMemoryRange* pMemoryRanges, Dispatch const &d = Dispatch() ) const;
40074#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40075 template<typename Dispatch = DispatchLoaderStatic>
40077#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40078
40079 template<typename Dispatch = DispatchLoaderStatic>
40080 void getMemoryCommitment( DeviceMemory memory, DeviceSize* pCommittedMemoryInBytes, Dispatch const &d = Dispatch() ) const;
40081#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40082 template<typename Dispatch = DispatchLoaderStatic>
40083 DeviceSize getMemoryCommitment( DeviceMemory memory, Dispatch const &d = Dispatch() ) const;
40084#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40085
40086 template<typename Dispatch = DispatchLoaderStatic>
40087 void getBufferMemoryRequirements( Buffer buffer, MemoryRequirements* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
40088#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40089 template<typename Dispatch = DispatchLoaderStatic>
40090 MemoryRequirements getBufferMemoryRequirements( Buffer buffer, Dispatch const &d = Dispatch() ) const;
40091#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40092
40093#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
40094 template<typename Dispatch = DispatchLoaderStatic>
40095 Result bindBufferMemory( Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d = Dispatch() ) const;
40096#else
40097 template<typename Dispatch = DispatchLoaderStatic>
40098 ResultValueType<void>::type bindBufferMemory( Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d = Dispatch() ) const;
40099#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40100
40101 template<typename Dispatch = DispatchLoaderStatic>
40102 void getImageMemoryRequirements( Image image, MemoryRequirements* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
40103#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40104 template<typename Dispatch = DispatchLoaderStatic>
40105 MemoryRequirements getImageMemoryRequirements( Image image, Dispatch const &d = Dispatch() ) const;
40106#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40107
40108#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
40109 template<typename Dispatch = DispatchLoaderStatic>
40110 Result bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d = Dispatch() ) const;
40111#else
40112 template<typename Dispatch = DispatchLoaderStatic>
40113 ResultValueType<void>::type bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d = Dispatch() ) const;
40114#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40115
40116 template<typename Dispatch = DispatchLoaderStatic>
40117 void getImageSparseMemoryRequirements( Image image, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements* pSparseMemoryRequirements, Dispatch const &d = Dispatch() ) const;
40118#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40119 template <typename Allocator = std::allocator<SparseImageMemoryRequirements>, typename Dispatch = DispatchLoaderStatic>
40120 std::vector<SparseImageMemoryRequirements,Allocator> getImageSparseMemoryRequirements( Image image, Dispatch const &d = Dispatch() ) const;
40121 template <typename Allocator = std::allocator<SparseImageMemoryRequirements>, typename Dispatch = DispatchLoaderStatic>
40122 std::vector<SparseImageMemoryRequirements,Allocator> getImageSparseMemoryRequirements( Image image, Allocator const& vectorAllocator, Dispatch const &d ) const;
40123#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40124
40125 template<typename Dispatch = DispatchLoaderStatic>
40126 Result createFence( const FenceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Fence* pFence, Dispatch const &d = Dispatch() ) const;
40127#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40128 template<typename Dispatch = DispatchLoaderStatic>
40129 ResultValueType<Fence>::type createFence( const FenceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40130#ifndef VULKAN_HPP_NO_SMART_HANDLE
40131 template<typename Dispatch = DispatchLoaderStatic>
40132 typename ResultValueType<UniqueHandle<Fence,Dispatch>>::type createFenceUnique( const FenceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40133#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
40134#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40135
40136 template<typename Dispatch = DispatchLoaderStatic>
40137 void destroyFence( Fence fence, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40138#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40139 template<typename Dispatch = DispatchLoaderStatic>
40140 void destroyFence( Fence fence, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40141#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40142
40143 template<typename Dispatch = DispatchLoaderStatic>
40144 void destroy( Fence fence, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40145#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40146 template<typename Dispatch = DispatchLoaderStatic>
40147 void destroy( Fence fence, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40148#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40149
40150 template<typename Dispatch = DispatchLoaderStatic>
40151 Result resetFences( uint32_t fenceCount, const Fence* pFences, Dispatch const &d = Dispatch() ) const;
40152#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40153 template<typename Dispatch = DispatchLoaderStatic>
40155#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40156
40157 template<typename Dispatch = DispatchLoaderStatic>
40158 Result getFenceStatus( Fence fence, Dispatch const &d = Dispatch() ) const;
40159
40160 template<typename Dispatch = DispatchLoaderStatic>
40161 Result waitForFences( uint32_t fenceCount, const Fence* pFences, Bool32 waitAll, uint64_t timeout, Dispatch const &d = Dispatch() ) const;
40162#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40163 template<typename Dispatch = DispatchLoaderStatic>
40164 Result waitForFences( ArrayProxy<const Fence> fences, Bool32 waitAll, uint64_t timeout, Dispatch const &d = Dispatch() ) const;
40165#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40166
40167 template<typename Dispatch = DispatchLoaderStatic>
40168 Result createSemaphore( const SemaphoreCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Semaphore* pSemaphore, Dispatch const &d = Dispatch() ) const;
40169#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40170 template<typename Dispatch = DispatchLoaderStatic>
40171 ResultValueType<Semaphore>::type createSemaphore( const SemaphoreCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40172#ifndef VULKAN_HPP_NO_SMART_HANDLE
40173 template<typename Dispatch = DispatchLoaderStatic>
40174 typename ResultValueType<UniqueHandle<Semaphore,Dispatch>>::type createSemaphoreUnique( const SemaphoreCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40175#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
40176#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40177
40178 template<typename Dispatch = DispatchLoaderStatic>
40179 void destroySemaphore( Semaphore semaphore, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40180#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40181 template<typename Dispatch = DispatchLoaderStatic>
40182 void destroySemaphore( Semaphore semaphore, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40183#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40184
40185 template<typename Dispatch = DispatchLoaderStatic>
40186 void destroy( Semaphore semaphore, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40187#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40188 template<typename Dispatch = DispatchLoaderStatic>
40189 void destroy( Semaphore semaphore, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40190#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40191
40192 template<typename Dispatch = DispatchLoaderStatic>
40193 Result createEvent( const EventCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Event* pEvent, Dispatch const &d = Dispatch() ) const;
40194#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40195 template<typename Dispatch = DispatchLoaderStatic>
40196 ResultValueType<Event>::type createEvent( const EventCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40197#ifndef VULKAN_HPP_NO_SMART_HANDLE
40198 template<typename Dispatch = DispatchLoaderStatic>
40199 typename ResultValueType<UniqueHandle<Event,Dispatch>>::type createEventUnique( const EventCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40200#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
40201#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40202
40203 template<typename Dispatch = DispatchLoaderStatic>
40204 void destroyEvent( Event event, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40205#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40206 template<typename Dispatch = DispatchLoaderStatic>
40207 void destroyEvent( Event event, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40208#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40209
40210 template<typename Dispatch = DispatchLoaderStatic>
40211 void destroy( Event event, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40212#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40213 template<typename Dispatch = DispatchLoaderStatic>
40214 void destroy( Event event, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40215#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40216
40217 template<typename Dispatch = DispatchLoaderStatic>
40218 Result getEventStatus( Event event, Dispatch const &d = Dispatch() ) const;
40219
40220#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
40221 template<typename Dispatch = DispatchLoaderStatic>
40222 Result setEvent( Event event, Dispatch const &d = Dispatch() ) const;
40223#else
40224 template<typename Dispatch = DispatchLoaderStatic>
40225 ResultValueType<void>::type setEvent( Event event, Dispatch const &d = Dispatch() ) const;
40226#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40227
40228#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
40229 template<typename Dispatch = DispatchLoaderStatic>
40230 Result resetEvent( Event event, Dispatch const &d = Dispatch() ) const;
40231#else
40232 template<typename Dispatch = DispatchLoaderStatic>
40233 ResultValueType<void>::type resetEvent( Event event, Dispatch const &d = Dispatch() ) const;
40234#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40235
40236 template<typename Dispatch = DispatchLoaderStatic>
40237 Result createQueryPool( const QueryPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, QueryPool* pQueryPool, Dispatch const &d = Dispatch() ) const;
40238#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40239 template<typename Dispatch = DispatchLoaderStatic>
40240 ResultValueType<QueryPool>::type createQueryPool( const QueryPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40241#ifndef VULKAN_HPP_NO_SMART_HANDLE
40242 template<typename Dispatch = DispatchLoaderStatic>
40243 typename ResultValueType<UniqueHandle<QueryPool,Dispatch>>::type createQueryPoolUnique( const QueryPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40244#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
40245#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40246
40247 template<typename Dispatch = DispatchLoaderStatic>
40248 void destroyQueryPool( QueryPool queryPool, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40249#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40250 template<typename Dispatch = DispatchLoaderStatic>
40251 void destroyQueryPool( QueryPool queryPool, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40252#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40253
40254 template<typename Dispatch = DispatchLoaderStatic>
40255 void destroy( QueryPool queryPool, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40256#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40257 template<typename Dispatch = DispatchLoaderStatic>
40258 void destroy( QueryPool queryPool, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40259#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40260
40261 template<typename Dispatch = DispatchLoaderStatic>
40262 Result getQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, DeviceSize stride, QueryResultFlags flags, Dispatch const &d = Dispatch() ) const;
40263#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40264 template <typename T, typename Dispatch = DispatchLoaderStatic>
40265 Result getQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, ArrayProxy<T> data, DeviceSize stride, QueryResultFlags flags, Dispatch const &d = Dispatch() ) const;
40266#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40267
40268 template<typename Dispatch = DispatchLoaderStatic>
40269 Result createBuffer( const BufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Buffer* pBuffer, Dispatch const &d = Dispatch() ) const;
40270#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40271 template<typename Dispatch = DispatchLoaderStatic>
40272 ResultValueType<Buffer>::type createBuffer( const BufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40273#ifndef VULKAN_HPP_NO_SMART_HANDLE
40274 template<typename Dispatch = DispatchLoaderStatic>
40275 typename ResultValueType<UniqueHandle<Buffer,Dispatch>>::type createBufferUnique( const BufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40276#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
40277#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40278
40279 template<typename Dispatch = DispatchLoaderStatic>
40280 void destroyBuffer( Buffer buffer, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40281#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40282 template<typename Dispatch = DispatchLoaderStatic>
40283 void destroyBuffer( Buffer buffer, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40284#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40285
40286 template<typename Dispatch = DispatchLoaderStatic>
40287 void destroy( Buffer buffer, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40288#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40289 template<typename Dispatch = DispatchLoaderStatic>
40290 void destroy( Buffer buffer, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40291#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40292
40293 template<typename Dispatch = DispatchLoaderStatic>
40294 Result createBufferView( const BufferViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, BufferView* pView, Dispatch const &d = Dispatch() ) const;
40295#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40296 template<typename Dispatch = DispatchLoaderStatic>
40297 ResultValueType<BufferView>::type createBufferView( const BufferViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40298#ifndef VULKAN_HPP_NO_SMART_HANDLE
40299 template<typename Dispatch = DispatchLoaderStatic>
40300 typename ResultValueType<UniqueHandle<BufferView,Dispatch>>::type createBufferViewUnique( const BufferViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40301#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
40302#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40303
40304 template<typename Dispatch = DispatchLoaderStatic>
40305 void destroyBufferView( BufferView bufferView, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40306#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40307 template<typename Dispatch = DispatchLoaderStatic>
40308 void destroyBufferView( BufferView bufferView, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40309#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40310
40311 template<typename Dispatch = DispatchLoaderStatic>
40312 void destroy( BufferView bufferView, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40313#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40314 template<typename Dispatch = DispatchLoaderStatic>
40315 void destroy( BufferView bufferView, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40316#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40317
40318 template<typename Dispatch = DispatchLoaderStatic>
40319 Result createImage( const ImageCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Image* pImage, Dispatch const &d = Dispatch() ) const;
40320#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40321 template<typename Dispatch = DispatchLoaderStatic>
40322 ResultValueType<Image>::type createImage( const ImageCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40323#ifndef VULKAN_HPP_NO_SMART_HANDLE
40324 template<typename Dispatch = DispatchLoaderStatic>
40325 typename ResultValueType<UniqueHandle<Image,Dispatch>>::type createImageUnique( const ImageCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40326#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
40327#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40328
40329 template<typename Dispatch = DispatchLoaderStatic>
40330 void destroyImage( Image image, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40331#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40332 template<typename Dispatch = DispatchLoaderStatic>
40333 void destroyImage( Image image, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40334#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40335
40336 template<typename Dispatch = DispatchLoaderStatic>
40337 void destroy( Image image, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40338#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40339 template<typename Dispatch = DispatchLoaderStatic>
40340 void destroy( Image image, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40341#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40342
40343 template<typename Dispatch = DispatchLoaderStatic>
40344 void getImageSubresourceLayout( Image image, const ImageSubresource* pSubresource, SubresourceLayout* pLayout, Dispatch const &d = Dispatch() ) const;
40345#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40346 template<typename Dispatch = DispatchLoaderStatic>
40347 SubresourceLayout getImageSubresourceLayout( Image image, const ImageSubresource & subresource, Dispatch const &d = Dispatch() ) const;
40348#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40349
40350 template<typename Dispatch = DispatchLoaderStatic>
40351 Result createImageView( const ImageViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, ImageView* pView, Dispatch const &d = Dispatch() ) const;
40352#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40353 template<typename Dispatch = DispatchLoaderStatic>
40354 ResultValueType<ImageView>::type createImageView( const ImageViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40355#ifndef VULKAN_HPP_NO_SMART_HANDLE
40356 template<typename Dispatch = DispatchLoaderStatic>
40357 typename ResultValueType<UniqueHandle<ImageView,Dispatch>>::type createImageViewUnique( const ImageViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40358#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
40359#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40360
40361 template<typename Dispatch = DispatchLoaderStatic>
40362 void destroyImageView( ImageView imageView, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40363#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40364 template<typename Dispatch = DispatchLoaderStatic>
40365 void destroyImageView( ImageView imageView, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40366#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40367
40368 template<typename Dispatch = DispatchLoaderStatic>
40369 void destroy( ImageView imageView, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40370#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40371 template<typename Dispatch = DispatchLoaderStatic>
40372 void destroy( ImageView imageView, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40373#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40374
40375 template<typename Dispatch = DispatchLoaderStatic>
40376 Result createShaderModule( const ShaderModuleCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, ShaderModule* pShaderModule, Dispatch const &d = Dispatch() ) const;
40377#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40378 template<typename Dispatch = DispatchLoaderStatic>
40379 ResultValueType<ShaderModule>::type createShaderModule( const ShaderModuleCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40380#ifndef VULKAN_HPP_NO_SMART_HANDLE
40381 template<typename Dispatch = DispatchLoaderStatic>
40383#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
40384#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40385
40386 template<typename Dispatch = DispatchLoaderStatic>
40387 void destroyShaderModule( ShaderModule shaderModule, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40388#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40389 template<typename Dispatch = DispatchLoaderStatic>
40390 void destroyShaderModule( ShaderModule shaderModule, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40391#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40392
40393 template<typename Dispatch = DispatchLoaderStatic>
40394 void destroy( ShaderModule shaderModule, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40395#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40396 template<typename Dispatch = DispatchLoaderStatic>
40397 void destroy( ShaderModule shaderModule, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40398#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40399
40400 template<typename Dispatch = DispatchLoaderStatic>
40401 Result createPipelineCache( const PipelineCacheCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, PipelineCache* pPipelineCache, Dispatch const &d = Dispatch() ) const;
40402#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40403 template<typename Dispatch = DispatchLoaderStatic>
40404 ResultValueType<PipelineCache>::type createPipelineCache( const PipelineCacheCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40405#ifndef VULKAN_HPP_NO_SMART_HANDLE
40406 template<typename Dispatch = DispatchLoaderStatic>
40408#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
40409#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40410
40411 template<typename Dispatch = DispatchLoaderStatic>
40412 void destroyPipelineCache( PipelineCache pipelineCache, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40413#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40414 template<typename Dispatch = DispatchLoaderStatic>
40415 void destroyPipelineCache( PipelineCache pipelineCache, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40416#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40417
40418 template<typename Dispatch = DispatchLoaderStatic>
40419 void destroy( PipelineCache pipelineCache, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40420#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40421 template<typename Dispatch = DispatchLoaderStatic>
40422 void destroy( PipelineCache pipelineCache, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40423#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40424
40425 template<typename Dispatch = DispatchLoaderStatic>
40426 Result getPipelineCacheData( PipelineCache pipelineCache, size_t* pDataSize, void* pData, Dispatch const &d = Dispatch() ) const;
40427#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40428 template <typename Allocator = std::allocator<uint8_t>, typename Dispatch = DispatchLoaderStatic>
40429 typename ResultValueType<std::vector<uint8_t,Allocator>>::type getPipelineCacheData( PipelineCache pipelineCache, Dispatch const &d = Dispatch() ) const;
40430 template <typename Allocator = std::allocator<uint8_t>, typename Dispatch = DispatchLoaderStatic>
40431 typename ResultValueType<std::vector<uint8_t,Allocator>>::type getPipelineCacheData( PipelineCache pipelineCache, Allocator const& vectorAllocator, Dispatch const &d ) const;
40432#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40433
40434 template<typename Dispatch = DispatchLoaderStatic>
40435 Result mergePipelineCaches( PipelineCache dstCache, uint32_t srcCacheCount, const PipelineCache* pSrcCaches, Dispatch const &d = Dispatch() ) const;
40436#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40437 template<typename Dispatch = DispatchLoaderStatic>
40438 ResultValueType<void>::type mergePipelineCaches( PipelineCache dstCache, ArrayProxy<const PipelineCache> srcCaches, Dispatch const &d = Dispatch() ) const;
40439#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40440
40441 template<typename Dispatch = DispatchLoaderStatic>
40442 Result createGraphicsPipelines( PipelineCache pipelineCache, uint32_t createInfoCount, const GraphicsPipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d = Dispatch() ) const;
40443#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40444 template <typename Allocator = std::allocator<Pipeline>, typename Dispatch = DispatchLoaderStatic>
40446 template <typename Allocator = std::allocator<Pipeline>, typename Dispatch = DispatchLoaderStatic>
40448 template<typename Dispatch = DispatchLoaderStatic>
40449 ResultValueType<Pipeline>::type createGraphicsPipeline( PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40450#ifndef VULKAN_HPP_NO_SMART_HANDLE
40451 template <typename Allocator = std::allocator<UniquePipeline>, typename Dispatch = DispatchLoaderStatic>
40453 template <typename Allocator = std::allocator<UniquePipeline>, typename Dispatch = DispatchLoaderStatic>
40455 template<typename Dispatch = DispatchLoaderStatic>
40456 typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type createGraphicsPipelineUnique( PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40457#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
40458#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40459
40460 template<typename Dispatch = DispatchLoaderStatic>
40461 Result createComputePipelines( PipelineCache pipelineCache, uint32_t createInfoCount, const ComputePipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d = Dispatch() ) const;
40462#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40463 template <typename Allocator = std::allocator<Pipeline>, typename Dispatch = DispatchLoaderStatic>
40465 template <typename Allocator = std::allocator<Pipeline>, typename Dispatch = DispatchLoaderStatic>
40466 typename ResultValueType<std::vector<Pipeline,Allocator>>::type createComputePipelines( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator, Allocator const& vectorAllocator, Dispatch const &d ) const;
40467 template<typename Dispatch = DispatchLoaderStatic>
40468 ResultValueType<Pipeline>::type createComputePipeline( PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40469#ifndef VULKAN_HPP_NO_SMART_HANDLE
40470 template <typename Allocator = std::allocator<UniquePipeline>, typename Dispatch = DispatchLoaderStatic>
40472 template <typename Allocator = std::allocator<UniquePipeline>, typename Dispatch = DispatchLoaderStatic>
40474 template<typename Dispatch = DispatchLoaderStatic>
40475 typename ResultValueType<UniqueHandle<Pipeline,Dispatch>>::type createComputePipelineUnique( PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40476#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
40477#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40478
40479 template<typename Dispatch = DispatchLoaderStatic>
40480 void destroyPipeline( Pipeline pipeline, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40481#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40482 template<typename Dispatch = DispatchLoaderStatic>
40483 void destroyPipeline( Pipeline pipeline, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40484#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40485
40486 template<typename Dispatch = DispatchLoaderStatic>
40487 void destroy( Pipeline pipeline, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40488#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40489 template<typename Dispatch = DispatchLoaderStatic>
40490 void destroy( Pipeline pipeline, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40491#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40492
40493 template<typename Dispatch = DispatchLoaderStatic>
40494 Result createPipelineLayout( const PipelineLayoutCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, PipelineLayout* pPipelineLayout, Dispatch const &d = Dispatch() ) const;
40495#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40496 template<typename Dispatch = DispatchLoaderStatic>
40497 ResultValueType<PipelineLayout>::type createPipelineLayout( const PipelineLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40498#ifndef VULKAN_HPP_NO_SMART_HANDLE
40499 template<typename Dispatch = DispatchLoaderStatic>
40501#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
40502#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40503
40504 template<typename Dispatch = DispatchLoaderStatic>
40505 void destroyPipelineLayout( PipelineLayout pipelineLayout, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40506#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40507 template<typename Dispatch = DispatchLoaderStatic>
40508 void destroyPipelineLayout( PipelineLayout pipelineLayout, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40509#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40510
40511 template<typename Dispatch = DispatchLoaderStatic>
40512 void destroy( PipelineLayout pipelineLayout, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40513#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40514 template<typename Dispatch = DispatchLoaderStatic>
40515 void destroy( PipelineLayout pipelineLayout, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40516#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40517
40518 template<typename Dispatch = DispatchLoaderStatic>
40519 Result createSampler( const SamplerCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Sampler* pSampler, Dispatch const &d = Dispatch() ) const;
40520#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40521 template<typename Dispatch = DispatchLoaderStatic>
40522 ResultValueType<Sampler>::type createSampler( const SamplerCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40523#ifndef VULKAN_HPP_NO_SMART_HANDLE
40524 template<typename Dispatch = DispatchLoaderStatic>
40525 typename ResultValueType<UniqueHandle<Sampler,Dispatch>>::type createSamplerUnique( const SamplerCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40526#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
40527#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40528
40529 template<typename Dispatch = DispatchLoaderStatic>
40530 void destroySampler( Sampler sampler, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40531#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40532 template<typename Dispatch = DispatchLoaderStatic>
40533 void destroySampler( Sampler sampler, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40534#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40535
40536 template<typename Dispatch = DispatchLoaderStatic>
40537 void destroy( Sampler sampler, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40538#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40539 template<typename Dispatch = DispatchLoaderStatic>
40540 void destroy( Sampler sampler, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40541#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40542
40543 template<typename Dispatch = DispatchLoaderStatic>
40544 Result createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorSetLayout* pSetLayout, Dispatch const &d = Dispatch() ) const;
40545#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40546 template<typename Dispatch = DispatchLoaderStatic>
40548#ifndef VULKAN_HPP_NO_SMART_HANDLE
40549 template<typename Dispatch = DispatchLoaderStatic>
40551#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
40552#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40553
40554 template<typename Dispatch = DispatchLoaderStatic>
40555 void destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40556#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40557 template<typename Dispatch = DispatchLoaderStatic>
40558 void destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40559#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40560
40561 template<typename Dispatch = DispatchLoaderStatic>
40562 void destroy( DescriptorSetLayout descriptorSetLayout, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40563#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40564 template<typename Dispatch = DispatchLoaderStatic>
40565 void destroy( DescriptorSetLayout descriptorSetLayout, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40566#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40567
40568 template<typename Dispatch = DispatchLoaderStatic>
40569 Result createDescriptorPool( const DescriptorPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorPool* pDescriptorPool, Dispatch const &d = Dispatch() ) const;
40570#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40571 template<typename Dispatch = DispatchLoaderStatic>
40572 ResultValueType<DescriptorPool>::type createDescriptorPool( const DescriptorPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40573#ifndef VULKAN_HPP_NO_SMART_HANDLE
40574 template<typename Dispatch = DispatchLoaderStatic>
40576#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
40577#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40578
40579 template<typename Dispatch = DispatchLoaderStatic>
40580 void destroyDescriptorPool( DescriptorPool descriptorPool, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40581#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40582 template<typename Dispatch = DispatchLoaderStatic>
40583 void destroyDescriptorPool( DescriptorPool descriptorPool, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40584#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40585
40586 template<typename Dispatch = DispatchLoaderStatic>
40587 void destroy( DescriptorPool descriptorPool, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40588#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40589 template<typename Dispatch = DispatchLoaderStatic>
40590 void destroy( DescriptorPool descriptorPool, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40591#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40592
40593#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
40594 template<typename Dispatch = DispatchLoaderStatic>
40595 Result resetDescriptorPool( DescriptorPool descriptorPool, DescriptorPoolResetFlags flags = DescriptorPoolResetFlags(), Dispatch const &d = Dispatch() ) const;
40596#else
40597 template<typename Dispatch = DispatchLoaderStatic>
40599#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40600
40601 template<typename Dispatch = DispatchLoaderStatic>
40602 Result allocateDescriptorSets( const DescriptorSetAllocateInfo* pAllocateInfo, DescriptorSet* pDescriptorSets, Dispatch const &d = Dispatch() ) const;
40603#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40604 template <typename Allocator = std::allocator<DescriptorSet>, typename Dispatch = DispatchLoaderStatic>
40605 typename ResultValueType<std::vector<DescriptorSet,Allocator>>::type allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const &d = Dispatch() ) const;
40606 template <typename Allocator = std::allocator<DescriptorSet>, typename Dispatch = DispatchLoaderStatic>
40607 typename ResultValueType<std::vector<DescriptorSet,Allocator>>::type allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const;
40608#ifndef VULKAN_HPP_NO_SMART_HANDLE
40609 template <typename Allocator = std::allocator<UniqueDescriptorSet>, typename Dispatch = DispatchLoaderStatic>
40610 typename ResultValueType<std::vector<UniqueHandle<DescriptorSet,Dispatch>,Allocator>>::type allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const &d = Dispatch() ) const;
40611 template <typename Allocator = std::allocator<UniqueDescriptorSet>, typename Dispatch = DispatchLoaderStatic>
40612 typename ResultValueType<std::vector<UniqueHandle<DescriptorSet,Dispatch>,Allocator>>::type allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const;
40613#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
40614#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40615
40616 template<typename Dispatch = DispatchLoaderStatic>
40617 Result freeDescriptorSets( DescriptorPool descriptorPool, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, Dispatch const &d = Dispatch() ) const;
40618#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40619 template<typename Dispatch = DispatchLoaderStatic>
40620 ResultValueType<void>::type freeDescriptorSets( DescriptorPool descriptorPool, ArrayProxy<const DescriptorSet> descriptorSets, Dispatch const &d = Dispatch() ) const;
40621#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40622
40623 template<typename Dispatch = DispatchLoaderStatic>
40624 Result free( DescriptorPool descriptorPool, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, Dispatch const &d = Dispatch() ) const;
40625#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40626 template<typename Dispatch = DispatchLoaderStatic>
40627 ResultValueType<void>::type free( DescriptorPool descriptorPool, ArrayProxy<const DescriptorSet> descriptorSets, Dispatch const &d = Dispatch() ) const;
40628#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40629
40630 template<typename Dispatch = DispatchLoaderStatic>
40631 void updateDescriptorSets( uint32_t descriptorWriteCount, const WriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const CopyDescriptorSet* pDescriptorCopies, Dispatch const &d = Dispatch() ) const;
40632#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40633 template<typename Dispatch = DispatchLoaderStatic>
40634 void updateDescriptorSets( ArrayProxy<const WriteDescriptorSet> descriptorWrites, ArrayProxy<const CopyDescriptorSet> descriptorCopies, Dispatch const &d = Dispatch() ) const;
40635#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40636
40637 template<typename Dispatch = DispatchLoaderStatic>
40638 Result createFramebuffer( const FramebufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Framebuffer* pFramebuffer, Dispatch const &d = Dispatch() ) const;
40639#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40640 template<typename Dispatch = DispatchLoaderStatic>
40641 ResultValueType<Framebuffer>::type createFramebuffer( const FramebufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40642#ifndef VULKAN_HPP_NO_SMART_HANDLE
40643 template<typename Dispatch = DispatchLoaderStatic>
40644 typename ResultValueType<UniqueHandle<Framebuffer,Dispatch>>::type createFramebufferUnique( const FramebufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40645#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
40646#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40647
40648 template<typename Dispatch = DispatchLoaderStatic>
40649 void destroyFramebuffer( Framebuffer framebuffer, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40650#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40651 template<typename Dispatch = DispatchLoaderStatic>
40652 void destroyFramebuffer( Framebuffer framebuffer, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40653#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40654
40655 template<typename Dispatch = DispatchLoaderStatic>
40656 void destroy( Framebuffer framebuffer, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40657#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40658 template<typename Dispatch = DispatchLoaderStatic>
40659 void destroy( Framebuffer framebuffer, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40660#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40661
40662 template<typename Dispatch = DispatchLoaderStatic>
40663 Result createRenderPass( const RenderPassCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, RenderPass* pRenderPass, Dispatch const &d = Dispatch() ) const;
40664#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40665 template<typename Dispatch = DispatchLoaderStatic>
40666 ResultValueType<RenderPass>::type createRenderPass( const RenderPassCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40667#ifndef VULKAN_HPP_NO_SMART_HANDLE
40668 template<typename Dispatch = DispatchLoaderStatic>
40669 typename ResultValueType<UniqueHandle<RenderPass,Dispatch>>::type createRenderPassUnique( const RenderPassCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40670#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
40671#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40672
40673 template<typename Dispatch = DispatchLoaderStatic>
40674 void destroyRenderPass( RenderPass renderPass, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40675#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40676 template<typename Dispatch = DispatchLoaderStatic>
40677 void destroyRenderPass( RenderPass renderPass, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40678#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40679
40680 template<typename Dispatch = DispatchLoaderStatic>
40681 void destroy( RenderPass renderPass, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40682#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40683 template<typename Dispatch = DispatchLoaderStatic>
40684 void destroy( RenderPass renderPass, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40685#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40686
40687 template<typename Dispatch = DispatchLoaderStatic>
40688 void getRenderAreaGranularity( RenderPass renderPass, Extent2D* pGranularity, Dispatch const &d = Dispatch() ) const;
40689#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40690 template<typename Dispatch = DispatchLoaderStatic>
40691 Extent2D getRenderAreaGranularity( RenderPass renderPass, Dispatch const &d = Dispatch() ) const;
40692#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40693
40694 template<typename Dispatch = DispatchLoaderStatic>
40695 Result createCommandPool( const CommandPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, CommandPool* pCommandPool, Dispatch const &d = Dispatch() ) const;
40696#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40697 template<typename Dispatch = DispatchLoaderStatic>
40698 ResultValueType<CommandPool>::type createCommandPool( const CommandPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40699#ifndef VULKAN_HPP_NO_SMART_HANDLE
40700 template<typename Dispatch = DispatchLoaderStatic>
40701 typename ResultValueType<UniqueHandle<CommandPool,Dispatch>>::type createCommandPoolUnique( const CommandPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40702#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
40703#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40704
40705 template<typename Dispatch = DispatchLoaderStatic>
40706 void destroyCommandPool( CommandPool commandPool, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40707#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40708 template<typename Dispatch = DispatchLoaderStatic>
40709 void destroyCommandPool( CommandPool commandPool, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40710#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40711
40712 template<typename Dispatch = DispatchLoaderStatic>
40713 void destroy( CommandPool commandPool, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40714#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40715 template<typename Dispatch = DispatchLoaderStatic>
40716 void destroy( CommandPool commandPool, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40717#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40718
40719#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
40720 template<typename Dispatch = DispatchLoaderStatic>
40721 Result resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags, Dispatch const &d = Dispatch() ) const;
40722#else
40723 template<typename Dispatch = DispatchLoaderStatic>
40724 ResultValueType<void>::type resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags, Dispatch const &d = Dispatch() ) const;
40725#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40726
40727 template<typename Dispatch = DispatchLoaderStatic>
40728 Result allocateCommandBuffers( const CommandBufferAllocateInfo* pAllocateInfo, CommandBuffer* pCommandBuffers, Dispatch const &d = Dispatch() ) const;
40729#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40730 template <typename Allocator = std::allocator<CommandBuffer>, typename Dispatch = DispatchLoaderStatic>
40731 typename ResultValueType<std::vector<CommandBuffer,Allocator>>::type allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, Dispatch const &d = Dispatch() ) const;
40732 template <typename Allocator = std::allocator<CommandBuffer>, typename Dispatch = DispatchLoaderStatic>
40733 typename ResultValueType<std::vector<CommandBuffer,Allocator>>::type allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const;
40734#ifndef VULKAN_HPP_NO_SMART_HANDLE
40735 template <typename Allocator = std::allocator<UniqueCommandBuffer>, typename Dispatch = DispatchLoaderStatic>
40736 typename ResultValueType<std::vector<UniqueHandle<CommandBuffer,Dispatch>,Allocator>>::type allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, Dispatch const &d = Dispatch() ) const;
40737 template <typename Allocator = std::allocator<UniqueCommandBuffer>, typename Dispatch = DispatchLoaderStatic>
40738 typename ResultValueType<std::vector<UniqueHandle<CommandBuffer,Dispatch>,Allocator>>::type allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const;
40739#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
40740#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40741
40742 template<typename Dispatch = DispatchLoaderStatic>
40743 void freeCommandBuffers( CommandPool commandPool, uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers, Dispatch const &d = Dispatch() ) const;
40744#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40745 template<typename Dispatch = DispatchLoaderStatic>
40746 void freeCommandBuffers( CommandPool commandPool, ArrayProxy<const CommandBuffer> commandBuffers, Dispatch const &d = Dispatch() ) const;
40747#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40748
40749 template<typename Dispatch = DispatchLoaderStatic>
40750 void free( CommandPool commandPool, uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers, Dispatch const &d = Dispatch() ) const;
40751#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40752 template<typename Dispatch = DispatchLoaderStatic>
40753 void free( CommandPool commandPool, ArrayProxy<const CommandBuffer> commandBuffers, Dispatch const &d = Dispatch() ) const;
40754#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40755
40756 template<typename Dispatch = DispatchLoaderStatic>
40757 Result createSharedSwapchainsKHR( uint32_t swapchainCount, const SwapchainCreateInfoKHR* pCreateInfos, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchains, Dispatch const &d = Dispatch() ) const;
40758#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40759 template <typename Allocator = std::allocator<SwapchainKHR>, typename Dispatch = DispatchLoaderStatic>
40761 template <typename Allocator = std::allocator<SwapchainKHR>, typename Dispatch = DispatchLoaderStatic>
40763 template<typename Dispatch = DispatchLoaderStatic>
40764 ResultValueType<SwapchainKHR>::type createSharedSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40765#ifndef VULKAN_HPP_NO_SMART_HANDLE
40766 template <typename Allocator = std::allocator<UniqueSwapchainKHR>, typename Dispatch = DispatchLoaderStatic>
40768 template <typename Allocator = std::allocator<UniqueSwapchainKHR>, typename Dispatch = DispatchLoaderStatic>
40770 template<typename Dispatch = DispatchLoaderStatic>
40772#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
40773#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40774
40775 template<typename Dispatch = DispatchLoaderStatic>
40776 Result createSwapchainKHR( const SwapchainCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchain, Dispatch const &d = Dispatch() ) const;
40777#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40778 template<typename Dispatch = DispatchLoaderStatic>
40779 ResultValueType<SwapchainKHR>::type createSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40780#ifndef VULKAN_HPP_NO_SMART_HANDLE
40781 template<typename Dispatch = DispatchLoaderStatic>
40783#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
40784#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40785
40786 template<typename Dispatch = DispatchLoaderStatic>
40787 void destroySwapchainKHR( SwapchainKHR swapchain, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40788#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40789 template<typename Dispatch = DispatchLoaderStatic>
40790 void destroySwapchainKHR( SwapchainKHR swapchain, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40791#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40792
40793 template<typename Dispatch = DispatchLoaderStatic>
40794 void destroy( SwapchainKHR swapchain, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40795#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40796 template<typename Dispatch = DispatchLoaderStatic>
40797 void destroy( SwapchainKHR swapchain, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40798#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40799
40800 template<typename Dispatch = DispatchLoaderStatic>
40801 Result getSwapchainImagesKHR( SwapchainKHR swapchain, uint32_t* pSwapchainImageCount, Image* pSwapchainImages, Dispatch const &d = Dispatch() ) const;
40802#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40803 template <typename Allocator = std::allocator<Image>, typename Dispatch = DispatchLoaderStatic>
40804 typename ResultValueType<std::vector<Image,Allocator>>::type getSwapchainImagesKHR( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const;
40805 template <typename Allocator = std::allocator<Image>, typename Dispatch = DispatchLoaderStatic>
40806 typename ResultValueType<std::vector<Image,Allocator>>::type getSwapchainImagesKHR( SwapchainKHR swapchain, Allocator const& vectorAllocator, Dispatch const &d ) const;
40807#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40808
40809 template<typename Dispatch = DispatchLoaderStatic>
40810 Result acquireNextImageKHR( SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence, uint32_t* pImageIndex, Dispatch const &d = Dispatch() ) const;
40811#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40812 template<typename Dispatch = DispatchLoaderStatic>
40813 ResultValue<uint32_t> acquireNextImageKHR( SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence, Dispatch const &d = Dispatch() ) const;
40814#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40815
40816 template<typename Dispatch = DispatchLoaderStatic>
40817 Result debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT* pNameInfo, Dispatch const &d = Dispatch() ) const;
40818#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40819 template<typename Dispatch = DispatchLoaderStatic>
40820 ResultValueType<void>::type debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT & nameInfo, Dispatch const &d = Dispatch() ) const;
40821#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40822
40823 template<typename Dispatch = DispatchLoaderStatic>
40824 Result debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT* pTagInfo, Dispatch const &d = Dispatch() ) const;
40825#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40826 template<typename Dispatch = DispatchLoaderStatic>
40827 ResultValueType<void>::type debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT & tagInfo, Dispatch const &d = Dispatch() ) const;
40828#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40829
40830#ifdef VK_USE_PLATFORM_WIN32_NV
40831 template<typename Dispatch = DispatchLoaderStatic>
40832 Result getMemoryWin32HandleNV( DeviceMemory memory, ExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle, Dispatch const &d = Dispatch() ) const;
40833#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40834 template<typename Dispatch = DispatchLoaderStatic>
40835 ResultValueType<HANDLE>::type getMemoryWin32HandleNV( DeviceMemory memory, ExternalMemoryHandleTypeFlagsNV handleType, Dispatch const &d = Dispatch() ) const;
40836#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40837#endif /*VK_USE_PLATFORM_WIN32_NV*/
40838
40839 template<typename Dispatch = DispatchLoaderStatic>
40840 Result createIndirectCommandsLayoutNVX( const IndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const AllocationCallbacks* pAllocator, IndirectCommandsLayoutNVX* pIndirectCommandsLayout, Dispatch const &d = Dispatch() ) const;
40841#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40842 template<typename Dispatch = DispatchLoaderStatic>
40844#ifndef VULKAN_HPP_NO_SMART_HANDLE
40845 template<typename Dispatch = DispatchLoaderStatic>
40847#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
40848#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40849
40850 template<typename Dispatch = DispatchLoaderStatic>
40851 void destroyIndirectCommandsLayoutNVX( IndirectCommandsLayoutNVX indirectCommandsLayout, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40852#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40853 template<typename Dispatch = DispatchLoaderStatic>
40854 void destroyIndirectCommandsLayoutNVX( IndirectCommandsLayoutNVX indirectCommandsLayout, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40855#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40856
40857 template<typename Dispatch = DispatchLoaderStatic>
40858 void destroy( IndirectCommandsLayoutNVX indirectCommandsLayout, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40859#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40860 template<typename Dispatch = DispatchLoaderStatic>
40861 void destroy( IndirectCommandsLayoutNVX indirectCommandsLayout, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40862#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40863
40864 template<typename Dispatch = DispatchLoaderStatic>
40865 Result createObjectTableNVX( const ObjectTableCreateInfoNVX* pCreateInfo, const AllocationCallbacks* pAllocator, ObjectTableNVX* pObjectTable, Dispatch const &d = Dispatch() ) const;
40866#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40867 template<typename Dispatch = DispatchLoaderStatic>
40868 ResultValueType<ObjectTableNVX>::type createObjectTableNVX( const ObjectTableCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40869#ifndef VULKAN_HPP_NO_SMART_HANDLE
40870 template<typename Dispatch = DispatchLoaderStatic>
40872#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
40873#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40874
40875 template<typename Dispatch = DispatchLoaderStatic>
40876 void destroyObjectTableNVX( ObjectTableNVX objectTable, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40877#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40878 template<typename Dispatch = DispatchLoaderStatic>
40879 void destroyObjectTableNVX( ObjectTableNVX objectTable, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40880#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40881
40882 template<typename Dispatch = DispatchLoaderStatic>
40883 void destroy( ObjectTableNVX objectTable, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
40884#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40885 template<typename Dispatch = DispatchLoaderStatic>
40886 void destroy( ObjectTableNVX objectTable, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
40887#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40888
40889 template<typename Dispatch = DispatchLoaderStatic>
40890 Result registerObjectsNVX( ObjectTableNVX objectTable, uint32_t objectCount, const ObjectTableEntryNVX* const* ppObjectTableEntries, const uint32_t* pObjectIndices, Dispatch const &d = Dispatch() ) const;
40891#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40892 template<typename Dispatch = DispatchLoaderStatic>
40893 ResultValueType<void>::type registerObjectsNVX( ObjectTableNVX objectTable, ArrayProxy<const ObjectTableEntryNVX* const> pObjectTableEntries, ArrayProxy<const uint32_t> objectIndices, Dispatch const &d = Dispatch() ) const;
40894#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40895
40896 template<typename Dispatch = DispatchLoaderStatic>
40897 Result unregisterObjectsNVX( ObjectTableNVX objectTable, uint32_t objectCount, const ObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices, Dispatch const &d = Dispatch() ) const;
40898#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40899 template<typename Dispatch = DispatchLoaderStatic>
40900 ResultValueType<void>::type unregisterObjectsNVX( ObjectTableNVX objectTable, ArrayProxy<const ObjectEntryTypeNVX> objectEntryTypes, ArrayProxy<const uint32_t> objectIndices, Dispatch const &d = Dispatch() ) const;
40901#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40902
40903 template<typename Dispatch = DispatchLoaderStatic>
40904 void trimCommandPool( CommandPool commandPool, CommandPoolTrimFlags flags = CommandPoolTrimFlags(), Dispatch const &d = Dispatch() ) const;
40905
40906 template<typename Dispatch = DispatchLoaderStatic>
40907 void trimCommandPoolKHR( CommandPool commandPool, CommandPoolTrimFlags flags = CommandPoolTrimFlags(), Dispatch const &d = Dispatch() ) const;
40908
40909#ifdef VK_USE_PLATFORM_WIN32_KHR
40910 template<typename Dispatch = DispatchLoaderStatic>
40911 Result getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d = Dispatch() ) const;
40912#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40913 template<typename Dispatch = DispatchLoaderStatic>
40914 ResultValueType<HANDLE>::type getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const &d = Dispatch() ) const;
40915#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40916#endif /*VK_USE_PLATFORM_WIN32_KHR*/
40917
40918#ifdef VK_USE_PLATFORM_WIN32_KHR
40919 template<typename Dispatch = DispatchLoaderStatic>
40920 Result getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, MemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties, Dispatch const &d = Dispatch() ) const;
40921#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40922 template<typename Dispatch = DispatchLoaderStatic>
40923 ResultValueType<MemoryWin32HandlePropertiesKHR>::type getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, Dispatch const &d = Dispatch() ) const;
40924#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40925#endif /*VK_USE_PLATFORM_WIN32_KHR*/
40926
40927 template<typename Dispatch = DispatchLoaderStatic>
40928 Result getMemoryFdKHR( const MemoryGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d = Dispatch() ) const;
40929#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40930 template<typename Dispatch = DispatchLoaderStatic>
40931 ResultValueType<int>::type getMemoryFdKHR( const MemoryGetFdInfoKHR & getFdInfo, Dispatch const &d = Dispatch() ) const;
40932#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40933
40934 template<typename Dispatch = DispatchLoaderStatic>
40935 Result getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, int fd, MemoryFdPropertiesKHR* pMemoryFdProperties, Dispatch const &d = Dispatch() ) const;
40936#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40937 template<typename Dispatch = DispatchLoaderStatic>
40939#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40940
40941#ifdef VK_USE_PLATFORM_WIN32_KHR
40942 template<typename Dispatch = DispatchLoaderStatic>
40943 Result getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d = Dispatch() ) const;
40944#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40945 template<typename Dispatch = DispatchLoaderStatic>
40946 ResultValueType<HANDLE>::type getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const &d = Dispatch() ) const;
40947#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40948#endif /*VK_USE_PLATFORM_WIN32_KHR*/
40949
40950#ifdef VK_USE_PLATFORM_WIN32_KHR
40951 template<typename Dispatch = DispatchLoaderStatic>
40952 Result importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo, Dispatch const &d = Dispatch() ) const;
40953#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40954 template<typename Dispatch = DispatchLoaderStatic>
40955 ResultValueType<void>::type importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo, Dispatch const &d = Dispatch() ) const;
40956#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40957#endif /*VK_USE_PLATFORM_WIN32_KHR*/
40958
40959 template<typename Dispatch = DispatchLoaderStatic>
40960 Result getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d = Dispatch() ) const;
40961#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40962 template<typename Dispatch = DispatchLoaderStatic>
40963 ResultValueType<int>::type getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR & getFdInfo, Dispatch const &d = Dispatch() ) const;
40964#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40965
40966 template<typename Dispatch = DispatchLoaderStatic>
40967 Result importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo, Dispatch const &d = Dispatch() ) const;
40968#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40969 template<typename Dispatch = DispatchLoaderStatic>
40970 ResultValueType<void>::type importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo, Dispatch const &d = Dispatch() ) const;
40971#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40972
40973#ifdef VK_USE_PLATFORM_WIN32_KHR
40974 template<typename Dispatch = DispatchLoaderStatic>
40975 Result getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d = Dispatch() ) const;
40976#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40977 template<typename Dispatch = DispatchLoaderStatic>
40978 ResultValueType<HANDLE>::type getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const &d = Dispatch() ) const;
40979#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40980#endif /*VK_USE_PLATFORM_WIN32_KHR*/
40981
40982#ifdef VK_USE_PLATFORM_WIN32_KHR
40983 template<typename Dispatch = DispatchLoaderStatic>
40984 Result importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo, Dispatch const &d = Dispatch() ) const;
40985#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40986 template<typename Dispatch = DispatchLoaderStatic>
40987 ResultValueType<void>::type importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo, Dispatch const &d = Dispatch() ) const;
40988#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40989#endif /*VK_USE_PLATFORM_WIN32_KHR*/
40990
40991 template<typename Dispatch = DispatchLoaderStatic>
40992 Result getFenceFdKHR( const FenceGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d = Dispatch() ) const;
40993#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
40994 template<typename Dispatch = DispatchLoaderStatic>
40995 ResultValueType<int>::type getFenceFdKHR( const FenceGetFdInfoKHR & getFdInfo, Dispatch const &d = Dispatch() ) const;
40996#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
40997
40998 template<typename Dispatch = DispatchLoaderStatic>
40999 Result importFenceFdKHR( const ImportFenceFdInfoKHR* pImportFenceFdInfo, Dispatch const &d = Dispatch() ) const;
41000#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41001 template<typename Dispatch = DispatchLoaderStatic>
41002 ResultValueType<void>::type importFenceFdKHR( const ImportFenceFdInfoKHR & importFenceFdInfo, Dispatch const &d = Dispatch() ) const;
41003#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41004
41005 template<typename Dispatch = DispatchLoaderStatic>
41006 Result displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT* pDisplayPowerInfo, Dispatch const &d = Dispatch() ) const;
41007#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41008 template<typename Dispatch = DispatchLoaderStatic>
41009 ResultValueType<void>::type displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT & displayPowerInfo, Dispatch const &d = Dispatch() ) const;
41010#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41011
41012 template<typename Dispatch = DispatchLoaderStatic>
41013 Result registerEventEXT( const DeviceEventInfoEXT* pDeviceEventInfo, const AllocationCallbacks* pAllocator, Fence* pFence, Dispatch const &d = Dispatch() ) const;
41014#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41015 template<typename Dispatch = DispatchLoaderStatic>
41016 ResultValueType<Fence>::type registerEventEXT( const DeviceEventInfoEXT & deviceEventInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
41017#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41018
41019 template<typename Dispatch = DispatchLoaderStatic>
41020 Result registerDisplayEventEXT( DisplayKHR display, const DisplayEventInfoEXT* pDisplayEventInfo, const AllocationCallbacks* pAllocator, Fence* pFence, Dispatch const &d = Dispatch() ) const;
41021#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41022 template<typename Dispatch = DispatchLoaderStatic>
41023 ResultValueType<Fence>::type registerDisplayEventEXT( DisplayKHR display, const DisplayEventInfoEXT & displayEventInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
41024#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41025
41026 template<typename Dispatch = DispatchLoaderStatic>
41027 Result getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue, Dispatch const &d = Dispatch() ) const;
41028#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41029 template<typename Dispatch = DispatchLoaderStatic>
41031#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41032
41033 template<typename Dispatch = DispatchLoaderStatic>
41034 void getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, PeerMemoryFeatureFlags* pPeerMemoryFeatures, Dispatch const &d = Dispatch() ) const;
41035#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41036 template<typename Dispatch = DispatchLoaderStatic>
41037 PeerMemoryFeatureFlags getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d = Dispatch() ) const;
41038#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41039
41040 template<typename Dispatch = DispatchLoaderStatic>
41041 void getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, PeerMemoryFeatureFlags* pPeerMemoryFeatures, Dispatch const &d = Dispatch() ) const;
41042#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41043 template<typename Dispatch = DispatchLoaderStatic>
41044 PeerMemoryFeatureFlags getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d = Dispatch() ) const;
41045#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41046
41047 template<typename Dispatch = DispatchLoaderStatic>
41048 Result bindBufferMemory2( uint32_t bindInfoCount, const BindBufferMemoryInfo* pBindInfos, Dispatch const &d = Dispatch() ) const;
41049#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41050 template<typename Dispatch = DispatchLoaderStatic>
41052#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41053
41054 template<typename Dispatch = DispatchLoaderStatic>
41055 Result bindBufferMemory2KHR( uint32_t bindInfoCount, const BindBufferMemoryInfo* pBindInfos, Dispatch const &d = Dispatch() ) const;
41056#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41057 template<typename Dispatch = DispatchLoaderStatic>
41059#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41060
41061 template<typename Dispatch = DispatchLoaderStatic>
41062 Result bindImageMemory2( uint32_t bindInfoCount, const BindImageMemoryInfo* pBindInfos, Dispatch const &d = Dispatch() ) const;
41063#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41064 template<typename Dispatch = DispatchLoaderStatic>
41066#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41067
41068 template<typename Dispatch = DispatchLoaderStatic>
41069 Result bindImageMemory2KHR( uint32_t bindInfoCount, const BindImageMemoryInfo* pBindInfos, Dispatch const &d = Dispatch() ) const;
41070#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41071 template<typename Dispatch = DispatchLoaderStatic>
41073#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41074
41075 template<typename Dispatch = DispatchLoaderStatic>
41076 Result getGroupPresentCapabilitiesKHR( DeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities, Dispatch const &d = Dispatch() ) const;
41077#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41078 template<typename Dispatch = DispatchLoaderStatic>
41080#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41081
41082 template<typename Dispatch = DispatchLoaderStatic>
41084#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41085 template<typename Dispatch = DispatchLoaderStatic>
41087#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41088
41089 template<typename Dispatch = DispatchLoaderStatic>
41090 Result acquireNextImage2KHR( const AcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex, Dispatch const &d = Dispatch() ) const;
41091#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41092 template<typename Dispatch = DispatchLoaderStatic>
41093 ResultValue<uint32_t> acquireNextImage2KHR( const AcquireNextImageInfoKHR & acquireInfo, Dispatch const &d = Dispatch() ) const;
41094#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41095
41096 template<typename Dispatch = DispatchLoaderStatic>
41097 Result createDescriptorUpdateTemplate( const DescriptorUpdateTemplateCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorUpdateTemplate* pDescriptorUpdateTemplate, Dispatch const &d = Dispatch() ) const;
41098#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41099 template<typename Dispatch = DispatchLoaderStatic>
41101#ifndef VULKAN_HPP_NO_SMART_HANDLE
41102 template<typename Dispatch = DispatchLoaderStatic>
41104#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
41105#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41106
41107 template<typename Dispatch = DispatchLoaderStatic>
41108 Result createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorUpdateTemplate* pDescriptorUpdateTemplate, Dispatch const &d = Dispatch() ) const;
41109#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41110 template<typename Dispatch = DispatchLoaderStatic>
41112#ifndef VULKAN_HPP_NO_SMART_HANDLE
41113 template<typename Dispatch = DispatchLoaderStatic>
41115#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
41116#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41117
41118 template<typename Dispatch = DispatchLoaderStatic>
41119 void destroyDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
41120#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41121 template<typename Dispatch = DispatchLoaderStatic>
41122 void destroyDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
41123#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41124
41125 template<typename Dispatch = DispatchLoaderStatic>
41126 void destroy( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
41127#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41128 template<typename Dispatch = DispatchLoaderStatic>
41129 void destroy( DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
41130#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41131
41132 template<typename Dispatch = DispatchLoaderStatic>
41133 void destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
41134#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41135 template<typename Dispatch = DispatchLoaderStatic>
41136 void destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
41137#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41138
41139 template<typename Dispatch = DispatchLoaderStatic>
41140 void updateDescriptorSetWithTemplate( DescriptorSet descriptorSet, DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d = Dispatch() ) const;
41141
41142 template<typename Dispatch = DispatchLoaderStatic>
41143 void updateDescriptorSetWithTemplateKHR( DescriptorSet descriptorSet, DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d = Dispatch() ) const;
41144
41145 template<typename Dispatch = DispatchLoaderStatic>
41146 void setHdrMetadataEXT( uint32_t swapchainCount, const SwapchainKHR* pSwapchains, const HdrMetadataEXT* pMetadata, Dispatch const &d = Dispatch() ) const;
41147#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41148 template<typename Dispatch = DispatchLoaderStatic>
41149 void setHdrMetadataEXT( ArrayProxy<const SwapchainKHR> swapchains, ArrayProxy<const HdrMetadataEXT> metadata, Dispatch const &d = Dispatch() ) const;
41150#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41151
41152 template<typename Dispatch = DispatchLoaderStatic>
41153 Result getSwapchainStatusKHR( SwapchainKHR swapchain, Dispatch const &d = Dispatch() ) const;
41154
41155 template<typename Dispatch = DispatchLoaderStatic>
41156 Result getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain, RefreshCycleDurationGOOGLE* pDisplayTimingProperties, Dispatch const &d = Dispatch() ) const;
41157#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41158 template<typename Dispatch = DispatchLoaderStatic>
41160#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41161
41162 template<typename Dispatch = DispatchLoaderStatic>
41163 Result getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, uint32_t* pPresentationTimingCount, PastPresentationTimingGOOGLE* pPresentationTimings, Dispatch const &d = Dispatch() ) const;
41164#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41165 template <typename Allocator = std::allocator<PastPresentationTimingGOOGLE>, typename Dispatch = DispatchLoaderStatic>
41167 template <typename Allocator = std::allocator<PastPresentationTimingGOOGLE>, typename Dispatch = DispatchLoaderStatic>
41168 typename ResultValueType<std::vector<PastPresentationTimingGOOGLE,Allocator>>::type getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, Allocator const& vectorAllocator, Dispatch const &d ) const;
41169#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41170
41171 template<typename Dispatch = DispatchLoaderStatic>
41172 void getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
41173#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41174 template<typename Dispatch = DispatchLoaderStatic>
41175 MemoryRequirements2 getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
41176 template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
41177 StructureChain<X, Y, Z...> getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
41178#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41179
41180 template<typename Dispatch = DispatchLoaderStatic>
41181 void getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
41182#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41183 template<typename Dispatch = DispatchLoaderStatic>
41184 MemoryRequirements2 getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
41185 template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
41186 StructureChain<X, Y, Z...> getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
41187#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41188
41189 template<typename Dispatch = DispatchLoaderStatic>
41190 void getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
41191#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41192 template<typename Dispatch = DispatchLoaderStatic>
41193 MemoryRequirements2 getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
41194 template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
41195 StructureChain<X, Y, Z...> getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
41196#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41197
41198 template<typename Dispatch = DispatchLoaderStatic>
41199 void getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
41200#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41201 template<typename Dispatch = DispatchLoaderStatic>
41202 MemoryRequirements2 getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
41203 template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
41204 StructureChain<X, Y, Z...> getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
41205#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41206
41207 template<typename Dispatch = DispatchLoaderStatic>
41208 void getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements2* pSparseMemoryRequirements, Dispatch const &d = Dispatch() ) const;
41209#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41210 template <typename Allocator = std::allocator<SparseImageMemoryRequirements2>, typename Dispatch = DispatchLoaderStatic>
41211 std::vector<SparseImageMemoryRequirements2,Allocator> getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
41212 template <typename Allocator = std::allocator<SparseImageMemoryRequirements2>, typename Dispatch = DispatchLoaderStatic>
41213 std::vector<SparseImageMemoryRequirements2,Allocator> getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info, Allocator const& vectorAllocator, Dispatch const &d ) const;
41214#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41215
41216 template<typename Dispatch = DispatchLoaderStatic>
41217 void getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements2* pSparseMemoryRequirements, Dispatch const &d = Dispatch() ) const;
41218#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41219 template <typename Allocator = std::allocator<SparseImageMemoryRequirements2>, typename Dispatch = DispatchLoaderStatic>
41220 std::vector<SparseImageMemoryRequirements2,Allocator> getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info, Dispatch const &d = Dispatch() ) const;
41221 template <typename Allocator = std::allocator<SparseImageMemoryRequirements2>, typename Dispatch = DispatchLoaderStatic>
41222 std::vector<SparseImageMemoryRequirements2,Allocator> getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info, Allocator const& vectorAllocator, Dispatch const &d ) const;
41223#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41224
41225 template<typename Dispatch = DispatchLoaderStatic>
41226 Result createSamplerYcbcrConversion( const SamplerYcbcrConversionCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, SamplerYcbcrConversion* pYcbcrConversion, Dispatch const &d = Dispatch() ) const;
41227#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41228 template<typename Dispatch = DispatchLoaderStatic>
41230#ifndef VULKAN_HPP_NO_SMART_HANDLE
41231 template<typename Dispatch = DispatchLoaderStatic>
41233#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
41234#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41235
41236 template<typename Dispatch = DispatchLoaderStatic>
41237 Result createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, SamplerYcbcrConversion* pYcbcrConversion, Dispatch const &d = Dispatch() ) const;
41238#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41239 template<typename Dispatch = DispatchLoaderStatic>
41241#ifndef VULKAN_HPP_NO_SMART_HANDLE
41242 template<typename Dispatch = DispatchLoaderStatic>
41244#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
41245#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41246
41247 template<typename Dispatch = DispatchLoaderStatic>
41248 void destroySamplerYcbcrConversion( SamplerYcbcrConversion ycbcrConversion, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
41249#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41250 template<typename Dispatch = DispatchLoaderStatic>
41251 void destroySamplerYcbcrConversion( SamplerYcbcrConversion ycbcrConversion, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
41252#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41253
41254 template<typename Dispatch = DispatchLoaderStatic>
41255 void destroy( SamplerYcbcrConversion ycbcrConversion, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
41256#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41257 template<typename Dispatch = DispatchLoaderStatic>
41258 void destroy( SamplerYcbcrConversion ycbcrConversion, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
41259#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41260
41261 template<typename Dispatch = DispatchLoaderStatic>
41262 void destroySamplerYcbcrConversionKHR( SamplerYcbcrConversion ycbcrConversion, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
41263#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41264 template<typename Dispatch = DispatchLoaderStatic>
41265 void destroySamplerYcbcrConversionKHR( SamplerYcbcrConversion ycbcrConversion, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
41266#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41267
41268 template<typename Dispatch = DispatchLoaderStatic>
41269 void getQueue2( const DeviceQueueInfo2* pQueueInfo, Queue* pQueue, Dispatch const &d = Dispatch() ) const;
41270#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41271 template<typename Dispatch = DispatchLoaderStatic>
41272 Queue getQueue2( const DeviceQueueInfo2 & queueInfo, Dispatch const &d = Dispatch() ) const;
41273#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41274
41275 template<typename Dispatch = DispatchLoaderStatic>
41276 Result createValidationCacheEXT( const ValidationCacheCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, ValidationCacheEXT* pValidationCache, Dispatch const &d = Dispatch() ) const;
41277#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41278 template<typename Dispatch = DispatchLoaderStatic>
41280#ifndef VULKAN_HPP_NO_SMART_HANDLE
41281 template<typename Dispatch = DispatchLoaderStatic>
41283#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
41284#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41285
41286 template<typename Dispatch = DispatchLoaderStatic>
41287 void destroyValidationCacheEXT( ValidationCacheEXT validationCache, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
41288#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41289 template<typename Dispatch = DispatchLoaderStatic>
41290 void destroyValidationCacheEXT( ValidationCacheEXT validationCache, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
41291#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41292
41293 template<typename Dispatch = DispatchLoaderStatic>
41294 void destroy( ValidationCacheEXT validationCache, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
41295#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41296 template<typename Dispatch = DispatchLoaderStatic>
41297 void destroy( ValidationCacheEXT validationCache, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
41298#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41299
41300 template<typename Dispatch = DispatchLoaderStatic>
41301 Result getValidationCacheDataEXT( ValidationCacheEXT validationCache, size_t* pDataSize, void* pData, Dispatch const &d = Dispatch() ) const;
41302#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41303 template <typename Allocator = std::allocator<uint8_t>, typename Dispatch = DispatchLoaderStatic>
41304 typename ResultValueType<std::vector<uint8_t,Allocator>>::type getValidationCacheDataEXT( ValidationCacheEXT validationCache, Dispatch const &d = Dispatch() ) const;
41305 template <typename Allocator = std::allocator<uint8_t>, typename Dispatch = DispatchLoaderStatic>
41306 typename ResultValueType<std::vector<uint8_t,Allocator>>::type getValidationCacheDataEXT( ValidationCacheEXT validationCache, Allocator const& vectorAllocator, Dispatch const &d ) const;
41307#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41308
41309 template<typename Dispatch = DispatchLoaderStatic>
41310 Result mergeValidationCachesEXT( ValidationCacheEXT dstCache, uint32_t srcCacheCount, const ValidationCacheEXT* pSrcCaches, Dispatch const &d = Dispatch() ) const;
41311#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41312 template<typename Dispatch = DispatchLoaderStatic>
41314#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41315
41316 template<typename Dispatch = DispatchLoaderStatic>
41317 void getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo* pCreateInfo, DescriptorSetLayoutSupport* pSupport, Dispatch const &d = Dispatch() ) const;
41318#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41319 template<typename Dispatch = DispatchLoaderStatic>
41320 DescriptorSetLayoutSupport getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = Dispatch() ) const;
41321 template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
41322 StructureChain<X, Y, Z...> getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = Dispatch() ) const;
41323#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41324
41325 template<typename Dispatch = DispatchLoaderStatic>
41326 void getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo* pCreateInfo, DescriptorSetLayoutSupport* pSupport, Dispatch const &d = Dispatch() ) const;
41327#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41328 template<typename Dispatch = DispatchLoaderStatic>
41329 DescriptorSetLayoutSupport getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = Dispatch() ) const;
41330 template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
41331 StructureChain<X, Y, Z...> getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const &d = Dispatch() ) const;
41332#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41333
41334 template<typename Dispatch = DispatchLoaderStatic>
41335 Result getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo, Dispatch const &d = Dispatch() ) const;
41336#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41337 template <typename Allocator = std::allocator<uint8_t>, typename Dispatch = DispatchLoaderStatic>
41338 typename ResultValueType<std::vector<uint8_t,Allocator>>::type getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, Dispatch const &d = Dispatch() ) const;
41339 template <typename Allocator = std::allocator<uint8_t>, typename Dispatch = DispatchLoaderStatic>
41340 typename ResultValueType<std::vector<uint8_t,Allocator>>::type getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, Allocator const& vectorAllocator, Dispatch const &d ) const;
41341#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41342
41343 template<typename Dispatch = DispatchLoaderStatic>
41344 Result getCalibratedTimestampsEXT( uint32_t timestampCount, const CalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation, Dispatch const &d = Dispatch() ) const;
41345#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41346 template<typename Dispatch = DispatchLoaderStatic>
41348#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41349
41350 template<typename Dispatch = DispatchLoaderStatic>
41351 Result setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT* pNameInfo, Dispatch const &d = Dispatch() ) const;
41352#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41353 template<typename Dispatch = DispatchLoaderStatic>
41354 ResultValueType<void>::type setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT & nameInfo, Dispatch const &d = Dispatch() ) const;
41355#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41356
41357 template<typename Dispatch = DispatchLoaderStatic>
41358 Result setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT* pTagInfo, Dispatch const &d = Dispatch() ) const;
41359#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41360 template<typename Dispatch = DispatchLoaderStatic>
41361 ResultValueType<void>::type setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT & tagInfo, Dispatch const &d = Dispatch() ) const;
41362#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41363
41364 template<typename Dispatch = DispatchLoaderStatic>
41365 Result getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, MemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties, Dispatch const &d = Dispatch() ) const;
41366#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41367 template<typename Dispatch = DispatchLoaderStatic>
41369#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41370
41371 template<typename Dispatch = DispatchLoaderStatic>
41372 Result createRenderPass2KHR( const RenderPassCreateInfo2KHR* pCreateInfo, const AllocationCallbacks* pAllocator, RenderPass* pRenderPass, Dispatch const &d = Dispatch() ) const;
41373#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41374 template<typename Dispatch = DispatchLoaderStatic>
41375 ResultValueType<RenderPass>::type createRenderPass2KHR( const RenderPassCreateInfo2KHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
41376#ifndef VULKAN_HPP_NO_SMART_HANDLE
41377 template<typename Dispatch = DispatchLoaderStatic>
41379#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
41380#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41381
41382#ifdef VK_USE_PLATFORM_ANDROID_ANDROID
41383 template<typename Dispatch = DispatchLoaderStatic>
41384 Result getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer* buffer, AndroidHardwareBufferPropertiesANDROID* pProperties, Dispatch const &d = Dispatch() ) const;
41385#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41386 template<typename Dispatch = DispatchLoaderStatic>
41387 ResultValueType<AndroidHardwareBufferPropertiesANDROID>::type getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const &d = Dispatch() ) const;
41388 template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
41389 typename ResultValueType<StructureChain<X, Y, Z...>>::type getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const &d = Dispatch() ) const;
41390#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41391#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/
41392
41393#ifdef VK_USE_PLATFORM_ANDROID_ANDROID
41394 template<typename Dispatch = DispatchLoaderStatic>
41395 Result getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer, Dispatch const &d = Dispatch() ) const;
41396#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41397 template<typename Dispatch = DispatchLoaderStatic>
41398 ResultValueType<struct AHardwareBuffer*>::type getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID & info, Dispatch const &d = Dispatch() ) const;
41399#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41400#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/
41401
41402#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
41403 template<typename Dispatch = DispatchLoaderStatic>
41404 Result compileDeferredNV( Pipeline pipeline, uint32_t shader, Dispatch const &d = Dispatch() ) const;
41405#else
41406 template<typename Dispatch = DispatchLoaderStatic>
41407 ResultValueType<void>::type compileDeferredNV( Pipeline pipeline, uint32_t shader, Dispatch const &d = Dispatch() ) const;
41408#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41409
41410 template<typename Dispatch = DispatchLoaderStatic>
41411 Result createAccelerationStructureNV( const AccelerationStructureCreateInfoNV* pCreateInfo, const AllocationCallbacks* pAllocator, AccelerationStructureNV* pAccelerationStructure, Dispatch const &d = Dispatch() ) const;
41412#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41413 template<typename Dispatch = DispatchLoaderStatic>
41415#ifndef VULKAN_HPP_NO_SMART_HANDLE
41416 template<typename Dispatch = DispatchLoaderStatic>
41418#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
41419#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41420
41421 template<typename Dispatch = DispatchLoaderStatic>
41422 void destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
41423#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41424 template<typename Dispatch = DispatchLoaderStatic>
41425 void destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
41426#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41427
41428 template<typename Dispatch = DispatchLoaderStatic>
41429 void destroy( AccelerationStructureNV accelerationStructure, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
41430#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41431 template<typename Dispatch = DispatchLoaderStatic>
41432 void destroy( AccelerationStructureNV accelerationStructure, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
41433#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41434
41435 template<typename Dispatch = DispatchLoaderStatic>
41436 void getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV* pInfo, MemoryRequirements2KHR* pMemoryRequirements, Dispatch const &d = Dispatch() ) const;
41437#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41438 template<typename Dispatch = DispatchLoaderStatic>
41440#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41441
41442 template<typename Dispatch = DispatchLoaderStatic>
41443 Result bindAccelerationStructureMemoryNV( uint32_t bindInfoCount, const BindAccelerationStructureMemoryInfoNV* pBindInfos, Dispatch const &d = Dispatch() ) const;
41444#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41445 template<typename Dispatch = DispatchLoaderStatic>
41447#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41448
41449 template<typename Dispatch = DispatchLoaderStatic>
41450 Result getRayTracingShaderGroupHandlesNV( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, Dispatch const &d = Dispatch() ) const;
41451#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41452 template <typename T, typename Dispatch = DispatchLoaderStatic>
41453 ResultValueType<void>::type getRayTracingShaderGroupHandlesNV( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, ArrayProxy<T> data, Dispatch const &d = Dispatch() ) const;
41454#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41455
41456 template<typename Dispatch = DispatchLoaderStatic>
41457 Result getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure, size_t dataSize, void* pData, Dispatch const &d = Dispatch() ) const;
41458#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41459 template <typename T, typename Dispatch = DispatchLoaderStatic>
41461#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41462
41463 template<typename Dispatch = DispatchLoaderStatic>
41464 Result createRayTracingPipelinesNV( PipelineCache pipelineCache, uint32_t createInfoCount, const RayTracingPipelineCreateInfoNV* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d = Dispatch() ) const;
41465#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41466 template <typename Allocator = std::allocator<Pipeline>, typename Dispatch = DispatchLoaderStatic>
41468 template <typename Allocator = std::allocator<Pipeline>, typename Dispatch = DispatchLoaderStatic>
41470 template<typename Dispatch = DispatchLoaderStatic>
41471 ResultValueType<Pipeline>::type createRayTracingPipelineNV( PipelineCache pipelineCache, const RayTracingPipelineCreateInfoNV & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
41472#ifndef VULKAN_HPP_NO_SMART_HANDLE
41473 template <typename Allocator = std::allocator<UniquePipeline>, typename Dispatch = DispatchLoaderStatic>
41475 template <typename Allocator = std::allocator<UniquePipeline>, typename Dispatch = DispatchLoaderStatic>
41477 template<typename Dispatch = DispatchLoaderStatic>
41479#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
41480#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41481
41482 template<typename Dispatch = DispatchLoaderStatic>
41484#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41485 template<typename Dispatch = DispatchLoaderStatic>
41487#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41488
41489
41490
41491 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDevice() const
41492 {
41493 return m_device;
41494 }
41495
41496 explicit operator bool() const
41497 {
41498 return m_device != VK_NULL_HANDLE;
41499 }
41500
41501 bool operator!() const
41502 {
41503 return m_device == VK_NULL_HANDLE;
41504 }
41505
41506 private:
41507 VkDevice m_device;
41508 };
41509
41510 static_assert( sizeof( Device ) == sizeof( VkDevice ), "handle and wrapper have different size!" );
41511
41512 template<typename Dispatch>
41513 VULKAN_HPP_INLINE PFN_vkVoidFunction Device::getProcAddr( const char* pName, Dispatch const &d) const
41514 {
41515 return d.vkGetDeviceProcAddr( m_device, pName );
41516 }
41517#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41518 template<typename Dispatch>
41520 {
41521 return d.vkGetDeviceProcAddr( m_device, name.c_str() );
41522 }
41523#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41524
41525 template<typename Dispatch>
41526 VULKAN_HPP_INLINE void Device::destroy( const AllocationCallbacks* pAllocator, Dispatch const &d) const
41527 {
41528 d.vkDestroyDevice( m_device, reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
41529 }
41530#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41531 template<typename Dispatch>
41533 {
41534 d.vkDestroyDevice( m_device, reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
41535 }
41536#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41537
41538 template<typename Dispatch>
41539 VULKAN_HPP_INLINE void Device::getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Queue* pQueue, Dispatch const &d) const
41540 {
41541 d.vkGetDeviceQueue( m_device, queueFamilyIndex, queueIndex, reinterpret_cast<VkQueue*>( pQueue ) );
41542 }
41543#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41544 template<typename Dispatch>
41545 VULKAN_HPP_INLINE Queue Device::getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Dispatch const &d ) const
41546 {
41547 Queue queue;
41548 d.vkGetDeviceQueue( m_device, queueFamilyIndex, queueIndex, reinterpret_cast<VkQueue*>( &queue ) );
41549 return queue;
41550 }
41551#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41552
41553#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
41554 template<typename Dispatch>
41555 VULKAN_HPP_INLINE Result Device::waitIdle(Dispatch const &d) const
41556 {
41557 return static_cast<Result>( d.vkDeviceWaitIdle( m_device ) );
41558 }
41559#else
41560 template<typename Dispatch>
41562 {
41563 Result result = static_cast<Result>( d.vkDeviceWaitIdle( m_device ) );
41564 return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::waitIdle" );
41565 }
41566#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41567
41568 template<typename Dispatch>
41569 VULKAN_HPP_INLINE Result Device::allocateMemory( const MemoryAllocateInfo* pAllocateInfo, const AllocationCallbacks* pAllocator, DeviceMemory* pMemory, Dispatch const &d) const
41570 {
41571 return static_cast<Result>( d.vkAllocateMemory( m_device, reinterpret_cast<const VkMemoryAllocateInfo*>( pAllocateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDeviceMemory*>( pMemory ) ) );
41572 }
41573#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41574 template<typename Dispatch>
41576 {
41578 Result result = static_cast<Result>( d.vkAllocateMemory( m_device, reinterpret_cast<const VkMemoryAllocateInfo*>( &allocateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDeviceMemory*>( &memory ) ) );
41579 return createResultValue( result, memory, VULKAN_HPP_NAMESPACE_STRING"::Device::allocateMemory" );
41580 }
41581#ifndef VULKAN_HPP_NO_SMART_HANDLE
41582 template<typename Dispatch>
41584 {
41586 Result result = static_cast<Result>( d.vkAllocateMemory( m_device, reinterpret_cast<const VkMemoryAllocateInfo*>( &allocateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDeviceMemory*>( &memory ) ) );
41587
41588 ObjectFree<Device,Dispatch> deleter( *this, allocator, d );
41589 return createResultValue<DeviceMemory,Dispatch>( result, memory, VULKAN_HPP_NAMESPACE_STRING"::Device::allocateMemoryUnique", deleter );
41590 }
41591#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
41592#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41593
41594 template<typename Dispatch>
41595 VULKAN_HPP_INLINE void Device::freeMemory( DeviceMemory memory, const AllocationCallbacks* pAllocator, Dispatch const &d) const
41596 {
41597 d.vkFreeMemory( m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
41598 }
41599#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41600 template<typename Dispatch>
41602 {
41603 d.vkFreeMemory( m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
41604 }
41605#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41606
41607 template<typename Dispatch>
41608 VULKAN_HPP_INLINE void Device::free( DeviceMemory memory, const AllocationCallbacks* pAllocator, Dispatch const &d) const
41609 {
41610 d.vkFreeMemory( m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
41611 }
41612#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41613 template<typename Dispatch>
41615 {
41616 d.vkFreeMemory( m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
41617 }
41618#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41619
41620 template<typename Dispatch>
41622 {
41623 return static_cast<Result>( d.vkMapMemory( m_device, static_cast<VkDeviceMemory>( memory ), offset, size, static_cast<VkMemoryMapFlags>( flags ), ppData ) );
41624 }
41625#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41626 template<typename Dispatch>
41628 {
41629 void* pData;
41630 Result result = static_cast<Result>( d.vkMapMemory( m_device, static_cast<VkDeviceMemory>( memory ), offset, size, static_cast<VkMemoryMapFlags>( flags ), &pData ) );
41631 return createResultValue( result, pData, VULKAN_HPP_NAMESPACE_STRING"::Device::mapMemory" );
41632 }
41633#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41634
41635#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
41636 template<typename Dispatch>
41637 VULKAN_HPP_INLINE void Device::unmapMemory( DeviceMemory memory, Dispatch const &d) const
41638 {
41639 d.vkUnmapMemory( m_device, static_cast<VkDeviceMemory>( memory ) );
41640 }
41641#else
41642 template<typename Dispatch>
41644 {
41645 d.vkUnmapMemory( m_device, static_cast<VkDeviceMemory>( memory ) );
41646 }
41647#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41648
41649 template<typename Dispatch>
41650 VULKAN_HPP_INLINE Result Device::flushMappedMemoryRanges( uint32_t memoryRangeCount, const MappedMemoryRange* pMemoryRanges, Dispatch const &d) const
41651 {
41652 return static_cast<Result>( d.vkFlushMappedMemoryRanges( m_device, memoryRangeCount, reinterpret_cast<const VkMappedMemoryRange*>( pMemoryRanges ) ) );
41653 }
41654#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41655 template<typename Dispatch>
41657 {
41658 Result result = static_cast<Result>( d.vkFlushMappedMemoryRanges( m_device, memoryRanges.size() , reinterpret_cast<const VkMappedMemoryRange*>( memoryRanges.data() ) ) );
41659 return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::flushMappedMemoryRanges" );
41660 }
41661#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41662
41663 template<typename Dispatch>
41664 VULKAN_HPP_INLINE Result Device::invalidateMappedMemoryRanges( uint32_t memoryRangeCount, const MappedMemoryRange* pMemoryRanges, Dispatch const &d) const
41665 {
41666 return static_cast<Result>( d.vkInvalidateMappedMemoryRanges( m_device, memoryRangeCount, reinterpret_cast<const VkMappedMemoryRange*>( pMemoryRanges ) ) );
41667 }
41668#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41669 template<typename Dispatch>
41671 {
41672 Result result = static_cast<Result>( d.vkInvalidateMappedMemoryRanges( m_device, memoryRanges.size() , reinterpret_cast<const VkMappedMemoryRange*>( memoryRanges.data() ) ) );
41673 return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::invalidateMappedMemoryRanges" );
41674 }
41675#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41676
41677 template<typename Dispatch>
41678 VULKAN_HPP_INLINE void Device::getMemoryCommitment( DeviceMemory memory, DeviceSize* pCommittedMemoryInBytes, Dispatch const &d) const
41679 {
41680 d.vkGetDeviceMemoryCommitment( m_device, static_cast<VkDeviceMemory>( memory ), pCommittedMemoryInBytes );
41681 }
41682#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41683 template<typename Dispatch>
41685 {
41686 DeviceSize committedMemoryInBytes;
41687 d.vkGetDeviceMemoryCommitment( m_device, static_cast<VkDeviceMemory>( memory ), &committedMemoryInBytes );
41688 return committedMemoryInBytes;
41689 }
41690#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41691
41692 template<typename Dispatch>
41694 {
41695 d.vkGetBufferMemoryRequirements( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<VkMemoryRequirements*>( pMemoryRequirements ) );
41696 }
41697#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41698 template<typename Dispatch>
41700 {
41701 MemoryRequirements memoryRequirements;
41702 d.vkGetBufferMemoryRequirements( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<VkMemoryRequirements*>( &memoryRequirements ) );
41703 return memoryRequirements;
41704 }
41705#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41706
41707#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
41708 template<typename Dispatch>
41710 {
41711 return static_cast<Result>( d.vkBindBufferMemory( m_device, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceMemory>( memory ), memoryOffset ) );
41712 }
41713#else
41714 template<typename Dispatch>
41716 {
41717 Result result = static_cast<Result>( d.vkBindBufferMemory( m_device, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceMemory>( memory ), memoryOffset ) );
41718 return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindBufferMemory" );
41719 }
41720#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41721
41722 template<typename Dispatch>
41723 VULKAN_HPP_INLINE void Device::getImageMemoryRequirements( Image image, MemoryRequirements* pMemoryRequirements, Dispatch const &d) const
41724 {
41725 d.vkGetImageMemoryRequirements( m_device, static_cast<VkImage>( image ), reinterpret_cast<VkMemoryRequirements*>( pMemoryRequirements ) );
41726 }
41727#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41728 template<typename Dispatch>
41730 {
41731 MemoryRequirements memoryRequirements;
41732 d.vkGetImageMemoryRequirements( m_device, static_cast<VkImage>( image ), reinterpret_cast<VkMemoryRequirements*>( &memoryRequirements ) );
41733 return memoryRequirements;
41734 }
41735#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41736
41737#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
41738 template<typename Dispatch>
41740 {
41741 return static_cast<Result>( d.vkBindImageMemory( m_device, static_cast<VkImage>( image ), static_cast<VkDeviceMemory>( memory ), memoryOffset ) );
41742 }
41743#else
41744 template<typename Dispatch>
41746 {
41747 Result result = static_cast<Result>( d.vkBindImageMemory( m_device, static_cast<VkImage>( image ), static_cast<VkDeviceMemory>( memory ), memoryOffset ) );
41748 return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindImageMemory" );
41749 }
41750#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41751
41752 template<typename Dispatch>
41753 VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements( Image image, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements* pSparseMemoryRequirements, Dispatch const &d) const
41754 {
41755 d.vkGetImageSparseMemoryRequirements( m_device, static_cast<VkImage>( image ), pSparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements*>( pSparseMemoryRequirements ) );
41756 }
41757#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41758 template <typename Allocator, typename Dispatch>
41759 VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements,Allocator> Device::getImageSparseMemoryRequirements( Image image, Dispatch const &d ) const
41760 {
41761 std::vector<SparseImageMemoryRequirements,Allocator> sparseMemoryRequirements;
41762 uint32_t sparseMemoryRequirementCount;
41763 d.vkGetImageSparseMemoryRequirements( m_device, static_cast<VkImage>( image ), &sparseMemoryRequirementCount, nullptr );
41764 sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
41765 d.vkGetImageSparseMemoryRequirements( m_device, static_cast<VkImage>( image ), &sparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements*>( sparseMemoryRequirements.data() ) );
41766 return sparseMemoryRequirements;
41767 }
41768 template <typename Allocator, typename Dispatch>
41769 VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements,Allocator> Device::getImageSparseMemoryRequirements( Image image, Allocator const& vectorAllocator, Dispatch const &d ) const
41770 {
41771 std::vector<SparseImageMemoryRequirements,Allocator> sparseMemoryRequirements( vectorAllocator );
41772 uint32_t sparseMemoryRequirementCount;
41773 d.vkGetImageSparseMemoryRequirements( m_device, static_cast<VkImage>( image ), &sparseMemoryRequirementCount, nullptr );
41774 sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
41775 d.vkGetImageSparseMemoryRequirements( m_device, static_cast<VkImage>( image ), &sparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements*>( sparseMemoryRequirements.data() ) );
41776 return sparseMemoryRequirements;
41777 }
41778#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41779
41780 template<typename Dispatch>
41781 VULKAN_HPP_INLINE Result Device::createFence( const FenceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Fence* pFence, Dispatch const &d) const
41782 {
41783 return static_cast<Result>( d.vkCreateFence( m_device, reinterpret_cast<const VkFenceCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkFence*>( pFence ) ) );
41784 }
41785#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41786 template<typename Dispatch>
41788 {
41789 Fence fence;
41790 Result result = static_cast<Result>( d.vkCreateFence( m_device, reinterpret_cast<const VkFenceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFence*>( &fence ) ) );
41791 return createResultValue( result, fence, VULKAN_HPP_NAMESPACE_STRING"::Device::createFence" );
41792 }
41793#ifndef VULKAN_HPP_NO_SMART_HANDLE
41794 template<typename Dispatch>
41796 {
41797 Fence fence;
41798 Result result = static_cast<Result>( d.vkCreateFence( m_device, reinterpret_cast<const VkFenceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFence*>( &fence ) ) );
41799
41800 ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
41801 return createResultValue<Fence,Dispatch>( result, fence, VULKAN_HPP_NAMESPACE_STRING"::Device::createFenceUnique", deleter );
41802 }
41803#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
41804#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41805
41806 template<typename Dispatch>
41807 VULKAN_HPP_INLINE void Device::destroyFence( Fence fence, const AllocationCallbacks* pAllocator, Dispatch const &d) const
41808 {
41809 d.vkDestroyFence( m_device, static_cast<VkFence>( fence ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
41810 }
41811#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41812 template<typename Dispatch>
41814 {
41815 d.vkDestroyFence( m_device, static_cast<VkFence>( fence ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
41816 }
41817#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41818
41819 template<typename Dispatch>
41820 VULKAN_HPP_INLINE void Device::destroy( Fence fence, const AllocationCallbacks* pAllocator, Dispatch const &d) const
41821 {
41822 d.vkDestroyFence( m_device, static_cast<VkFence>( fence ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
41823 }
41824#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41825 template<typename Dispatch>
41826 VULKAN_HPP_INLINE void Device::destroy( Fence fence, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
41827 {
41828 d.vkDestroyFence( m_device, static_cast<VkFence>( fence ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
41829 }
41830#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41831
41832 template<typename Dispatch>
41833 VULKAN_HPP_INLINE Result Device::resetFences( uint32_t fenceCount, const Fence* pFences, Dispatch const &d) const
41834 {
41835 return static_cast<Result>( d.vkResetFences( m_device, fenceCount, reinterpret_cast<const VkFence*>( pFences ) ) );
41836 }
41837#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41838 template<typename Dispatch>
41840 {
41841 Result result = static_cast<Result>( d.vkResetFences( m_device, fences.size() , reinterpret_cast<const VkFence*>( fences.data() ) ) );
41842 return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::resetFences" );
41843 }
41844#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41845
41846#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
41847 template<typename Dispatch>
41848 VULKAN_HPP_INLINE Result Device::getFenceStatus( Fence fence, Dispatch const &d) const
41849 {
41850 return static_cast<Result>( d.vkGetFenceStatus( m_device, static_cast<VkFence>( fence ) ) );
41851 }
41852#else
41853 template<typename Dispatch>
41855 {
41856 Result result = static_cast<Result>( d.vkGetFenceStatus( m_device, static_cast<VkFence>( fence ) ) );
41858 }
41859#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41860
41861 template<typename Dispatch>
41862 VULKAN_HPP_INLINE Result Device::waitForFences( uint32_t fenceCount, const Fence* pFences, Bool32 waitAll, uint64_t timeout, Dispatch const &d) const
41863 {
41864 return static_cast<Result>( d.vkWaitForFences( m_device, fenceCount, reinterpret_cast<const VkFence*>( pFences ), waitAll, timeout ) );
41865 }
41866#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41867 template<typename Dispatch>
41869 {
41870 Result result = static_cast<Result>( d.vkWaitForFences( m_device, fences.size() , reinterpret_cast<const VkFence*>( fences.data() ), waitAll, timeout ) );
41872 }
41873#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41874
41875 template<typename Dispatch>
41876 VULKAN_HPP_INLINE Result Device::createSemaphore( const SemaphoreCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Semaphore* pSemaphore, Dispatch const &d) const
41877 {
41878 return static_cast<Result>( d.vkCreateSemaphore( m_device, reinterpret_cast<const VkSemaphoreCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSemaphore*>( pSemaphore ) ) );
41879 }
41880#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41881 template<typename Dispatch>
41883 {
41884 Semaphore semaphore;
41885 Result result = static_cast<Result>( d.vkCreateSemaphore( m_device, reinterpret_cast<const VkSemaphoreCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSemaphore*>( &semaphore ) ) );
41886 return createResultValue( result, semaphore, VULKAN_HPP_NAMESPACE_STRING"::Device::createSemaphore" );
41887 }
41888#ifndef VULKAN_HPP_NO_SMART_HANDLE
41889 template<typename Dispatch>
41891 {
41892 Semaphore semaphore;
41893 Result result = static_cast<Result>( d.vkCreateSemaphore( m_device, reinterpret_cast<const VkSemaphoreCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSemaphore*>( &semaphore ) ) );
41894
41895 ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
41896 return createResultValue<Semaphore,Dispatch>( result, semaphore, VULKAN_HPP_NAMESPACE_STRING"::Device::createSemaphoreUnique", deleter );
41897 }
41898#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
41899#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41900
41901 template<typename Dispatch>
41902 VULKAN_HPP_INLINE void Device::destroySemaphore( Semaphore semaphore, const AllocationCallbacks* pAllocator, Dispatch const &d) const
41903 {
41904 d.vkDestroySemaphore( m_device, static_cast<VkSemaphore>( semaphore ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
41905 }
41906#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41907 template<typename Dispatch>
41909 {
41910 d.vkDestroySemaphore( m_device, static_cast<VkSemaphore>( semaphore ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
41911 }
41912#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41913
41914 template<typename Dispatch>
41915 VULKAN_HPP_INLINE void Device::destroy( Semaphore semaphore, const AllocationCallbacks* pAllocator, Dispatch const &d) const
41916 {
41917 d.vkDestroySemaphore( m_device, static_cast<VkSemaphore>( semaphore ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
41918 }
41919#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41920 template<typename Dispatch>
41921 VULKAN_HPP_INLINE void Device::destroy( Semaphore semaphore, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
41922 {
41923 d.vkDestroySemaphore( m_device, static_cast<VkSemaphore>( semaphore ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
41924 }
41925#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41926
41927 template<typename Dispatch>
41928 VULKAN_HPP_INLINE Result Device::createEvent( const EventCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Event* pEvent, Dispatch const &d) const
41929 {
41930 return static_cast<Result>( d.vkCreateEvent( m_device, reinterpret_cast<const VkEventCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkEvent*>( pEvent ) ) );
41931 }
41932#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41933 template<typename Dispatch>
41935 {
41936 Event event;
41937 Result result = static_cast<Result>( d.vkCreateEvent( m_device, reinterpret_cast<const VkEventCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkEvent*>( &event ) ) );
41938 return createResultValue( result, event, VULKAN_HPP_NAMESPACE_STRING"::Device::createEvent" );
41939 }
41940#ifndef VULKAN_HPP_NO_SMART_HANDLE
41941 template<typename Dispatch>
41943 {
41944 Event event;
41945 Result result = static_cast<Result>( d.vkCreateEvent( m_device, reinterpret_cast<const VkEventCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkEvent*>( &event ) ) );
41946
41947 ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
41948 return createResultValue<Event,Dispatch>( result, event, VULKAN_HPP_NAMESPACE_STRING"::Device::createEventUnique", deleter );
41949 }
41950#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
41951#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41952
41953 template<typename Dispatch>
41954 VULKAN_HPP_INLINE void Device::destroyEvent( Event event, const AllocationCallbacks* pAllocator, Dispatch const &d) const
41955 {
41956 d.vkDestroyEvent( m_device, static_cast<VkEvent>( event ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
41957 }
41958#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41959 template<typename Dispatch>
41961 {
41962 d.vkDestroyEvent( m_device, static_cast<VkEvent>( event ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
41963 }
41964#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41965
41966 template<typename Dispatch>
41967 VULKAN_HPP_INLINE void Device::destroy( Event event, const AllocationCallbacks* pAllocator, Dispatch const &d) const
41968 {
41969 d.vkDestroyEvent( m_device, static_cast<VkEvent>( event ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
41970 }
41971#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
41972 template<typename Dispatch>
41974 {
41975 d.vkDestroyEvent( m_device, static_cast<VkEvent>( event ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
41976 }
41977#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41978
41979#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
41980 template<typename Dispatch>
41982 {
41983 return static_cast<Result>( d.vkGetEventStatus( m_device, static_cast<VkEvent>( event ) ) );
41984 }
41985#else
41986 template<typename Dispatch>
41988 {
41989 Result result = static_cast<Result>( d.vkGetEventStatus( m_device, static_cast<VkEvent>( event ) ) );
41991 }
41992#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
41993
41994#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
41995 template<typename Dispatch>
41996 VULKAN_HPP_INLINE Result Device::setEvent( Event event, Dispatch const &d) const
41997 {
41998 return static_cast<Result>( d.vkSetEvent( m_device, static_cast<VkEvent>( event ) ) );
41999 }
42000#else
42001 template<typename Dispatch>
42003 {
42004 Result result = static_cast<Result>( d.vkSetEvent( m_device, static_cast<VkEvent>( event ) ) );
42005 return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::setEvent" );
42006 }
42007#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42008
42009#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
42010 template<typename Dispatch>
42011 VULKAN_HPP_INLINE Result Device::resetEvent( Event event, Dispatch const &d) const
42012 {
42013 return static_cast<Result>( d.vkResetEvent( m_device, static_cast<VkEvent>( event ) ) );
42014 }
42015#else
42016 template<typename Dispatch>
42018 {
42019 Result result = static_cast<Result>( d.vkResetEvent( m_device, static_cast<VkEvent>( event ) ) );
42020 return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::resetEvent" );
42021 }
42022#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42023
42024 template<typename Dispatch>
42025 VULKAN_HPP_INLINE Result Device::createQueryPool( const QueryPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, QueryPool* pQueryPool, Dispatch const &d) const
42026 {
42027 return static_cast<Result>( d.vkCreateQueryPool( m_device, reinterpret_cast<const VkQueryPoolCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkQueryPool*>( pQueryPool ) ) );
42028 }
42029#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42030 template<typename Dispatch>
42032 {
42033 QueryPool queryPool;
42034 Result result = static_cast<Result>( d.vkCreateQueryPool( m_device, reinterpret_cast<const VkQueryPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkQueryPool*>( &queryPool ) ) );
42035 return createResultValue( result, queryPool, VULKAN_HPP_NAMESPACE_STRING"::Device::createQueryPool" );
42036 }
42037#ifndef VULKAN_HPP_NO_SMART_HANDLE
42038 template<typename Dispatch>
42040 {
42041 QueryPool queryPool;
42042 Result result = static_cast<Result>( d.vkCreateQueryPool( m_device, reinterpret_cast<const VkQueryPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkQueryPool*>( &queryPool ) ) );
42043
42044 ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
42045 return createResultValue<QueryPool,Dispatch>( result, queryPool, VULKAN_HPP_NAMESPACE_STRING"::Device::createQueryPoolUnique", deleter );
42046 }
42047#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
42048#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42049
42050 template<typename Dispatch>
42051 VULKAN_HPP_INLINE void Device::destroyQueryPool( QueryPool queryPool, const AllocationCallbacks* pAllocator, Dispatch const &d) const
42052 {
42053 d.vkDestroyQueryPool( m_device, static_cast<VkQueryPool>( queryPool ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
42054 }
42055#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42056 template<typename Dispatch>
42058 {
42059 d.vkDestroyQueryPool( m_device, static_cast<VkQueryPool>( queryPool ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
42060 }
42061#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42062
42063 template<typename Dispatch>
42064 VULKAN_HPP_INLINE void Device::destroy( QueryPool queryPool, const AllocationCallbacks* pAllocator, Dispatch const &d) const
42065 {
42066 d.vkDestroyQueryPool( m_device, static_cast<VkQueryPool>( queryPool ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
42067 }
42068#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42069 template<typename Dispatch>
42070 VULKAN_HPP_INLINE void Device::destroy( QueryPool queryPool, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
42071 {
42072 d.vkDestroyQueryPool( m_device, static_cast<VkQueryPool>( queryPool ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
42073 }
42074#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42075
42076 template<typename Dispatch>
42077 VULKAN_HPP_INLINE Result Device::getQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, DeviceSize stride, QueryResultFlags flags, Dispatch const &d) const
42078 {
42079 return static_cast<Result>( d.vkGetQueryPoolResults( m_device, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount, dataSize, pData, stride, static_cast<VkQueryResultFlags>( flags ) ) );
42080 }
42081#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42082 template <typename T, typename Dispatch>
42084 {
42085 Result result = static_cast<Result>( d.vkGetQueryPoolResults( m_device, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount, data.size() * sizeof( T ) , reinterpret_cast<void*>( data.data() ), stride, static_cast<VkQueryResultFlags>( flags ) ) );
42086 return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getQueryPoolResults", { Result::eSuccess, Result::eNotReady } );
42087 }
42088#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42089
42090 template<typename Dispatch>
42091 VULKAN_HPP_INLINE Result Device::createBuffer( const BufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Buffer* pBuffer, Dispatch const &d) const
42092 {
42093 return static_cast<Result>( d.vkCreateBuffer( m_device, reinterpret_cast<const VkBufferCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkBuffer*>( pBuffer ) ) );
42094 }
42095#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42096 template<typename Dispatch>
42098 {
42099 Buffer buffer;
42100 Result result = static_cast<Result>( d.vkCreateBuffer( m_device, reinterpret_cast<const VkBufferCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkBuffer*>( &buffer ) ) );
42101 return createResultValue( result, buffer, VULKAN_HPP_NAMESPACE_STRING"::Device::createBuffer" );
42102 }
42103#ifndef VULKAN_HPP_NO_SMART_HANDLE
42104 template<typename Dispatch>
42106 {
42107 Buffer buffer;
42108 Result result = static_cast<Result>( d.vkCreateBuffer( m_device, reinterpret_cast<const VkBufferCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkBuffer*>( &buffer ) ) );
42109
42110 ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
42111 return createResultValue<Buffer,Dispatch>( result, buffer, VULKAN_HPP_NAMESPACE_STRING"::Device::createBufferUnique", deleter );
42112 }
42113#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
42114#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42115
42116 template<typename Dispatch>
42117 VULKAN_HPP_INLINE void Device::destroyBuffer( Buffer buffer, const AllocationCallbacks* pAllocator, Dispatch const &d) const
42118 {
42119 d.vkDestroyBuffer( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
42120 }
42121#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42122 template<typename Dispatch>
42124 {
42125 d.vkDestroyBuffer( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
42126 }
42127#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42128
42129 template<typename Dispatch>
42130 VULKAN_HPP_INLINE void Device::destroy( Buffer buffer, const AllocationCallbacks* pAllocator, Dispatch const &d) const
42131 {
42132 d.vkDestroyBuffer( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
42133 }
42134#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42135 template<typename Dispatch>
42137 {
42138 d.vkDestroyBuffer( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
42139 }
42140#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42141
42142 template<typename Dispatch>
42143 VULKAN_HPP_INLINE Result Device::createBufferView( const BufferViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, BufferView* pView, Dispatch const &d) const
42144 {
42145 return static_cast<Result>( d.vkCreateBufferView( m_device, reinterpret_cast<const VkBufferViewCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkBufferView*>( pView ) ) );
42146 }
42147#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42148 template<typename Dispatch>
42150 {
42151 BufferView view;
42152 Result result = static_cast<Result>( d.vkCreateBufferView( m_device, reinterpret_cast<const VkBufferViewCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkBufferView*>( &view ) ) );
42153 return createResultValue( result, view, VULKAN_HPP_NAMESPACE_STRING"::Device::createBufferView" );
42154 }
42155#ifndef VULKAN_HPP_NO_SMART_HANDLE
42156 template<typename Dispatch>
42158 {
42159 BufferView view;
42160 Result result = static_cast<Result>( d.vkCreateBufferView( m_device, reinterpret_cast<const VkBufferViewCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkBufferView*>( &view ) ) );
42161
42162 ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
42163 return createResultValue<BufferView,Dispatch>( result, view, VULKAN_HPP_NAMESPACE_STRING"::Device::createBufferViewUnique", deleter );
42164 }
42165#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
42166#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42167
42168 template<typename Dispatch>
42169 VULKAN_HPP_INLINE void Device::destroyBufferView( BufferView bufferView, const AllocationCallbacks* pAllocator, Dispatch const &d) const
42170 {
42171 d.vkDestroyBufferView( m_device, static_cast<VkBufferView>( bufferView ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
42172 }
42173#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42174 template<typename Dispatch>
42176 {
42177 d.vkDestroyBufferView( m_device, static_cast<VkBufferView>( bufferView ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
42178 }
42179#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42180
42181 template<typename Dispatch>
42182 VULKAN_HPP_INLINE void Device::destroy( BufferView bufferView, const AllocationCallbacks* pAllocator, Dispatch const &d) const
42183 {
42184 d.vkDestroyBufferView( m_device, static_cast<VkBufferView>( bufferView ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
42185 }
42186#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42187 template<typename Dispatch>
42188 VULKAN_HPP_INLINE void Device::destroy( BufferView bufferView, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
42189 {
42190 d.vkDestroyBufferView( m_device, static_cast<VkBufferView>( bufferView ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
42191 }
42192#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42193
42194 template<typename Dispatch>
42195 VULKAN_HPP_INLINE Result Device::createImage( const ImageCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Image* pImage, Dispatch const &d) const
42196 {
42197 return static_cast<Result>( d.vkCreateImage( m_device, reinterpret_cast<const VkImageCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkImage*>( pImage ) ) );
42198 }
42199#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42200 template<typename Dispatch>
42202 {
42203 Image image;
42204 Result result = static_cast<Result>( d.vkCreateImage( m_device, reinterpret_cast<const VkImageCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkImage*>( &image ) ) );
42205 return createResultValue( result, image, VULKAN_HPP_NAMESPACE_STRING"::Device::createImage" );
42206 }
42207#ifndef VULKAN_HPP_NO_SMART_HANDLE
42208 template<typename Dispatch>
42210 {
42211 Image image;
42212 Result result = static_cast<Result>( d.vkCreateImage( m_device, reinterpret_cast<const VkImageCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkImage*>( &image ) ) );
42213
42214 ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
42215 return createResultValue<Image,Dispatch>( result, image, VULKAN_HPP_NAMESPACE_STRING"::Device::createImageUnique", deleter );
42216 }
42217#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
42218#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42219
42220 template<typename Dispatch>
42221 VULKAN_HPP_INLINE void Device::destroyImage( Image image, const AllocationCallbacks* pAllocator, Dispatch const &d) const
42222 {
42223 d.vkDestroyImage( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
42224 }
42225#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42226 template<typename Dispatch>
42228 {
42229 d.vkDestroyImage( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
42230 }
42231#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42232
42233 template<typename Dispatch>
42234 VULKAN_HPP_INLINE void Device::destroy( Image image, const AllocationCallbacks* pAllocator, Dispatch const &d) const
42235 {
42236 d.vkDestroyImage( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
42237 }
42238#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42239 template<typename Dispatch>
42241 {
42242 d.vkDestroyImage( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
42243 }
42244#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42245
42246 template<typename Dispatch>
42247 VULKAN_HPP_INLINE void Device::getImageSubresourceLayout( Image image, const ImageSubresource* pSubresource, SubresourceLayout* pLayout, Dispatch const &d) const
42248 {
42249 d.vkGetImageSubresourceLayout( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkImageSubresource*>( pSubresource ), reinterpret_cast<VkSubresourceLayout*>( pLayout ) );
42250 }
42251#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42252 template<typename Dispatch>
42254 {
42255 SubresourceLayout layout;
42256 d.vkGetImageSubresourceLayout( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkImageSubresource*>( &subresource ), reinterpret_cast<VkSubresourceLayout*>( &layout ) );
42257 return layout;
42258 }
42259#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42260
42261 template<typename Dispatch>
42262 VULKAN_HPP_INLINE Result Device::createImageView( const ImageViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, ImageView* pView, Dispatch const &d) const
42263 {
42264 return static_cast<Result>( d.vkCreateImageView( m_device, reinterpret_cast<const VkImageViewCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkImageView*>( pView ) ) );
42265 }
42266#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42267 template<typename Dispatch>
42269 {
42270 ImageView view;
42271 Result result = static_cast<Result>( d.vkCreateImageView( m_device, reinterpret_cast<const VkImageViewCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkImageView*>( &view ) ) );
42272 return createResultValue( result, view, VULKAN_HPP_NAMESPACE_STRING"::Device::createImageView" );
42273 }
42274#ifndef VULKAN_HPP_NO_SMART_HANDLE
42275 template<typename Dispatch>
42277 {
42278 ImageView view;
42279 Result result = static_cast<Result>( d.vkCreateImageView( m_device, reinterpret_cast<const VkImageViewCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkImageView*>( &view ) ) );
42280
42281 ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
42282 return createResultValue<ImageView,Dispatch>( result, view, VULKAN_HPP_NAMESPACE_STRING"::Device::createImageViewUnique", deleter );
42283 }
42284#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
42285#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42286
42287 template<typename Dispatch>
42288 VULKAN_HPP_INLINE void Device::destroyImageView( ImageView imageView, const AllocationCallbacks* pAllocator, Dispatch const &d) const
42289 {
42290 d.vkDestroyImageView( m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
42291 }
42292#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42293 template<typename Dispatch>
42295 {
42296 d.vkDestroyImageView( m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
42297 }
42298#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42299
42300 template<typename Dispatch>
42301 VULKAN_HPP_INLINE void Device::destroy( ImageView imageView, const AllocationCallbacks* pAllocator, Dispatch const &d) const
42302 {
42303 d.vkDestroyImageView( m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
42304 }
42305#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42306 template<typename Dispatch>
42307 VULKAN_HPP_INLINE void Device::destroy( ImageView imageView, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
42308 {
42309 d.vkDestroyImageView( m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
42310 }
42311#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42312
42313 template<typename Dispatch>
42314 VULKAN_HPP_INLINE Result Device::createShaderModule( const ShaderModuleCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, ShaderModule* pShaderModule, Dispatch const &d) const
42315 {
42316 return static_cast<Result>( d.vkCreateShaderModule( m_device, reinterpret_cast<const VkShaderModuleCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkShaderModule*>( pShaderModule ) ) );
42317 }
42318#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42319 template<typename Dispatch>
42321 {
42322 ShaderModule shaderModule;
42323 Result result = static_cast<Result>( d.vkCreateShaderModule( m_device, reinterpret_cast<const VkShaderModuleCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkShaderModule*>( &shaderModule ) ) );
42324 return createResultValue( result, shaderModule, VULKAN_HPP_NAMESPACE_STRING"::Device::createShaderModule" );
42325 }
42326#ifndef VULKAN_HPP_NO_SMART_HANDLE
42327 template<typename Dispatch>
42329 {
42330 ShaderModule shaderModule;
42331 Result result = static_cast<Result>( d.vkCreateShaderModule( m_device, reinterpret_cast<const VkShaderModuleCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkShaderModule*>( &shaderModule ) ) );
42332
42333 ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
42334 return createResultValue<ShaderModule,Dispatch>( result, shaderModule, VULKAN_HPP_NAMESPACE_STRING"::Device::createShaderModuleUnique", deleter );
42335 }
42336#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
42337#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42338
42339 template<typename Dispatch>
42340 VULKAN_HPP_INLINE void Device::destroyShaderModule( ShaderModule shaderModule, const AllocationCallbacks* pAllocator, Dispatch const &d) const
42341 {
42342 d.vkDestroyShaderModule( m_device, static_cast<VkShaderModule>( shaderModule ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
42343 }
42344#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42345 template<typename Dispatch>
42347 {
42348 d.vkDestroyShaderModule( m_device, static_cast<VkShaderModule>( shaderModule ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
42349 }
42350#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42351
42352 template<typename Dispatch>
42353 VULKAN_HPP_INLINE void Device::destroy( ShaderModule shaderModule, const AllocationCallbacks* pAllocator, Dispatch const &d) const
42354 {
42355 d.vkDestroyShaderModule( m_device, static_cast<VkShaderModule>( shaderModule ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
42356 }
42357#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42358 template<typename Dispatch>
42359 VULKAN_HPP_INLINE void Device::destroy( ShaderModule shaderModule, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
42360 {
42361 d.vkDestroyShaderModule( m_device, static_cast<VkShaderModule>( shaderModule ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
42362 }
42363#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42364
42365 template<typename Dispatch>
42366 VULKAN_HPP_INLINE Result Device::createPipelineCache( const PipelineCacheCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, PipelineCache* pPipelineCache, Dispatch const &d) const
42367 {
42368 return static_cast<Result>( d.vkCreatePipelineCache( m_device, reinterpret_cast<const VkPipelineCacheCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkPipelineCache*>( pPipelineCache ) ) );
42369 }
42370#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42371 template<typename Dispatch>
42373 {
42374 PipelineCache pipelineCache;
42375 Result result = static_cast<Result>( d.vkCreatePipelineCache( m_device, reinterpret_cast<const VkPipelineCacheCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipelineCache*>( &pipelineCache ) ) );
42376 return createResultValue( result, pipelineCache, VULKAN_HPP_NAMESPACE_STRING"::Device::createPipelineCache" );
42377 }
42378#ifndef VULKAN_HPP_NO_SMART_HANDLE
42379 template<typename Dispatch>
42381 {
42382 PipelineCache pipelineCache;
42383 Result result = static_cast<Result>( d.vkCreatePipelineCache( m_device, reinterpret_cast<const VkPipelineCacheCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipelineCache*>( &pipelineCache ) ) );
42384
42385 ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
42386 return createResultValue<PipelineCache,Dispatch>( result, pipelineCache, VULKAN_HPP_NAMESPACE_STRING"::Device::createPipelineCacheUnique", deleter );
42387 }
42388#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
42389#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42390
42391 template<typename Dispatch>
42392 VULKAN_HPP_INLINE void Device::destroyPipelineCache( PipelineCache pipelineCache, const AllocationCallbacks* pAllocator, Dispatch const &d) const
42393 {
42394 d.vkDestroyPipelineCache( m_device, static_cast<VkPipelineCache>( pipelineCache ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
42395 }
42396#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42397 template<typename Dispatch>
42399 {
42400 d.vkDestroyPipelineCache( m_device, static_cast<VkPipelineCache>( pipelineCache ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
42401 }
42402#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42403
42404 template<typename Dispatch>
42405 VULKAN_HPP_INLINE void Device::destroy( PipelineCache pipelineCache, const AllocationCallbacks* pAllocator, Dispatch const &d) const
42406 {
42407 d.vkDestroyPipelineCache( m_device, static_cast<VkPipelineCache>( pipelineCache ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
42408 }
42409#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42410 template<typename Dispatch>
42411 VULKAN_HPP_INLINE void Device::destroy( PipelineCache pipelineCache, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
42412 {
42413 d.vkDestroyPipelineCache( m_device, static_cast<VkPipelineCache>( pipelineCache ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
42414 }
42415#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42416
42417 template<typename Dispatch>
42418 VULKAN_HPP_INLINE Result Device::getPipelineCacheData( PipelineCache pipelineCache, size_t* pDataSize, void* pData, Dispatch const &d) const
42419 {
42420 return static_cast<Result>( d.vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), pDataSize, pData ) );
42421 }
42422#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42423 template <typename Allocator, typename Dispatch>
42425 {
42426 std::vector<uint8_t,Allocator> data;
42427 size_t dataSize;
42428 Result result;
42429 do
42430 {
42431 result = static_cast<Result>( d.vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), &dataSize, nullptr ) );
42432 if ( ( result == Result::eSuccess ) && dataSize )
42433 {
42434 data.resize( dataSize );
42435 result = static_cast<Result>( d.vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), &dataSize, reinterpret_cast<void*>( data.data() ) ) );
42436 }
42437 } while ( result == Result::eIncomplete );
42438 VULKAN_HPP_ASSERT( dataSize <= data.size() );
42439 data.resize( dataSize );
42440 return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING"::Device::getPipelineCacheData" );
42441 }
42442 template <typename Allocator, typename Dispatch>
42443 VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getPipelineCacheData( PipelineCache pipelineCache, Allocator const& vectorAllocator, Dispatch const &d ) const
42444 {
42445 std::vector<uint8_t,Allocator> data( vectorAllocator );
42446 size_t dataSize;
42447 Result result;
42448 do
42449 {
42450 result = static_cast<Result>( d.vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), &dataSize, nullptr ) );
42451 if ( ( result == Result::eSuccess ) && dataSize )
42452 {
42453 data.resize( dataSize );
42454 result = static_cast<Result>( d.vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), &dataSize, reinterpret_cast<void*>( data.data() ) ) );
42455 }
42456 } while ( result == Result::eIncomplete );
42457 VULKAN_HPP_ASSERT( dataSize <= data.size() );
42458 data.resize( dataSize );
42459 return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING"::Device::getPipelineCacheData" );
42460 }
42461#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42462
42463 template<typename Dispatch>
42464 VULKAN_HPP_INLINE Result Device::mergePipelineCaches( PipelineCache dstCache, uint32_t srcCacheCount, const PipelineCache* pSrcCaches, Dispatch const &d) const
42465 {
42466 return static_cast<Result>( d.vkMergePipelineCaches( m_device, static_cast<VkPipelineCache>( dstCache ), srcCacheCount, reinterpret_cast<const VkPipelineCache*>( pSrcCaches ) ) );
42467 }
42468#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42469 template<typename Dispatch>
42471 {
42472 Result result = static_cast<Result>( d.vkMergePipelineCaches( m_device, static_cast<VkPipelineCache>( dstCache ), srcCaches.size() , reinterpret_cast<const VkPipelineCache*>( srcCaches.data() ) ) );
42473 return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::mergePipelineCaches" );
42474 }
42475#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42476
42477 template<typename Dispatch>
42478 VULKAN_HPP_INLINE Result Device::createGraphicsPipelines( PipelineCache pipelineCache, uint32_t createInfoCount, const GraphicsPipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d) const
42479 {
42480 return static_cast<Result>( d.vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfoCount, reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( pCreateInfos ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkPipeline*>( pPipelines ) ) );
42481 }
42482#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42483 template <typename Allocator, typename Dispatch>
42485 {
42486 std::vector<Pipeline,Allocator> pipelines( createInfos.size() );
42487 Result result = static_cast<Result>( d.vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( pipelines.data() ) ) );
42488 return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createGraphicsPipelines" );
42489 }
42490 template <typename Allocator, typename Dispatch>
42492 {
42493 std::vector<Pipeline,Allocator> pipelines( createInfos.size(), vectorAllocator );
42494 Result result = static_cast<Result>( d.vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( pipelines.data() ) ) );
42495 return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createGraphicsPipelines" );
42496 }
42497 template<typename Dispatch>
42499 {
42500 Pipeline pipeline;
42501 Result result = static_cast<Result>( d.vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), 1 , reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( &pipeline ) ) );
42502 return createResultValue( result, pipeline, VULKAN_HPP_NAMESPACE_STRING"::Device::createGraphicsPipeline" );
42503 }
42504#ifndef VULKAN_HPP_NO_SMART_HANDLE
42505 template <typename Allocator, typename Dispatch>
42507 {
42508 static_assert( sizeof( Pipeline ) <= sizeof( UniquePipeline ), "Pipeline is greater than UniquePipeline!" );
42509 std::vector<UniquePipeline, Allocator> pipelines;
42510 pipelines.reserve( createInfos.size() );
42511 Pipeline* buffer = reinterpret_cast<Pipeline*>( reinterpret_cast<char*>( pipelines.data() ) + createInfos.size() * ( sizeof( UniquePipeline ) - sizeof( Pipeline ) ) );
42512 Result result = static_cast<Result>(d.vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( buffer ) ) );
42513
42514 ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
42515 for ( size_t i=0 ; i<createInfos.size() ; i++ )
42516 {
42517 pipelines.push_back( UniquePipeline( buffer[i], deleter ) );
42518 }
42519
42520 return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelinesUnique" );
42521 }
42522 template <typename Allocator, typename Dispatch>
42524 {
42525 static_assert( sizeof( Pipeline ) <= sizeof( UniquePipeline ), "Pipeline is greater than UniquePipeline!" );
42526 std::vector<UniquePipeline, Allocator> pipelines;
42527 pipelines.reserve( createInfos.size() );
42528 Pipeline* buffer = reinterpret_cast<Pipeline*>( reinterpret_cast<char*>( pipelines.data() ) + createInfos.size() * ( sizeof( UniquePipeline ) - sizeof( Pipeline ) ) );
42529 Result result = static_cast<Result>(d.vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( buffer ) ) );
42530
42531 ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
42532 for ( size_t i=0 ; i<createInfos.size() ; i++ )
42533 {
42534 pipelines.push_back( UniquePipeline( buffer[i], deleter ) );
42535 }
42536
42537 return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelinesUnique" );
42538 }
42539 template<typename Dispatch>
42541 {
42542 Pipeline pipeline;
42543 Result result = static_cast<Result>( d.vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), 1 , reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( &pipeline ) ) );
42544
42545 ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
42546 return createResultValue<Pipeline,Dispatch>( result, pipeline, VULKAN_HPP_NAMESPACE_STRING"::Device::createGraphicsPipelineUnique", deleter );
42547 }
42548#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
42549#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42550
42551 template<typename Dispatch>
42552 VULKAN_HPP_INLINE Result Device::createComputePipelines( PipelineCache pipelineCache, uint32_t createInfoCount, const ComputePipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d) const
42553 {
42554 return static_cast<Result>( d.vkCreateComputePipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfoCount, reinterpret_cast<const VkComputePipelineCreateInfo*>( pCreateInfos ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkPipeline*>( pPipelines ) ) );
42555 }
42556#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42557 template <typename Allocator, typename Dispatch>
42559 {
42560 std::vector<Pipeline,Allocator> pipelines( createInfos.size() );
42561 Result result = static_cast<Result>( d.vkCreateComputePipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkComputePipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( pipelines.data() ) ) );
42562 return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createComputePipelines" );
42563 }
42564 template <typename Allocator, typename Dispatch>
42566 {
42567 std::vector<Pipeline,Allocator> pipelines( createInfos.size(), vectorAllocator );
42568 Result result = static_cast<Result>( d.vkCreateComputePipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkComputePipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( pipelines.data() ) ) );
42569 return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createComputePipelines" );
42570 }
42571 template<typename Dispatch>
42573 {
42574 Pipeline pipeline;
42575 Result result = static_cast<Result>( d.vkCreateComputePipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), 1 , reinterpret_cast<const VkComputePipelineCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( &pipeline ) ) );
42576 return createResultValue( result, pipeline, VULKAN_HPP_NAMESPACE_STRING"::Device::createComputePipeline" );
42577 }
42578#ifndef VULKAN_HPP_NO_SMART_HANDLE
42579 template <typename Allocator, typename Dispatch>
42581 {
42582 static_assert( sizeof( Pipeline ) <= sizeof( UniquePipeline ), "Pipeline is greater than UniquePipeline!" );
42583 std::vector<UniquePipeline, Allocator> pipelines;
42584 pipelines.reserve( createInfos.size() );
42585 Pipeline* buffer = reinterpret_cast<Pipeline*>( reinterpret_cast<char*>( pipelines.data() ) + createInfos.size() * ( sizeof( UniquePipeline ) - sizeof( Pipeline ) ) );
42586 Result result = static_cast<Result>(d.vkCreateComputePipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkComputePipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( buffer ) ) );
42587
42588 ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
42589 for ( size_t i=0 ; i<createInfos.size() ; i++ )
42590 {
42591 pipelines.push_back( UniquePipeline( buffer[i], deleter ) );
42592 }
42593
42594 return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelinesUnique" );
42595 }
42596 template <typename Allocator, typename Dispatch>
42598 {
42599 static_assert( sizeof( Pipeline ) <= sizeof( UniquePipeline ), "Pipeline is greater than UniquePipeline!" );
42600 std::vector<UniquePipeline, Allocator> pipelines;
42601 pipelines.reserve( createInfos.size() );
42602 Pipeline* buffer = reinterpret_cast<Pipeline*>( reinterpret_cast<char*>( pipelines.data() ) + createInfos.size() * ( sizeof( UniquePipeline ) - sizeof( Pipeline ) ) );
42603 Result result = static_cast<Result>(d.vkCreateComputePipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkComputePipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( buffer ) ) );
42604
42605 ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
42606 for ( size_t i=0 ; i<createInfos.size() ; i++ )
42607 {
42608 pipelines.push_back( UniquePipeline( buffer[i], deleter ) );
42609 }
42610
42611 return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelinesUnique" );
42612 }
42613 template<typename Dispatch>
42615 {
42616 Pipeline pipeline;
42617 Result result = static_cast<Result>( d.vkCreateComputePipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), 1 , reinterpret_cast<const VkComputePipelineCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( &pipeline ) ) );
42618
42619 ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
42620 return createResultValue<Pipeline,Dispatch>( result, pipeline, VULKAN_HPP_NAMESPACE_STRING"::Device::createComputePipelineUnique", deleter );
42621 }
42622#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
42623#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42624
42625 template<typename Dispatch>
42626 VULKAN_HPP_INLINE void Device::destroyPipeline( Pipeline pipeline, const AllocationCallbacks* pAllocator, Dispatch const &d) const
42627 {
42628 d.vkDestroyPipeline( m_device, static_cast<VkPipeline>( pipeline ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
42629 }
42630#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42631 template<typename Dispatch>
42633 {
42634 d.vkDestroyPipeline( m_device, static_cast<VkPipeline>( pipeline ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
42635 }
42636#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42637
42638 template<typename Dispatch>
42639 VULKAN_HPP_INLINE void Device::destroy( Pipeline pipeline, const AllocationCallbacks* pAllocator, Dispatch const &d) const
42640 {
42641 d.vkDestroyPipeline( m_device, static_cast<VkPipeline>( pipeline ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
42642 }
42643#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42644 template<typename Dispatch>
42645 VULKAN_HPP_INLINE void Device::destroy( Pipeline pipeline, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
42646 {
42647 d.vkDestroyPipeline( m_device, static_cast<VkPipeline>( pipeline ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
42648 }
42649#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42650
42651 template<typename Dispatch>
42652 VULKAN_HPP_INLINE Result Device::createPipelineLayout( const PipelineLayoutCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, PipelineLayout* pPipelineLayout, Dispatch const &d) const
42653 {
42654 return static_cast<Result>( d.vkCreatePipelineLayout( m_device, reinterpret_cast<const VkPipelineLayoutCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkPipelineLayout*>( pPipelineLayout ) ) );
42655 }
42656#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42657 template<typename Dispatch>
42659 {
42660 PipelineLayout pipelineLayout;
42661 Result result = static_cast<Result>( d.vkCreatePipelineLayout( m_device, reinterpret_cast<const VkPipelineLayoutCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipelineLayout*>( &pipelineLayout ) ) );
42662 return createResultValue( result, pipelineLayout, VULKAN_HPP_NAMESPACE_STRING"::Device::createPipelineLayout" );
42663 }
42664#ifndef VULKAN_HPP_NO_SMART_HANDLE
42665 template<typename Dispatch>
42667 {
42668 PipelineLayout pipelineLayout;
42669 Result result = static_cast<Result>( d.vkCreatePipelineLayout( m_device, reinterpret_cast<const VkPipelineLayoutCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipelineLayout*>( &pipelineLayout ) ) );
42670
42671 ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
42672 return createResultValue<PipelineLayout,Dispatch>( result, pipelineLayout, VULKAN_HPP_NAMESPACE_STRING"::Device::createPipelineLayoutUnique", deleter );
42673 }
42674#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
42675#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42676
42677 template<typename Dispatch>
42678 VULKAN_HPP_INLINE void Device::destroyPipelineLayout( PipelineLayout pipelineLayout, const AllocationCallbacks* pAllocator, Dispatch const &d) const
42679 {
42680 d.vkDestroyPipelineLayout( m_device, static_cast<VkPipelineLayout>( pipelineLayout ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
42681 }
42682#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42683 template<typename Dispatch>
42685 {
42686 d.vkDestroyPipelineLayout( m_device, static_cast<VkPipelineLayout>( pipelineLayout ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
42687 }
42688#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42689
42690 template<typename Dispatch>
42691 VULKAN_HPP_INLINE void Device::destroy( PipelineLayout pipelineLayout, const AllocationCallbacks* pAllocator, Dispatch const &d) const
42692 {
42693 d.vkDestroyPipelineLayout( m_device, static_cast<VkPipelineLayout>( pipelineLayout ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
42694 }
42695#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42696 template<typename Dispatch>
42697 VULKAN_HPP_INLINE void Device::destroy( PipelineLayout pipelineLayout, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
42698 {
42699 d.vkDestroyPipelineLayout( m_device, static_cast<VkPipelineLayout>( pipelineLayout ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
42700 }
42701#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42702
42703 template<typename Dispatch>
42704 VULKAN_HPP_INLINE Result Device::createSampler( const SamplerCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Sampler* pSampler, Dispatch const &d) const
42705 {
42706 return static_cast<Result>( d.vkCreateSampler( m_device, reinterpret_cast<const VkSamplerCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSampler*>( pSampler ) ) );
42707 }
42708#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42709 template<typename Dispatch>
42711 {
42713 Result result = static_cast<Result>( d.vkCreateSampler( m_device, reinterpret_cast<const VkSamplerCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSampler*>( &sampler ) ) );
42714 return createResultValue( result, sampler, VULKAN_HPP_NAMESPACE_STRING"::Device::createSampler" );
42715 }
42716#ifndef VULKAN_HPP_NO_SMART_HANDLE
42717 template<typename Dispatch>
42719 {
42721 Result result = static_cast<Result>( d.vkCreateSampler( m_device, reinterpret_cast<const VkSamplerCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSampler*>( &sampler ) ) );
42722
42723 ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
42724 return createResultValue<Sampler,Dispatch>( result, sampler, VULKAN_HPP_NAMESPACE_STRING"::Device::createSamplerUnique", deleter );
42725 }
42726#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
42727#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42728
42729 template<typename Dispatch>
42730 VULKAN_HPP_INLINE void Device::destroySampler( Sampler sampler, const AllocationCallbacks* pAllocator, Dispatch const &d) const
42731 {
42732 d.vkDestroySampler( m_device, static_cast<VkSampler>( sampler ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
42733 }
42734#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42735 template<typename Dispatch>
42737 {
42738 d.vkDestroySampler( m_device, static_cast<VkSampler>( sampler ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
42739 }
42740#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42741
42742 template<typename Dispatch>
42743 VULKAN_HPP_INLINE void Device::destroy( Sampler sampler, const AllocationCallbacks* pAllocator, Dispatch const &d) const
42744 {
42745 d.vkDestroySampler( m_device, static_cast<VkSampler>( sampler ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
42746 }
42747#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42748 template<typename Dispatch>
42750 {
42751 d.vkDestroySampler( m_device, static_cast<VkSampler>( sampler ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
42752 }
42753#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42754
42755 template<typename Dispatch>
42757 {
42758 return static_cast<Result>( d.vkCreateDescriptorSetLayout( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDescriptorSetLayout*>( pSetLayout ) ) );
42759 }
42760#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42761 template<typename Dispatch>
42763 {
42764 DescriptorSetLayout setLayout;
42765 Result result = static_cast<Result>( d.vkCreateDescriptorSetLayout( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorSetLayout*>( &setLayout ) ) );
42766 return createResultValue( result, setLayout, VULKAN_HPP_NAMESPACE_STRING"::Device::createDescriptorSetLayout" );
42767 }
42768#ifndef VULKAN_HPP_NO_SMART_HANDLE
42769 template<typename Dispatch>
42771 {
42772 DescriptorSetLayout setLayout;
42773 Result result = static_cast<Result>( d.vkCreateDescriptorSetLayout( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorSetLayout*>( &setLayout ) ) );
42774
42775 ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
42776 return createResultValue<DescriptorSetLayout,Dispatch>( result, setLayout, VULKAN_HPP_NAMESPACE_STRING"::Device::createDescriptorSetLayoutUnique", deleter );
42777 }
42778#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
42779#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42780
42781 template<typename Dispatch>
42782 VULKAN_HPP_INLINE void Device::destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout, const AllocationCallbacks* pAllocator, Dispatch const &d) const
42783 {
42784 d.vkDestroyDescriptorSetLayout( m_device, static_cast<VkDescriptorSetLayout>( descriptorSetLayout ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
42785 }
42786#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42787 template<typename Dispatch>
42789 {
42790 d.vkDestroyDescriptorSetLayout( m_device, static_cast<VkDescriptorSetLayout>( descriptorSetLayout ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
42791 }
42792#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42793
42794 template<typename Dispatch>
42795 VULKAN_HPP_INLINE void Device::destroy( DescriptorSetLayout descriptorSetLayout, const AllocationCallbacks* pAllocator, Dispatch const &d) const
42796 {
42797 d.vkDestroyDescriptorSetLayout( m_device, static_cast<VkDescriptorSetLayout>( descriptorSetLayout ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
42798 }
42799#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42800 template<typename Dispatch>
42801 VULKAN_HPP_INLINE void Device::destroy( DescriptorSetLayout descriptorSetLayout, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
42802 {
42803 d.vkDestroyDescriptorSetLayout( m_device, static_cast<VkDescriptorSetLayout>( descriptorSetLayout ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
42804 }
42805#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42806
42807 template<typename Dispatch>
42808 VULKAN_HPP_INLINE Result Device::createDescriptorPool( const DescriptorPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorPool* pDescriptorPool, Dispatch const &d) const
42809 {
42810 return static_cast<Result>( d.vkCreateDescriptorPool( m_device, reinterpret_cast<const VkDescriptorPoolCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDescriptorPool*>( pDescriptorPool ) ) );
42811 }
42812#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42813 template<typename Dispatch>
42815 {
42816 DescriptorPool descriptorPool;
42817 Result result = static_cast<Result>( d.vkCreateDescriptorPool( m_device, reinterpret_cast<const VkDescriptorPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorPool*>( &descriptorPool ) ) );
42818 return createResultValue( result, descriptorPool, VULKAN_HPP_NAMESPACE_STRING"::Device::createDescriptorPool" );
42819 }
42820#ifndef VULKAN_HPP_NO_SMART_HANDLE
42821 template<typename Dispatch>
42823 {
42824 DescriptorPool descriptorPool;
42825 Result result = static_cast<Result>( d.vkCreateDescriptorPool( m_device, reinterpret_cast<const VkDescriptorPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorPool*>( &descriptorPool ) ) );
42826
42827 ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
42828 return createResultValue<DescriptorPool,Dispatch>( result, descriptorPool, VULKAN_HPP_NAMESPACE_STRING"::Device::createDescriptorPoolUnique", deleter );
42829 }
42830#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
42831#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42832
42833 template<typename Dispatch>
42834 VULKAN_HPP_INLINE void Device::destroyDescriptorPool( DescriptorPool descriptorPool, const AllocationCallbacks* pAllocator, Dispatch const &d) const
42835 {
42836 d.vkDestroyDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
42837 }
42838#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42839 template<typename Dispatch>
42841 {
42842 d.vkDestroyDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
42843 }
42844#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42845
42846 template<typename Dispatch>
42847 VULKAN_HPP_INLINE void Device::destroy( DescriptorPool descriptorPool, const AllocationCallbacks* pAllocator, Dispatch const &d) const
42848 {
42849 d.vkDestroyDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
42850 }
42851#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42852 template<typename Dispatch>
42853 VULKAN_HPP_INLINE void Device::destroy( DescriptorPool descriptorPool, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
42854 {
42855 d.vkDestroyDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
42856 }
42857#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42858
42859#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
42860 template<typename Dispatch>
42862 {
42863 return static_cast<Result>( d.vkResetDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), static_cast<VkDescriptorPoolResetFlags>( flags ) ) );
42864 }
42865#else
42866 template<typename Dispatch>
42868 {
42869 Result result = static_cast<Result>( d.vkResetDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), static_cast<VkDescriptorPoolResetFlags>( flags ) ) );
42870 return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::resetDescriptorPool" );
42871 }
42872#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42873
42874 template<typename Dispatch>
42875 VULKAN_HPP_INLINE Result Device::allocateDescriptorSets( const DescriptorSetAllocateInfo* pAllocateInfo, DescriptorSet* pDescriptorSets, Dispatch const &d) const
42876 {
42877 return static_cast<Result>( d.vkAllocateDescriptorSets( m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo*>( pAllocateInfo ), reinterpret_cast<VkDescriptorSet*>( pDescriptorSets ) ) );
42878 }
42879#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42880 template <typename Allocator, typename Dispatch>
42882 {
42883 std::vector<DescriptorSet,Allocator> descriptorSets( allocateInfo.descriptorSetCount );
42884 Result result = static_cast<Result>( d.vkAllocateDescriptorSets( m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkDescriptorSet*>( descriptorSets.data() ) ) );
42885 return createResultValue( result, descriptorSets, VULKAN_HPP_NAMESPACE_STRING"::Device::allocateDescriptorSets" );
42886 }
42887 template <typename Allocator, typename Dispatch>
42888 VULKAN_HPP_INLINE typename ResultValueType<std::vector<DescriptorSet,Allocator>>::type Device::allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const
42889 {
42890 std::vector<DescriptorSet,Allocator> descriptorSets( allocateInfo.descriptorSetCount, vectorAllocator );
42891 Result result = static_cast<Result>( d.vkAllocateDescriptorSets( m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkDescriptorSet*>( descriptorSets.data() ) ) );
42892 return createResultValue( result, descriptorSets, VULKAN_HPP_NAMESPACE_STRING"::Device::allocateDescriptorSets" );
42893 }
42894#ifndef VULKAN_HPP_NO_SMART_HANDLE
42895 template <typename Allocator, typename Dispatch>
42897 {
42898 static_assert( sizeof( DescriptorSet ) <= sizeof( UniqueDescriptorSet ), "DescriptorSet is greater than UniqueDescriptorSet!" );
42899 std::vector<UniqueDescriptorSet, Allocator> descriptorSets;
42900 descriptorSets.reserve( allocateInfo.descriptorSetCount );
42901 DescriptorSet* buffer = reinterpret_cast<DescriptorSet*>( reinterpret_cast<char*>( descriptorSets.data() ) + allocateInfo.descriptorSetCount * ( sizeof( UniqueDescriptorSet ) - sizeof( DescriptorSet ) ) );
42902 Result result = static_cast<Result>(d.vkAllocateDescriptorSets( m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkDescriptorSet*>( buffer ) ) );
42903
42904 PoolFree<Device,DescriptorPool,Dispatch> deleter( *this, allocateInfo.descriptorPool, d );
42905 for ( size_t i=0 ; i<allocateInfo.descriptorSetCount ; i++ )
42906 {
42907 descriptorSets.push_back( UniqueDescriptorSet( buffer[i], deleter ) );
42908 }
42909
42910 return createResultValue( result, descriptorSets, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique" );
42911 }
42912 template <typename Allocator, typename Dispatch>
42913 VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<DescriptorSet,Dispatch>,Allocator>>::type Device::allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const
42914 {
42915 static_assert( sizeof( DescriptorSet ) <= sizeof( UniqueDescriptorSet ), "DescriptorSet is greater than UniqueDescriptorSet!" );
42916 std::vector<UniqueDescriptorSet, Allocator> descriptorSets;
42917 descriptorSets.reserve( allocateInfo.descriptorSetCount );
42918 DescriptorSet* buffer = reinterpret_cast<DescriptorSet*>( reinterpret_cast<char*>( descriptorSets.data() ) + allocateInfo.descriptorSetCount * ( sizeof( UniqueDescriptorSet ) - sizeof( DescriptorSet ) ) );
42919 Result result = static_cast<Result>(d.vkAllocateDescriptorSets( m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkDescriptorSet*>( buffer ) ) );
42920
42921 PoolFree<Device,DescriptorPool,Dispatch> deleter( *this, allocateInfo.descriptorPool, d );
42922 for ( size_t i=0 ; i<allocateInfo.descriptorSetCount ; i++ )
42923 {
42924 descriptorSets.push_back( UniqueDescriptorSet( buffer[i], deleter ) );
42925 }
42926
42927 return createResultValue( result, descriptorSets, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique" );
42928 }
42929#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
42930#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42931
42932 template<typename Dispatch>
42933 VULKAN_HPP_INLINE Result Device::freeDescriptorSets( DescriptorPool descriptorPool, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, Dispatch const &d) const
42934 {
42935 return static_cast<Result>( d.vkFreeDescriptorSets( m_device, static_cast<VkDescriptorPool>( descriptorPool ), descriptorSetCount, reinterpret_cast<const VkDescriptorSet*>( pDescriptorSets ) ) );
42936 }
42937#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42938 template<typename Dispatch>
42940 {
42941 Result result = static_cast<Result>( d.vkFreeDescriptorSets( m_device, static_cast<VkDescriptorPool>( descriptorPool ), descriptorSets.size() , reinterpret_cast<const VkDescriptorSet*>( descriptorSets.data() ) ) );
42942 return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::freeDescriptorSets" );
42943 }
42944#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42945
42946 template<typename Dispatch>
42947 VULKAN_HPP_INLINE Result Device::free( DescriptorPool descriptorPool, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, Dispatch const &d) const
42948 {
42949 return static_cast<Result>( d.vkFreeDescriptorSets( m_device, static_cast<VkDescriptorPool>( descriptorPool ), descriptorSetCount, reinterpret_cast<const VkDescriptorSet*>( pDescriptorSets ) ) );
42950 }
42951#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42952 template<typename Dispatch>
42954 {
42955 Result result = static_cast<Result>( d.vkFreeDescriptorSets( m_device, static_cast<VkDescriptorPool>( descriptorPool ), descriptorSets.size() , reinterpret_cast<const VkDescriptorSet*>( descriptorSets.data() ) ) );
42956 return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::free" );
42957 }
42958#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42959
42960 template<typename Dispatch>
42961 VULKAN_HPP_INLINE void Device::updateDescriptorSets( uint32_t descriptorWriteCount, const WriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const CopyDescriptorSet* pDescriptorCopies, Dispatch const &d) const
42962 {
42963 d.vkUpdateDescriptorSets( m_device, descriptorWriteCount, reinterpret_cast<const VkWriteDescriptorSet*>( pDescriptorWrites ), descriptorCopyCount, reinterpret_cast<const VkCopyDescriptorSet*>( pDescriptorCopies ) );
42964 }
42965#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42966 template<typename Dispatch>
42968 {
42969 d.vkUpdateDescriptorSets( m_device, descriptorWrites.size() , reinterpret_cast<const VkWriteDescriptorSet*>( descriptorWrites.data() ), descriptorCopies.size() , reinterpret_cast<const VkCopyDescriptorSet*>( descriptorCopies.data() ) );
42970 }
42971#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42972
42973 template<typename Dispatch>
42974 VULKAN_HPP_INLINE Result Device::createFramebuffer( const FramebufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Framebuffer* pFramebuffer, Dispatch const &d) const
42975 {
42976 return static_cast<Result>( d.vkCreateFramebuffer( m_device, reinterpret_cast<const VkFramebufferCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkFramebuffer*>( pFramebuffer ) ) );
42977 }
42978#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
42979 template<typename Dispatch>
42981 {
42983 Result result = static_cast<Result>( d.vkCreateFramebuffer( m_device, reinterpret_cast<const VkFramebufferCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFramebuffer*>( &framebuffer ) ) );
42984 return createResultValue( result, framebuffer, VULKAN_HPP_NAMESPACE_STRING"::Device::createFramebuffer" );
42985 }
42986#ifndef VULKAN_HPP_NO_SMART_HANDLE
42987 template<typename Dispatch>
42989 {
42991 Result result = static_cast<Result>( d.vkCreateFramebuffer( m_device, reinterpret_cast<const VkFramebufferCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFramebuffer*>( &framebuffer ) ) );
42992
42993 ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
42994 return createResultValue<Framebuffer,Dispatch>( result, framebuffer, VULKAN_HPP_NAMESPACE_STRING"::Device::createFramebufferUnique", deleter );
42995 }
42996#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
42997#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
42998
42999 template<typename Dispatch>
43001 {
43002 d.vkDestroyFramebuffer( m_device, static_cast<VkFramebuffer>( framebuffer ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
43003 }
43004#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43005 template<typename Dispatch>
43007 {
43008 d.vkDestroyFramebuffer( m_device, static_cast<VkFramebuffer>( framebuffer ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
43009 }
43010#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43011
43012 template<typename Dispatch>
43013 VULKAN_HPP_INLINE void Device::destroy( Framebuffer framebuffer, const AllocationCallbacks* pAllocator, Dispatch const &d) const
43014 {
43015 d.vkDestroyFramebuffer( m_device, static_cast<VkFramebuffer>( framebuffer ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
43016 }
43017#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43018 template<typename Dispatch>
43020 {
43021 d.vkDestroyFramebuffer( m_device, static_cast<VkFramebuffer>( framebuffer ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
43022 }
43023#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43024
43025 template<typename Dispatch>
43026 VULKAN_HPP_INLINE Result Device::createRenderPass( const RenderPassCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, RenderPass* pRenderPass, Dispatch const &d) const
43027 {
43028 return static_cast<Result>( d.vkCreateRenderPass( m_device, reinterpret_cast<const VkRenderPassCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkRenderPass*>( pRenderPass ) ) );
43029 }
43030#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43031 template<typename Dispatch>
43033 {
43034 RenderPass renderPass;
43035 Result result = static_cast<Result>( d.vkCreateRenderPass( m_device, reinterpret_cast<const VkRenderPassCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkRenderPass*>( &renderPass ) ) );
43036 return createResultValue( result, renderPass, VULKAN_HPP_NAMESPACE_STRING"::Device::createRenderPass" );
43037 }
43038#ifndef VULKAN_HPP_NO_SMART_HANDLE
43039 template<typename Dispatch>
43041 {
43042 RenderPass renderPass;
43043 Result result = static_cast<Result>( d.vkCreateRenderPass( m_device, reinterpret_cast<const VkRenderPassCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkRenderPass*>( &renderPass ) ) );
43044
43045 ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
43046 return createResultValue<RenderPass,Dispatch>( result, renderPass, VULKAN_HPP_NAMESPACE_STRING"::Device::createRenderPassUnique", deleter );
43047 }
43048#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
43049#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43050
43051 template<typename Dispatch>
43052 VULKAN_HPP_INLINE void Device::destroyRenderPass( RenderPass renderPass, const AllocationCallbacks* pAllocator, Dispatch const &d) const
43053 {
43054 d.vkDestroyRenderPass( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
43055 }
43056#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43057 template<typename Dispatch>
43059 {
43060 d.vkDestroyRenderPass( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
43061 }
43062#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43063
43064 template<typename Dispatch>
43065 VULKAN_HPP_INLINE void Device::destroy( RenderPass renderPass, const AllocationCallbacks* pAllocator, Dispatch const &d) const
43066 {
43067 d.vkDestroyRenderPass( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
43068 }
43069#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43070 template<typename Dispatch>
43071 VULKAN_HPP_INLINE void Device::destroy( RenderPass renderPass, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
43072 {
43073 d.vkDestroyRenderPass( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
43074 }
43075#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43076
43077 template<typename Dispatch>
43078 VULKAN_HPP_INLINE void Device::getRenderAreaGranularity( RenderPass renderPass, Extent2D* pGranularity, Dispatch const &d) const
43079 {
43080 d.vkGetRenderAreaGranularity( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<VkExtent2D*>( pGranularity ) );
43081 }
43082#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43083 template<typename Dispatch>
43085 {
43086 Extent2D granularity;
43087 d.vkGetRenderAreaGranularity( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<VkExtent2D*>( &granularity ) );
43088 return granularity;
43089 }
43090#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43091
43092 template<typename Dispatch>
43093 VULKAN_HPP_INLINE Result Device::createCommandPool( const CommandPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, CommandPool* pCommandPool, Dispatch const &d) const
43094 {
43095 return static_cast<Result>( d.vkCreateCommandPool( m_device, reinterpret_cast<const VkCommandPoolCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkCommandPool*>( pCommandPool ) ) );
43096 }
43097#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43098 template<typename Dispatch>
43100 {
43101 CommandPool commandPool;
43102 Result result = static_cast<Result>( d.vkCreateCommandPool( m_device, reinterpret_cast<const VkCommandPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkCommandPool*>( &commandPool ) ) );
43103 return createResultValue( result, commandPool, VULKAN_HPP_NAMESPACE_STRING"::Device::createCommandPool" );
43104 }
43105#ifndef VULKAN_HPP_NO_SMART_HANDLE
43106 template<typename Dispatch>
43108 {
43109 CommandPool commandPool;
43110 Result result = static_cast<Result>( d.vkCreateCommandPool( m_device, reinterpret_cast<const VkCommandPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkCommandPool*>( &commandPool ) ) );
43111
43112 ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
43113 return createResultValue<CommandPool,Dispatch>( result, commandPool, VULKAN_HPP_NAMESPACE_STRING"::Device::createCommandPoolUnique", deleter );
43114 }
43115#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
43116#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43117
43118 template<typename Dispatch>
43119 VULKAN_HPP_INLINE void Device::destroyCommandPool( CommandPool commandPool, const AllocationCallbacks* pAllocator, Dispatch const &d) const
43120 {
43121 d.vkDestroyCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
43122 }
43123#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43124 template<typename Dispatch>
43126 {
43127 d.vkDestroyCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
43128 }
43129#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43130
43131 template<typename Dispatch>
43132 VULKAN_HPP_INLINE void Device::destroy( CommandPool commandPool, const AllocationCallbacks* pAllocator, Dispatch const &d) const
43133 {
43134 d.vkDestroyCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
43135 }
43136#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43137 template<typename Dispatch>
43138 VULKAN_HPP_INLINE void Device::destroy( CommandPool commandPool, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
43139 {
43140 d.vkDestroyCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
43141 }
43142#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43143
43144#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
43145 template<typename Dispatch>
43147 {
43148 return static_cast<Result>( d.vkResetCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolResetFlags>( flags ) ) );
43149 }
43150#else
43151 template<typename Dispatch>
43153 {
43154 Result result = static_cast<Result>( d.vkResetCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolResetFlags>( flags ) ) );
43155 return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::resetCommandPool" );
43156 }
43157#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43158
43159 template<typename Dispatch>
43160 VULKAN_HPP_INLINE Result Device::allocateCommandBuffers( const CommandBufferAllocateInfo* pAllocateInfo, CommandBuffer* pCommandBuffers, Dispatch const &d) const
43161 {
43162 return static_cast<Result>( d.vkAllocateCommandBuffers( m_device, reinterpret_cast<const VkCommandBufferAllocateInfo*>( pAllocateInfo ), reinterpret_cast<VkCommandBuffer*>( pCommandBuffers ) ) );
43163 }
43164#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43165 template <typename Allocator, typename Dispatch>
43167 {
43168 std::vector<CommandBuffer,Allocator> commandBuffers( allocateInfo.commandBufferCount );
43169 Result result = static_cast<Result>( d.vkAllocateCommandBuffers( m_device, reinterpret_cast<const VkCommandBufferAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkCommandBuffer*>( commandBuffers.data() ) ) );
43170 return createResultValue( result, commandBuffers, VULKAN_HPP_NAMESPACE_STRING"::Device::allocateCommandBuffers" );
43171 }
43172 template <typename Allocator, typename Dispatch>
43173 VULKAN_HPP_INLINE typename ResultValueType<std::vector<CommandBuffer,Allocator>>::type Device::allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const
43174 {
43175 std::vector<CommandBuffer,Allocator> commandBuffers( allocateInfo.commandBufferCount, vectorAllocator );
43176 Result result = static_cast<Result>( d.vkAllocateCommandBuffers( m_device, reinterpret_cast<const VkCommandBufferAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkCommandBuffer*>( commandBuffers.data() ) ) );
43177 return createResultValue( result, commandBuffers, VULKAN_HPP_NAMESPACE_STRING"::Device::allocateCommandBuffers" );
43178 }
43179#ifndef VULKAN_HPP_NO_SMART_HANDLE
43180 template <typename Allocator, typename Dispatch>
43182 {
43183 static_assert( sizeof( CommandBuffer ) <= sizeof( UniqueCommandBuffer ), "CommandBuffer is greater than UniqueCommandBuffer!" );
43184 std::vector<UniqueCommandBuffer, Allocator> commandBuffers;
43185 commandBuffers.reserve( allocateInfo.commandBufferCount );
43186 CommandBuffer* buffer = reinterpret_cast<CommandBuffer*>( reinterpret_cast<char*>( commandBuffers.data() ) + allocateInfo.commandBufferCount * ( sizeof( UniqueCommandBuffer ) - sizeof( CommandBuffer ) ) );
43187 Result result = static_cast<Result>(d.vkAllocateCommandBuffers( m_device, reinterpret_cast<const VkCommandBufferAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkCommandBuffer*>( buffer ) ) );
43188
43189 PoolFree<Device,CommandPool,Dispatch> deleter( *this, allocateInfo.commandPool, d );
43190 for ( size_t i=0 ; i<allocateInfo.commandBufferCount ; i++ )
43191 {
43192 commandBuffers.push_back( UniqueCommandBuffer( buffer[i], deleter ) );
43193 }
43194
43195 return createResultValue( result, commandBuffers, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique" );
43196 }
43197 template <typename Allocator, typename Dispatch>
43198 VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueHandle<CommandBuffer,Dispatch>,Allocator>>::type Device::allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, Allocator const& vectorAllocator, Dispatch const &d ) const
43199 {
43200 static_assert( sizeof( CommandBuffer ) <= sizeof( UniqueCommandBuffer ), "CommandBuffer is greater than UniqueCommandBuffer!" );
43201 std::vector<UniqueCommandBuffer, Allocator> commandBuffers;
43202 commandBuffers.reserve( allocateInfo.commandBufferCount );
43203 CommandBuffer* buffer = reinterpret_cast<CommandBuffer*>( reinterpret_cast<char*>( commandBuffers.data() ) + allocateInfo.commandBufferCount * ( sizeof( UniqueCommandBuffer ) - sizeof( CommandBuffer ) ) );
43204 Result result = static_cast<Result>(d.vkAllocateCommandBuffers( m_device, reinterpret_cast<const VkCommandBufferAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkCommandBuffer*>( buffer ) ) );
43205
43206 PoolFree<Device,CommandPool,Dispatch> deleter( *this, allocateInfo.commandPool, d );
43207 for ( size_t i=0 ; i<allocateInfo.commandBufferCount ; i++ )
43208 {
43209 commandBuffers.push_back( UniqueCommandBuffer( buffer[i], deleter ) );
43210 }
43211
43212 return createResultValue( result, commandBuffers, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique" );
43213 }
43214#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
43215#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43216
43217 template<typename Dispatch>
43218 VULKAN_HPP_INLINE void Device::freeCommandBuffers( CommandPool commandPool, uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers, Dispatch const &d) const
43219 {
43220 d.vkFreeCommandBuffers( m_device, static_cast<VkCommandPool>( commandPool ), commandBufferCount, reinterpret_cast<const VkCommandBuffer*>( pCommandBuffers ) );
43221 }
43222#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43223 template<typename Dispatch>
43224 VULKAN_HPP_INLINE void Device::freeCommandBuffers( CommandPool commandPool, ArrayProxy<const CommandBuffer> commandBuffers, Dispatch const &d ) const
43225 {
43226 d.vkFreeCommandBuffers( m_device, static_cast<VkCommandPool>( commandPool ), commandBuffers.size() , reinterpret_cast<const VkCommandBuffer*>( commandBuffers.data() ) );
43227 }
43228#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43229
43230 template<typename Dispatch>
43231 VULKAN_HPP_INLINE void Device::free( CommandPool commandPool, uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers, Dispatch const &d) const
43232 {
43233 d.vkFreeCommandBuffers( m_device, static_cast<VkCommandPool>( commandPool ), commandBufferCount, reinterpret_cast<const VkCommandBuffer*>( pCommandBuffers ) );
43234 }
43235#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43236 template<typename Dispatch>
43237 VULKAN_HPP_INLINE void Device::free( CommandPool commandPool, ArrayProxy<const CommandBuffer> commandBuffers, Dispatch const &d ) const
43238 {
43239 d.vkFreeCommandBuffers( m_device, static_cast<VkCommandPool>( commandPool ), commandBuffers.size() , reinterpret_cast<const VkCommandBuffer*>( commandBuffers.data() ) );
43240 }
43241#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43242
43243 template<typename Dispatch>
43244 VULKAN_HPP_INLINE Result Device::createSharedSwapchainsKHR( uint32_t swapchainCount, const SwapchainCreateInfoKHR* pCreateInfos, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchains, Dispatch const &d) const
43245 {
43246 return static_cast<Result>( d.vkCreateSharedSwapchainsKHR( m_device, swapchainCount, reinterpret_cast<const VkSwapchainCreateInfoKHR*>( pCreateInfos ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSwapchainKHR*>( pSwapchains ) ) );
43247 }
43248#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43249 template <typename Allocator, typename Dispatch>
43251 {
43252 std::vector<SwapchainKHR,Allocator> swapchains( createInfos.size() );
43253 Result result = static_cast<Result>( d.vkCreateSharedSwapchainsKHR( m_device, createInfos.size() , reinterpret_cast<const VkSwapchainCreateInfoKHR*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( swapchains.data() ) ) );
43254 return createResultValue( result, swapchains, VULKAN_HPP_NAMESPACE_STRING"::Device::createSharedSwapchainsKHR" );
43255 }
43256 template <typename Allocator, typename Dispatch>
43258 {
43259 std::vector<SwapchainKHR,Allocator> swapchains( createInfos.size(), vectorAllocator );
43260 Result result = static_cast<Result>( d.vkCreateSharedSwapchainsKHR( m_device, createInfos.size() , reinterpret_cast<const VkSwapchainCreateInfoKHR*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( swapchains.data() ) ) );
43261 return createResultValue( result, swapchains, VULKAN_HPP_NAMESPACE_STRING"::Device::createSharedSwapchainsKHR" );
43262 }
43263 template<typename Dispatch>
43265 {
43266 SwapchainKHR swapchain;
43267 Result result = static_cast<Result>( d.vkCreateSharedSwapchainsKHR( m_device, 1 , reinterpret_cast<const VkSwapchainCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( &swapchain ) ) );
43268 return createResultValue( result, swapchain, VULKAN_HPP_NAMESPACE_STRING"::Device::createSharedSwapchainKHR" );
43269 }
43270#ifndef VULKAN_HPP_NO_SMART_HANDLE
43271 template <typename Allocator, typename Dispatch>
43273 {
43274 static_assert( sizeof( SwapchainKHR ) <= sizeof( UniqueSwapchainKHR ), "SwapchainKHR is greater than UniqueSwapchainKHR!" );
43275 std::vector<UniqueSwapchainKHR, Allocator> swapchainKHRs;
43276 swapchainKHRs.reserve( createInfos.size() );
43277 SwapchainKHR* buffer = reinterpret_cast<SwapchainKHR*>( reinterpret_cast<char*>( swapchainKHRs.data() ) + createInfos.size() * ( sizeof( UniqueSwapchainKHR ) - sizeof( SwapchainKHR ) ) );
43278 Result result = static_cast<Result>(d.vkCreateSharedSwapchainsKHR( m_device, createInfos.size() , reinterpret_cast<const VkSwapchainCreateInfoKHR*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( buffer ) ) );
43279
43280 ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
43281 for ( size_t i=0 ; i<createInfos.size() ; i++ )
43282 {
43283 swapchainKHRs.push_back( UniqueSwapchainKHR( buffer[i], deleter ) );
43284 }
43285
43286 return createResultValue( result, swapchainKHRs, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" );
43287 }
43288 template <typename Allocator, typename Dispatch>
43290 {
43291 static_assert( sizeof( SwapchainKHR ) <= sizeof( UniqueSwapchainKHR ), "SwapchainKHR is greater than UniqueSwapchainKHR!" );
43292 std::vector<UniqueSwapchainKHR, Allocator> swapchainKHRs;
43293 swapchainKHRs.reserve( createInfos.size() );
43294 SwapchainKHR* buffer = reinterpret_cast<SwapchainKHR*>( reinterpret_cast<char*>( swapchainKHRs.data() ) + createInfos.size() * ( sizeof( UniqueSwapchainKHR ) - sizeof( SwapchainKHR ) ) );
43295 Result result = static_cast<Result>(d.vkCreateSharedSwapchainsKHR( m_device, createInfos.size() , reinterpret_cast<const VkSwapchainCreateInfoKHR*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( buffer ) ) );
43296
43297 ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
43298 for ( size_t i=0 ; i<createInfos.size() ; i++ )
43299 {
43300 swapchainKHRs.push_back( UniqueSwapchainKHR( buffer[i], deleter ) );
43301 }
43302
43303 return createResultValue( result, swapchainKHRs, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" );
43304 }
43305 template<typename Dispatch>
43307 {
43308 SwapchainKHR swapchain;
43309 Result result = static_cast<Result>( d.vkCreateSharedSwapchainsKHR( m_device, 1 , reinterpret_cast<const VkSwapchainCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( &swapchain ) ) );
43310
43311 ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
43312 return createResultValue<SwapchainKHR,Dispatch>( result, swapchain, VULKAN_HPP_NAMESPACE_STRING"::Device::createSharedSwapchainKHRUnique", deleter );
43313 }
43314#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
43315#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43316
43317 template<typename Dispatch>
43318 VULKAN_HPP_INLINE Result Device::createSwapchainKHR( const SwapchainCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchain, Dispatch const &d) const
43319 {
43320 return static_cast<Result>( d.vkCreateSwapchainKHR( m_device, reinterpret_cast<const VkSwapchainCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSwapchainKHR*>( pSwapchain ) ) );
43321 }
43322#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43323 template<typename Dispatch>
43325 {
43326 SwapchainKHR swapchain;
43327 Result result = static_cast<Result>( d.vkCreateSwapchainKHR( m_device, reinterpret_cast<const VkSwapchainCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( &swapchain ) ) );
43328 return createResultValue( result, swapchain, VULKAN_HPP_NAMESPACE_STRING"::Device::createSwapchainKHR" );
43329 }
43330#ifndef VULKAN_HPP_NO_SMART_HANDLE
43331 template<typename Dispatch>
43333 {
43334 SwapchainKHR swapchain;
43335 Result result = static_cast<Result>( d.vkCreateSwapchainKHR( m_device, reinterpret_cast<const VkSwapchainCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( &swapchain ) ) );
43336
43337 ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
43338 return createResultValue<SwapchainKHR,Dispatch>( result, swapchain, VULKAN_HPP_NAMESPACE_STRING"::Device::createSwapchainKHRUnique", deleter );
43339 }
43340#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
43341#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43342
43343 template<typename Dispatch>
43344 VULKAN_HPP_INLINE void Device::destroySwapchainKHR( SwapchainKHR swapchain, const AllocationCallbacks* pAllocator, Dispatch const &d) const
43345 {
43346 d.vkDestroySwapchainKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
43347 }
43348#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43349 template<typename Dispatch>
43351 {
43352 d.vkDestroySwapchainKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
43353 }
43354#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43355
43356 template<typename Dispatch>
43357 VULKAN_HPP_INLINE void Device::destroy( SwapchainKHR swapchain, const AllocationCallbacks* pAllocator, Dispatch const &d) const
43358 {
43359 d.vkDestroySwapchainKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
43360 }
43361#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43362 template<typename Dispatch>
43363 VULKAN_HPP_INLINE void Device::destroy( SwapchainKHR swapchain, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
43364 {
43365 d.vkDestroySwapchainKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
43366 }
43367#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43368
43369 template<typename Dispatch>
43370 VULKAN_HPP_INLINE Result Device::getSwapchainImagesKHR( SwapchainKHR swapchain, uint32_t* pSwapchainImageCount, Image* pSwapchainImages, Dispatch const &d) const
43371 {
43372 return static_cast<Result>( d.vkGetSwapchainImagesKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), pSwapchainImageCount, reinterpret_cast<VkImage*>( pSwapchainImages ) ) );
43373 }
43374#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43375 template <typename Allocator, typename Dispatch>
43377 {
43378 std::vector<Image,Allocator> swapchainImages;
43379 uint32_t swapchainImageCount;
43380 Result result;
43381 do
43382 {
43383 result = static_cast<Result>( d.vkGetSwapchainImagesKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), &swapchainImageCount, nullptr ) );
43384 if ( ( result == Result::eSuccess ) && swapchainImageCount )
43385 {
43386 swapchainImages.resize( swapchainImageCount );
43387 result = static_cast<Result>( d.vkGetSwapchainImagesKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), &swapchainImageCount, reinterpret_cast<VkImage*>( swapchainImages.data() ) ) );
43388 }
43389 } while ( result == Result::eIncomplete );
43390 VULKAN_HPP_ASSERT( swapchainImageCount <= swapchainImages.size() );
43391 swapchainImages.resize( swapchainImageCount );
43392 return createResultValue( result, swapchainImages, VULKAN_HPP_NAMESPACE_STRING"::Device::getSwapchainImagesKHR" );
43393 }
43394 template <typename Allocator, typename Dispatch>
43395 VULKAN_HPP_INLINE typename ResultValueType<std::vector<Image,Allocator>>::type Device::getSwapchainImagesKHR( SwapchainKHR swapchain, Allocator const& vectorAllocator, Dispatch const &d ) const
43396 {
43397 std::vector<Image,Allocator> swapchainImages( vectorAllocator );
43398 uint32_t swapchainImageCount;
43399 Result result;
43400 do
43401 {
43402 result = static_cast<Result>( d.vkGetSwapchainImagesKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), &swapchainImageCount, nullptr ) );
43403 if ( ( result == Result::eSuccess ) && swapchainImageCount )
43404 {
43405 swapchainImages.resize( swapchainImageCount );
43406 result = static_cast<Result>( d.vkGetSwapchainImagesKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), &swapchainImageCount, reinterpret_cast<VkImage*>( swapchainImages.data() ) ) );
43407 }
43408 } while ( result == Result::eIncomplete );
43409 VULKAN_HPP_ASSERT( swapchainImageCount <= swapchainImages.size() );
43410 swapchainImages.resize( swapchainImageCount );
43411 return createResultValue( result, swapchainImages, VULKAN_HPP_NAMESPACE_STRING"::Device::getSwapchainImagesKHR" );
43412 }
43413#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43414
43415 template<typename Dispatch>
43416 VULKAN_HPP_INLINE Result Device::acquireNextImageKHR( SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence, uint32_t* pImageIndex, Dispatch const &d) const
43417 {
43418 return static_cast<Result>( d.vkAcquireNextImageKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), timeout, static_cast<VkSemaphore>( semaphore ), static_cast<VkFence>( fence ), pImageIndex ) );
43419 }
43420#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43421 template<typename Dispatch>
43423 {
43424 uint32_t imageIndex;
43425 Result result = static_cast<Result>( d.vkAcquireNextImageKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), timeout, static_cast<VkSemaphore>( semaphore ), static_cast<VkFence>( fence ), &imageIndex ) );
43427 }
43428#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43429
43430 template<typename Dispatch>
43432 {
43433 return static_cast<Result>( d.vkDebugMarkerSetObjectNameEXT( m_device, reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT*>( pNameInfo ) ) );
43434 }
43435#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43436 template<typename Dispatch>
43438 {
43439 Result result = static_cast<Result>( d.vkDebugMarkerSetObjectNameEXT( m_device, reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT*>( &nameInfo ) ) );
43440 return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::debugMarkerSetObjectNameEXT" );
43441 }
43442#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43443
43444 template<typename Dispatch>
43446 {
43447 return static_cast<Result>( d.vkDebugMarkerSetObjectTagEXT( m_device, reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT*>( pTagInfo ) ) );
43448 }
43449#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43450 template<typename Dispatch>
43452 {
43453 Result result = static_cast<Result>( d.vkDebugMarkerSetObjectTagEXT( m_device, reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT*>( &tagInfo ) ) );
43454 return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::debugMarkerSetObjectTagEXT" );
43455 }
43456#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43457
43458#ifdef VK_USE_PLATFORM_WIN32_NV
43459 template<typename Dispatch>
43460 VULKAN_HPP_INLINE Result Device::getMemoryWin32HandleNV( DeviceMemory memory, ExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle, Dispatch const &d) const
43461 {
43462 return static_cast<Result>( d.vkGetMemoryWin32HandleNV( m_device, static_cast<VkDeviceMemory>( memory ), static_cast<VkExternalMemoryHandleTypeFlagsNV>( handleType ), pHandle ) );
43463 }
43464#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43465 template<typename Dispatch>
43466 VULKAN_HPP_INLINE ResultValueType<HANDLE>::type Device::getMemoryWin32HandleNV( DeviceMemory memory, ExternalMemoryHandleTypeFlagsNV handleType, Dispatch const &d ) const
43467 {
43468 HANDLE handle;
43469 Result result = static_cast<Result>( d.vkGetMemoryWin32HandleNV( m_device, static_cast<VkDeviceMemory>( memory ), static_cast<VkExternalMemoryHandleTypeFlagsNV>( handleType ), &handle ) );
43470 return createResultValue( result, handle, VULKAN_HPP_NAMESPACE_STRING"::Device::getMemoryWin32HandleNV" );
43471 }
43472#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43473#endif /*VK_USE_PLATFORM_WIN32_NV*/
43474
43475 template<typename Dispatch>
43477 {
43478 return static_cast<Result>( d.vkCreateIndirectCommandsLayoutNVX( m_device, reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNVX*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkIndirectCommandsLayoutNVX*>( pIndirectCommandsLayout ) ) );
43479 }
43480#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43481 template<typename Dispatch>
43483 {
43484 IndirectCommandsLayoutNVX indirectCommandsLayout;
43485 Result result = static_cast<Result>( d.vkCreateIndirectCommandsLayoutNVX( m_device, reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNVX*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkIndirectCommandsLayoutNVX*>( &indirectCommandsLayout ) ) );
43486 return createResultValue( result, indirectCommandsLayout, VULKAN_HPP_NAMESPACE_STRING"::Device::createIndirectCommandsLayoutNVX" );
43487 }
43488#ifndef VULKAN_HPP_NO_SMART_HANDLE
43489 template<typename Dispatch>
43491 {
43492 IndirectCommandsLayoutNVX indirectCommandsLayout;
43493 Result result = static_cast<Result>( d.vkCreateIndirectCommandsLayoutNVX( m_device, reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNVX*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkIndirectCommandsLayoutNVX*>( &indirectCommandsLayout ) ) );
43494
43495 ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
43496 return createResultValue<IndirectCommandsLayoutNVX,Dispatch>( result, indirectCommandsLayout, VULKAN_HPP_NAMESPACE_STRING"::Device::createIndirectCommandsLayoutNVXUnique", deleter );
43497 }
43498#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
43499#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43500
43501 template<typename Dispatch>
43502 VULKAN_HPP_INLINE void Device::destroyIndirectCommandsLayoutNVX( IndirectCommandsLayoutNVX indirectCommandsLayout, const AllocationCallbacks* pAllocator, Dispatch const &d) const
43503 {
43504 d.vkDestroyIndirectCommandsLayoutNVX( m_device, static_cast<VkIndirectCommandsLayoutNVX>( indirectCommandsLayout ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
43505 }
43506#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43507 template<typename Dispatch>
43509 {
43510 d.vkDestroyIndirectCommandsLayoutNVX( m_device, static_cast<VkIndirectCommandsLayoutNVX>( indirectCommandsLayout ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
43511 }
43512#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43513
43514 template<typename Dispatch>
43515 VULKAN_HPP_INLINE void Device::destroy( IndirectCommandsLayoutNVX indirectCommandsLayout, const AllocationCallbacks* pAllocator, Dispatch const &d) const
43516 {
43517 d.vkDestroyIndirectCommandsLayoutNVX( m_device, static_cast<VkIndirectCommandsLayoutNVX>( indirectCommandsLayout ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
43518 }
43519#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43520 template<typename Dispatch>
43521 VULKAN_HPP_INLINE void Device::destroy( IndirectCommandsLayoutNVX indirectCommandsLayout, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
43522 {
43523 d.vkDestroyIndirectCommandsLayoutNVX( m_device, static_cast<VkIndirectCommandsLayoutNVX>( indirectCommandsLayout ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
43524 }
43525#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43526
43527 template<typename Dispatch>
43528 VULKAN_HPP_INLINE Result Device::createObjectTableNVX( const ObjectTableCreateInfoNVX* pCreateInfo, const AllocationCallbacks* pAllocator, ObjectTableNVX* pObjectTable, Dispatch const &d) const
43529 {
43530 return static_cast<Result>( d.vkCreateObjectTableNVX( m_device, reinterpret_cast<const VkObjectTableCreateInfoNVX*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkObjectTableNVX*>( pObjectTable ) ) );
43531 }
43532#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43533 template<typename Dispatch>
43535 {
43536 ObjectTableNVX objectTable;
43537 Result result = static_cast<Result>( d.vkCreateObjectTableNVX( m_device, reinterpret_cast<const VkObjectTableCreateInfoNVX*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkObjectTableNVX*>( &objectTable ) ) );
43538 return createResultValue( result, objectTable, VULKAN_HPP_NAMESPACE_STRING"::Device::createObjectTableNVX" );
43539 }
43540#ifndef VULKAN_HPP_NO_SMART_HANDLE
43541 template<typename Dispatch>
43543 {
43544 ObjectTableNVX objectTable;
43545 Result result = static_cast<Result>( d.vkCreateObjectTableNVX( m_device, reinterpret_cast<const VkObjectTableCreateInfoNVX*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkObjectTableNVX*>( &objectTable ) ) );
43546
43547 ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
43548 return createResultValue<ObjectTableNVX,Dispatch>( result, objectTable, VULKAN_HPP_NAMESPACE_STRING"::Device::createObjectTableNVXUnique", deleter );
43549 }
43550#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
43551#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43552
43553 template<typename Dispatch>
43554 VULKAN_HPP_INLINE void Device::destroyObjectTableNVX( ObjectTableNVX objectTable, const AllocationCallbacks* pAllocator, Dispatch const &d) const
43555 {
43556 d.vkDestroyObjectTableNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
43557 }
43558#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43559 template<typename Dispatch>
43561 {
43562 d.vkDestroyObjectTableNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
43563 }
43564#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43565
43566 template<typename Dispatch>
43567 VULKAN_HPP_INLINE void Device::destroy( ObjectTableNVX objectTable, const AllocationCallbacks* pAllocator, Dispatch const &d) const
43568 {
43569 d.vkDestroyObjectTableNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
43570 }
43571#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43572 template<typename Dispatch>
43573 VULKAN_HPP_INLINE void Device::destroy( ObjectTableNVX objectTable, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
43574 {
43575 d.vkDestroyObjectTableNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
43576 }
43577#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43578
43579 template<typename Dispatch>
43580 VULKAN_HPP_INLINE Result Device::registerObjectsNVX( ObjectTableNVX objectTable, uint32_t objectCount, const ObjectTableEntryNVX* const* ppObjectTableEntries, const uint32_t* pObjectIndices, Dispatch const &d) const
43581 {
43582 return static_cast<Result>( d.vkRegisterObjectsNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), objectCount, reinterpret_cast<const VkObjectTableEntryNVX* const*>( ppObjectTableEntries ), pObjectIndices ) );
43583 }
43584#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43585 template<typename Dispatch>
43587 {
43588#ifdef VULKAN_HPP_NO_EXCEPTIONS
43589 VULKAN_HPP_ASSERT( pObjectTableEntries.size() == objectIndices.size() );
43590#else
43591 if ( pObjectTableEntries.size() != objectIndices.size() )
43592 {
43593 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::registerObjectsNVX: pObjectTableEntries.size() != objectIndices.size()" );
43594 }
43595#endif // VULKAN_HPP_NO_EXCEPTIONS
43596 Result result = static_cast<Result>( d.vkRegisterObjectsNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), pObjectTableEntries.size() , reinterpret_cast<const VkObjectTableEntryNVX* const*>( pObjectTableEntries.data() ), objectIndices.data() ) );
43597 return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::registerObjectsNVX" );
43598 }
43599#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43600
43601 template<typename Dispatch>
43602 VULKAN_HPP_INLINE Result Device::unregisterObjectsNVX( ObjectTableNVX objectTable, uint32_t objectCount, const ObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices, Dispatch const &d) const
43603 {
43604 return static_cast<Result>( d.vkUnregisterObjectsNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), objectCount, reinterpret_cast<const VkObjectEntryTypeNVX*>( pObjectEntryTypes ), pObjectIndices ) );
43605 }
43606#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43607 template<typename Dispatch>
43609 {
43610#ifdef VULKAN_HPP_NO_EXCEPTIONS
43611 VULKAN_HPP_ASSERT( objectEntryTypes.size() == objectIndices.size() );
43612#else
43613 if ( objectEntryTypes.size() != objectIndices.size() )
43614 {
43615 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::unregisterObjectsNVX: objectEntryTypes.size() != objectIndices.size()" );
43616 }
43617#endif // VULKAN_HPP_NO_EXCEPTIONS
43618 Result result = static_cast<Result>( d.vkUnregisterObjectsNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), objectEntryTypes.size() , reinterpret_cast<const VkObjectEntryTypeNVX*>( objectEntryTypes.data() ), objectIndices.data() ) );
43619 return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::unregisterObjectsNVX" );
43620 }
43621#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43622
43623#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
43624 template<typename Dispatch>
43625 VULKAN_HPP_INLINE void Device::trimCommandPool( CommandPool commandPool, CommandPoolTrimFlags flags, Dispatch const &d) const
43626 {
43627 d.vkTrimCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolTrimFlags>( flags ) );
43628 }
43629#else
43630 template<typename Dispatch>
43632 {
43633 d.vkTrimCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolTrimFlags>( flags ) );
43634 }
43635#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43636
43637#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
43638 template<typename Dispatch>
43639 VULKAN_HPP_INLINE void Device::trimCommandPoolKHR( CommandPool commandPool, CommandPoolTrimFlags flags, Dispatch const &d) const
43640 {
43641 d.vkTrimCommandPoolKHR( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolTrimFlags>( flags ) );
43642 }
43643#else
43644 template<typename Dispatch>
43646 {
43647 d.vkTrimCommandPoolKHR( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolTrimFlags>( flags ) );
43648 }
43649#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43650
43651#ifdef VK_USE_PLATFORM_WIN32_KHR
43652 template<typename Dispatch>
43653 VULKAN_HPP_INLINE Result Device::getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d) const
43654 {
43655 return static_cast<Result>( d.vkGetMemoryWin32HandleKHR( m_device, reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR*>( pGetWin32HandleInfo ), pHandle ) );
43656 }
43657#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43658 template<typename Dispatch>
43659 VULKAN_HPP_INLINE ResultValueType<HANDLE>::type Device::getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const &d ) const
43660 {
43661 HANDLE handle;
43662 Result result = static_cast<Result>( d.vkGetMemoryWin32HandleKHR( m_device, reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR*>( &getWin32HandleInfo ), &handle ) );
43663 return createResultValue( result, handle, VULKAN_HPP_NAMESPACE_STRING"::Device::getMemoryWin32HandleKHR" );
43664 }
43665#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43666#endif /*VK_USE_PLATFORM_WIN32_KHR*/
43667
43668#ifdef VK_USE_PLATFORM_WIN32_KHR
43669 template<typename Dispatch>
43670 VULKAN_HPP_INLINE Result Device::getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, MemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties, Dispatch const &d) const
43671 {
43672 return static_cast<Result>( d.vkGetMemoryWin32HandlePropertiesKHR( m_device, static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), handle, reinterpret_cast<VkMemoryWin32HandlePropertiesKHR*>( pMemoryWin32HandleProperties ) ) );
43673 }
43674#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43675 template<typename Dispatch>
43676 VULKAN_HPP_INLINE ResultValueType<MemoryWin32HandlePropertiesKHR>::type Device::getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, Dispatch const &d ) const
43677 {
43678 MemoryWin32HandlePropertiesKHR memoryWin32HandleProperties;
43679 Result result = static_cast<Result>( d.vkGetMemoryWin32HandlePropertiesKHR( m_device, static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), handle, reinterpret_cast<VkMemoryWin32HandlePropertiesKHR*>( &memoryWin32HandleProperties ) ) );
43680 return createResultValue( result, memoryWin32HandleProperties, VULKAN_HPP_NAMESPACE_STRING"::Device::getMemoryWin32HandlePropertiesKHR" );
43681 }
43682#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43683#endif /*VK_USE_PLATFORM_WIN32_KHR*/
43684
43685 template<typename Dispatch>
43686 VULKAN_HPP_INLINE Result Device::getMemoryFdKHR( const MemoryGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d) const
43687 {
43688 return static_cast<Result>( d.vkGetMemoryFdKHR( m_device, reinterpret_cast<const VkMemoryGetFdInfoKHR*>( pGetFdInfo ), pFd ) );
43689 }
43690#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43691 template<typename Dispatch>
43693 {
43694 int fd;
43695 Result result = static_cast<Result>( d.vkGetMemoryFdKHR( m_device, reinterpret_cast<const VkMemoryGetFdInfoKHR*>( &getFdInfo ), &fd ) );
43696 return createResultValue( result, fd, VULKAN_HPP_NAMESPACE_STRING"::Device::getMemoryFdKHR" );
43697 }
43698#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43699
43700 template<typename Dispatch>
43702 {
43703 return static_cast<Result>( d.vkGetMemoryFdPropertiesKHR( m_device, static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), fd, reinterpret_cast<VkMemoryFdPropertiesKHR*>( pMemoryFdProperties ) ) );
43704 }
43705#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43706 template<typename Dispatch>
43708 {
43709 MemoryFdPropertiesKHR memoryFdProperties;
43710 Result result = static_cast<Result>( d.vkGetMemoryFdPropertiesKHR( m_device, static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), fd, reinterpret_cast<VkMemoryFdPropertiesKHR*>( &memoryFdProperties ) ) );
43711 return createResultValue( result, memoryFdProperties, VULKAN_HPP_NAMESPACE_STRING"::Device::getMemoryFdPropertiesKHR" );
43712 }
43713#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43714
43715#ifdef VK_USE_PLATFORM_WIN32_KHR
43716 template<typename Dispatch>
43717 VULKAN_HPP_INLINE Result Device::getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d) const
43718 {
43719 return static_cast<Result>( d.vkGetSemaphoreWin32HandleKHR( m_device, reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR*>( pGetWin32HandleInfo ), pHandle ) );
43720 }
43721#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43722 template<typename Dispatch>
43723 VULKAN_HPP_INLINE ResultValueType<HANDLE>::type Device::getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const &d ) const
43724 {
43725 HANDLE handle;
43726 Result result = static_cast<Result>( d.vkGetSemaphoreWin32HandleKHR( m_device, reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR*>( &getWin32HandleInfo ), &handle ) );
43727 return createResultValue( result, handle, VULKAN_HPP_NAMESPACE_STRING"::Device::getSemaphoreWin32HandleKHR" );
43728 }
43729#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43730#endif /*VK_USE_PLATFORM_WIN32_KHR*/
43731
43732#ifdef VK_USE_PLATFORM_WIN32_KHR
43733 template<typename Dispatch>
43734 VULKAN_HPP_INLINE Result Device::importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo, Dispatch const &d) const
43735 {
43736 return static_cast<Result>( d.vkImportSemaphoreWin32HandleKHR( m_device, reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR*>( pImportSemaphoreWin32HandleInfo ) ) );
43737 }
43738#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43739 template<typename Dispatch>
43740 VULKAN_HPP_INLINE ResultValueType<void>::type Device::importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo, Dispatch const &d ) const
43741 {
43742 Result result = static_cast<Result>( d.vkImportSemaphoreWin32HandleKHR( m_device, reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR*>( &importSemaphoreWin32HandleInfo ) ) );
43743 return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::importSemaphoreWin32HandleKHR" );
43744 }
43745#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43746#endif /*VK_USE_PLATFORM_WIN32_KHR*/
43747
43748 template<typename Dispatch>
43749 VULKAN_HPP_INLINE Result Device::getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d) const
43750 {
43751 return static_cast<Result>( d.vkGetSemaphoreFdKHR( m_device, reinterpret_cast<const VkSemaphoreGetFdInfoKHR*>( pGetFdInfo ), pFd ) );
43752 }
43753#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43754 template<typename Dispatch>
43756 {
43757 int fd;
43758 Result result = static_cast<Result>( d.vkGetSemaphoreFdKHR( m_device, reinterpret_cast<const VkSemaphoreGetFdInfoKHR*>( &getFdInfo ), &fd ) );
43759 return createResultValue( result, fd, VULKAN_HPP_NAMESPACE_STRING"::Device::getSemaphoreFdKHR" );
43760 }
43761#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43762
43763 template<typename Dispatch>
43764 VULKAN_HPP_INLINE Result Device::importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo, Dispatch const &d) const
43765 {
43766 return static_cast<Result>( d.vkImportSemaphoreFdKHR( m_device, reinterpret_cast<const VkImportSemaphoreFdInfoKHR*>( pImportSemaphoreFdInfo ) ) );
43767 }
43768#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43769 template<typename Dispatch>
43771 {
43772 Result result = static_cast<Result>( d.vkImportSemaphoreFdKHR( m_device, reinterpret_cast<const VkImportSemaphoreFdInfoKHR*>( &importSemaphoreFdInfo ) ) );
43773 return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::importSemaphoreFdKHR" );
43774 }
43775#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43776
43777#ifdef VK_USE_PLATFORM_WIN32_KHR
43778 template<typename Dispatch>
43779 VULKAN_HPP_INLINE Result Device::getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle, Dispatch const &d) const
43780 {
43781 return static_cast<Result>( d.vkGetFenceWin32HandleKHR( m_device, reinterpret_cast<const VkFenceGetWin32HandleInfoKHR*>( pGetWin32HandleInfo ), pHandle ) );
43782 }
43783#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43784 template<typename Dispatch>
43785 VULKAN_HPP_INLINE ResultValueType<HANDLE>::type Device::getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const &d ) const
43786 {
43787 HANDLE handle;
43788 Result result = static_cast<Result>( d.vkGetFenceWin32HandleKHR( m_device, reinterpret_cast<const VkFenceGetWin32HandleInfoKHR*>( &getWin32HandleInfo ), &handle ) );
43789 return createResultValue( result, handle, VULKAN_HPP_NAMESPACE_STRING"::Device::getFenceWin32HandleKHR" );
43790 }
43791#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43792#endif /*VK_USE_PLATFORM_WIN32_KHR*/
43793
43794#ifdef VK_USE_PLATFORM_WIN32_KHR
43795 template<typename Dispatch>
43796 VULKAN_HPP_INLINE Result Device::importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo, Dispatch const &d) const
43797 {
43798 return static_cast<Result>( d.vkImportFenceWin32HandleKHR( m_device, reinterpret_cast<const VkImportFenceWin32HandleInfoKHR*>( pImportFenceWin32HandleInfo ) ) );
43799 }
43800#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43801 template<typename Dispatch>
43802 VULKAN_HPP_INLINE ResultValueType<void>::type Device::importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo, Dispatch const &d ) const
43803 {
43804 Result result = static_cast<Result>( d.vkImportFenceWin32HandleKHR( m_device, reinterpret_cast<const VkImportFenceWin32HandleInfoKHR*>( &importFenceWin32HandleInfo ) ) );
43805 return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::importFenceWin32HandleKHR" );
43806 }
43807#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43808#endif /*VK_USE_PLATFORM_WIN32_KHR*/
43809
43810 template<typename Dispatch>
43811 VULKAN_HPP_INLINE Result Device::getFenceFdKHR( const FenceGetFdInfoKHR* pGetFdInfo, int* pFd, Dispatch const &d) const
43812 {
43813 return static_cast<Result>( d.vkGetFenceFdKHR( m_device, reinterpret_cast<const VkFenceGetFdInfoKHR*>( pGetFdInfo ), pFd ) );
43814 }
43815#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43816 template<typename Dispatch>
43818 {
43819 int fd;
43820 Result result = static_cast<Result>( d.vkGetFenceFdKHR( m_device, reinterpret_cast<const VkFenceGetFdInfoKHR*>( &getFdInfo ), &fd ) );
43821 return createResultValue( result, fd, VULKAN_HPP_NAMESPACE_STRING"::Device::getFenceFdKHR" );
43822 }
43823#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43824
43825 template<typename Dispatch>
43826 VULKAN_HPP_INLINE Result Device::importFenceFdKHR( const ImportFenceFdInfoKHR* pImportFenceFdInfo, Dispatch const &d) const
43827 {
43828 return static_cast<Result>( d.vkImportFenceFdKHR( m_device, reinterpret_cast<const VkImportFenceFdInfoKHR*>( pImportFenceFdInfo ) ) );
43829 }
43830#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43831 template<typename Dispatch>
43833 {
43834 Result result = static_cast<Result>( d.vkImportFenceFdKHR( m_device, reinterpret_cast<const VkImportFenceFdInfoKHR*>( &importFenceFdInfo ) ) );
43835 return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::importFenceFdKHR" );
43836 }
43837#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43838
43839 template<typename Dispatch>
43840 VULKAN_HPP_INLINE Result Device::displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT* pDisplayPowerInfo, Dispatch const &d) const
43841 {
43842 return static_cast<Result>( d.vkDisplayPowerControlEXT( m_device, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayPowerInfoEXT*>( pDisplayPowerInfo ) ) );
43843 }
43844#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43845 template<typename Dispatch>
43847 {
43848 Result result = static_cast<Result>( d.vkDisplayPowerControlEXT( m_device, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayPowerInfoEXT*>( &displayPowerInfo ) ) );
43849 return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::displayPowerControlEXT" );
43850 }
43851#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43852
43853 template<typename Dispatch>
43854 VULKAN_HPP_INLINE Result Device::registerEventEXT( const DeviceEventInfoEXT* pDeviceEventInfo, const AllocationCallbacks* pAllocator, Fence* pFence, Dispatch const &d) const
43855 {
43856 return static_cast<Result>( d.vkRegisterDeviceEventEXT( m_device, reinterpret_cast<const VkDeviceEventInfoEXT*>( pDeviceEventInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkFence*>( pFence ) ) );
43857 }
43858#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43859 template<typename Dispatch>
43861 {
43862 Fence fence;
43863 Result result = static_cast<Result>( d.vkRegisterDeviceEventEXT( m_device, reinterpret_cast<const VkDeviceEventInfoEXT*>( &deviceEventInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFence*>( &fence ) ) );
43864 return createResultValue( result, fence, VULKAN_HPP_NAMESPACE_STRING"::Device::registerEventEXT" );
43865 }
43866#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43867
43868 template<typename Dispatch>
43869 VULKAN_HPP_INLINE Result Device::registerDisplayEventEXT( DisplayKHR display, const DisplayEventInfoEXT* pDisplayEventInfo, const AllocationCallbacks* pAllocator, Fence* pFence, Dispatch const &d) const
43870 {
43871 return static_cast<Result>( d.vkRegisterDisplayEventEXT( m_device, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayEventInfoEXT*>( pDisplayEventInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkFence*>( pFence ) ) );
43872 }
43873#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43874 template<typename Dispatch>
43876 {
43877 Fence fence;
43878 Result result = static_cast<Result>( d.vkRegisterDisplayEventEXT( m_device, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayEventInfoEXT*>( &displayEventInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFence*>( &fence ) ) );
43879 return createResultValue( result, fence, VULKAN_HPP_NAMESPACE_STRING"::Device::registerDisplayEventEXT" );
43880 }
43881#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43882
43883 template<typename Dispatch>
43885 {
43886 return static_cast<Result>( d.vkGetSwapchainCounterEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ), static_cast<VkSurfaceCounterFlagBitsEXT>( counter ), pCounterValue ) );
43887 }
43888#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43889 template<typename Dispatch>
43891 {
43892 uint64_t counterValue;
43893 Result result = static_cast<Result>( d.vkGetSwapchainCounterEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ), static_cast<VkSurfaceCounterFlagBitsEXT>( counter ), &counterValue ) );
43894 return createResultValue( result, counterValue, VULKAN_HPP_NAMESPACE_STRING"::Device::getSwapchainCounterEXT" );
43895 }
43896#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43897
43898 template<typename Dispatch>
43899 VULKAN_HPP_INLINE void Device::getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, PeerMemoryFeatureFlags* pPeerMemoryFeatures, Dispatch const &d) const
43900 {
43901 d.vkGetDeviceGroupPeerMemoryFeatures( m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlags*>( pPeerMemoryFeatures ) );
43902 }
43903#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43904 template<typename Dispatch>
43905 VULKAN_HPP_INLINE PeerMemoryFeatureFlags Device::getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d ) const
43906 {
43907 PeerMemoryFeatureFlags peerMemoryFeatures;
43908 d.vkGetDeviceGroupPeerMemoryFeatures( m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlags*>( &peerMemoryFeatures ) );
43909 return peerMemoryFeatures;
43910 }
43911#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43912
43913 template<typename Dispatch>
43914 VULKAN_HPP_INLINE void Device::getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, PeerMemoryFeatureFlags* pPeerMemoryFeatures, Dispatch const &d) const
43915 {
43916 d.vkGetDeviceGroupPeerMemoryFeaturesKHR( m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlags*>( pPeerMemoryFeatures ) );
43917 }
43918#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43919 template<typename Dispatch>
43920 VULKAN_HPP_INLINE PeerMemoryFeatureFlags Device::getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d ) const
43921 {
43922 PeerMemoryFeatureFlags peerMemoryFeatures;
43923 d.vkGetDeviceGroupPeerMemoryFeaturesKHR( m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlags*>( &peerMemoryFeatures ) );
43924 return peerMemoryFeatures;
43925 }
43926#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43927
43928 template<typename Dispatch>
43929 VULKAN_HPP_INLINE Result Device::bindBufferMemory2( uint32_t bindInfoCount, const BindBufferMemoryInfo* pBindInfos, Dispatch const &d) const
43930 {
43931 return static_cast<Result>( d.vkBindBufferMemory2( m_device, bindInfoCount, reinterpret_cast<const VkBindBufferMemoryInfo*>( pBindInfos ) ) );
43932 }
43933#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43934 template<typename Dispatch>
43936 {
43937 Result result = static_cast<Result>( d.vkBindBufferMemory2( m_device, bindInfos.size() , reinterpret_cast<const VkBindBufferMemoryInfo*>( bindInfos.data() ) ) );
43938 return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindBufferMemory2" );
43939 }
43940#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43941
43942 template<typename Dispatch>
43943 VULKAN_HPP_INLINE Result Device::bindBufferMemory2KHR( uint32_t bindInfoCount, const BindBufferMemoryInfo* pBindInfos, Dispatch const &d) const
43944 {
43945 return static_cast<Result>( d.vkBindBufferMemory2KHR( m_device, bindInfoCount, reinterpret_cast<const VkBindBufferMemoryInfo*>( pBindInfos ) ) );
43946 }
43947#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43948 template<typename Dispatch>
43950 {
43951 Result result = static_cast<Result>( d.vkBindBufferMemory2KHR( m_device, bindInfos.size() , reinterpret_cast<const VkBindBufferMemoryInfo*>( bindInfos.data() ) ) );
43952 return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindBufferMemory2KHR" );
43953 }
43954#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43955
43956 template<typename Dispatch>
43957 VULKAN_HPP_INLINE Result Device::bindImageMemory2( uint32_t bindInfoCount, const BindImageMemoryInfo* pBindInfos, Dispatch const &d) const
43958 {
43959 return static_cast<Result>( d.vkBindImageMemory2( m_device, bindInfoCount, reinterpret_cast<const VkBindImageMemoryInfo*>( pBindInfos ) ) );
43960 }
43961#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43962 template<typename Dispatch>
43964 {
43965 Result result = static_cast<Result>( d.vkBindImageMemory2( m_device, bindInfos.size() , reinterpret_cast<const VkBindImageMemoryInfo*>( bindInfos.data() ) ) );
43966 return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindImageMemory2" );
43967 }
43968#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43969
43970 template<typename Dispatch>
43971 VULKAN_HPP_INLINE Result Device::bindImageMemory2KHR( uint32_t bindInfoCount, const BindImageMemoryInfo* pBindInfos, Dispatch const &d) const
43972 {
43973 return static_cast<Result>( d.vkBindImageMemory2KHR( m_device, bindInfoCount, reinterpret_cast<const VkBindImageMemoryInfo*>( pBindInfos ) ) );
43974 }
43975#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43976 template<typename Dispatch>
43978 {
43979 Result result = static_cast<Result>( d.vkBindImageMemory2KHR( m_device, bindInfos.size() , reinterpret_cast<const VkBindImageMemoryInfo*>( bindInfos.data() ) ) );
43980 return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindImageMemory2KHR" );
43981 }
43982#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43983
43984 template<typename Dispatch>
43986 {
43987 return static_cast<Result>( d.vkGetDeviceGroupPresentCapabilitiesKHR( m_device, reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR*>( pDeviceGroupPresentCapabilities ) ) );
43988 }
43989#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
43990 template<typename Dispatch>
43992 {
43993 DeviceGroupPresentCapabilitiesKHR deviceGroupPresentCapabilities;
43994 Result result = static_cast<Result>( d.vkGetDeviceGroupPresentCapabilitiesKHR( m_device, reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR*>( &deviceGroupPresentCapabilities ) ) );
43995 return createResultValue( result, deviceGroupPresentCapabilities, VULKAN_HPP_NAMESPACE_STRING"::Device::getGroupPresentCapabilitiesKHR" );
43996 }
43997#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
43998
43999 template<typename Dispatch>
44001 {
44002 return static_cast<Result>( d.vkGetDeviceGroupSurfacePresentModesKHR( m_device, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR*>( pModes ) ) );
44003 }
44004#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44005 template<typename Dispatch>
44007 {
44009 Result result = static_cast<Result>( d.vkGetDeviceGroupSurfacePresentModesKHR( m_device, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR*>( &modes ) ) );
44010 return createResultValue( result, modes, VULKAN_HPP_NAMESPACE_STRING"::Device::getGroupSurfacePresentModesKHR" );
44011 }
44012#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44013
44014 template<typename Dispatch>
44015 VULKAN_HPP_INLINE Result Device::acquireNextImage2KHR( const AcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex, Dispatch const &d) const
44016 {
44017 return static_cast<Result>( d.vkAcquireNextImage2KHR( m_device, reinterpret_cast<const VkAcquireNextImageInfoKHR*>( pAcquireInfo ), pImageIndex ) );
44018 }
44019#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44020 template<typename Dispatch>
44022 {
44023 uint32_t imageIndex;
44024 Result result = static_cast<Result>( d.vkAcquireNextImage2KHR( m_device, reinterpret_cast<const VkAcquireNextImageInfoKHR*>( &acquireInfo ), &imageIndex ) );
44026 }
44027#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44028
44029 template<typename Dispatch>
44030 VULKAN_HPP_INLINE Result Device::createDescriptorUpdateTemplate( const DescriptorUpdateTemplateCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorUpdateTemplate* pDescriptorUpdateTemplate, Dispatch const &d) const
44031 {
44032 return static_cast<Result>( d.vkCreateDescriptorUpdateTemplate( m_device, reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDescriptorUpdateTemplate*>( pDescriptorUpdateTemplate ) ) );
44033 }
44034#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44035 template<typename Dispatch>
44037 {
44038 DescriptorUpdateTemplate descriptorUpdateTemplate;
44039 Result result = static_cast<Result>( d.vkCreateDescriptorUpdateTemplate( m_device, reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorUpdateTemplate*>( &descriptorUpdateTemplate ) ) );
44040 return createResultValue( result, descriptorUpdateTemplate, VULKAN_HPP_NAMESPACE_STRING"::Device::createDescriptorUpdateTemplate" );
44041 }
44042#ifndef VULKAN_HPP_NO_SMART_HANDLE
44043 template<typename Dispatch>
44045 {
44046 DescriptorUpdateTemplate descriptorUpdateTemplate;
44047 Result result = static_cast<Result>( d.vkCreateDescriptorUpdateTemplate( m_device, reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorUpdateTemplate*>( &descriptorUpdateTemplate ) ) );
44048
44049 ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
44050 return createResultValue<DescriptorUpdateTemplate,Dispatch>( result, descriptorUpdateTemplate, VULKAN_HPP_NAMESPACE_STRING"::Device::createDescriptorUpdateTemplateUnique", deleter );
44051 }
44052#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
44053#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44054
44055 template<typename Dispatch>
44056 VULKAN_HPP_INLINE Result Device::createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorUpdateTemplate* pDescriptorUpdateTemplate, Dispatch const &d) const
44057 {
44058 return static_cast<Result>( d.vkCreateDescriptorUpdateTemplateKHR( m_device, reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDescriptorUpdateTemplate*>( pDescriptorUpdateTemplate ) ) );
44059 }
44060#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44061 template<typename Dispatch>
44063 {
44064 DescriptorUpdateTemplate descriptorUpdateTemplate;
44065 Result result = static_cast<Result>( d.vkCreateDescriptorUpdateTemplateKHR( m_device, reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorUpdateTemplate*>( &descriptorUpdateTemplate ) ) );
44066 return createResultValue( result, descriptorUpdateTemplate, VULKAN_HPP_NAMESPACE_STRING"::Device::createDescriptorUpdateTemplateKHR" );
44067 }
44068#ifndef VULKAN_HPP_NO_SMART_HANDLE
44069 template<typename Dispatch>
44071 {
44072 DescriptorUpdateTemplate descriptorUpdateTemplate;
44073 Result result = static_cast<Result>( d.vkCreateDescriptorUpdateTemplateKHR( m_device, reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorUpdateTemplate*>( &descriptorUpdateTemplate ) ) );
44074
44075 ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
44076 return createResultValue<DescriptorUpdateTemplate,Dispatch>( result, descriptorUpdateTemplate, VULKAN_HPP_NAMESPACE_STRING"::Device::createDescriptorUpdateTemplateKHRUnique", deleter );
44077 }
44078#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
44079#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44080
44081 template<typename Dispatch>
44082 VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks* pAllocator, Dispatch const &d) const
44083 {
44084 d.vkDestroyDescriptorUpdateTemplate( m_device, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
44085 }
44086#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44087 template<typename Dispatch>
44089 {
44090 d.vkDestroyDescriptorUpdateTemplate( m_device, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
44091 }
44092#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44093
44094 template<typename Dispatch>
44095 VULKAN_HPP_INLINE void Device::destroy( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks* pAllocator, Dispatch const &d) const
44096 {
44097 d.vkDestroyDescriptorUpdateTemplate( m_device, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
44098 }
44099#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44100 template<typename Dispatch>
44101 VULKAN_HPP_INLINE void Device::destroy( DescriptorUpdateTemplate descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
44102 {
44103 d.vkDestroyDescriptorUpdateTemplate( m_device, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
44104 }
44105#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44106
44107 template<typename Dispatch>
44108 VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks* pAllocator, Dispatch const &d) const
44109 {
44110 d.vkDestroyDescriptorUpdateTemplateKHR( m_device, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
44111 }
44112#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44113 template<typename Dispatch>
44115 {
44116 d.vkDestroyDescriptorUpdateTemplateKHR( m_device, static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
44117 }
44118#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44119
44120#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
44121 template<typename Dispatch>
44122 VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplate( DescriptorSet descriptorSet, DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d) const
44123 {
44124 d.vkUpdateDescriptorSetWithTemplate( m_device, static_cast<VkDescriptorSet>( descriptorSet ), static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), pData );
44125 }
44126#else
44127 template<typename Dispatch>
44128 VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplate( DescriptorSet descriptorSet, DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d ) const
44129 {
44130 d.vkUpdateDescriptorSetWithTemplate( m_device, static_cast<VkDescriptorSet>( descriptorSet ), static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), pData );
44131 }
44132#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44133
44134#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
44135 template<typename Dispatch>
44136 VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplateKHR( DescriptorSet descriptorSet, DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d) const
44137 {
44138 d.vkUpdateDescriptorSetWithTemplateKHR( m_device, static_cast<VkDescriptorSet>( descriptorSet ), static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), pData );
44139 }
44140#else
44141 template<typename Dispatch>
44142 VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplateKHR( DescriptorSet descriptorSet, DescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, Dispatch const &d ) const
44143 {
44144 d.vkUpdateDescriptorSetWithTemplateKHR( m_device, static_cast<VkDescriptorSet>( descriptorSet ), static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ), pData );
44145 }
44146#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44147
44148 template<typename Dispatch>
44149 VULKAN_HPP_INLINE void Device::setHdrMetadataEXT( uint32_t swapchainCount, const SwapchainKHR* pSwapchains, const HdrMetadataEXT* pMetadata, Dispatch const &d) const
44150 {
44151 d.vkSetHdrMetadataEXT( m_device, swapchainCount, reinterpret_cast<const VkSwapchainKHR*>( pSwapchains ), reinterpret_cast<const VkHdrMetadataEXT*>( pMetadata ) );
44152 }
44153#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44154 template<typename Dispatch>
44156 {
44157#ifdef VULKAN_HPP_NO_EXCEPTIONS
44158 VULKAN_HPP_ASSERT( swapchains.size() == metadata.size() );
44159#else
44160 if ( swapchains.size() != metadata.size() )
44161 {
44162 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::setHdrMetadataEXT: swapchains.size() != metadata.size()" );
44163 }
44164#endif // VULKAN_HPP_NO_EXCEPTIONS
44165 d.vkSetHdrMetadataEXT( m_device, swapchains.size() , reinterpret_cast<const VkSwapchainKHR*>( swapchains.data() ), reinterpret_cast<const VkHdrMetadataEXT*>( metadata.data() ) );
44166 }
44167#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44168
44169#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
44170 template<typename Dispatch>
44171 VULKAN_HPP_INLINE Result Device::getSwapchainStatusKHR( SwapchainKHR swapchain, Dispatch const &d) const
44172 {
44173 return static_cast<Result>( d.vkGetSwapchainStatusKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) );
44174 }
44175#else
44176 template<typename Dispatch>
44178 {
44179 Result result = static_cast<Result>( d.vkGetSwapchainStatusKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) );
44180 return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getSwapchainStatusKHR", { Result::eSuccess, Result::eSuboptimalKHR } );
44181 }
44182#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44183
44184 template<typename Dispatch>
44186 {
44187 return static_cast<Result>( d.vkGetRefreshCycleDurationGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<VkRefreshCycleDurationGOOGLE*>( pDisplayTimingProperties ) ) );
44188 }
44189#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44190 template<typename Dispatch>
44192 {
44193 RefreshCycleDurationGOOGLE displayTimingProperties;
44194 Result result = static_cast<Result>( d.vkGetRefreshCycleDurationGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<VkRefreshCycleDurationGOOGLE*>( &displayTimingProperties ) ) );
44195 return createResultValue( result, displayTimingProperties, VULKAN_HPP_NAMESPACE_STRING"::Device::getRefreshCycleDurationGOOGLE" );
44196 }
44197#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44198
44199 template<typename Dispatch>
44200 VULKAN_HPP_INLINE Result Device::getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, uint32_t* pPresentationTimingCount, PastPresentationTimingGOOGLE* pPresentationTimings, Dispatch const &d) const
44201 {
44202 return static_cast<Result>( d.vkGetPastPresentationTimingGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), pPresentationTimingCount, reinterpret_cast<VkPastPresentationTimingGOOGLE*>( pPresentationTimings ) ) );
44203 }
44204#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44205 template <typename Allocator, typename Dispatch>
44207 {
44208 std::vector<PastPresentationTimingGOOGLE,Allocator> presentationTimings;
44209 uint32_t presentationTimingCount;
44210 Result result;
44211 do
44212 {
44213 result = static_cast<Result>( d.vkGetPastPresentationTimingGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), &presentationTimingCount, nullptr ) );
44214 if ( ( result == Result::eSuccess ) && presentationTimingCount )
44215 {
44216 presentationTimings.resize( presentationTimingCount );
44217 result = static_cast<Result>( d.vkGetPastPresentationTimingGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), &presentationTimingCount, reinterpret_cast<VkPastPresentationTimingGOOGLE*>( presentationTimings.data() ) ) );
44218 }
44219 } while ( result == Result::eIncomplete );
44220 VULKAN_HPP_ASSERT( presentationTimingCount <= presentationTimings.size() );
44221 presentationTimings.resize( presentationTimingCount );
44222 return createResultValue( result, presentationTimings, VULKAN_HPP_NAMESPACE_STRING"::Device::getPastPresentationTimingGOOGLE" );
44223 }
44224 template <typename Allocator, typename Dispatch>
44226 {
44227 std::vector<PastPresentationTimingGOOGLE,Allocator> presentationTimings( vectorAllocator );
44228 uint32_t presentationTimingCount;
44229 Result result;
44230 do
44231 {
44232 result = static_cast<Result>( d.vkGetPastPresentationTimingGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), &presentationTimingCount, nullptr ) );
44233 if ( ( result == Result::eSuccess ) && presentationTimingCount )
44234 {
44235 presentationTimings.resize( presentationTimingCount );
44236 result = static_cast<Result>( d.vkGetPastPresentationTimingGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), &presentationTimingCount, reinterpret_cast<VkPastPresentationTimingGOOGLE*>( presentationTimings.data() ) ) );
44237 }
44238 } while ( result == Result::eIncomplete );
44239 VULKAN_HPP_ASSERT( presentationTimingCount <= presentationTimings.size() );
44240 presentationTimings.resize( presentationTimingCount );
44241 return createResultValue( result, presentationTimings, VULKAN_HPP_NAMESPACE_STRING"::Device::getPastPresentationTimingGOOGLE" );
44242 }
44243#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44244
44245 template<typename Dispatch>
44247 {
44248 d.vkGetBufferMemoryRequirements2( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( pInfo ), reinterpret_cast<VkMemoryRequirements2*>( pMemoryRequirements ) );
44249 }
44250#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44251 template<typename Dispatch>
44253 {
44254 MemoryRequirements2 memoryRequirements;
44255 d.vkGetBufferMemoryRequirements2( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
44256 return memoryRequirements;
44257 }
44258 template <typename X, typename Y, typename ...Z, typename Dispatch>
44260 {
44261 StructureChain<X, Y, Z...> structureChain;
44262 MemoryRequirements2& memoryRequirements = structureChain.template get<MemoryRequirements2>();
44263 d.vkGetBufferMemoryRequirements2( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
44264 return structureChain;
44265 }
44266#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44267
44268 template<typename Dispatch>
44270 {
44271 d.vkGetBufferMemoryRequirements2KHR( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( pInfo ), reinterpret_cast<VkMemoryRequirements2*>( pMemoryRequirements ) );
44272 }
44273#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44274 template<typename Dispatch>
44276 {
44277 MemoryRequirements2 memoryRequirements;
44278 d.vkGetBufferMemoryRequirements2KHR( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
44279 return memoryRequirements;
44280 }
44281 template <typename X, typename Y, typename ...Z, typename Dispatch>
44283 {
44284 StructureChain<X, Y, Z...> structureChain;
44285 MemoryRequirements2& memoryRequirements = structureChain.template get<MemoryRequirements2>();
44286 d.vkGetBufferMemoryRequirements2KHR( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
44287 return structureChain;
44288 }
44289#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44290
44291 template<typename Dispatch>
44292 VULKAN_HPP_INLINE void Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2* pInfo, MemoryRequirements2* pMemoryRequirements, Dispatch const &d) const
44293 {
44294 d.vkGetImageMemoryRequirements2( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( pInfo ), reinterpret_cast<VkMemoryRequirements2*>( pMemoryRequirements ) );
44295 }
44296#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44297 template<typename Dispatch>
44299 {
44300 MemoryRequirements2 memoryRequirements;
44301 d.vkGetImageMemoryRequirements2( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
44302 return memoryRequirements;
44303 }
44304 template <typename X, typename Y, typename ...Z, typename Dispatch>
44306 {
44307 StructureChain<X, Y, Z...> structureChain;
44308 MemoryRequirements2& memoryRequirements = structureChain.template get<MemoryRequirements2>();
44309 d.vkGetImageMemoryRequirements2( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
44310 return structureChain;
44311 }
44312#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44313
44314 template<typename Dispatch>
44316 {
44317 d.vkGetImageMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( pInfo ), reinterpret_cast<VkMemoryRequirements2*>( pMemoryRequirements ) );
44318 }
44319#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44320 template<typename Dispatch>
44322 {
44323 MemoryRequirements2 memoryRequirements;
44324 d.vkGetImageMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
44325 return memoryRequirements;
44326 }
44327 template <typename X, typename Y, typename ...Z, typename Dispatch>
44329 {
44330 StructureChain<X, Y, Z...> structureChain;
44331 MemoryRequirements2& memoryRequirements = structureChain.template get<MemoryRequirements2>();
44332 d.vkGetImageMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2*>( &info ), reinterpret_cast<VkMemoryRequirements2*>( &memoryRequirements ) );
44333 return structureChain;
44334 }
44335#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44336
44337 template<typename Dispatch>
44338 VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements2* pSparseMemoryRequirements, Dispatch const &d) const
44339 {
44340 d.vkGetImageSparseMemoryRequirements2( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( pInfo ), pSparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements2*>( pSparseMemoryRequirements ) );
44341 }
44342#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44343 template <typename Allocator, typename Dispatch>
44344 VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2,Allocator> Device::getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info, Dispatch const &d ) const
44345 {
44346 std::vector<SparseImageMemoryRequirements2,Allocator> sparseMemoryRequirements;
44347 uint32_t sparseMemoryRequirementCount;
44348 d.vkGetImageSparseMemoryRequirements2( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, nullptr );
44349 sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
44350 d.vkGetImageSparseMemoryRequirements2( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements2*>( sparseMemoryRequirements.data() ) );
44351 return sparseMemoryRequirements;
44352 }
44353 template <typename Allocator, typename Dispatch>
44354 VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2,Allocator> Device::getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info, Allocator const& vectorAllocator, Dispatch const &d ) const
44355 {
44356 std::vector<SparseImageMemoryRequirements2,Allocator> sparseMemoryRequirements( vectorAllocator );
44357 uint32_t sparseMemoryRequirementCount;
44358 d.vkGetImageSparseMemoryRequirements2( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, nullptr );
44359 sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
44360 d.vkGetImageSparseMemoryRequirements2( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements2*>( sparseMemoryRequirements.data() ) );
44361 return sparseMemoryRequirements;
44362 }
44363#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44364
44365 template<typename Dispatch>
44366 VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements2* pSparseMemoryRequirements, Dispatch const &d) const
44367 {
44368 d.vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( pInfo ), pSparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements2*>( pSparseMemoryRequirements ) );
44369 }
44370#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44371 template <typename Allocator, typename Dispatch>
44372 VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2,Allocator> Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info, Dispatch const &d ) const
44373 {
44374 std::vector<SparseImageMemoryRequirements2,Allocator> sparseMemoryRequirements;
44375 uint32_t sparseMemoryRequirementCount;
44376 d.vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, nullptr );
44377 sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
44378 d.vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements2*>( sparseMemoryRequirements.data() ) );
44379 return sparseMemoryRequirements;
44380 }
44381 template <typename Allocator, typename Dispatch>
44382 VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2,Allocator> Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info, Allocator const& vectorAllocator, Dispatch const &d ) const
44383 {
44384 std::vector<SparseImageMemoryRequirements2,Allocator> sparseMemoryRequirements( vectorAllocator );
44385 uint32_t sparseMemoryRequirementCount;
44386 d.vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, nullptr );
44387 sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
44388 d.vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2*>( &info ), &sparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements2*>( sparseMemoryRequirements.data() ) );
44389 return sparseMemoryRequirements;
44390 }
44391#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44392
44393 template<typename Dispatch>
44395 {
44396 return static_cast<Result>( d.vkCreateSamplerYcbcrConversion( m_device, reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSamplerYcbcrConversion*>( pYcbcrConversion ) ) );
44397 }
44398#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44399 template<typename Dispatch>
44401 {
44402 SamplerYcbcrConversion ycbcrConversion;
44403 Result result = static_cast<Result>( d.vkCreateSamplerYcbcrConversion( m_device, reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSamplerYcbcrConversion*>( &ycbcrConversion ) ) );
44404 return createResultValue( result, ycbcrConversion, VULKAN_HPP_NAMESPACE_STRING"::Device::createSamplerYcbcrConversion" );
44405 }
44406#ifndef VULKAN_HPP_NO_SMART_HANDLE
44407 template<typename Dispatch>
44409 {
44410 SamplerYcbcrConversion ycbcrConversion;
44411 Result result = static_cast<Result>( d.vkCreateSamplerYcbcrConversion( m_device, reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSamplerYcbcrConversion*>( &ycbcrConversion ) ) );
44412
44413 ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
44414 return createResultValue<SamplerYcbcrConversion,Dispatch>( result, ycbcrConversion, VULKAN_HPP_NAMESPACE_STRING"::Device::createSamplerYcbcrConversionUnique", deleter );
44415 }
44416#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
44417#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44418
44419 template<typename Dispatch>
44421 {
44422 return static_cast<Result>( d.vkCreateSamplerYcbcrConversionKHR( m_device, reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSamplerYcbcrConversion*>( pYcbcrConversion ) ) );
44423 }
44424#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44425 template<typename Dispatch>
44427 {
44428 SamplerYcbcrConversion ycbcrConversion;
44429 Result result = static_cast<Result>( d.vkCreateSamplerYcbcrConversionKHR( m_device, reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSamplerYcbcrConversion*>( &ycbcrConversion ) ) );
44430 return createResultValue( result, ycbcrConversion, VULKAN_HPP_NAMESPACE_STRING"::Device::createSamplerYcbcrConversionKHR" );
44431 }
44432#ifndef VULKAN_HPP_NO_SMART_HANDLE
44433 template<typename Dispatch>
44435 {
44436 SamplerYcbcrConversion ycbcrConversion;
44437 Result result = static_cast<Result>( d.vkCreateSamplerYcbcrConversionKHR( m_device, reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSamplerYcbcrConversion*>( &ycbcrConversion ) ) );
44438
44439 ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
44440 return createResultValue<SamplerYcbcrConversion,Dispatch>( result, ycbcrConversion, VULKAN_HPP_NAMESPACE_STRING"::Device::createSamplerYcbcrConversionKHRUnique", deleter );
44441 }
44442#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
44443#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44444
44445 template<typename Dispatch>
44446 VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversion( SamplerYcbcrConversion ycbcrConversion, const AllocationCallbacks* pAllocator, Dispatch const &d) const
44447 {
44448 d.vkDestroySamplerYcbcrConversion( m_device, static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
44449 }
44450#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44451 template<typename Dispatch>
44453 {
44454 d.vkDestroySamplerYcbcrConversion( m_device, static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
44455 }
44456#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44457
44458 template<typename Dispatch>
44459 VULKAN_HPP_INLINE void Device::destroy( SamplerYcbcrConversion ycbcrConversion, const AllocationCallbacks* pAllocator, Dispatch const &d) const
44460 {
44461 d.vkDestroySamplerYcbcrConversion( m_device, static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
44462 }
44463#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44464 template<typename Dispatch>
44466 {
44467 d.vkDestroySamplerYcbcrConversion( m_device, static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
44468 }
44469#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44470
44471 template<typename Dispatch>
44472 VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversionKHR( SamplerYcbcrConversion ycbcrConversion, const AllocationCallbacks* pAllocator, Dispatch const &d) const
44473 {
44474 d.vkDestroySamplerYcbcrConversionKHR( m_device, static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
44475 }
44476#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44477 template<typename Dispatch>
44479 {
44480 d.vkDestroySamplerYcbcrConversionKHR( m_device, static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
44481 }
44482#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44483
44484 template<typename Dispatch>
44485 VULKAN_HPP_INLINE void Device::getQueue2( const DeviceQueueInfo2* pQueueInfo, Queue* pQueue, Dispatch const &d) const
44486 {
44487 d.vkGetDeviceQueue2( m_device, reinterpret_cast<const VkDeviceQueueInfo2*>( pQueueInfo ), reinterpret_cast<VkQueue*>( pQueue ) );
44488 }
44489#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44490 template<typename Dispatch>
44491 VULKAN_HPP_INLINE Queue Device::getQueue2( const DeviceQueueInfo2 & queueInfo, Dispatch const &d ) const
44492 {
44493 Queue queue;
44494 d.vkGetDeviceQueue2( m_device, reinterpret_cast<const VkDeviceQueueInfo2*>( &queueInfo ), reinterpret_cast<VkQueue*>( &queue ) );
44495 return queue;
44496 }
44497#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44498
44499 template<typename Dispatch>
44500 VULKAN_HPP_INLINE Result Device::createValidationCacheEXT( const ValidationCacheCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, ValidationCacheEXT* pValidationCache, Dispatch const &d) const
44501 {
44502 return static_cast<Result>( d.vkCreateValidationCacheEXT( m_device, reinterpret_cast<const VkValidationCacheCreateInfoEXT*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkValidationCacheEXT*>( pValidationCache ) ) );
44503 }
44504#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44505 template<typename Dispatch>
44507 {
44508 ValidationCacheEXT validationCache;
44509 Result result = static_cast<Result>( d.vkCreateValidationCacheEXT( m_device, reinterpret_cast<const VkValidationCacheCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkValidationCacheEXT*>( &validationCache ) ) );
44510 return createResultValue( result, validationCache, VULKAN_HPP_NAMESPACE_STRING"::Device::createValidationCacheEXT" );
44511 }
44512#ifndef VULKAN_HPP_NO_SMART_HANDLE
44513 template<typename Dispatch>
44515 {
44516 ValidationCacheEXT validationCache;
44517 Result result = static_cast<Result>( d.vkCreateValidationCacheEXT( m_device, reinterpret_cast<const VkValidationCacheCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkValidationCacheEXT*>( &validationCache ) ) );
44518
44519 ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
44520 return createResultValue<ValidationCacheEXT,Dispatch>( result, validationCache, VULKAN_HPP_NAMESPACE_STRING"::Device::createValidationCacheEXTUnique", deleter );
44521 }
44522#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
44523#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44524
44525 template<typename Dispatch>
44526 VULKAN_HPP_INLINE void Device::destroyValidationCacheEXT( ValidationCacheEXT validationCache, const AllocationCallbacks* pAllocator, Dispatch const &d) const
44527 {
44528 d.vkDestroyValidationCacheEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
44529 }
44530#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44531 template<typename Dispatch>
44533 {
44534 d.vkDestroyValidationCacheEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
44535 }
44536#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44537
44538 template<typename Dispatch>
44539 VULKAN_HPP_INLINE void Device::destroy( ValidationCacheEXT validationCache, const AllocationCallbacks* pAllocator, Dispatch const &d) const
44540 {
44541 d.vkDestroyValidationCacheEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
44542 }
44543#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44544 template<typename Dispatch>
44545 VULKAN_HPP_INLINE void Device::destroy( ValidationCacheEXT validationCache, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
44546 {
44547 d.vkDestroyValidationCacheEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
44548 }
44549#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44550
44551 template<typename Dispatch>
44552 VULKAN_HPP_INLINE Result Device::getValidationCacheDataEXT( ValidationCacheEXT validationCache, size_t* pDataSize, void* pData, Dispatch const &d) const
44553 {
44554 return static_cast<Result>( d.vkGetValidationCacheDataEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), pDataSize, pData ) );
44555 }
44556#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44557 template <typename Allocator, typename Dispatch>
44559 {
44560 std::vector<uint8_t,Allocator> data;
44561 size_t dataSize;
44562 Result result;
44563 do
44564 {
44565 result = static_cast<Result>( d.vkGetValidationCacheDataEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), &dataSize, nullptr ) );
44566 if ( ( result == Result::eSuccess ) && dataSize )
44567 {
44568 data.resize( dataSize );
44569 result = static_cast<Result>( d.vkGetValidationCacheDataEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), &dataSize, reinterpret_cast<void*>( data.data() ) ) );
44570 }
44571 } while ( result == Result::eIncomplete );
44572 VULKAN_HPP_ASSERT( dataSize <= data.size() );
44573 data.resize( dataSize );
44574 return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING"::Device::getValidationCacheDataEXT" );
44575 }
44576 template <typename Allocator, typename Dispatch>
44577 VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getValidationCacheDataEXT( ValidationCacheEXT validationCache, Allocator const& vectorAllocator, Dispatch const &d ) const
44578 {
44579 std::vector<uint8_t,Allocator> data( vectorAllocator );
44580 size_t dataSize;
44581 Result result;
44582 do
44583 {
44584 result = static_cast<Result>( d.vkGetValidationCacheDataEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), &dataSize, nullptr ) );
44585 if ( ( result == Result::eSuccess ) && dataSize )
44586 {
44587 data.resize( dataSize );
44588 result = static_cast<Result>( d.vkGetValidationCacheDataEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), &dataSize, reinterpret_cast<void*>( data.data() ) ) );
44589 }
44590 } while ( result == Result::eIncomplete );
44591 VULKAN_HPP_ASSERT( dataSize <= data.size() );
44592 data.resize( dataSize );
44593 return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING"::Device::getValidationCacheDataEXT" );
44594 }
44595#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44596
44597 template<typename Dispatch>
44598 VULKAN_HPP_INLINE Result Device::mergeValidationCachesEXT( ValidationCacheEXT dstCache, uint32_t srcCacheCount, const ValidationCacheEXT* pSrcCaches, Dispatch const &d) const
44599 {
44600 return static_cast<Result>( d.vkMergeValidationCachesEXT( m_device, static_cast<VkValidationCacheEXT>( dstCache ), srcCacheCount, reinterpret_cast<const VkValidationCacheEXT*>( pSrcCaches ) ) );
44601 }
44602#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44603 template<typename Dispatch>
44605 {
44606 Result result = static_cast<Result>( d.vkMergeValidationCachesEXT( m_device, static_cast<VkValidationCacheEXT>( dstCache ), srcCaches.size() , reinterpret_cast<const VkValidationCacheEXT*>( srcCaches.data() ) ) );
44607 return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::mergeValidationCachesEXT" );
44608 }
44609#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44610
44611 template<typename Dispatch>
44613 {
44614 d.vkGetDescriptorSetLayoutSupport( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( pCreateInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport*>( pSupport ) );
44615 }
44616#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44617 template<typename Dispatch>
44619 {
44621 d.vkGetDescriptorSetLayoutSupport( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport*>( &support ) );
44622 return support;
44623 }
44624 template <typename X, typename Y, typename ...Z, typename Dispatch>
44626 {
44627 StructureChain<X, Y, Z...> structureChain;
44628 DescriptorSetLayoutSupport& support = structureChain.template get<DescriptorSetLayoutSupport>();
44629 d.vkGetDescriptorSetLayoutSupport( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport*>( &support ) );
44630 return structureChain;
44631 }
44632#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44633
44634 template<typename Dispatch>
44636 {
44637 d.vkGetDescriptorSetLayoutSupportKHR( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( pCreateInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport*>( pSupport ) );
44638 }
44639#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44640 template<typename Dispatch>
44642 {
44644 d.vkGetDescriptorSetLayoutSupportKHR( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport*>( &support ) );
44645 return support;
44646 }
44647 template <typename X, typename Y, typename ...Z, typename Dispatch>
44649 {
44650 StructureChain<X, Y, Z...> structureChain;
44651 DescriptorSetLayoutSupport& support = structureChain.template get<DescriptorSetLayoutSupport>();
44652 d.vkGetDescriptorSetLayoutSupportKHR( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<VkDescriptorSetLayoutSupport*>( &support ) );
44653 return structureChain;
44654 }
44655#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44656
44657 template<typename Dispatch>
44658 VULKAN_HPP_INLINE Result Device::getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo, Dispatch const &d) const
44659 {
44660 return static_cast<Result>( d.vkGetShaderInfoAMD( m_device, static_cast<VkPipeline>( pipeline ), static_cast<VkShaderStageFlagBits>( shaderStage ), static_cast<VkShaderInfoTypeAMD>( infoType ), pInfoSize, pInfo ) );
44661 }
44662#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44663 template <typename Allocator, typename Dispatch>
44665 {
44666 std::vector<uint8_t,Allocator> info;
44667 size_t infoSize;
44668 Result result;
44669 do
44670 {
44671 result = static_cast<Result>( d.vkGetShaderInfoAMD( m_device, static_cast<VkPipeline>( pipeline ), static_cast<VkShaderStageFlagBits>( shaderStage ), static_cast<VkShaderInfoTypeAMD>( infoType ), &infoSize, nullptr ) );
44672 if ( ( result == Result::eSuccess ) && infoSize )
44673 {
44674 info.resize( infoSize );
44675 result = static_cast<Result>( d.vkGetShaderInfoAMD( m_device, static_cast<VkPipeline>( pipeline ), static_cast<VkShaderStageFlagBits>( shaderStage ), static_cast<VkShaderInfoTypeAMD>( infoType ), &infoSize, reinterpret_cast<void*>( info.data() ) ) );
44676 }
44677 } while ( result == Result::eIncomplete );
44678 VULKAN_HPP_ASSERT( infoSize <= info.size() );
44679 info.resize( infoSize );
44680 return createResultValue( result, info, VULKAN_HPP_NAMESPACE_STRING"::Device::getShaderInfoAMD" );
44681 }
44682 template <typename Allocator, typename Dispatch>
44683 VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, Allocator const& vectorAllocator, Dispatch const &d ) const
44684 {
44685 std::vector<uint8_t,Allocator> info( vectorAllocator );
44686 size_t infoSize;
44687 Result result;
44688 do
44689 {
44690 result = static_cast<Result>( d.vkGetShaderInfoAMD( m_device, static_cast<VkPipeline>( pipeline ), static_cast<VkShaderStageFlagBits>( shaderStage ), static_cast<VkShaderInfoTypeAMD>( infoType ), &infoSize, nullptr ) );
44691 if ( ( result == Result::eSuccess ) && infoSize )
44692 {
44693 info.resize( infoSize );
44694 result = static_cast<Result>( d.vkGetShaderInfoAMD( m_device, static_cast<VkPipeline>( pipeline ), static_cast<VkShaderStageFlagBits>( shaderStage ), static_cast<VkShaderInfoTypeAMD>( infoType ), &infoSize, reinterpret_cast<void*>( info.data() ) ) );
44695 }
44696 } while ( result == Result::eIncomplete );
44697 VULKAN_HPP_ASSERT( infoSize <= info.size() );
44698 info.resize( infoSize );
44699 return createResultValue( result, info, VULKAN_HPP_NAMESPACE_STRING"::Device::getShaderInfoAMD" );
44700 }
44701#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44702
44703 template<typename Dispatch>
44704 VULKAN_HPP_INLINE Result Device::getCalibratedTimestampsEXT( uint32_t timestampCount, const CalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation, Dispatch const &d) const
44705 {
44706 return static_cast<Result>( d.vkGetCalibratedTimestampsEXT( m_device, timestampCount, reinterpret_cast<const VkCalibratedTimestampInfoEXT*>( pTimestampInfos ), pTimestamps, pMaxDeviation ) );
44707 }
44708#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44709 template<typename Dispatch>
44711 {
44712#ifdef VULKAN_HPP_NO_EXCEPTIONS
44713 VULKAN_HPP_ASSERT( timestampInfos.size() == timestamps.size() );
44714#else
44715 if ( timestampInfos.size() != timestamps.size() )
44716 {
44717 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT: timestampInfos.size() != timestamps.size()" );
44718 }
44719#endif // VULKAN_HPP_NO_EXCEPTIONS
44720 uint64_t maxDeviation;
44721 Result result = static_cast<Result>( d.vkGetCalibratedTimestampsEXT( m_device, timestampInfos.size() , reinterpret_cast<const VkCalibratedTimestampInfoEXT*>( timestampInfos.data() ), timestamps.data(), &maxDeviation ) );
44722 return createResultValue( result, maxDeviation, VULKAN_HPP_NAMESPACE_STRING"::Device::getCalibratedTimestampsEXT" );
44723 }
44724#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44725
44726 template<typename Dispatch>
44728 {
44729 return static_cast<Result>( d.vkSetDebugUtilsObjectNameEXT( m_device, reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT*>( pNameInfo ) ) );
44730 }
44731#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44732 template<typename Dispatch>
44734 {
44735 Result result = static_cast<Result>( d.vkSetDebugUtilsObjectNameEXT( m_device, reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT*>( &nameInfo ) ) );
44736 return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::setDebugUtilsObjectNameEXT" );
44737 }
44738#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44739
44740 template<typename Dispatch>
44742 {
44743 return static_cast<Result>( d.vkSetDebugUtilsObjectTagEXT( m_device, reinterpret_cast<const VkDebugUtilsObjectTagInfoEXT*>( pTagInfo ) ) );
44744 }
44745#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44746 template<typename Dispatch>
44748 {
44749 Result result = static_cast<Result>( d.vkSetDebugUtilsObjectTagEXT( m_device, reinterpret_cast<const VkDebugUtilsObjectTagInfoEXT*>( &tagInfo ) ) );
44750 return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::setDebugUtilsObjectTagEXT" );
44751 }
44752#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44753
44754 template<typename Dispatch>
44756 {
44757 return static_cast<Result>( d.vkGetMemoryHostPointerPropertiesEXT( m_device, static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), pHostPointer, reinterpret_cast<VkMemoryHostPointerPropertiesEXT*>( pMemoryHostPointerProperties ) ) );
44758 }
44759#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44760 template<typename Dispatch>
44762 {
44763 MemoryHostPointerPropertiesEXT memoryHostPointerProperties;
44764 Result result = static_cast<Result>( d.vkGetMemoryHostPointerPropertiesEXT( m_device, static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ), pHostPointer, reinterpret_cast<VkMemoryHostPointerPropertiesEXT*>( &memoryHostPointerProperties ) ) );
44765 return createResultValue( result, memoryHostPointerProperties, VULKAN_HPP_NAMESPACE_STRING"::Device::getMemoryHostPointerPropertiesEXT" );
44766 }
44767#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44768
44769 template<typename Dispatch>
44770 VULKAN_HPP_INLINE Result Device::createRenderPass2KHR( const RenderPassCreateInfo2KHR* pCreateInfo, const AllocationCallbacks* pAllocator, RenderPass* pRenderPass, Dispatch const &d) const
44771 {
44772 return static_cast<Result>( d.vkCreateRenderPass2KHR( m_device, reinterpret_cast<const VkRenderPassCreateInfo2KHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkRenderPass*>( pRenderPass ) ) );
44773 }
44774#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44775 template<typename Dispatch>
44777 {
44778 RenderPass renderPass;
44779 Result result = static_cast<Result>( d.vkCreateRenderPass2KHR( m_device, reinterpret_cast<const VkRenderPassCreateInfo2KHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkRenderPass*>( &renderPass ) ) );
44780 return createResultValue( result, renderPass, VULKAN_HPP_NAMESPACE_STRING"::Device::createRenderPass2KHR" );
44781 }
44782#ifndef VULKAN_HPP_NO_SMART_HANDLE
44783 template<typename Dispatch>
44785 {
44786 RenderPass renderPass;
44787 Result result = static_cast<Result>( d.vkCreateRenderPass2KHR( m_device, reinterpret_cast<const VkRenderPassCreateInfo2KHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkRenderPass*>( &renderPass ) ) );
44788
44789 ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
44790 return createResultValue<RenderPass,Dispatch>( result, renderPass, VULKAN_HPP_NAMESPACE_STRING"::Device::createRenderPass2KHRUnique", deleter );
44791 }
44792#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
44793#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44794
44795#ifdef VK_USE_PLATFORM_ANDROID_ANDROID
44796 template<typename Dispatch>
44797 VULKAN_HPP_INLINE Result Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer* buffer, AndroidHardwareBufferPropertiesANDROID* pProperties, Dispatch const &d) const
44798 {
44799 return static_cast<Result>( d.vkGetAndroidHardwareBufferPropertiesANDROID( m_device, buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID*>( pProperties ) ) );
44800 }
44801#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44802 template<typename Dispatch>
44803 VULKAN_HPP_INLINE ResultValueType<AndroidHardwareBufferPropertiesANDROID>::type Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const &d ) const
44804 {
44805 AndroidHardwareBufferPropertiesANDROID properties;
44806 Result result = static_cast<Result>( d.vkGetAndroidHardwareBufferPropertiesANDROID( m_device, buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID*>( &properties ) ) );
44807 return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::Device::getAndroidHardwareBufferPropertiesANDROID" );
44808 }
44809 template <typename X, typename Y, typename ...Z, typename Dispatch>
44810 VULKAN_HPP_INLINE typename ResultValueType<StructureChain<X, Y, Z...>>::type Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const &d ) const
44811 {
44812 StructureChain<X, Y, Z...> structureChain;
44813 AndroidHardwareBufferPropertiesANDROID& properties = structureChain.template get<AndroidHardwareBufferPropertiesANDROID>();
44814 Result result = static_cast<Result>( d.vkGetAndroidHardwareBufferPropertiesANDROID( m_device, buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID*>( &properties ) ) );
44815 return createResultValue( result, structureChain, VULKAN_HPP_NAMESPACE_STRING"::Device::getAndroidHardwareBufferPropertiesANDROID" );
44816 }
44817#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44818#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/
44819
44820#ifdef VK_USE_PLATFORM_ANDROID_ANDROID
44821 template<typename Dispatch>
44822 VULKAN_HPP_INLINE Result Device::getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer, Dispatch const &d) const
44823 {
44824 return static_cast<Result>( d.vkGetMemoryAndroidHardwareBufferANDROID( m_device, reinterpret_cast<const VkMemoryGetAndroidHardwareBufferInfoANDROID*>( pInfo ), pBuffer ) );
44825 }
44826#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44827 template<typename Dispatch>
44828 VULKAN_HPP_INLINE ResultValueType<struct AHardwareBuffer*>::type Device::getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID & info, Dispatch const &d ) const
44829 {
44830 struct AHardwareBuffer* buffer;
44831 Result result = static_cast<Result>( d.vkGetMemoryAndroidHardwareBufferANDROID( m_device, reinterpret_cast<const VkMemoryGetAndroidHardwareBufferInfoANDROID*>( &info ), &buffer ) );
44832 return createResultValue( result, buffer, VULKAN_HPP_NAMESPACE_STRING"::Device::getMemoryAndroidHardwareBufferANDROID" );
44833 }
44834#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44835#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/
44836
44837#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
44838 template<typename Dispatch>
44839 VULKAN_HPP_INLINE Result Device::compileDeferredNV( Pipeline pipeline, uint32_t shader, Dispatch const &d) const
44840 {
44841 return static_cast<Result>( d.vkCompileDeferredNV( m_device, static_cast<VkPipeline>( pipeline ), shader ) );
44842 }
44843#else
44844 template<typename Dispatch>
44846 {
44847 Result result = static_cast<Result>( d.vkCompileDeferredNV( m_device, static_cast<VkPipeline>( pipeline ), shader ) );
44848 return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::compileDeferredNV" );
44849 }
44850#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44851
44852 template<typename Dispatch>
44853 VULKAN_HPP_INLINE Result Device::createAccelerationStructureNV( const AccelerationStructureCreateInfoNV* pCreateInfo, const AllocationCallbacks* pAllocator, AccelerationStructureNV* pAccelerationStructure, Dispatch const &d) const
44854 {
44855 return static_cast<Result>( d.vkCreateAccelerationStructureNV( m_device, reinterpret_cast<const VkAccelerationStructureCreateInfoNV*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkAccelerationStructureNV*>( pAccelerationStructure ) ) );
44856 }
44857#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44858 template<typename Dispatch>
44860 {
44861 AccelerationStructureNV accelerationStructure;
44862 Result result = static_cast<Result>( d.vkCreateAccelerationStructureNV( m_device, reinterpret_cast<const VkAccelerationStructureCreateInfoNV*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkAccelerationStructureNV*>( &accelerationStructure ) ) );
44863 return createResultValue( result, accelerationStructure, VULKAN_HPP_NAMESPACE_STRING"::Device::createAccelerationStructureNV" );
44864 }
44865#ifndef VULKAN_HPP_NO_SMART_HANDLE
44866 template<typename Dispatch>
44868 {
44869 AccelerationStructureNV accelerationStructure;
44870 Result result = static_cast<Result>( d.vkCreateAccelerationStructureNV( m_device, reinterpret_cast<const VkAccelerationStructureCreateInfoNV*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkAccelerationStructureNV*>( &accelerationStructure ) ) );
44871
44872 ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
44873 return createResultValue<AccelerationStructureNV,Dispatch>( result, accelerationStructure, VULKAN_HPP_NAMESPACE_STRING"::Device::createAccelerationStructureNVUnique", deleter );
44874 }
44875#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
44876#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44877
44878 template<typename Dispatch>
44879 VULKAN_HPP_INLINE void Device::destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure, const AllocationCallbacks* pAllocator, Dispatch const &d) const
44880 {
44881 d.vkDestroyAccelerationStructureNV( m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
44882 }
44883#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44884 template<typename Dispatch>
44886 {
44887 d.vkDestroyAccelerationStructureNV( m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
44888 }
44889#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44890
44891 template<typename Dispatch>
44892 VULKAN_HPP_INLINE void Device::destroy( AccelerationStructureNV accelerationStructure, const AllocationCallbacks* pAllocator, Dispatch const &d) const
44893 {
44894 d.vkDestroyAccelerationStructureNV( m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
44895 }
44896#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44897 template<typename Dispatch>
44898 VULKAN_HPP_INLINE void Device::destroy( AccelerationStructureNV accelerationStructure, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
44899 {
44900 d.vkDestroyAccelerationStructureNV( m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
44901 }
44902#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44903
44904 template<typename Dispatch>
44906 {
44907 d.vkGetAccelerationStructureMemoryRequirementsNV( m_device, reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV*>( pInfo ), reinterpret_cast<VkMemoryRequirements2KHR*>( pMemoryRequirements ) );
44908 }
44909#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44910 template<typename Dispatch>
44912 {
44913 MemoryRequirements2KHR memoryRequirements;
44914 d.vkGetAccelerationStructureMemoryRequirementsNV( m_device, reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV*>( &info ), reinterpret_cast<VkMemoryRequirements2KHR*>( &memoryRequirements ) );
44915 return memoryRequirements;
44916 }
44917#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44918
44919 template<typename Dispatch>
44921 {
44922 return static_cast<Result>( d.vkBindAccelerationStructureMemoryNV( m_device, bindInfoCount, reinterpret_cast<const VkBindAccelerationStructureMemoryInfoNV*>( pBindInfos ) ) );
44923 }
44924#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44925 template<typename Dispatch>
44927 {
44928 Result result = static_cast<Result>( d.vkBindAccelerationStructureMemoryNV( m_device, bindInfos.size() , reinterpret_cast<const VkBindAccelerationStructureMemoryInfoNV*>( bindInfos.data() ) ) );
44929 return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::bindAccelerationStructureMemoryNV" );
44930 }
44931#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44932
44933 template<typename Dispatch>
44934 VULKAN_HPP_INLINE Result Device::getRayTracingShaderGroupHandlesNV( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, Dispatch const &d) const
44935 {
44936 return static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesNV( m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, dataSize, pData ) );
44937 }
44938#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44939 template <typename T, typename Dispatch>
44941 {
44942 Result result = static_cast<Result>( d.vkGetRayTracingShaderGroupHandlesNV( m_device, static_cast<VkPipeline>( pipeline ), firstGroup, groupCount, data.size() * sizeof( T ) , reinterpret_cast<void*>( data.data() ) ) );
44943 return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getRayTracingShaderGroupHandlesNV" );
44944 }
44945#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44946
44947 template<typename Dispatch>
44948 VULKAN_HPP_INLINE Result Device::getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure, size_t dataSize, void* pData, Dispatch const &d) const
44949 {
44950 return static_cast<Result>( d.vkGetAccelerationStructureHandleNV( m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), dataSize, pData ) );
44951 }
44952#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44953 template <typename T, typename Dispatch>
44955 {
44956 Result result = static_cast<Result>( d.vkGetAccelerationStructureHandleNV( m_device, static_cast<VkAccelerationStructureNV>( accelerationStructure ), data.size() * sizeof( T ) , reinterpret_cast<void*>( data.data() ) ) );
44957 return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::Device::getAccelerationStructureHandleNV" );
44958 }
44959#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
44960
44961 template<typename Dispatch>
44962 VULKAN_HPP_INLINE Result Device::createRayTracingPipelinesNV( PipelineCache pipelineCache, uint32_t createInfoCount, const RayTracingPipelineCreateInfoNV* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines, Dispatch const &d) const
44963 {
44964 return static_cast<Result>( d.vkCreateRayTracingPipelinesNV( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfoCount, reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( pCreateInfos ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkPipeline*>( pPipelines ) ) );
44965 }
44966#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
44967 template <typename Allocator, typename Dispatch>
44969 {
44970 std::vector<Pipeline,Allocator> pipelines( createInfos.size() );
44971 Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesNV( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( pipelines.data() ) ) );
44972 return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createRayTracingPipelinesNV" );
44973 }
44974 template <typename Allocator, typename Dispatch>
44976 {
44977 std::vector<Pipeline,Allocator> pipelines( createInfos.size(), vectorAllocator );
44978 Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesNV( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( pipelines.data() ) ) );
44979 return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING"::Device::createRayTracingPipelinesNV" );
44980 }
44981 template<typename Dispatch>
44983 {
44984 Pipeline pipeline;
44985 Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesNV( m_device, static_cast<VkPipelineCache>( pipelineCache ), 1 , reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( &pipeline ) ) );
44986 return createResultValue( result, pipeline, VULKAN_HPP_NAMESPACE_STRING"::Device::createRayTracingPipelineNV" );
44987 }
44988#ifndef VULKAN_HPP_NO_SMART_HANDLE
44989 template <typename Allocator, typename Dispatch>
44991 {
44992 static_assert( sizeof( Pipeline ) <= sizeof( UniquePipeline ), "Pipeline is greater than UniquePipeline!" );
44993 std::vector<UniquePipeline, Allocator> pipelines;
44994 pipelines.reserve( createInfos.size() );
44995 Pipeline* buffer = reinterpret_cast<Pipeline*>( reinterpret_cast<char*>( pipelines.data() ) + createInfos.size() * ( sizeof( UniquePipeline ) - sizeof( Pipeline ) ) );
44996 Result result = static_cast<Result>(d.vkCreateRayTracingPipelinesNV( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( buffer ) ) );
44997
44998 ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
44999 for ( size_t i=0 ; i<createInfos.size() ; i++ )
45000 {
45001 pipelines.push_back( UniquePipeline( buffer[i], deleter ) );
45002 }
45003
45004 return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNVUnique" );
45005 }
45006 template <typename Allocator, typename Dispatch>
45008 {
45009 static_assert( sizeof( Pipeline ) <= sizeof( UniquePipeline ), "Pipeline is greater than UniquePipeline!" );
45010 std::vector<UniquePipeline, Allocator> pipelines;
45011 pipelines.reserve( createInfos.size() );
45012 Pipeline* buffer = reinterpret_cast<Pipeline*>( reinterpret_cast<char*>( pipelines.data() ) + createInfos.size() * ( sizeof( UniquePipeline ) - sizeof( Pipeline ) ) );
45013 Result result = static_cast<Result>(d.vkCreateRayTracingPipelinesNV( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( buffer ) ) );
45014
45015 ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
45016 for ( size_t i=0 ; i<createInfos.size() ; i++ )
45017 {
45018 pipelines.push_back( UniquePipeline( buffer[i], deleter ) );
45019 }
45020
45021 return createResultValue( result, pipelines, VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNVUnique" );
45022 }
45023 template<typename Dispatch>
45025 {
45026 Pipeline pipeline;
45027 Result result = static_cast<Result>( d.vkCreateRayTracingPipelinesNV( m_device, static_cast<VkPipelineCache>( pipelineCache ), 1 , reinterpret_cast<const VkRayTracingPipelineCreateInfoNV*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( &pipeline ) ) );
45028
45029 ObjectDestroy<Device,Dispatch> deleter( *this, allocator, d );
45030 return createResultValue<Pipeline,Dispatch>( result, pipeline, VULKAN_HPP_NAMESPACE_STRING"::Device::createRayTracingPipelineNVUnique", deleter );
45031 }
45032#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
45033#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45034
45035 template<typename Dispatch>
45037 {
45038 return static_cast<Result>( d.vkGetImageDrmFormatModifierPropertiesEXT( m_device, static_cast<VkImage>( image ), reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT*>( pProperties ) ) );
45039 }
45040#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45041 template<typename Dispatch>
45043 {
45045 Result result = static_cast<Result>( d.vkGetImageDrmFormatModifierPropertiesEXT( m_device, static_cast<VkImage>( image ), reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT*>( &properties ) ) );
45046 return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::Device::getImageDrmFormatModifierPropertiesEXT" );
45047 }
45048#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45049
45050#ifndef VULKAN_HPP_NO_SMART_HANDLE
45051
45052 template <typename Dispatch> class UniqueHandleTraits<Device,Dispatch> {public: using deleter = ObjectDestroy<NoParent,Dispatch>; };
45054#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
45055
45057 {
45058 public:
45061 {}
45062
45065 {}
45066
45067 VULKAN_HPP_TYPESAFE_EXPLICIT PhysicalDevice( VkPhysicalDevice physicalDevice )
45068 : m_physicalDevice( physicalDevice )
45069 {}
45070
45071#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
45072 PhysicalDevice & operator=(VkPhysicalDevice physicalDevice)
45073 {
45074 m_physicalDevice = physicalDevice;
45075 return *this;
45076 }
45077#endif
45078
45079 PhysicalDevice & operator=( std::nullptr_t )
45080 {
45082 return *this;
45083 }
45084
45085 bool operator==( PhysicalDevice const & rhs ) const
45086 {
45087 return m_physicalDevice == rhs.m_physicalDevice;
45088 }
45089
45090 bool operator!=(PhysicalDevice const & rhs ) const
45091 {
45092 return m_physicalDevice != rhs.m_physicalDevice;
45093 }
45094
45095 bool operator<(PhysicalDevice const & rhs ) const
45096 {
45098 }
45099
45100 template<typename Dispatch = DispatchLoaderStatic>
45101 void getProperties( PhysicalDeviceProperties* pProperties, Dispatch const &d = Dispatch() ) const;
45102#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45103 template<typename Dispatch = DispatchLoaderStatic>
45104 PhysicalDeviceProperties getProperties(Dispatch const &d = Dispatch() ) const;
45105 template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
45106 StructureChain<X, Y, Z...> getProperties(Dispatch const &d = Dispatch() ) const;
45107#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45108
45109 template<typename Dispatch = DispatchLoaderStatic>
45110 void getQueueFamilyProperties( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties* pQueueFamilyProperties, Dispatch const &d = Dispatch() ) const;
45111#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45112 template <typename Allocator = std::allocator<QueueFamilyProperties>, typename Dispatch = DispatchLoaderStatic>
45113 std::vector<QueueFamilyProperties,Allocator> getQueueFamilyProperties(Dispatch const &d = Dispatch() ) const;
45114 template <typename Allocator = std::allocator<QueueFamilyProperties>, typename Dispatch = DispatchLoaderStatic>
45115 std::vector<QueueFamilyProperties,Allocator> getQueueFamilyProperties(Allocator const& vectorAllocator, Dispatch const &d ) const;
45116#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45117
45118 template<typename Dispatch = DispatchLoaderStatic>
45119 void getMemoryProperties( PhysicalDeviceMemoryProperties* pMemoryProperties, Dispatch const &d = Dispatch() ) const;
45120#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45121 template<typename Dispatch = DispatchLoaderStatic>
45122 PhysicalDeviceMemoryProperties getMemoryProperties(Dispatch const &d = Dispatch() ) const;
45123#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45124
45125 template<typename Dispatch = DispatchLoaderStatic>
45126 void getFeatures( PhysicalDeviceFeatures* pFeatures, Dispatch const &d = Dispatch() ) const;
45127#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45128 template<typename Dispatch = DispatchLoaderStatic>
45129 PhysicalDeviceFeatures getFeatures(Dispatch const &d = Dispatch() ) const;
45130#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45131
45132 template<typename Dispatch = DispatchLoaderStatic>
45133 void getFormatProperties( Format format, FormatProperties* pFormatProperties, Dispatch const &d = Dispatch() ) const;
45134#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45135 template<typename Dispatch = DispatchLoaderStatic>
45136 FormatProperties getFormatProperties( Format format, Dispatch const &d = Dispatch() ) const;
45137#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45138
45139 template<typename Dispatch = DispatchLoaderStatic>
45141#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45142 template<typename Dispatch = DispatchLoaderStatic>
45144#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45145
45146 template<typename Dispatch = DispatchLoaderStatic>
45147 Result createDevice( const DeviceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Device* pDevice, Dispatch const &d = Dispatch() ) const;
45148#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45149 template<typename Dispatch = DispatchLoaderStatic>
45150 ResultValueType<Device>::type createDevice( const DeviceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
45151#ifndef VULKAN_HPP_NO_SMART_HANDLE
45152 template<typename Dispatch = DispatchLoaderStatic>
45153 typename ResultValueType<UniqueHandle<Device,Dispatch>>::type createDeviceUnique( const DeviceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
45154#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
45155#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45156
45157 template<typename Dispatch = DispatchLoaderStatic>
45158 Result enumerateDeviceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties, Dispatch const &d = Dispatch() ) const;
45159#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45160 template <typename Allocator = std::allocator<LayerProperties>, typename Dispatch = DispatchLoaderStatic>
45162 template <typename Allocator = std::allocator<LayerProperties>, typename Dispatch = DispatchLoaderStatic>
45163 typename ResultValueType<std::vector<LayerProperties,Allocator>>::type enumerateDeviceLayerProperties(Allocator const& vectorAllocator, Dispatch const &d ) const;
45164#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45165
45166 template<typename Dispatch = DispatchLoaderStatic>
45167 Result enumerateDeviceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties, Dispatch const &d = Dispatch() ) const;
45168#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45169 template <typename Allocator = std::allocator<ExtensionProperties>, typename Dispatch = DispatchLoaderStatic>
45171 template <typename Allocator = std::allocator<ExtensionProperties>, typename Dispatch = DispatchLoaderStatic>
45173#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45174
45175 template<typename Dispatch = DispatchLoaderStatic>
45177#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45178 template <typename Allocator = std::allocator<SparseImageFormatProperties>, typename Dispatch = DispatchLoaderStatic>
45179 std::vector<SparseImageFormatProperties,Allocator> getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, Dispatch const &d = Dispatch() ) const;
45180 template <typename Allocator = std::allocator<SparseImageFormatProperties>, typename Dispatch = DispatchLoaderStatic>
45181 std::vector<SparseImageFormatProperties,Allocator> getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, Allocator const& vectorAllocator, Dispatch const &d ) const;
45182#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45183
45184 template<typename Dispatch = DispatchLoaderStatic>
45185 Result getDisplayPropertiesKHR( uint32_t* pPropertyCount, DisplayPropertiesKHR* pProperties, Dispatch const &d = Dispatch() ) const;
45186#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45187 template <typename Allocator = std::allocator<DisplayPropertiesKHR>, typename Dispatch = DispatchLoaderStatic>
45189 template <typename Allocator = std::allocator<DisplayPropertiesKHR>, typename Dispatch = DispatchLoaderStatic>
45190 typename ResultValueType<std::vector<DisplayPropertiesKHR,Allocator>>::type getDisplayPropertiesKHR(Allocator const& vectorAllocator, Dispatch const &d ) const;
45191#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45192
45193 template<typename Dispatch = DispatchLoaderStatic>
45194 Result getDisplayPlanePropertiesKHR( uint32_t* pPropertyCount, DisplayPlanePropertiesKHR* pProperties, Dispatch const &d = Dispatch() ) const;
45195#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45196 template <typename Allocator = std::allocator<DisplayPlanePropertiesKHR>, typename Dispatch = DispatchLoaderStatic>
45198 template <typename Allocator = std::allocator<DisplayPlanePropertiesKHR>, typename Dispatch = DispatchLoaderStatic>
45199 typename ResultValueType<std::vector<DisplayPlanePropertiesKHR,Allocator>>::type getDisplayPlanePropertiesKHR(Allocator const& vectorAllocator, Dispatch const &d ) const;
45200#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45201
45202 template<typename Dispatch = DispatchLoaderStatic>
45203 Result getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, uint32_t* pDisplayCount, DisplayKHR* pDisplays, Dispatch const &d = Dispatch() ) const;
45204#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45205 template <typename Allocator = std::allocator<DisplayKHR>, typename Dispatch = DispatchLoaderStatic>
45207 template <typename Allocator = std::allocator<DisplayKHR>, typename Dispatch = DispatchLoaderStatic>
45208 typename ResultValueType<std::vector<DisplayKHR,Allocator>>::type getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Allocator const& vectorAllocator, Dispatch const &d ) const;
45209#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45210
45211 template<typename Dispatch = DispatchLoaderStatic>
45212 Result getDisplayModePropertiesKHR( DisplayKHR display, uint32_t* pPropertyCount, DisplayModePropertiesKHR* pProperties, Dispatch const &d = Dispatch() ) const;
45213#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45214 template <typename Allocator = std::allocator<DisplayModePropertiesKHR>, typename Dispatch = DispatchLoaderStatic>
45216 template <typename Allocator = std::allocator<DisplayModePropertiesKHR>, typename Dispatch = DispatchLoaderStatic>
45217 typename ResultValueType<std::vector<DisplayModePropertiesKHR,Allocator>>::type getDisplayModePropertiesKHR( DisplayKHR display, Allocator const& vectorAllocator, Dispatch const &d ) const;
45218#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45219
45220 template<typename Dispatch = DispatchLoaderStatic>
45221 Result createDisplayModeKHR( DisplayKHR display, const DisplayModeCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, DisplayModeKHR* pMode, Dispatch const &d = Dispatch() ) const;
45222#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45223 template<typename Dispatch = DispatchLoaderStatic>
45224 ResultValueType<DisplayModeKHR>::type createDisplayModeKHR( DisplayKHR display, const DisplayModeCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
45225#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45226
45227 template<typename Dispatch = DispatchLoaderStatic>
45228 Result getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, uint32_t planeIndex, DisplayPlaneCapabilitiesKHR* pCapabilities, Dispatch const &d = Dispatch() ) const;
45229#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45230 template<typename Dispatch = DispatchLoaderStatic>
45232#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45233
45234 template<typename Dispatch = DispatchLoaderStatic>
45235 Result getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Bool32* pSupported, Dispatch const &d = Dispatch() ) const;
45236#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45237 template<typename Dispatch = DispatchLoaderStatic>
45238 ResultValueType<Bool32>::type getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Dispatch const &d = Dispatch() ) const;
45239#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45240
45241 template<typename Dispatch = DispatchLoaderStatic>
45242 Result getSurfaceCapabilitiesKHR( SurfaceKHR surface, SurfaceCapabilitiesKHR* pSurfaceCapabilities, Dispatch const &d = Dispatch() ) const;
45243#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45244 template<typename Dispatch = DispatchLoaderStatic>
45246#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45247
45248 template<typename Dispatch = DispatchLoaderStatic>
45249 Result getSurfaceFormatsKHR( SurfaceKHR surface, uint32_t* pSurfaceFormatCount, SurfaceFormatKHR* pSurfaceFormats, Dispatch const &d = Dispatch() ) const;
45250#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45251 template <typename Allocator = std::allocator<SurfaceFormatKHR>, typename Dispatch = DispatchLoaderStatic>
45253 template <typename Allocator = std::allocator<SurfaceFormatKHR>, typename Dispatch = DispatchLoaderStatic>
45254 typename ResultValueType<std::vector<SurfaceFormatKHR,Allocator>>::type getSurfaceFormatsKHR( SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const;
45255#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45256
45257 template<typename Dispatch = DispatchLoaderStatic>
45258 Result getSurfacePresentModesKHR( SurfaceKHR surface, uint32_t* pPresentModeCount, PresentModeKHR* pPresentModes, Dispatch const &d = Dispatch() ) const;
45259#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45260 template <typename Allocator = std::allocator<PresentModeKHR>, typename Dispatch = DispatchLoaderStatic>
45262 template <typename Allocator = std::allocator<PresentModeKHR>, typename Dispatch = DispatchLoaderStatic>
45263 typename ResultValueType<std::vector<PresentModeKHR,Allocator>>::type getSurfacePresentModesKHR( SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const;
45264#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45265
45266#ifdef VK_USE_PLATFORM_WAYLAND_KHR
45267 template<typename Dispatch = DispatchLoaderStatic>
45268 Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display* display, Dispatch const &d = Dispatch() ) const;
45269#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45270 template<typename Dispatch = DispatchLoaderStatic>
45271 Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display & display, Dispatch const &d = Dispatch() ) const;
45272#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45273#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
45274
45275#ifdef VK_USE_PLATFORM_WIN32_KHR
45276 template<typename Dispatch = DispatchLoaderStatic>
45277 Bool32 getWin32PresentationSupportKHR( uint32_t queueFamilyIndex, Dispatch const &d = Dispatch() ) const;
45278#endif /*VK_USE_PLATFORM_WIN32_KHR*/
45279
45280#ifdef VK_USE_PLATFORM_XLIB_KHR
45281 template<typename Dispatch = DispatchLoaderStatic>
45282 Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display* dpy, VisualID visualID, Dispatch const &d = Dispatch() ) const;
45283#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45284 template<typename Dispatch = DispatchLoaderStatic>
45285 Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display & dpy, VisualID visualID, Dispatch const &d = Dispatch() ) const;
45286#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45287#endif /*VK_USE_PLATFORM_XLIB_KHR*/
45288
45289#ifdef VK_USE_PLATFORM_XCB_KHR
45290 template<typename Dispatch = DispatchLoaderStatic>
45291 Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id, Dispatch const &d = Dispatch() ) const;
45292#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45293 template<typename Dispatch = DispatchLoaderStatic>
45294 Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t & connection, xcb_visualid_t visual_id, Dispatch const &d = Dispatch() ) const;
45295#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45296#endif /*VK_USE_PLATFORM_XCB_KHR*/
45297
45298 template<typename Dispatch = DispatchLoaderStatic>
45300#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45301 template<typename Dispatch = DispatchLoaderStatic>
45303#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45304
45305 template<typename Dispatch = DispatchLoaderStatic>
45306 void getGeneratedCommandsPropertiesNVX( DeviceGeneratedCommandsFeaturesNVX* pFeatures, DeviceGeneratedCommandsLimitsNVX* pLimits, Dispatch const &d = Dispatch() ) const;
45307#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45308 template<typename Dispatch = DispatchLoaderStatic>
45310#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45311
45312 template<typename Dispatch = DispatchLoaderStatic>
45313 void getFeatures2( PhysicalDeviceFeatures2* pFeatures, Dispatch const &d = Dispatch() ) const;
45314#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45315 template<typename Dispatch = DispatchLoaderStatic>
45316 PhysicalDeviceFeatures2 getFeatures2(Dispatch const &d = Dispatch() ) const;
45317 template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
45318 StructureChain<X, Y, Z...> getFeatures2(Dispatch const &d = Dispatch() ) const;
45319#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45320
45321 template<typename Dispatch = DispatchLoaderStatic>
45322 void getFeatures2KHR( PhysicalDeviceFeatures2* pFeatures, Dispatch const &d = Dispatch() ) const;
45323#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45324 template<typename Dispatch = DispatchLoaderStatic>
45325 PhysicalDeviceFeatures2 getFeatures2KHR(Dispatch const &d = Dispatch() ) const;
45326 template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
45327 StructureChain<X, Y, Z...> getFeatures2KHR(Dispatch const &d = Dispatch() ) const;
45328#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45329
45330 template<typename Dispatch = DispatchLoaderStatic>
45331 void getProperties2( PhysicalDeviceProperties2* pProperties, Dispatch const &d = Dispatch() ) const;
45332#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45333 template<typename Dispatch = DispatchLoaderStatic>
45334 PhysicalDeviceProperties2 getProperties2(Dispatch const &d = Dispatch() ) const;
45335 template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
45336 StructureChain<X, Y, Z...> getProperties2(Dispatch const &d = Dispatch() ) const;
45337#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45338
45339 template<typename Dispatch = DispatchLoaderStatic>
45340 void getProperties2KHR( PhysicalDeviceProperties2* pProperties, Dispatch const &d = Dispatch() ) const;
45341#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45342 template<typename Dispatch = DispatchLoaderStatic>
45343 PhysicalDeviceProperties2 getProperties2KHR(Dispatch const &d = Dispatch() ) const;
45344 template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
45345 StructureChain<X, Y, Z...> getProperties2KHR(Dispatch const &d = Dispatch() ) const;
45346#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45347
45348 template<typename Dispatch = DispatchLoaderStatic>
45349 void getFormatProperties2( Format format, FormatProperties2* pFormatProperties, Dispatch const &d = Dispatch() ) const;
45350#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45351 template<typename Dispatch = DispatchLoaderStatic>
45352 FormatProperties2 getFormatProperties2( Format format, Dispatch const &d = Dispatch() ) const;
45353 template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
45354 StructureChain<X, Y, Z...> getFormatProperties2( Format format, Dispatch const &d = Dispatch() ) const;
45355#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45356
45357 template<typename Dispatch = DispatchLoaderStatic>
45358 void getFormatProperties2KHR( Format format, FormatProperties2* pFormatProperties, Dispatch const &d = Dispatch() ) const;
45359#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45360 template<typename Dispatch = DispatchLoaderStatic>
45361 FormatProperties2 getFormatProperties2KHR( Format format, Dispatch const &d = Dispatch() ) const;
45362 template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
45363 StructureChain<X, Y, Z...> getFormatProperties2KHR( Format format, Dispatch const &d = Dispatch() ) const;
45364#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45365
45366 template<typename Dispatch = DispatchLoaderStatic>
45367 Result getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2* pImageFormatInfo, ImageFormatProperties2* pImageFormatProperties, Dispatch const &d = Dispatch() ) const;
45368#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45369 template<typename Dispatch = DispatchLoaderStatic>
45371 template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
45372 typename ResultValueType<StructureChain<X, Y, Z...>>::type getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d = Dispatch() ) const;
45373#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45374
45375 template<typename Dispatch = DispatchLoaderStatic>
45376 Result getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2* pImageFormatInfo, ImageFormatProperties2* pImageFormatProperties, Dispatch const &d = Dispatch() ) const;
45377#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45378 template<typename Dispatch = DispatchLoaderStatic>
45380 template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
45381 typename ResultValueType<StructureChain<X, Y, Z...>>::type getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const &d = Dispatch() ) const;
45382#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45383
45384 template<typename Dispatch = DispatchLoaderStatic>
45385 void getQueueFamilyProperties2( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties2* pQueueFamilyProperties, Dispatch const &d = Dispatch() ) const;
45386#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45387 template <typename Allocator = std::allocator<QueueFamilyProperties2>, typename Dispatch = DispatchLoaderStatic>
45388 std::vector<QueueFamilyProperties2,Allocator> getQueueFamilyProperties2(Dispatch const &d = Dispatch() ) const;
45389 template <typename Allocator = std::allocator<QueueFamilyProperties2>, typename Dispatch = DispatchLoaderStatic>
45390 std::vector<QueueFamilyProperties2,Allocator> getQueueFamilyProperties2(Allocator const& vectorAllocator, Dispatch const &d ) const;
45391#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45392
45393 template<typename Dispatch = DispatchLoaderStatic>
45394 void getQueueFamilyProperties2KHR( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties2* pQueueFamilyProperties, Dispatch const &d = Dispatch() ) const;
45395#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45396 template <typename Allocator = std::allocator<QueueFamilyProperties2>, typename Dispatch = DispatchLoaderStatic>
45397 std::vector<QueueFamilyProperties2,Allocator> getQueueFamilyProperties2KHR(Dispatch const &d = Dispatch() ) const;
45398 template <typename Allocator = std::allocator<QueueFamilyProperties2>, typename Dispatch = DispatchLoaderStatic>
45399 std::vector<QueueFamilyProperties2,Allocator> getQueueFamilyProperties2KHR(Allocator const& vectorAllocator, Dispatch const &d ) const;
45400#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45401
45402 template<typename Dispatch = DispatchLoaderStatic>
45403 void getMemoryProperties2( PhysicalDeviceMemoryProperties2* pMemoryProperties, Dispatch const &d = Dispatch() ) const;
45404#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45405 template<typename Dispatch = DispatchLoaderStatic>
45406 PhysicalDeviceMemoryProperties2 getMemoryProperties2(Dispatch const &d = Dispatch() ) const;
45407#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45408
45409 template<typename Dispatch = DispatchLoaderStatic>
45410 void getMemoryProperties2KHR( PhysicalDeviceMemoryProperties2* pMemoryProperties, Dispatch const &d = Dispatch() ) const;
45411#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45412 template<typename Dispatch = DispatchLoaderStatic>
45413 PhysicalDeviceMemoryProperties2 getMemoryProperties2KHR(Dispatch const &d = Dispatch() ) const;
45414#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45415
45416 template<typename Dispatch = DispatchLoaderStatic>
45417 void getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, SparseImageFormatProperties2* pProperties, Dispatch const &d = Dispatch() ) const;
45418#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45419 template <typename Allocator = std::allocator<SparseImageFormatProperties2>, typename Dispatch = DispatchLoaderStatic>
45420 std::vector<SparseImageFormatProperties2,Allocator> getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Dispatch const &d = Dispatch() ) const;
45421 template <typename Allocator = std::allocator<SparseImageFormatProperties2>, typename Dispatch = DispatchLoaderStatic>
45422 std::vector<SparseImageFormatProperties2,Allocator> getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Allocator const& vectorAllocator, Dispatch const &d ) const;
45423#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45424
45425 template<typename Dispatch = DispatchLoaderStatic>
45426 void getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, SparseImageFormatProperties2* pProperties, Dispatch const &d = Dispatch() ) const;
45427#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45428 template <typename Allocator = std::allocator<SparseImageFormatProperties2>, typename Dispatch = DispatchLoaderStatic>
45429 std::vector<SparseImageFormatProperties2,Allocator> getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Dispatch const &d = Dispatch() ) const;
45430 template <typename Allocator = std::allocator<SparseImageFormatProperties2>, typename Dispatch = DispatchLoaderStatic>
45431 std::vector<SparseImageFormatProperties2,Allocator> getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Allocator const& vectorAllocator, Dispatch const &d ) const;
45432#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45433
45434 template<typename Dispatch = DispatchLoaderStatic>
45435 void getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo* pExternalBufferInfo, ExternalBufferProperties* pExternalBufferProperties, Dispatch const &d = Dispatch() ) const;
45436#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45437 template<typename Dispatch = DispatchLoaderStatic>
45438 ExternalBufferProperties getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const &d = Dispatch() ) const;
45439#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45440
45441 template<typename Dispatch = DispatchLoaderStatic>
45442 void getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo* pExternalBufferInfo, ExternalBufferProperties* pExternalBufferProperties, Dispatch const &d = Dispatch() ) const;
45443#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45444 template<typename Dispatch = DispatchLoaderStatic>
45445 ExternalBufferProperties getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const &d = Dispatch() ) const;
45446#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45447
45448 template<typename Dispatch = DispatchLoaderStatic>
45449 void getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, ExternalSemaphoreProperties* pExternalSemaphoreProperties, Dispatch const &d = Dispatch() ) const;
45450#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45451 template<typename Dispatch = DispatchLoaderStatic>
45452 ExternalSemaphoreProperties getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const &d = Dispatch() ) const;
45453#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45454
45455 template<typename Dispatch = DispatchLoaderStatic>
45456 void getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, ExternalSemaphoreProperties* pExternalSemaphoreProperties, Dispatch const &d = Dispatch() ) const;
45457#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45458 template<typename Dispatch = DispatchLoaderStatic>
45459 ExternalSemaphoreProperties getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const &d = Dispatch() ) const;
45460#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45461
45462 template<typename Dispatch = DispatchLoaderStatic>
45463 void getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo* pExternalFenceInfo, ExternalFenceProperties* pExternalFenceProperties, Dispatch const &d = Dispatch() ) const;
45464#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45465 template<typename Dispatch = DispatchLoaderStatic>
45466 ExternalFenceProperties getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const &d = Dispatch() ) const;
45467#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45468
45469 template<typename Dispatch = DispatchLoaderStatic>
45470 void getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo* pExternalFenceInfo, ExternalFenceProperties* pExternalFenceProperties, Dispatch const &d = Dispatch() ) const;
45471#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45472 template<typename Dispatch = DispatchLoaderStatic>
45473 ExternalFenceProperties getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const &d = Dispatch() ) const;
45474#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45475
45476#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
45477 template<typename Dispatch = DispatchLoaderStatic>
45478 Result releaseDisplayEXT( DisplayKHR display, Dispatch const &d = Dispatch() ) const;
45479#else
45480 template<typename Dispatch = DispatchLoaderStatic>
45481 ResultValueType<void>::type releaseDisplayEXT( DisplayKHR display, Dispatch const &d = Dispatch() ) const;
45482#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45483
45484#ifdef VK_USE_PLATFORM_XLIB_XRANDR_NV
45485 template<typename Dispatch = DispatchLoaderStatic>
45486 Result acquireXlibDisplayEXT( Display* dpy, DisplayKHR display, Dispatch const &d = Dispatch() ) const;
45487#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45488 template<typename Dispatch = DispatchLoaderStatic>
45489 ResultValueType<Display>::type acquireXlibDisplayEXT( DisplayKHR display, Dispatch const &d = Dispatch() ) const;
45490#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45491#endif /*VK_USE_PLATFORM_XLIB_XRANDR_NV*/
45492
45493#ifdef VK_USE_PLATFORM_XLIB_XRANDR_NV
45494 template<typename Dispatch = DispatchLoaderStatic>
45495 Result getRandROutputDisplayEXT( Display* dpy, RROutput rrOutput, DisplayKHR* pDisplay, Dispatch const &d = Dispatch() ) const;
45496#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45497 template<typename Dispatch = DispatchLoaderStatic>
45498 ResultValueType<DisplayKHR>::type getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput, Dispatch const &d = Dispatch() ) const;
45499#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45500#endif /*VK_USE_PLATFORM_XLIB_XRANDR_NV*/
45501
45502 template<typename Dispatch = DispatchLoaderStatic>
45503 Result getSurfaceCapabilities2EXT( SurfaceKHR surface, SurfaceCapabilities2EXT* pSurfaceCapabilities, Dispatch const &d = Dispatch() ) const;
45504#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45505 template<typename Dispatch = DispatchLoaderStatic>
45507#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45508
45509 template<typename Dispatch = DispatchLoaderStatic>
45510 Result getPresentRectanglesKHR( SurfaceKHR surface, uint32_t* pRectCount, Rect2D* pRects, Dispatch const &d = Dispatch() ) const;
45511#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45512 template <typename Allocator = std::allocator<Rect2D>, typename Dispatch = DispatchLoaderStatic>
45514 template <typename Allocator = std::allocator<Rect2D>, typename Dispatch = DispatchLoaderStatic>
45515 typename ResultValueType<std::vector<Rect2D,Allocator>>::type getPresentRectanglesKHR( SurfaceKHR surface, Allocator const& vectorAllocator, Dispatch const &d ) const;
45516#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45517
45518 template<typename Dispatch = DispatchLoaderStatic>
45519 void getMultisamplePropertiesEXT( SampleCountFlagBits samples, MultisamplePropertiesEXT* pMultisampleProperties, Dispatch const &d = Dispatch() ) const;
45520#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45521 template<typename Dispatch = DispatchLoaderStatic>
45523#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45524
45525 template<typename Dispatch = DispatchLoaderStatic>
45526 Result getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, SurfaceCapabilities2KHR* pSurfaceCapabilities, Dispatch const &d = Dispatch() ) const;
45527#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45528 template<typename Dispatch = DispatchLoaderStatic>
45530 template <typename X, typename Y, typename ...Z, typename Dispatch = DispatchLoaderStatic>
45531 typename ResultValueType<StructureChain<X, Y, Z...>>::type getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const &d = Dispatch() ) const;
45532#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45533
45534 template<typename Dispatch = DispatchLoaderStatic>
45535 Result getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, SurfaceFormat2KHR* pSurfaceFormats, Dispatch const &d = Dispatch() ) const;
45536#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45537 template <typename Allocator = std::allocator<SurfaceFormat2KHR>, typename Dispatch = DispatchLoaderStatic>
45539 template <typename Allocator = std::allocator<SurfaceFormat2KHR>, typename Dispatch = DispatchLoaderStatic>
45540 typename ResultValueType<std::vector<SurfaceFormat2KHR,Allocator>>::type getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Allocator const& vectorAllocator, Dispatch const &d ) const;
45541#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45542
45543 template<typename Dispatch = DispatchLoaderStatic>
45544 Result getDisplayProperties2KHR( uint32_t* pPropertyCount, DisplayProperties2KHR* pProperties, Dispatch const &d = Dispatch() ) const;
45545#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45546 template <typename Allocator = std::allocator<DisplayProperties2KHR>, typename Dispatch = DispatchLoaderStatic>
45548 template <typename Allocator = std::allocator<DisplayProperties2KHR>, typename Dispatch = DispatchLoaderStatic>
45549 typename ResultValueType<std::vector<DisplayProperties2KHR,Allocator>>::type getDisplayProperties2KHR(Allocator const& vectorAllocator, Dispatch const &d ) const;
45550#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45551
45552 template<typename Dispatch = DispatchLoaderStatic>
45553 Result getDisplayPlaneProperties2KHR( uint32_t* pPropertyCount, DisplayPlaneProperties2KHR* pProperties, Dispatch const &d = Dispatch() ) const;
45554#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45555 template <typename Allocator = std::allocator<DisplayPlaneProperties2KHR>, typename Dispatch = DispatchLoaderStatic>
45557 template <typename Allocator = std::allocator<DisplayPlaneProperties2KHR>, typename Dispatch = DispatchLoaderStatic>
45558 typename ResultValueType<std::vector<DisplayPlaneProperties2KHR,Allocator>>::type getDisplayPlaneProperties2KHR(Allocator const& vectorAllocator, Dispatch const &d ) const;
45559#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45560
45561 template<typename Dispatch = DispatchLoaderStatic>
45562 Result getDisplayModeProperties2KHR( DisplayKHR display, uint32_t* pPropertyCount, DisplayModeProperties2KHR* pProperties, Dispatch const &d = Dispatch() ) const;
45563#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45564 template <typename Allocator = std::allocator<DisplayModeProperties2KHR>, typename Dispatch = DispatchLoaderStatic>
45566 template <typename Allocator = std::allocator<DisplayModeProperties2KHR>, typename Dispatch = DispatchLoaderStatic>
45567 typename ResultValueType<std::vector<DisplayModeProperties2KHR,Allocator>>::type getDisplayModeProperties2KHR( DisplayKHR display, Allocator const& vectorAllocator, Dispatch const &d ) const;
45568#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45569
45570 template<typename Dispatch = DispatchLoaderStatic>
45571 Result getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR* pDisplayPlaneInfo, DisplayPlaneCapabilities2KHR* pCapabilities, Dispatch const &d = Dispatch() ) const;
45572#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45573 template<typename Dispatch = DispatchLoaderStatic>
45575#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45576
45577 template<typename Dispatch = DispatchLoaderStatic>
45578 Result getCalibrateableTimeDomainsEXT( uint32_t* pTimeDomainCount, TimeDomainEXT* pTimeDomains, Dispatch const &d = Dispatch() ) const;
45579#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45580 template <typename Allocator = std::allocator<TimeDomainEXT>, typename Dispatch = DispatchLoaderStatic>
45582 template <typename Allocator = std::allocator<TimeDomainEXT>, typename Dispatch = DispatchLoaderStatic>
45583 typename ResultValueType<std::vector<TimeDomainEXT,Allocator>>::type getCalibrateableTimeDomainsEXT(Allocator const& vectorAllocator, Dispatch const &d ) const;
45584#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45585
45586
45587
45588 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPhysicalDevice() const
45589 {
45590 return m_physicalDevice;
45591 }
45592
45593 explicit operator bool() const
45594 {
45596 }
45597
45598 bool operator!() const
45599 {
45601 }
45602
45603 private:
45604 VkPhysicalDevice m_physicalDevice;
45605 };
45606
45607 static_assert( sizeof( PhysicalDevice ) == sizeof( VkPhysicalDevice ), "handle and wrapper have different size!" );
45608
45609 template<typename Dispatch>
45611 {
45612 d.vkGetPhysicalDeviceProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties*>( pProperties ) );
45613 }
45614#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45615 template<typename Dispatch>
45617 {
45618 PhysicalDeviceProperties properties;
45619 d.vkGetPhysicalDeviceProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties*>( &properties ) );
45620 return properties;
45621 }
45622 template <typename X, typename Y, typename ...Z, typename Dispatch>
45624 {
45625 StructureChain<X, Y, Z...> structureChain;
45626 PhysicalDeviceProperties& properties = structureChain.template get<PhysicalDeviceProperties>();
45627 d.vkGetPhysicalDeviceProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties*>( &properties ) );
45628 return structureChain;
45629 }
45630#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45631
45632 template<typename Dispatch>
45633 VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties* pQueueFamilyProperties, Dispatch const &d) const
45634 {
45635 d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, pQueueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties*>( pQueueFamilyProperties ) );
45636 }
45637#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45638 template <typename Allocator, typename Dispatch>
45639 VULKAN_HPP_INLINE std::vector<QueueFamilyProperties,Allocator> PhysicalDevice::getQueueFamilyProperties(Dispatch const &d ) const
45640 {
45641 std::vector<QueueFamilyProperties,Allocator> queueFamilyProperties;
45642 uint32_t queueFamilyPropertyCount;
45643 d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
45644 queueFamilyProperties.resize( queueFamilyPropertyCount );
45645 d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties*>( queueFamilyProperties.data() ) );
45646 return queueFamilyProperties;
45647 }
45648 template <typename Allocator, typename Dispatch>
45649 VULKAN_HPP_INLINE std::vector<QueueFamilyProperties,Allocator> PhysicalDevice::getQueueFamilyProperties(Allocator const& vectorAllocator, Dispatch const &d ) const
45650 {
45651 std::vector<QueueFamilyProperties,Allocator> queueFamilyProperties( vectorAllocator );
45652 uint32_t queueFamilyPropertyCount;
45653 d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
45654 queueFamilyProperties.resize( queueFamilyPropertyCount );
45655 d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties*>( queueFamilyProperties.data() ) );
45656 return queueFamilyProperties;
45657 }
45658#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45659
45660 template<typename Dispatch>
45662 {
45663 d.vkGetPhysicalDeviceMemoryProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties*>( pMemoryProperties ) );
45664 }
45665#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45666 template<typename Dispatch>
45668 {
45669 PhysicalDeviceMemoryProperties memoryProperties;
45670 d.vkGetPhysicalDeviceMemoryProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties*>( &memoryProperties ) );
45671 return memoryProperties;
45672 }
45673#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45674
45675 template<typename Dispatch>
45677 {
45678 d.vkGetPhysicalDeviceFeatures( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures*>( pFeatures ) );
45679 }
45680#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45681 template<typename Dispatch>
45683 {
45684 PhysicalDeviceFeatures features;
45685 d.vkGetPhysicalDeviceFeatures( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures*>( &features ) );
45686 return features;
45687 }
45688#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45689
45690 template<typename Dispatch>
45692 {
45693 d.vkGetPhysicalDeviceFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties*>( pFormatProperties ) );
45694 }
45695#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45696 template<typename Dispatch>
45698 {
45699 FormatProperties formatProperties;
45700 d.vkGetPhysicalDeviceFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties*>( &formatProperties ) );
45701 return formatProperties;
45702 }
45703#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45704
45705 template<typename Dispatch>
45707 {
45708 return static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkImageTiling>( tiling ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageCreateFlags>( flags ), reinterpret_cast<VkImageFormatProperties*>( pImageFormatProperties ) ) );
45709 }
45710#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45711 template<typename Dispatch>
45713 {
45714 ImageFormatProperties imageFormatProperties;
45715 Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkImageTiling>( tiling ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageCreateFlags>( flags ), reinterpret_cast<VkImageFormatProperties*>( &imageFormatProperties ) ) );
45716 return createResultValue( result, imageFormatProperties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties" );
45717 }
45718#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45719
45720 template<typename Dispatch>
45721 VULKAN_HPP_INLINE Result PhysicalDevice::createDevice( const DeviceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Device* pDevice, Dispatch const &d) const
45722 {
45723 return static_cast<Result>( d.vkCreateDevice( m_physicalDevice, reinterpret_cast<const VkDeviceCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDevice*>( pDevice ) ) );
45724 }
45725#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45726 template<typename Dispatch>
45728 {
45729 Device device;
45730 Result result = static_cast<Result>( d.vkCreateDevice( m_physicalDevice, reinterpret_cast<const VkDeviceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDevice*>( &device ) ) );
45731 return createResultValue( result, device, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::createDevice" );
45732 }
45733#ifndef VULKAN_HPP_NO_SMART_HANDLE
45734 template<typename Dispatch>
45736 {
45737 Device device;
45738 Result result = static_cast<Result>( d.vkCreateDevice( m_physicalDevice, reinterpret_cast<const VkDeviceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDevice*>( &device ) ) );
45739
45740 ObjectDestroy<NoParent,Dispatch> deleter( allocator, d );
45741 return createResultValue<Device,Dispatch>( result, device, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::createDeviceUnique", deleter );
45742 }
45743#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
45744#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45745
45746 template<typename Dispatch>
45748 {
45749 return static_cast<Result>( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, pPropertyCount, reinterpret_cast<VkLayerProperties*>( pProperties ) ) );
45750 }
45751#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45752 template <typename Allocator, typename Dispatch>
45754 {
45755 std::vector<LayerProperties,Allocator> properties;
45756 uint32_t propertyCount;
45757 Result result;
45758 do
45759 {
45760 result = static_cast<Result>( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, nullptr ) );
45761 if ( ( result == Result::eSuccess ) && propertyCount )
45762 {
45763 properties.resize( propertyCount );
45764 result = static_cast<Result>( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, reinterpret_cast<VkLayerProperties*>( properties.data() ) ) );
45765 }
45766 } while ( result == Result::eIncomplete );
45767 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
45768 properties.resize( propertyCount );
45769 return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::enumerateDeviceLayerProperties" );
45770 }
45771 template <typename Allocator, typename Dispatch>
45773 {
45774 std::vector<LayerProperties,Allocator> properties( vectorAllocator );
45775 uint32_t propertyCount;
45776 Result result;
45777 do
45778 {
45779 result = static_cast<Result>( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, nullptr ) );
45780 if ( ( result == Result::eSuccess ) && propertyCount )
45781 {
45782 properties.resize( propertyCount );
45783 result = static_cast<Result>( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, reinterpret_cast<VkLayerProperties*>( properties.data() ) ) );
45784 }
45785 } while ( result == Result::eIncomplete );
45786 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
45787 properties.resize( propertyCount );
45788 return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::enumerateDeviceLayerProperties" );
45789 }
45790#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45791
45792 template<typename Dispatch>
45793 VULKAN_HPP_INLINE Result PhysicalDevice::enumerateDeviceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties, Dispatch const &d) const
45794 {
45795 return static_cast<Result>( d.vkEnumerateDeviceExtensionProperties( m_physicalDevice, pLayerName, pPropertyCount, reinterpret_cast<VkExtensionProperties*>( pProperties ) ) );
45796 }
45797#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45798 template <typename Allocator, typename Dispatch>
45800 {
45801 std::vector<ExtensionProperties,Allocator> properties;
45802 uint32_t propertyCount;
45803 Result result;
45804 do
45805 {
45806 result = static_cast<Result>( d.vkEnumerateDeviceExtensionProperties( m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) );
45807 if ( ( result == Result::eSuccess ) && propertyCount )
45808 {
45809 properties.resize( propertyCount );
45810 result = static_cast<Result>( d.vkEnumerateDeviceExtensionProperties( m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast<VkExtensionProperties*>( properties.data() ) ) );
45811 }
45812 } while ( result == Result::eIncomplete );
45813 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
45814 properties.resize( propertyCount );
45815 return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::enumerateDeviceExtensionProperties" );
45816 }
45817 template <typename Allocator, typename Dispatch>
45819 {
45820 std::vector<ExtensionProperties,Allocator> properties( vectorAllocator );
45821 uint32_t propertyCount;
45822 Result result;
45823 do
45824 {
45825 result = static_cast<Result>( d.vkEnumerateDeviceExtensionProperties( m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) );
45826 if ( ( result == Result::eSuccess ) && propertyCount )
45827 {
45828 properties.resize( propertyCount );
45829 result = static_cast<Result>( d.vkEnumerateDeviceExtensionProperties( m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast<VkExtensionProperties*>( properties.data() ) ) );
45830 }
45831 } while ( result == Result::eIncomplete );
45832 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
45833 properties.resize( propertyCount );
45834 return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::enumerateDeviceExtensionProperties" );
45835 }
45836#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45837
45838 template<typename Dispatch>
45840 {
45841 d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkSampleCountFlagBits>( samples ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageTiling>( tiling ), pPropertyCount, reinterpret_cast<VkSparseImageFormatProperties*>( pProperties ) );
45842 }
45843#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45844 template <typename Allocator, typename Dispatch>
45846 {
45847 std::vector<SparseImageFormatProperties,Allocator> properties;
45848 uint32_t propertyCount;
45849 d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkSampleCountFlagBits>( samples ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageTiling>( tiling ), &propertyCount, nullptr );
45850 properties.resize( propertyCount );
45851 d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkSampleCountFlagBits>( samples ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageTiling>( tiling ), &propertyCount, reinterpret_cast<VkSparseImageFormatProperties*>( properties.data() ) );
45852 return properties;
45853 }
45854 template <typename Allocator, typename Dispatch>
45855 VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties,Allocator> PhysicalDevice::getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, Allocator const& vectorAllocator, Dispatch const &d ) const
45856 {
45857 std::vector<SparseImageFormatProperties,Allocator> properties( vectorAllocator );
45858 uint32_t propertyCount;
45859 d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkSampleCountFlagBits>( samples ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageTiling>( tiling ), &propertyCount, nullptr );
45860 properties.resize( propertyCount );
45861 d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkSampleCountFlagBits>( samples ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageTiling>( tiling ), &propertyCount, reinterpret_cast<VkSparseImageFormatProperties*>( properties.data() ) );
45862 return properties;
45863 }
45864#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45865
45866 template<typename Dispatch>
45868 {
45869 return static_cast<Result>( d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, pPropertyCount, reinterpret_cast<VkDisplayPropertiesKHR*>( pProperties ) ) );
45870 }
45871#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45872 template <typename Allocator, typename Dispatch>
45874 {
45875 std::vector<DisplayPropertiesKHR,Allocator> properties;
45876 uint32_t propertyCount;
45877 Result result;
45878 do
45879 {
45880 result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) );
45881 if ( ( result == Result::eSuccess ) && propertyCount )
45882 {
45883 properties.resize( propertyCount );
45884 result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPropertiesKHR*>( properties.data() ) ) );
45885 }
45886 } while ( result == Result::eIncomplete );
45887 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
45888 properties.resize( propertyCount );
45889 return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPropertiesKHR" );
45890 }
45891 template <typename Allocator, typename Dispatch>
45893 {
45894 std::vector<DisplayPropertiesKHR,Allocator> properties( vectorAllocator );
45895 uint32_t propertyCount;
45896 Result result;
45897 do
45898 {
45899 result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) );
45900 if ( ( result == Result::eSuccess ) && propertyCount )
45901 {
45902 properties.resize( propertyCount );
45903 result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPropertiesKHR*>( properties.data() ) ) );
45904 }
45905 } while ( result == Result::eIncomplete );
45906 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
45907 properties.resize( propertyCount );
45908 return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPropertiesKHR" );
45909 }
45910#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45911
45912 template<typename Dispatch>
45914 {
45915 return static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, pPropertyCount, reinterpret_cast<VkDisplayPlanePropertiesKHR*>( pProperties ) ) );
45916 }
45917#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45918 template <typename Allocator, typename Dispatch>
45920 {
45921 std::vector<DisplayPlanePropertiesKHR,Allocator> properties;
45922 uint32_t propertyCount;
45923 Result result;
45924 do
45925 {
45926 result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) );
45927 if ( ( result == Result::eSuccess ) && propertyCount )
45928 {
45929 properties.resize( propertyCount );
45930 result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPlanePropertiesKHR*>( properties.data() ) ) );
45931 }
45932 } while ( result == Result::eIncomplete );
45933 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
45934 properties.resize( propertyCount );
45935 return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlanePropertiesKHR" );
45936 }
45937 template <typename Allocator, typename Dispatch>
45939 {
45940 std::vector<DisplayPlanePropertiesKHR,Allocator> properties( vectorAllocator );
45941 uint32_t propertyCount;
45942 Result result;
45943 do
45944 {
45945 result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) );
45946 if ( ( result == Result::eSuccess ) && propertyCount )
45947 {
45948 properties.resize( propertyCount );
45949 result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPlanePropertiesKHR*>( properties.data() ) ) );
45950 }
45951 } while ( result == Result::eIncomplete );
45952 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
45953 properties.resize( propertyCount );
45954 return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlanePropertiesKHR" );
45955 }
45956#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
45957
45958 template<typename Dispatch>
45959 VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, uint32_t* pDisplayCount, DisplayKHR* pDisplays, Dispatch const &d) const
45960 {
45961 return static_cast<Result>( d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, pDisplayCount, reinterpret_cast<VkDisplayKHR*>( pDisplays ) ) );
45962 }
45963#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
45964 template <typename Allocator, typename Dispatch>
45966 {
45967 std::vector<DisplayKHR,Allocator> displays;
45968 uint32_t displayCount;
45969 Result result;
45970 do
45971 {
45972 result = static_cast<Result>( d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, nullptr ) );
45973 if ( ( result == Result::eSuccess ) && displayCount )
45974 {
45975 displays.resize( displayCount );
45976 result = static_cast<Result>( d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, reinterpret_cast<VkDisplayKHR*>( displays.data() ) ) );
45977 }
45978 } while ( result == Result::eIncomplete );
45979 VULKAN_HPP_ASSERT( displayCount <= displays.size() );
45980 displays.resize( displayCount );
45981 return createResultValue( result, displays, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR" );
45982 }
45983 template <typename Allocator, typename Dispatch>
45985 {
45986 std::vector<DisplayKHR,Allocator> displays( vectorAllocator );
45987 uint32_t displayCount;
45988 Result result;
45989 do
45990 {
45991 result = static_cast<Result>( d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, nullptr ) );
45992 if ( ( result == Result::eSuccess ) && displayCount )
45993 {
45994 displays.resize( displayCount );
45995 result = static_cast<Result>( d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, reinterpret_cast<VkDisplayKHR*>( displays.data() ) ) );
45996 }
45997 } while ( result == Result::eIncomplete );
45998 VULKAN_HPP_ASSERT( displayCount <= displays.size() );
45999 displays.resize( displayCount );
46000 return createResultValue( result, displays, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR" );
46001 }
46002#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
46003
46004 template<typename Dispatch>
46006 {
46007 return static_cast<Result>( d.vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), pPropertyCount, reinterpret_cast<VkDisplayModePropertiesKHR*>( pProperties ) ) );
46008 }
46009#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
46010 template <typename Allocator, typename Dispatch>
46012 {
46013 std::vector<DisplayModePropertiesKHR,Allocator> properties;
46014 uint32_t propertyCount;
46015 Result result;
46016 do
46017 {
46018 result = static_cast<Result>( d.vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, nullptr ) );
46019 if ( ( result == Result::eSuccess ) && propertyCount )
46020 {
46021 properties.resize( propertyCount );
46022 result = static_cast<Result>( d.vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, reinterpret_cast<VkDisplayModePropertiesKHR*>( properties.data() ) ) );
46023 }
46024 } while ( result == Result::eIncomplete );
46025 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
46026 properties.resize( propertyCount );
46027 return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayModePropertiesKHR" );
46028 }
46029 template <typename Allocator, typename Dispatch>
46031 {
46032 std::vector<DisplayModePropertiesKHR,Allocator> properties( vectorAllocator );
46033 uint32_t propertyCount;
46034 Result result;
46035 do
46036 {
46037 result = static_cast<Result>( d.vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, nullptr ) );
46038 if ( ( result == Result::eSuccess ) && propertyCount )
46039 {
46040 properties.resize( propertyCount );
46041 result = static_cast<Result>( d.vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, reinterpret_cast<VkDisplayModePropertiesKHR*>( properties.data() ) ) );
46042 }
46043 } while ( result == Result::eIncomplete );
46044 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
46045 properties.resize( propertyCount );
46046 return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayModePropertiesKHR" );
46047 }
46048#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
46049
46050 template<typename Dispatch>
46051 VULKAN_HPP_INLINE Result PhysicalDevice::createDisplayModeKHR( DisplayKHR display, const DisplayModeCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, DisplayModeKHR* pMode, Dispatch const &d) const
46052 {
46053 return static_cast<Result>( d.vkCreateDisplayModeKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayModeCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDisplayModeKHR*>( pMode ) ) );
46054 }
46055#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
46056 template<typename Dispatch>
46058 {
46060 Result result = static_cast<Result>( d.vkCreateDisplayModeKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayModeCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDisplayModeKHR*>( &mode ) ) );
46061 return createResultValue( result, mode, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::createDisplayModeKHR" );
46062 }
46063#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
46064
46065 template<typename Dispatch>
46067 {
46068 return static_cast<Result>( d.vkGetDisplayPlaneCapabilitiesKHR( m_physicalDevice, static_cast<VkDisplayModeKHR>( mode ), planeIndex, reinterpret_cast<VkDisplayPlaneCapabilitiesKHR*>( pCapabilities ) ) );
46069 }
46070#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
46071 template<typename Dispatch>
46073 {
46074 DisplayPlaneCapabilitiesKHR capabilities;
46075 Result result = static_cast<Result>( d.vkGetDisplayPlaneCapabilitiesKHR( m_physicalDevice, static_cast<VkDisplayModeKHR>( mode ), planeIndex, reinterpret_cast<VkDisplayPlaneCapabilitiesKHR*>( &capabilities ) ) );
46076 return createResultValue( result, capabilities, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlaneCapabilitiesKHR" );
46077 }
46078#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
46079
46080 template<typename Dispatch>
46081 VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Bool32* pSupported, Dispatch const &d) const
46082 {
46083 return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceSupportKHR( m_physicalDevice, queueFamilyIndex, static_cast<VkSurfaceKHR>( surface ), pSupported ) );
46084 }
46085#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
46086 template<typename Dispatch>
46088 {
46089 Bool32 supported;
46090 Result result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceSupportKHR( m_physicalDevice, queueFamilyIndex, static_cast<VkSurfaceKHR>( surface ), &supported ) );
46091 return createResultValue( result, supported, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceSupportKHR" );
46092 }
46093#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
46094
46095 template<typename Dispatch>
46097 {
46098 return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilitiesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkSurfaceCapabilitiesKHR*>( pSurfaceCapabilities ) ) );
46099 }
46100#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
46101 template<typename Dispatch>
46103 {
46104 SurfaceCapabilitiesKHR surfaceCapabilities;
46105 Result result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilitiesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkSurfaceCapabilitiesKHR*>( &surfaceCapabilities ) ) );
46106 return createResultValue( result, surfaceCapabilities, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceCapabilitiesKHR" );
46107 }
46108#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
46109
46110 template<typename Dispatch>
46111 VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceFormatsKHR( SurfaceKHR surface, uint32_t* pSurfaceFormatCount, SurfaceFormatKHR* pSurfaceFormats, Dispatch const &d) const
46112 {
46113 return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), pSurfaceFormatCount, reinterpret_cast<VkSurfaceFormatKHR*>( pSurfaceFormats ) ) );
46114 }
46115#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
46116 template <typename Allocator, typename Dispatch>
46118 {
46119 std::vector<SurfaceFormatKHR,Allocator> surfaceFormats;
46120 uint32_t surfaceFormatCount;
46121 Result result;
46122 do
46123 {
46124 result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &surfaceFormatCount, nullptr ) );
46125 if ( ( result == Result::eSuccess ) && surfaceFormatCount )
46126 {
46127 surfaceFormats.resize( surfaceFormatCount );
46128 result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &surfaceFormatCount, reinterpret_cast<VkSurfaceFormatKHR*>( surfaceFormats.data() ) ) );
46129 }
46130 } while ( result == Result::eIncomplete );
46131 VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() );
46132 surfaceFormats.resize( surfaceFormatCount );
46133 return createResultValue( result, surfaceFormats, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceFormatsKHR" );
46134 }
46135 template <typename Allocator, typename Dispatch>
46137 {
46138 std::vector<SurfaceFormatKHR,Allocator> surfaceFormats( vectorAllocator );
46139 uint32_t surfaceFormatCount;
46140 Result result;
46141 do
46142 {
46143 result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &surfaceFormatCount, nullptr ) );
46144 if ( ( result == Result::eSuccess ) && surfaceFormatCount )
46145 {
46146 surfaceFormats.resize( surfaceFormatCount );
46147 result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &surfaceFormatCount, reinterpret_cast<VkSurfaceFormatKHR*>( surfaceFormats.data() ) ) );
46148 }
46149 } while ( result == Result::eIncomplete );
46150 VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() );
46151 surfaceFormats.resize( surfaceFormatCount );
46152 return createResultValue( result, surfaceFormats, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceFormatsKHR" );
46153 }
46154#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
46155
46156 template<typename Dispatch>
46158 {
46159 return static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), pPresentModeCount, reinterpret_cast<VkPresentModeKHR*>( pPresentModes ) ) );
46160 }
46161#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
46162 template <typename Allocator, typename Dispatch>
46164 {
46165 std::vector<PresentModeKHR,Allocator> presentModes;
46166 uint32_t presentModeCount;
46167 Result result;
46168 do
46169 {
46170 result = static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &presentModeCount, nullptr ) );
46171 if ( ( result == Result::eSuccess ) && presentModeCount )
46172 {
46173 presentModes.resize( presentModeCount );
46174 result = static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &presentModeCount, reinterpret_cast<VkPresentModeKHR*>( presentModes.data() ) ) );
46175 }
46176 } while ( result == Result::eIncomplete );
46177 VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() );
46178 presentModes.resize( presentModeCount );
46179 return createResultValue( result, presentModes, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfacePresentModesKHR" );
46180 }
46181 template <typename Allocator, typename Dispatch>
46183 {
46184 std::vector<PresentModeKHR,Allocator> presentModes( vectorAllocator );
46185 uint32_t presentModeCount;
46186 Result result;
46187 do
46188 {
46189 result = static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &presentModeCount, nullptr ) );
46190 if ( ( result == Result::eSuccess ) && presentModeCount )
46191 {
46192 presentModes.resize( presentModeCount );
46193 result = static_cast<Result>( d.vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &presentModeCount, reinterpret_cast<VkPresentModeKHR*>( presentModes.data() ) ) );
46194 }
46195 } while ( result == Result::eIncomplete );
46196 VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() );
46197 presentModes.resize( presentModeCount );
46198 return createResultValue( result, presentModes, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfacePresentModesKHR" );
46199 }
46200#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
46201
46202#ifdef VK_USE_PLATFORM_WAYLAND_KHR
46203 template<typename Dispatch>
46204 VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display* display, Dispatch const &d) const
46205 {
46206 return d.vkGetPhysicalDeviceWaylandPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, display );
46207 }
46208#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
46209 template<typename Dispatch>
46210 VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display & display, Dispatch const &d ) const
46211 {
46212 return d.vkGetPhysicalDeviceWaylandPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &display );
46213 }
46214#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
46215#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
46216
46217#ifdef VK_USE_PLATFORM_WIN32_KHR
46218#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
46219 template<typename Dispatch>
46220 VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWin32PresentationSupportKHR( uint32_t queueFamilyIndex, Dispatch const &d) const
46221 {
46222 return d.vkGetPhysicalDeviceWin32PresentationSupportKHR( m_physicalDevice, queueFamilyIndex );
46223 }
46224#else
46225 template<typename Dispatch>
46226 VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWin32PresentationSupportKHR( uint32_t queueFamilyIndex, Dispatch const &d ) const
46227 {
46228 return d.vkGetPhysicalDeviceWin32PresentationSupportKHR( m_physicalDevice, queueFamilyIndex );
46229 }
46230#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
46231#endif /*VK_USE_PLATFORM_WIN32_KHR*/
46232
46233#ifdef VK_USE_PLATFORM_XLIB_KHR
46234 template<typename Dispatch>
46235 VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display* dpy, VisualID visualID, Dispatch const &d) const
46236 {
46237 return d.vkGetPhysicalDeviceXlibPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, dpy, visualID );
46238 }
46239#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
46240 template<typename Dispatch>
46241 VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display & dpy, VisualID visualID, Dispatch const &d ) const
46242 {
46243 return d.vkGetPhysicalDeviceXlibPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &dpy, visualID );
46244 }
46245#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
46246#endif /*VK_USE_PLATFORM_XLIB_KHR*/
46247
46248#ifdef VK_USE_PLATFORM_XCB_KHR
46249 template<typename Dispatch>
46250 VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id, Dispatch const &d) const
46251 {
46252 return d.vkGetPhysicalDeviceXcbPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, connection, visual_id );
46253 }
46254#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
46255 template<typename Dispatch>
46256 VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t & connection, xcb_visualid_t visual_id, Dispatch const &d ) const
46257 {
46258 return d.vkGetPhysicalDeviceXcbPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &connection, visual_id );
46259 }
46260#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
46261#endif /*VK_USE_PLATFORM_XCB_KHR*/
46262
46263 template<typename Dispatch>
46265 {
46266 return static_cast<Result>( d.vkGetPhysicalDeviceExternalImageFormatPropertiesNV( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkImageTiling>( tiling ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageCreateFlags>( flags ), static_cast<VkExternalMemoryHandleTypeFlagsNV>( externalHandleType ), reinterpret_cast<VkExternalImageFormatPropertiesNV*>( pExternalImageFormatProperties ) ) );
46267 }
46268#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
46269 template<typename Dispatch>
46271 {
46272 ExternalImageFormatPropertiesNV externalImageFormatProperties;
46273 Result result = static_cast<Result>( d.vkGetPhysicalDeviceExternalImageFormatPropertiesNV( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkImageTiling>( tiling ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageCreateFlags>( flags ), static_cast<VkExternalMemoryHandleTypeFlagsNV>( externalHandleType ), reinterpret_cast<VkExternalImageFormatPropertiesNV*>( &externalImageFormatProperties ) ) );
46274 return createResultValue( result, externalImageFormatProperties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getExternalImageFormatPropertiesNV" );
46275 }
46276#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
46277
46278 template<typename Dispatch>
46280 {
46281 d.vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( m_physicalDevice, reinterpret_cast<VkDeviceGeneratedCommandsFeaturesNVX*>( pFeatures ), reinterpret_cast<VkDeviceGeneratedCommandsLimitsNVX*>( pLimits ) );
46282 }
46283#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
46284 template<typename Dispatch>
46286 {
46288 d.vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( m_physicalDevice, reinterpret_cast<VkDeviceGeneratedCommandsFeaturesNVX*>( &features ), reinterpret_cast<VkDeviceGeneratedCommandsLimitsNVX*>( &limits ) );
46289 return limits;
46290 }
46291#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
46292
46293 template<typename Dispatch>
46295 {
46296 d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( pFeatures ) );
46297 }
46298#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
46299 template<typename Dispatch>
46301 {
46302 PhysicalDeviceFeatures2 features;
46303 d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( &features ) );
46304 return features;
46305 }
46306 template <typename X, typename Y, typename ...Z, typename Dispatch>
46308 {
46309 StructureChain<X, Y, Z...> structureChain;
46310 PhysicalDeviceFeatures2& features = structureChain.template get<PhysicalDeviceFeatures2>();
46311 d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( &features ) );
46312 return structureChain;
46313 }
46314#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
46315
46316 template<typename Dispatch>
46318 {
46319 d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( pFeatures ) );
46320 }
46321#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
46322 template<typename Dispatch>
46324 {
46325 PhysicalDeviceFeatures2 features;
46326 d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( &features ) );
46327 return features;
46328 }
46329 template <typename X, typename Y, typename ...Z, typename Dispatch>
46331 {
46332 StructureChain<X, Y, Z...> structureChain;
46333 PhysicalDeviceFeatures2& features = structureChain.template get<PhysicalDeviceFeatures2>();
46334 d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2*>( &features ) );
46335 return structureChain;
46336 }
46337#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
46338
46339 template<typename Dispatch>
46341 {
46342 d.vkGetPhysicalDeviceProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( pProperties ) );
46343 }
46344#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
46345 template<typename Dispatch>
46347 {
46348 PhysicalDeviceProperties2 properties;
46349 d.vkGetPhysicalDeviceProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( &properties ) );
46350 return properties;
46351 }
46352 template <typename X, typename Y, typename ...Z, typename Dispatch>
46354 {
46355 StructureChain<X, Y, Z...> structureChain;
46356 PhysicalDeviceProperties2& properties = structureChain.template get<PhysicalDeviceProperties2>();
46357 d.vkGetPhysicalDeviceProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( &properties ) );
46358 return structureChain;
46359 }
46360#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
46361
46362 template<typename Dispatch>
46364 {
46365 d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( pProperties ) );
46366 }
46367#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
46368 template<typename Dispatch>
46370 {
46371 PhysicalDeviceProperties2 properties;
46372 d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( &properties ) );
46373 return properties;
46374 }
46375 template <typename X, typename Y, typename ...Z, typename Dispatch>
46377 {
46378 StructureChain<X, Y, Z...> structureChain;
46379 PhysicalDeviceProperties2& properties = structureChain.template get<PhysicalDeviceProperties2>();
46380 d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2*>( &properties ) );
46381 return structureChain;
46382 }
46383#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
46384
46385 template<typename Dispatch>
46387 {
46388 d.vkGetPhysicalDeviceFormatProperties2( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( pFormatProperties ) );
46389 }
46390#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
46391 template<typename Dispatch>
46393 {
46394 FormatProperties2 formatProperties;
46395 d.vkGetPhysicalDeviceFormatProperties2( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( &formatProperties ) );
46396 return formatProperties;
46397 }
46398 template <typename X, typename Y, typename ...Z, typename Dispatch>
46400 {
46401 StructureChain<X, Y, Z...> structureChain;
46402 FormatProperties2& formatProperties = structureChain.template get<FormatProperties2>();
46403 d.vkGetPhysicalDeviceFormatProperties2( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( &formatProperties ) );
46404 return structureChain;
46405 }
46406#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
46407
46408 template<typename Dispatch>
46410 {
46411 d.vkGetPhysicalDeviceFormatProperties2KHR( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( pFormatProperties ) );
46412 }
46413#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
46414 template<typename Dispatch>
46416 {
46417 FormatProperties2 formatProperties;
46418 d.vkGetPhysicalDeviceFormatProperties2KHR( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( &formatProperties ) );
46419 return formatProperties;
46420 }
46421 template <typename X, typename Y, typename ...Z, typename Dispatch>
46423 {
46424 StructureChain<X, Y, Z...> structureChain;
46425 FormatProperties2& formatProperties = structureChain.template get<FormatProperties2>();
46426 d.vkGetPhysicalDeviceFormatProperties2KHR( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2*>( &formatProperties ) );
46427 return structureChain;
46428 }
46429#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
46430
46431 template<typename Dispatch>
46433 {
46434 return static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( pImageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( pImageFormatProperties ) ) );
46435 }
46436#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
46437 template<typename Dispatch>
46439 {
46440 ImageFormatProperties2 imageFormatProperties;
46441 Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( &imageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( &imageFormatProperties ) ) );
46442 return createResultValue( result, imageFormatProperties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties2" );
46443 }
46444 template <typename X, typename Y, typename ...Z, typename Dispatch>
46446 {
46447 StructureChain<X, Y, Z...> structureChain;
46448 ImageFormatProperties2& imageFormatProperties = structureChain.template get<ImageFormatProperties2>();
46449 Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( &imageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( &imageFormatProperties ) ) );
46450 return createResultValue( result, structureChain, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties2" );
46451 }
46452#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
46453
46454 template<typename Dispatch>
46456 {
46457 return static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( pImageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( pImageFormatProperties ) ) );
46458 }
46459#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
46460 template<typename Dispatch>
46462 {
46463 ImageFormatProperties2 imageFormatProperties;
46464 Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( &imageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( &imageFormatProperties ) ) );
46465 return createResultValue( result, imageFormatProperties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties2KHR" );
46466 }
46467 template <typename X, typename Y, typename ...Z, typename Dispatch>
46469 {
46470 StructureChain<X, Y, Z...> structureChain;
46471 ImageFormatProperties2& imageFormatProperties = structureChain.template get<ImageFormatProperties2>();
46472 Result result = static_cast<Result>( d.vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2*>( &imageFormatInfo ), reinterpret_cast<VkImageFormatProperties2*>( &imageFormatProperties ) ) );
46473 return createResultValue( result, structureChain, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getImageFormatProperties2KHR" );
46474 }
46475#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
46476
46477 template<typename Dispatch>
46478 VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties2( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties2* pQueueFamilyProperties, Dispatch const &d) const
46479 {
46480 d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, pQueueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( pQueueFamilyProperties ) );
46481 }
46482#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
46483 template <typename Allocator, typename Dispatch>
46484 VULKAN_HPP_INLINE std::vector<QueueFamilyProperties2,Allocator> PhysicalDevice::getQueueFamilyProperties2(Dispatch const &d ) const
46485 {
46486 std::vector<QueueFamilyProperties2,Allocator> queueFamilyProperties;
46487 uint32_t queueFamilyPropertyCount;
46488 d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
46489 queueFamilyProperties.resize( queueFamilyPropertyCount );
46490 d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( queueFamilyProperties.data() ) );
46491 return queueFamilyProperties;
46492 }
46493 template <typename Allocator, typename Dispatch>
46494 VULKAN_HPP_INLINE std::vector<QueueFamilyProperties2,Allocator> PhysicalDevice::getQueueFamilyProperties2(Allocator const& vectorAllocator, Dispatch const &d ) const
46495 {
46496 std::vector<QueueFamilyProperties2,Allocator> queueFamilyProperties( vectorAllocator );
46497 uint32_t queueFamilyPropertyCount;
46498 d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
46499 queueFamilyProperties.resize( queueFamilyPropertyCount );
46500 d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( queueFamilyProperties.data() ) );
46501 return queueFamilyProperties;
46502 }
46503#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
46504
46505 template<typename Dispatch>
46506 VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties2KHR( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties2* pQueueFamilyProperties, Dispatch const &d) const
46507 {
46508 d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, pQueueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( pQueueFamilyProperties ) );
46509 }
46510#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
46511 template <typename Allocator, typename Dispatch>
46512 VULKAN_HPP_INLINE std::vector<QueueFamilyProperties2,Allocator> PhysicalDevice::getQueueFamilyProperties2KHR(Dispatch const &d ) const
46513 {
46514 std::vector<QueueFamilyProperties2,Allocator> queueFamilyProperties;
46515 uint32_t queueFamilyPropertyCount;
46516 d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
46517 queueFamilyProperties.resize( queueFamilyPropertyCount );
46518 d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( queueFamilyProperties.data() ) );
46519 return queueFamilyProperties;
46520 }
46521 template <typename Allocator, typename Dispatch>
46522 VULKAN_HPP_INLINE std::vector<QueueFamilyProperties2,Allocator> PhysicalDevice::getQueueFamilyProperties2KHR(Allocator const& vectorAllocator, Dispatch const &d ) const
46523 {
46524 std::vector<QueueFamilyProperties2,Allocator> queueFamilyProperties( vectorAllocator );
46525 uint32_t queueFamilyPropertyCount;
46526 d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
46527 queueFamilyProperties.resize( queueFamilyPropertyCount );
46528 d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2*>( queueFamilyProperties.data() ) );
46529 return queueFamilyProperties;
46530 }
46531#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
46532
46533 template<typename Dispatch>
46535 {
46536 d.vkGetPhysicalDeviceMemoryProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>( pMemoryProperties ) );
46537 }
46538#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
46539 template<typename Dispatch>
46541 {
46542 PhysicalDeviceMemoryProperties2 memoryProperties;
46543 d.vkGetPhysicalDeviceMemoryProperties2( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>( &memoryProperties ) );
46544 return memoryProperties;
46545 }
46546#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
46547
46548 template<typename Dispatch>
46550 {
46551 d.vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>( pMemoryProperties ) );
46552 }
46553#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
46554 template<typename Dispatch>
46556 {
46557 PhysicalDeviceMemoryProperties2 memoryProperties;
46558 d.vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2*>( &memoryProperties ) );
46559 return memoryProperties;
46560 }
46561#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
46562
46563 template<typename Dispatch>
46565 {
46566 d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( pFormatInfo ), pPropertyCount, reinterpret_cast<VkSparseImageFormatProperties2*>( pProperties ) );
46567 }
46568#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
46569 template <typename Allocator, typename Dispatch>
46570 VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2,Allocator> PhysicalDevice::getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Dispatch const &d ) const
46571 {
46572 std::vector<SparseImageFormatProperties2,Allocator> properties;
46573 uint32_t propertyCount;
46574 d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, nullptr );
46575 properties.resize( propertyCount );
46576 d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, reinterpret_cast<VkSparseImageFormatProperties2*>( properties.data() ) );
46577 return properties;
46578 }
46579 template <typename Allocator, typename Dispatch>
46580 VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2,Allocator> PhysicalDevice::getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Allocator const& vectorAllocator, Dispatch const &d ) const
46581 {
46582 std::vector<SparseImageFormatProperties2,Allocator> properties( vectorAllocator );
46583 uint32_t propertyCount;
46584 d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, nullptr );
46585 properties.resize( propertyCount );
46586 d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, reinterpret_cast<VkSparseImageFormatProperties2*>( properties.data() ) );
46587 return properties;
46588 }
46589#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
46590
46591 template<typename Dispatch>
46593 {
46594 d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( pFormatInfo ), pPropertyCount, reinterpret_cast<VkSparseImageFormatProperties2*>( pProperties ) );
46595 }
46596#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
46597 template <typename Allocator, typename Dispatch>
46598 VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2,Allocator> PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Dispatch const &d ) const
46599 {
46600 std::vector<SparseImageFormatProperties2,Allocator> properties;
46601 uint32_t propertyCount;
46602 d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, nullptr );
46603 properties.resize( propertyCount );
46604 d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, reinterpret_cast<VkSparseImageFormatProperties2*>( properties.data() ) );
46605 return properties;
46606 }
46607 template <typename Allocator, typename Dispatch>
46608 VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2,Allocator> PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Allocator const& vectorAllocator, Dispatch const &d ) const
46609 {
46610 std::vector<SparseImageFormatProperties2,Allocator> properties( vectorAllocator );
46611 uint32_t propertyCount;
46612 d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, nullptr );
46613 properties.resize( propertyCount );
46614 d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2*>( &formatInfo ), &propertyCount, reinterpret_cast<VkSparseImageFormatProperties2*>( properties.data() ) );
46615 return properties;
46616 }
46617#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
46618
46619 template<typename Dispatch>
46620 VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo* pExternalBufferInfo, ExternalBufferProperties* pExternalBufferProperties, Dispatch const &d) const
46621 {
46622 d.vkGetPhysicalDeviceExternalBufferProperties( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo*>( pExternalBufferInfo ), reinterpret_cast<VkExternalBufferProperties*>( pExternalBufferProperties ) );
46623 }
46624#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
46625 template<typename Dispatch>
46627 {
46628 ExternalBufferProperties externalBufferProperties;
46629 d.vkGetPhysicalDeviceExternalBufferProperties( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo*>( &externalBufferInfo ), reinterpret_cast<VkExternalBufferProperties*>( &externalBufferProperties ) );
46630 return externalBufferProperties;
46631 }
46632#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
46633
46634 template<typename Dispatch>
46635 VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo* pExternalBufferInfo, ExternalBufferProperties* pExternalBufferProperties, Dispatch const &d) const
46636 {
46637 d.vkGetPhysicalDeviceExternalBufferPropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo*>( pExternalBufferInfo ), reinterpret_cast<VkExternalBufferProperties*>( pExternalBufferProperties ) );
46638 }
46639#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
46640 template<typename Dispatch>
46642 {
46643 ExternalBufferProperties externalBufferProperties;
46644 d.vkGetPhysicalDeviceExternalBufferPropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo*>( &externalBufferInfo ), reinterpret_cast<VkExternalBufferProperties*>( &externalBufferProperties ) );
46645 return externalBufferProperties;
46646 }
46647#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
46648
46649 template<typename Dispatch>
46650 VULKAN_HPP_INLINE void PhysicalDevice::getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, ExternalSemaphoreProperties* pExternalSemaphoreProperties, Dispatch const &d) const
46651 {
46652 d.vkGetPhysicalDeviceExternalSemaphoreProperties( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo*>( pExternalSemaphoreInfo ), reinterpret_cast<VkExternalSemaphoreProperties*>( pExternalSemaphoreProperties ) );
46653 }
46654#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
46655 template<typename Dispatch>
46657 {
46658 ExternalSemaphoreProperties externalSemaphoreProperties;
46659 d.vkGetPhysicalDeviceExternalSemaphoreProperties( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo*>( &externalSemaphoreInfo ), reinterpret_cast<VkExternalSemaphoreProperties*>( &externalSemaphoreProperties ) );
46660 return externalSemaphoreProperties;
46661 }
46662#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
46663
46664 template<typename Dispatch>
46665 VULKAN_HPP_INLINE void PhysicalDevice::getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, ExternalSemaphoreProperties* pExternalSemaphoreProperties, Dispatch const &d) const
46666 {
46667 d.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo*>( pExternalSemaphoreInfo ), reinterpret_cast<VkExternalSemaphoreProperties*>( pExternalSemaphoreProperties ) );
46668 }
46669#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
46670 template<typename Dispatch>
46672 {
46673 ExternalSemaphoreProperties externalSemaphoreProperties;
46674 d.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo*>( &externalSemaphoreInfo ), reinterpret_cast<VkExternalSemaphoreProperties*>( &externalSemaphoreProperties ) );
46675 return externalSemaphoreProperties;
46676 }
46677#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
46678
46679 template<typename Dispatch>
46680 VULKAN_HPP_INLINE void PhysicalDevice::getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo* pExternalFenceInfo, ExternalFenceProperties* pExternalFenceProperties, Dispatch const &d) const
46681 {
46682 d.vkGetPhysicalDeviceExternalFenceProperties( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo*>( pExternalFenceInfo ), reinterpret_cast<VkExternalFenceProperties*>( pExternalFenceProperties ) );
46683 }
46684#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
46685 template<typename Dispatch>
46687 {
46688 ExternalFenceProperties externalFenceProperties;
46689 d.vkGetPhysicalDeviceExternalFenceProperties( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo*>( &externalFenceInfo ), reinterpret_cast<VkExternalFenceProperties*>( &externalFenceProperties ) );
46690 return externalFenceProperties;
46691 }
46692#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
46693
46694 template<typename Dispatch>
46695 VULKAN_HPP_INLINE void PhysicalDevice::getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo* pExternalFenceInfo, ExternalFenceProperties* pExternalFenceProperties, Dispatch const &d) const
46696 {
46697 d.vkGetPhysicalDeviceExternalFencePropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo*>( pExternalFenceInfo ), reinterpret_cast<VkExternalFenceProperties*>( pExternalFenceProperties ) );
46698 }
46699#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
46700 template<typename Dispatch>
46702 {
46703 ExternalFenceProperties externalFenceProperties;
46704 d.vkGetPhysicalDeviceExternalFencePropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo*>( &externalFenceInfo ), reinterpret_cast<VkExternalFenceProperties*>( &externalFenceProperties ) );
46705 return externalFenceProperties;
46706 }
46707#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
46708
46709#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
46710 template<typename Dispatch>
46712 {
46713 return static_cast<Result>( d.vkReleaseDisplayEXT( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ) );
46714 }
46715#else
46716 template<typename Dispatch>
46718 {
46719 Result result = static_cast<Result>( d.vkReleaseDisplayEXT( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ) );
46720 return createResultValue( result, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::releaseDisplayEXT" );
46721 }
46722#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
46723
46724#ifdef VK_USE_PLATFORM_XLIB_XRANDR_NV
46725 template<typename Dispatch>
46726 VULKAN_HPP_INLINE Result PhysicalDevice::acquireXlibDisplayEXT( Display* dpy, DisplayKHR display, Dispatch const &d) const
46727 {
46728 return static_cast<Result>( d.vkAcquireXlibDisplayEXT( m_physicalDevice, dpy, static_cast<VkDisplayKHR>( display ) ) );
46729 }
46730#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
46731 template<typename Dispatch>
46732 VULKAN_HPP_INLINE ResultValueType<Display>::type PhysicalDevice::acquireXlibDisplayEXT( DisplayKHR display, Dispatch const &d ) const
46733 {
46734 Display dpy;
46735 Result result = static_cast<Result>( d.vkAcquireXlibDisplayEXT( m_physicalDevice, &dpy, static_cast<VkDisplayKHR>( display ) ) );
46736 return createResultValue( result, dpy, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::acquireXlibDisplayEXT" );
46737 }
46738#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
46739#endif /*VK_USE_PLATFORM_XLIB_XRANDR_NV*/
46740
46741#ifdef VK_USE_PLATFORM_XLIB_XRANDR_NV
46742 template<typename Dispatch>
46743 VULKAN_HPP_INLINE Result PhysicalDevice::getRandROutputDisplayEXT( Display* dpy, RROutput rrOutput, DisplayKHR* pDisplay, Dispatch const &d) const
46744 {
46745 return static_cast<Result>( d.vkGetRandROutputDisplayEXT( m_physicalDevice, dpy, rrOutput, reinterpret_cast<VkDisplayKHR*>( pDisplay ) ) );
46746 }
46747#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
46748 template<typename Dispatch>
46749 VULKAN_HPP_INLINE ResultValueType<DisplayKHR>::type PhysicalDevice::getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput, Dispatch const &d ) const
46750 {
46751 DisplayKHR display;
46752 Result result = static_cast<Result>( d.vkGetRandROutputDisplayEXT( m_physicalDevice, &dpy, rrOutput, reinterpret_cast<VkDisplayKHR*>( &display ) ) );
46753 return createResultValue( result, display, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getRandROutputDisplayEXT" );
46754 }
46755#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
46756#endif /*VK_USE_PLATFORM_XLIB_XRANDR_NV*/
46757
46758 template<typename Dispatch>
46760 {
46761 return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2EXT( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkSurfaceCapabilities2EXT*>( pSurfaceCapabilities ) ) );
46762 }
46763#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
46764 template<typename Dispatch>
46766 {
46767 SurfaceCapabilities2EXT surfaceCapabilities;
46768 Result result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2EXT( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkSurfaceCapabilities2EXT*>( &surfaceCapabilities ) ) );
46769 return createResultValue( result, surfaceCapabilities, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceCapabilities2EXT" );
46770 }
46771#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
46772
46773 template<typename Dispatch>
46775 {
46776 return static_cast<Result>( d.vkGetPhysicalDevicePresentRectanglesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), pRectCount, reinterpret_cast<VkRect2D*>( pRects ) ) );
46777 }
46778#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
46779 template <typename Allocator, typename Dispatch>
46781 {
46782 std::vector<Rect2D,Allocator> rects;
46783 uint32_t rectCount;
46784 Result result;
46785 do
46786 {
46787 result = static_cast<Result>( d.vkGetPhysicalDevicePresentRectanglesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &rectCount, nullptr ) );
46788 if ( ( result == Result::eSuccess ) && rectCount )
46789 {
46790 rects.resize( rectCount );
46791 result = static_cast<Result>( d.vkGetPhysicalDevicePresentRectanglesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &rectCount, reinterpret_cast<VkRect2D*>( rects.data() ) ) );
46792 }
46793 } while ( result == Result::eIncomplete );
46794 VULKAN_HPP_ASSERT( rectCount <= rects.size() );
46795 rects.resize( rectCount );
46796 return createResultValue( result, rects, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getPresentRectanglesKHR" );
46797 }
46798 template <typename Allocator, typename Dispatch>
46800 {
46801 std::vector<Rect2D,Allocator> rects( vectorAllocator );
46802 uint32_t rectCount;
46803 Result result;
46804 do
46805 {
46806 result = static_cast<Result>( d.vkGetPhysicalDevicePresentRectanglesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &rectCount, nullptr ) );
46807 if ( ( result == Result::eSuccess ) && rectCount )
46808 {
46809 rects.resize( rectCount );
46810 result = static_cast<Result>( d.vkGetPhysicalDevicePresentRectanglesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &rectCount, reinterpret_cast<VkRect2D*>( rects.data() ) ) );
46811 }
46812 } while ( result == Result::eIncomplete );
46813 VULKAN_HPP_ASSERT( rectCount <= rects.size() );
46814 rects.resize( rectCount );
46815 return createResultValue( result, rects, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getPresentRectanglesKHR" );
46816 }
46817#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
46818
46819 template<typename Dispatch>
46821 {
46822 d.vkGetPhysicalDeviceMultisamplePropertiesEXT( m_physicalDevice, static_cast<VkSampleCountFlagBits>( samples ), reinterpret_cast<VkMultisamplePropertiesEXT*>( pMultisampleProperties ) );
46823 }
46824#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
46825 template<typename Dispatch>
46827 {
46828 MultisamplePropertiesEXT multisampleProperties;
46829 d.vkGetPhysicalDeviceMultisamplePropertiesEXT( m_physicalDevice, static_cast<VkSampleCountFlagBits>( samples ), reinterpret_cast<VkMultisamplePropertiesEXT*>( &multisampleProperties ) );
46830 return multisampleProperties;
46831 }
46832#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
46833
46834 template<typename Dispatch>
46836 {
46837 return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( pSurfaceInfo ), reinterpret_cast<VkSurfaceCapabilities2KHR*>( pSurfaceCapabilities ) ) );
46838 }
46839#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
46840 template<typename Dispatch>
46842 {
46843 SurfaceCapabilities2KHR surfaceCapabilities;
46844 Result result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), reinterpret_cast<VkSurfaceCapabilities2KHR*>( &surfaceCapabilities ) ) );
46845 return createResultValue( result, surfaceCapabilities, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceCapabilities2KHR" );
46846 }
46847 template <typename X, typename Y, typename ...Z, typename Dispatch>
46849 {
46850 StructureChain<X, Y, Z...> structureChain;
46851 SurfaceCapabilities2KHR& surfaceCapabilities = structureChain.template get<SurfaceCapabilities2KHR>();
46852 Result result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), reinterpret_cast<VkSurfaceCapabilities2KHR*>( &surfaceCapabilities ) ) );
46853 return createResultValue( result, structureChain, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceCapabilities2KHR" );
46854 }
46855#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
46856
46857 template<typename Dispatch>
46858 VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, SurfaceFormat2KHR* pSurfaceFormats, Dispatch const &d) const
46859 {
46860 return static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( pSurfaceInfo ), pSurfaceFormatCount, reinterpret_cast<VkSurfaceFormat2KHR*>( pSurfaceFormats ) ) );
46861 }
46862#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
46863 template <typename Allocator, typename Dispatch>
46865 {
46866 std::vector<SurfaceFormat2KHR,Allocator> surfaceFormats;
46867 uint32_t surfaceFormatCount;
46868 Result result;
46869 do
46870 {
46871 result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), &surfaceFormatCount, nullptr ) );
46872 if ( ( result == Result::eSuccess ) && surfaceFormatCount )
46873 {
46874 surfaceFormats.resize( surfaceFormatCount );
46875 result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), &surfaceFormatCount, reinterpret_cast<VkSurfaceFormat2KHR*>( surfaceFormats.data() ) ) );
46876 }
46877 } while ( result == Result::eIncomplete );
46878 VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() );
46879 surfaceFormats.resize( surfaceFormatCount );
46880 return createResultValue( result, surfaceFormats, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceFormats2KHR" );
46881 }
46882 template <typename Allocator, typename Dispatch>
46884 {
46885 std::vector<SurfaceFormat2KHR,Allocator> surfaceFormats( vectorAllocator );
46886 uint32_t surfaceFormatCount;
46887 Result result;
46888 do
46889 {
46890 result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), &surfaceFormatCount, nullptr ) );
46891 if ( ( result == Result::eSuccess ) && surfaceFormatCount )
46892 {
46893 surfaceFormats.resize( surfaceFormatCount );
46894 result = static_cast<Result>( d.vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), &surfaceFormatCount, reinterpret_cast<VkSurfaceFormat2KHR*>( surfaceFormats.data() ) ) );
46895 }
46896 } while ( result == Result::eIncomplete );
46897 VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() );
46898 surfaceFormats.resize( surfaceFormatCount );
46899 return createResultValue( result, surfaceFormats, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getSurfaceFormats2KHR" );
46900 }
46901#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
46902
46903 template<typename Dispatch>
46905 {
46906 return static_cast<Result>( d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, pPropertyCount, reinterpret_cast<VkDisplayProperties2KHR*>( pProperties ) ) );
46907 }
46908#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
46909 template <typename Allocator, typename Dispatch>
46911 {
46912 std::vector<DisplayProperties2KHR,Allocator> properties;
46913 uint32_t propertyCount;
46914 Result result;
46915 do
46916 {
46917 result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) );
46918 if ( ( result == Result::eSuccess ) && propertyCount )
46919 {
46920 properties.resize( propertyCount );
46921 result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayProperties2KHR*>( properties.data() ) ) );
46922 }
46923 } while ( result == Result::eIncomplete );
46924 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
46925 properties.resize( propertyCount );
46926 return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayProperties2KHR" );
46927 }
46928 template <typename Allocator, typename Dispatch>
46930 {
46931 std::vector<DisplayProperties2KHR,Allocator> properties( vectorAllocator );
46932 uint32_t propertyCount;
46933 Result result;
46934 do
46935 {
46936 result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) );
46937 if ( ( result == Result::eSuccess ) && propertyCount )
46938 {
46939 properties.resize( propertyCount );
46940 result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayProperties2KHR*>( properties.data() ) ) );
46941 }
46942 } while ( result == Result::eIncomplete );
46943 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
46944 properties.resize( propertyCount );
46945 return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayProperties2KHR" );
46946 }
46947#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
46948
46949 template<typename Dispatch>
46951 {
46952 return static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, pPropertyCount, reinterpret_cast<VkDisplayPlaneProperties2KHR*>( pProperties ) ) );
46953 }
46954#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
46955 template <typename Allocator, typename Dispatch>
46957 {
46958 std::vector<DisplayPlaneProperties2KHR,Allocator> properties;
46959 uint32_t propertyCount;
46960 Result result;
46961 do
46962 {
46963 result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) );
46964 if ( ( result == Result::eSuccess ) && propertyCount )
46965 {
46966 properties.resize( propertyCount );
46967 result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPlaneProperties2KHR*>( properties.data() ) ) );
46968 }
46969 } while ( result == Result::eIncomplete );
46970 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
46971 properties.resize( propertyCount );
46972 return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlaneProperties2KHR" );
46973 }
46974 template <typename Allocator, typename Dispatch>
46976 {
46977 std::vector<DisplayPlaneProperties2KHR,Allocator> properties( vectorAllocator );
46978 uint32_t propertyCount;
46979 Result result;
46980 do
46981 {
46982 result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) );
46983 if ( ( result == Result::eSuccess ) && propertyCount )
46984 {
46985 properties.resize( propertyCount );
46986 result = static_cast<Result>( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPlaneProperties2KHR*>( properties.data() ) ) );
46987 }
46988 } while ( result == Result::eIncomplete );
46989 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
46990 properties.resize( propertyCount );
46991 return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlaneProperties2KHR" );
46992 }
46993#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
46994
46995 template<typename Dispatch>
46997 {
46998 return static_cast<Result>( d.vkGetDisplayModeProperties2KHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), pPropertyCount, reinterpret_cast<VkDisplayModeProperties2KHR*>( pProperties ) ) );
46999 }
47000#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47001 template <typename Allocator, typename Dispatch>
47003 {
47004 std::vector<DisplayModeProperties2KHR,Allocator> properties;
47005 uint32_t propertyCount;
47006 Result result;
47007 do
47008 {
47009 result = static_cast<Result>( d.vkGetDisplayModeProperties2KHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, nullptr ) );
47010 if ( ( result == Result::eSuccess ) && propertyCount )
47011 {
47012 properties.resize( propertyCount );
47013 result = static_cast<Result>( d.vkGetDisplayModeProperties2KHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, reinterpret_cast<VkDisplayModeProperties2KHR*>( properties.data() ) ) );
47014 }
47015 } while ( result == Result::eIncomplete );
47016 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
47017 properties.resize( propertyCount );
47018 return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayModeProperties2KHR" );
47019 }
47020 template <typename Allocator, typename Dispatch>
47022 {
47023 std::vector<DisplayModeProperties2KHR,Allocator> properties( vectorAllocator );
47024 uint32_t propertyCount;
47025 Result result;
47026 do
47027 {
47028 result = static_cast<Result>( d.vkGetDisplayModeProperties2KHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, nullptr ) );
47029 if ( ( result == Result::eSuccess ) && propertyCount )
47030 {
47031 properties.resize( propertyCount );
47032 result = static_cast<Result>( d.vkGetDisplayModeProperties2KHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, reinterpret_cast<VkDisplayModeProperties2KHR*>( properties.data() ) ) );
47033 }
47034 } while ( result == Result::eIncomplete );
47035 VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
47036 properties.resize( propertyCount );
47037 return createResultValue( result, properties, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayModeProperties2KHR" );
47038 }
47039#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
47040
47041 template<typename Dispatch>
47043 {
47044 return static_cast<Result>( d.vkGetDisplayPlaneCapabilities2KHR( m_physicalDevice, reinterpret_cast<const VkDisplayPlaneInfo2KHR*>( pDisplayPlaneInfo ), reinterpret_cast<VkDisplayPlaneCapabilities2KHR*>( pCapabilities ) ) );
47045 }
47046#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47047 template<typename Dispatch>
47049 {
47050 DisplayPlaneCapabilities2KHR capabilities;
47051 Result result = static_cast<Result>( d.vkGetDisplayPlaneCapabilities2KHR( m_physicalDevice, reinterpret_cast<const VkDisplayPlaneInfo2KHR*>( &displayPlaneInfo ), reinterpret_cast<VkDisplayPlaneCapabilities2KHR*>( &capabilities ) ) );
47052 return createResultValue( result, capabilities, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getDisplayPlaneCapabilities2KHR" );
47053 }
47054#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
47055
47056 template<typename Dispatch>
47057 VULKAN_HPP_INLINE Result PhysicalDevice::getCalibrateableTimeDomainsEXT( uint32_t* pTimeDomainCount, TimeDomainEXT* pTimeDomains, Dispatch const &d) const
47058 {
47059 return static_cast<Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, pTimeDomainCount, reinterpret_cast<VkTimeDomainEXT*>( pTimeDomains ) ) );
47060 }
47061#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47062 template <typename Allocator, typename Dispatch>
47064 {
47065 std::vector<TimeDomainEXT,Allocator> timeDomains;
47066 uint32_t timeDomainCount;
47067 Result result;
47068 do
47069 {
47070 result = static_cast<Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, nullptr ) );
47071 if ( ( result == Result::eSuccess ) && timeDomainCount )
47072 {
47073 timeDomains.resize( timeDomainCount );
47074 result = static_cast<Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, reinterpret_cast<VkTimeDomainEXT*>( timeDomains.data() ) ) );
47075 }
47076 } while ( result == Result::eIncomplete );
47077 VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() );
47078 timeDomains.resize( timeDomainCount );
47079 return createResultValue( result, timeDomains, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getCalibrateableTimeDomainsEXT" );
47080 }
47081 template <typename Allocator, typename Dispatch>
47083 {
47084 std::vector<TimeDomainEXT,Allocator> timeDomains( vectorAllocator );
47085 uint32_t timeDomainCount;
47086 Result result;
47087 do
47088 {
47089 result = static_cast<Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, nullptr ) );
47090 if ( ( result == Result::eSuccess ) && timeDomainCount )
47091 {
47092 timeDomains.resize( timeDomainCount );
47093 result = static_cast<Result>( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, reinterpret_cast<VkTimeDomainEXT*>( timeDomains.data() ) ) );
47094 }
47095 } while ( result == Result::eIncomplete );
47096 VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() );
47097 timeDomains.resize( timeDomainCount );
47098 return createResultValue( result, timeDomains, VULKAN_HPP_NAMESPACE_STRING"::PhysicalDevice::getCalibrateableTimeDomainsEXT" );
47099 }
47100#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
47101
47103 {
47105 IndirectCommandsLayoutNVX indirectCommandsLayout_ = IndirectCommandsLayoutNVX(),
47106 uint32_t indirectCommandsTokenCount_ = 0,
47107 const IndirectCommandsTokenNVX* pIndirectCommandsTokens_ = nullptr,
47108 uint32_t maxSequencesCount_ = 0,
47109 CommandBuffer targetCommandBuffer_ = CommandBuffer(),
47110 Buffer sequencesCountBuffer_ = Buffer(),
47111 DeviceSize sequencesCountOffset_ = 0,
47112 Buffer sequencesIndexBuffer_ = Buffer(),
47113 DeviceSize sequencesIndexOffset_ = 0 )
47114 : objectTable( objectTable_ )
47115 , indirectCommandsLayout( indirectCommandsLayout_ )
47116 , indirectCommandsTokenCount( indirectCommandsTokenCount_ )
47117 , pIndirectCommandsTokens( pIndirectCommandsTokens_ )
47118 , maxSequencesCount( maxSequencesCount_ )
47119 , targetCommandBuffer( targetCommandBuffer_ )
47120 , sequencesCountBuffer( sequencesCountBuffer_ )
47121 , sequencesCountOffset( sequencesCountOffset_ )
47122 , sequencesIndexBuffer( sequencesIndexBuffer_ )
47123 , sequencesIndexOffset( sequencesIndexOffset_ )
47124 {
47125 }
47126
47128 {
47129 memcpy( this, &rhs, sizeof( CmdProcessCommandsInfoNVX ) );
47130 }
47131
47133 {
47134 memcpy( this, &rhs, sizeof( CmdProcessCommandsInfoNVX ) );
47135 return *this;
47136 }
47138 {
47139 pNext = pNext_;
47140 return *this;
47141 }
47142
47144 {
47145 objectTable = objectTable_;
47146 return *this;
47147 }
47148
47150 {
47151 indirectCommandsLayout = indirectCommandsLayout_;
47152 return *this;
47153 }
47154
47156 {
47157 indirectCommandsTokenCount = indirectCommandsTokenCount_;
47158 return *this;
47159 }
47160
47162 {
47163 pIndirectCommandsTokens = pIndirectCommandsTokens_;
47164 return *this;
47165 }
47166
47168 {
47169 maxSequencesCount = maxSequencesCount_;
47170 return *this;
47171 }
47172
47174 {
47175 targetCommandBuffer = targetCommandBuffer_;
47176 return *this;
47177 }
47178
47180 {
47181 sequencesCountBuffer = sequencesCountBuffer_;
47182 return *this;
47183 }
47184
47186 {
47187 sequencesCountOffset = sequencesCountOffset_;
47188 return *this;
47189 }
47190
47192 {
47193 sequencesIndexBuffer = sequencesIndexBuffer_;
47194 return *this;
47195 }
47196
47198 {
47199 sequencesIndexOffset = sequencesIndexOffset_;
47200 return *this;
47201 }
47202
47203 operator VkCmdProcessCommandsInfoNVX const&() const
47204 {
47205 return *reinterpret_cast<const VkCmdProcessCommandsInfoNVX*>(this);
47206 }
47207
47209 {
47210 return *reinterpret_cast<VkCmdProcessCommandsInfoNVX*>(this);
47211 }
47212
47213 bool operator==( CmdProcessCommandsInfoNVX const& rhs ) const
47214 {
47215 return ( sType == rhs.sType )
47216 && ( pNext == rhs.pNext )
47217 && ( objectTable == rhs.objectTable )
47227 }
47228
47229 bool operator!=( CmdProcessCommandsInfoNVX const& rhs ) const
47230 {
47231 return !operator==( rhs );
47232 }
47233
47234 private:
47236
47237 public:
47238 const void* pNext = nullptr;
47249 };
47250 static_assert( sizeof( CmdProcessCommandsInfoNVX ) == sizeof( VkCmdProcessCommandsInfoNVX ), "struct and wrapper have different size!" );
47251
47253 {
47254 operator VkPhysicalDeviceGroupProperties const&() const
47255 {
47256 return *reinterpret_cast<const VkPhysicalDeviceGroupProperties*>(this);
47257 }
47258
47260 {
47261 return *reinterpret_cast<VkPhysicalDeviceGroupProperties*>(this);
47262 }
47263
47265 {
47266 return ( sType == rhs.sType )
47267 && ( pNext == rhs.pNext )
47269 && ( memcmp( physicalDevices, rhs.physicalDevices, VK_MAX_DEVICE_GROUP_SIZE * sizeof( PhysicalDevice ) ) == 0 )
47270 && ( subsetAllocation == rhs.subsetAllocation );
47271 }
47272
47274 {
47275 return !operator==( rhs );
47276 }
47277
47278 private:
47280
47281 public:
47282 void* pNext = nullptr;
47286 };
47287 static_assert( sizeof( PhysicalDeviceGroupProperties ) == sizeof( VkPhysicalDeviceGroupProperties ), "struct and wrapper have different size!" );
47288
47290
47291#ifndef VULKAN_HPP_NO_SMART_HANDLE
47292 class Instance;
47293
47294 template <typename Dispatch> class UniqueHandleTraits<DebugReportCallbackEXT,Dispatch> {public: using deleter = ObjectDestroy<Instance,Dispatch>; };
47296 template <typename Dispatch> class UniqueHandleTraits<DebugUtilsMessengerEXT,Dispatch> {public: using deleter = ObjectDestroy<Instance,Dispatch>; };
47298 template <typename Dispatch> class UniqueHandleTraits<SurfaceKHR,Dispatch> {public: using deleter = ObjectDestroy<Instance,Dispatch>; };
47300#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
47301
47303 {
47304 public:
47307 {}
47308
47311 {}
47312
47314 : m_instance( instance )
47315 {}
47316
47317#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
47318 Instance & operator=(VkInstance instance)
47319 {
47320 m_instance = instance;
47321 return *this;
47322 }
47323#endif
47324
47325 Instance & operator=( std::nullptr_t )
47326 {
47328 return *this;
47329 }
47330
47331 bool operator==( Instance const & rhs ) const
47332 {
47333 return m_instance == rhs.m_instance;
47334 }
47335
47336 bool operator!=(Instance const & rhs ) const
47337 {
47338 return m_instance != rhs.m_instance;
47339 }
47340
47341 bool operator<(Instance const & rhs ) const
47342 {
47343 return m_instance < rhs.m_instance;
47344 }
47345
47346 template<typename Dispatch = DispatchLoaderStatic>
47347 void destroy( const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
47348#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47349 template<typename Dispatch = DispatchLoaderStatic>
47350 void destroy( Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
47351#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
47352
47353 template<typename Dispatch = DispatchLoaderStatic>
47354 Result enumeratePhysicalDevices( uint32_t* pPhysicalDeviceCount, PhysicalDevice* pPhysicalDevices, Dispatch const &d = Dispatch() ) const;
47355#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47356 template <typename Allocator = std::allocator<PhysicalDevice>, typename Dispatch = DispatchLoaderStatic>
47358 template <typename Allocator = std::allocator<PhysicalDevice>, typename Dispatch = DispatchLoaderStatic>
47359 typename ResultValueType<std::vector<PhysicalDevice,Allocator>>::type enumeratePhysicalDevices(Allocator const& vectorAllocator, Dispatch const &d ) const;
47360#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
47361
47362 template<typename Dispatch = DispatchLoaderStatic>
47363 PFN_vkVoidFunction getProcAddr( const char* pName, Dispatch const &d = Dispatch() ) const;
47364#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47365 template<typename Dispatch = DispatchLoaderStatic>
47366 PFN_vkVoidFunction getProcAddr( const std::string & name, Dispatch const &d = Dispatch() ) const;
47367#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
47368
47369#ifdef VK_USE_PLATFORM_ANDROID_KHR
47370 template<typename Dispatch = DispatchLoaderStatic>
47371 Result createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
47372#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47373 template<typename Dispatch = DispatchLoaderStatic>
47374 ResultValueType<SurfaceKHR>::type createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
47375#ifndef VULKAN_HPP_NO_SMART_HANDLE
47376 template<typename Dispatch = DispatchLoaderStatic>
47377 typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createAndroidSurfaceKHRUnique( const AndroidSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
47378#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
47379#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
47380#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
47381
47382 template<typename Dispatch = DispatchLoaderStatic>
47383 Result createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
47384#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47385 template<typename Dispatch = DispatchLoaderStatic>
47387#ifndef VULKAN_HPP_NO_SMART_HANDLE
47388 template<typename Dispatch = DispatchLoaderStatic>
47390#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
47391#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
47392
47393 template<typename Dispatch = DispatchLoaderStatic>
47394 void destroySurfaceKHR( SurfaceKHR surface, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
47395#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47396 template<typename Dispatch = DispatchLoaderStatic>
47397 void destroySurfaceKHR( SurfaceKHR surface, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
47398#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
47399
47400 template<typename Dispatch = DispatchLoaderStatic>
47401 void destroy( SurfaceKHR surface, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
47402#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47403 template<typename Dispatch = DispatchLoaderStatic>
47404 void destroy( SurfaceKHR surface, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
47405#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
47406
47407#ifdef VK_USE_PLATFORM_VI_NN
47408 template<typename Dispatch = DispatchLoaderStatic>
47409 Result createViSurfaceNN( const ViSurfaceCreateInfoNN* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
47410#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47411 template<typename Dispatch = DispatchLoaderStatic>
47412 ResultValueType<SurfaceKHR>::type createViSurfaceNN( const ViSurfaceCreateInfoNN & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
47413#ifndef VULKAN_HPP_NO_SMART_HANDLE
47414 template<typename Dispatch = DispatchLoaderStatic>
47415 typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createViSurfaceNNUnique( const ViSurfaceCreateInfoNN & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
47416#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
47417#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
47418#endif /*VK_USE_PLATFORM_VI_NN*/
47419
47420#ifdef VK_USE_PLATFORM_WAYLAND_KHR
47421 template<typename Dispatch = DispatchLoaderStatic>
47422 Result createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
47423#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47424 template<typename Dispatch = DispatchLoaderStatic>
47425 ResultValueType<SurfaceKHR>::type createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
47426#ifndef VULKAN_HPP_NO_SMART_HANDLE
47427 template<typename Dispatch = DispatchLoaderStatic>
47428 typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createWaylandSurfaceKHRUnique( const WaylandSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
47429#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
47430#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
47431#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
47432
47433#ifdef VK_USE_PLATFORM_WIN32_KHR
47434 template<typename Dispatch = DispatchLoaderStatic>
47435 Result createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
47436#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47437 template<typename Dispatch = DispatchLoaderStatic>
47438 ResultValueType<SurfaceKHR>::type createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
47439#ifndef VULKAN_HPP_NO_SMART_HANDLE
47440 template<typename Dispatch = DispatchLoaderStatic>
47441 typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createWin32SurfaceKHRUnique( const Win32SurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
47442#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
47443#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
47444#endif /*VK_USE_PLATFORM_WIN32_KHR*/
47445
47446#ifdef VK_USE_PLATFORM_XLIB_KHR
47447 template<typename Dispatch = DispatchLoaderStatic>
47448 Result createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
47449#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47450 template<typename Dispatch = DispatchLoaderStatic>
47451 ResultValueType<SurfaceKHR>::type createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
47452#ifndef VULKAN_HPP_NO_SMART_HANDLE
47453 template<typename Dispatch = DispatchLoaderStatic>
47454 typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createXlibSurfaceKHRUnique( const XlibSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
47455#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
47456#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
47457#endif /*VK_USE_PLATFORM_XLIB_KHR*/
47458
47459#ifdef VK_USE_PLATFORM_XCB_KHR
47460 template<typename Dispatch = DispatchLoaderStatic>
47461 Result createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
47462#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47463 template<typename Dispatch = DispatchLoaderStatic>
47464 ResultValueType<SurfaceKHR>::type createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
47465#ifndef VULKAN_HPP_NO_SMART_HANDLE
47466 template<typename Dispatch = DispatchLoaderStatic>
47467 typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createXcbSurfaceKHRUnique( const XcbSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
47468#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
47469#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
47470#endif /*VK_USE_PLATFORM_XCB_KHR*/
47471
47472#ifdef VK_USE_PLATFORM_FUCHSIA_FUCHSIA
47473 template<typename Dispatch = DispatchLoaderStatic>
47474 Result createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
47475#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47476 template<typename Dispatch = DispatchLoaderStatic>
47477 ResultValueType<SurfaceKHR>::type createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
47478#ifndef VULKAN_HPP_NO_SMART_HANDLE
47479 template<typename Dispatch = DispatchLoaderStatic>
47480 typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createImagePipeSurfaceFUCHSIAUnique( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
47481#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
47482#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
47483#endif /*VK_USE_PLATFORM_FUCHSIA_FUCHSIA*/
47484
47485 template<typename Dispatch = DispatchLoaderStatic>
47486 Result createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, DebugReportCallbackEXT* pCallback, Dispatch const &d = Dispatch() ) const;
47487#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47488 template<typename Dispatch = DispatchLoaderStatic>
47490#ifndef VULKAN_HPP_NO_SMART_HANDLE
47491 template<typename Dispatch = DispatchLoaderStatic>
47493#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
47494#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
47495
47496 template<typename Dispatch = DispatchLoaderStatic>
47497 void destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
47498#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47499 template<typename Dispatch = DispatchLoaderStatic>
47500 void destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
47501#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
47502
47503 template<typename Dispatch = DispatchLoaderStatic>
47504 void destroy( DebugReportCallbackEXT callback, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
47505#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47506 template<typename Dispatch = DispatchLoaderStatic>
47507 void destroy( DebugReportCallbackEXT callback, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
47508#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
47509
47510 template<typename Dispatch = DispatchLoaderStatic>
47511 void debugReportMessageEXT( DebugReportFlagsEXT flags, DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage, Dispatch const &d = Dispatch() ) const;
47512#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47513 template<typename Dispatch = DispatchLoaderStatic>
47514 void debugReportMessageEXT( DebugReportFlagsEXT flags, DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const std::string & layerPrefix, const std::string & message, Dispatch const &d = Dispatch() ) const;
47515#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
47516
47517 template<typename Dispatch = DispatchLoaderStatic>
47518 Result enumeratePhysicalDeviceGroups( uint32_t* pPhysicalDeviceGroupCount, PhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, Dispatch const &d = Dispatch() ) const;
47519#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47520 template <typename Allocator = std::allocator<PhysicalDeviceGroupProperties>, typename Dispatch = DispatchLoaderStatic>
47522 template <typename Allocator = std::allocator<PhysicalDeviceGroupProperties>, typename Dispatch = DispatchLoaderStatic>
47524#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
47525
47526 template<typename Dispatch = DispatchLoaderStatic>
47527 Result enumeratePhysicalDeviceGroupsKHR( uint32_t* pPhysicalDeviceGroupCount, PhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, Dispatch const &d = Dispatch() ) const;
47528#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47529 template <typename Allocator = std::allocator<PhysicalDeviceGroupProperties>, typename Dispatch = DispatchLoaderStatic>
47531 template <typename Allocator = std::allocator<PhysicalDeviceGroupProperties>, typename Dispatch = DispatchLoaderStatic>
47533#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
47534
47535#ifdef VK_USE_PLATFORM_IOS_MVK
47536 template<typename Dispatch = DispatchLoaderStatic>
47537 Result createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
47538#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47539 template<typename Dispatch = DispatchLoaderStatic>
47540 ResultValueType<SurfaceKHR>::type createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
47541#ifndef VULKAN_HPP_NO_SMART_HANDLE
47542 template<typename Dispatch = DispatchLoaderStatic>
47543 typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createIOSSurfaceMVKUnique( const IOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
47544#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
47545#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
47546#endif /*VK_USE_PLATFORM_IOS_MVK*/
47547
47548#ifdef VK_USE_PLATFORM_MACOS_MVK
47549 template<typename Dispatch = DispatchLoaderStatic>
47550 Result createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d = Dispatch() ) const;
47551#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47552 template<typename Dispatch = DispatchLoaderStatic>
47553 ResultValueType<SurfaceKHR>::type createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
47554#ifndef VULKAN_HPP_NO_SMART_HANDLE
47555 template<typename Dispatch = DispatchLoaderStatic>
47556 typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type createMacOSSurfaceMVKUnique( const MacOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
47557#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
47558#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
47559#endif /*VK_USE_PLATFORM_MACOS_MVK*/
47560
47561 template<typename Dispatch = DispatchLoaderStatic>
47562 Result createDebugUtilsMessengerEXT( const DebugUtilsMessengerCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, DebugUtilsMessengerEXT* pMessenger, Dispatch const &d = Dispatch() ) const;
47563#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47564 template<typename Dispatch = DispatchLoaderStatic>
47566#ifndef VULKAN_HPP_NO_SMART_HANDLE
47567 template<typename Dispatch = DispatchLoaderStatic>
47569#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
47570#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
47571
47572 template<typename Dispatch = DispatchLoaderStatic>
47573 void destroyDebugUtilsMessengerEXT( DebugUtilsMessengerEXT messenger, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
47574#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47575 template<typename Dispatch = DispatchLoaderStatic>
47576 void destroyDebugUtilsMessengerEXT( DebugUtilsMessengerEXT messenger, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
47577#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
47578
47579 template<typename Dispatch = DispatchLoaderStatic>
47580 void destroy( DebugUtilsMessengerEXT messenger, const AllocationCallbacks* pAllocator, Dispatch const &d = Dispatch() ) const;
47581#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47582 template<typename Dispatch = DispatchLoaderStatic>
47583 void destroy( DebugUtilsMessengerEXT messenger, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() ) const;
47584#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
47585
47586 template<typename Dispatch = DispatchLoaderStatic>
47587 void submitDebugUtilsMessageEXT( DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, DebugUtilsMessageTypeFlagsEXT messageTypes, const DebugUtilsMessengerCallbackDataEXT* pCallbackData, Dispatch const &d = Dispatch() ) const;
47588#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47589 template<typename Dispatch = DispatchLoaderStatic>
47590 void submitDebugUtilsMessageEXT( DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, DebugUtilsMessageTypeFlagsEXT messageTypes, const DebugUtilsMessengerCallbackDataEXT & callbackData, Dispatch const &d = Dispatch() ) const;
47591#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
47592
47593
47594
47595 VULKAN_HPP_TYPESAFE_EXPLICIT operator VkInstance() const
47596 {
47597 return m_instance;
47598 }
47599
47600 explicit operator bool() const
47601 {
47602 return m_instance != VK_NULL_HANDLE;
47603 }
47604
47605 bool operator!() const
47606 {
47607 return m_instance == VK_NULL_HANDLE;
47608 }
47609
47610 private:
47611 VkInstance m_instance;
47612 };
47613
47614 static_assert( sizeof( Instance ) == sizeof( VkInstance ), "handle and wrapper have different size!" );
47615
47616 template<typename Dispatch>
47617 VULKAN_HPP_INLINE void Instance::destroy( const AllocationCallbacks* pAllocator, Dispatch const &d) const
47618 {
47619 d.vkDestroyInstance( m_instance, reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
47620 }
47621#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47622 template<typename Dispatch>
47624 {
47625 d.vkDestroyInstance( m_instance, reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
47626 }
47627#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
47628
47629 template<typename Dispatch>
47630 VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDevices( uint32_t* pPhysicalDeviceCount, PhysicalDevice* pPhysicalDevices, Dispatch const &d) const
47631 {
47632 return static_cast<Result>( d.vkEnumeratePhysicalDevices( m_instance, pPhysicalDeviceCount, reinterpret_cast<VkPhysicalDevice*>( pPhysicalDevices ) ) );
47633 }
47634#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47635 template <typename Allocator, typename Dispatch>
47637 {
47638 std::vector<PhysicalDevice,Allocator> physicalDevices;
47639 uint32_t physicalDeviceCount;
47640 Result result;
47641 do
47642 {
47643 result = static_cast<Result>( d.vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, nullptr ) );
47644 if ( ( result == Result::eSuccess ) && physicalDeviceCount )
47645 {
47646 physicalDevices.resize( physicalDeviceCount );
47647 result = static_cast<Result>( d.vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, reinterpret_cast<VkPhysicalDevice*>( physicalDevices.data() ) ) );
47648 }
47649 } while ( result == Result::eIncomplete );
47650 VULKAN_HPP_ASSERT( physicalDeviceCount <= physicalDevices.size() );
47651 physicalDevices.resize( physicalDeviceCount );
47652 return createResultValue( result, physicalDevices, VULKAN_HPP_NAMESPACE_STRING"::Instance::enumeratePhysicalDevices" );
47653 }
47654 template <typename Allocator, typename Dispatch>
47656 {
47657 std::vector<PhysicalDevice,Allocator> physicalDevices( vectorAllocator );
47658 uint32_t physicalDeviceCount;
47659 Result result;
47660 do
47661 {
47662 result = static_cast<Result>( d.vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, nullptr ) );
47663 if ( ( result == Result::eSuccess ) && physicalDeviceCount )
47664 {
47665 physicalDevices.resize( physicalDeviceCount );
47666 result = static_cast<Result>( d.vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, reinterpret_cast<VkPhysicalDevice*>( physicalDevices.data() ) ) );
47667 }
47668 } while ( result == Result::eIncomplete );
47669 VULKAN_HPP_ASSERT( physicalDeviceCount <= physicalDevices.size() );
47670 physicalDevices.resize( physicalDeviceCount );
47671 return createResultValue( result, physicalDevices, VULKAN_HPP_NAMESPACE_STRING"::Instance::enumeratePhysicalDevices" );
47672 }
47673#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
47674
47675 template<typename Dispatch>
47676 VULKAN_HPP_INLINE PFN_vkVoidFunction Instance::getProcAddr( const char* pName, Dispatch const &d) const
47677 {
47678 return d.vkGetInstanceProcAddr( m_instance, pName );
47679 }
47680#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47681 template<typename Dispatch>
47683 {
47684 return d.vkGetInstanceProcAddr( m_instance, name.c_str() );
47685 }
47686#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
47687
47688#ifdef VK_USE_PLATFORM_ANDROID_KHR
47689 template<typename Dispatch>
47690 VULKAN_HPP_INLINE Result Instance::createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
47691 {
47692 return static_cast<Result>( d.vkCreateAndroidSurfaceKHR( m_instance, reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
47693 }
47694#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47695 template<typename Dispatch>
47696 VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
47697 {
47698 SurfaceKHR surface;
47699 Result result = static_cast<Result>( d.vkCreateAndroidSurfaceKHR( m_instance, reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
47700 return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createAndroidSurfaceKHR" );
47701 }
47702#ifndef VULKAN_HPP_NO_SMART_HANDLE
47703 template<typename Dispatch>
47704 VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createAndroidSurfaceKHRUnique( const AndroidSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
47705 {
47706 SurfaceKHR surface;
47707 Result result = static_cast<Result>( d.vkCreateAndroidSurfaceKHR( m_instance, reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
47708
47709 ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
47710 return createResultValue<SurfaceKHR,Dispatch>( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createAndroidSurfaceKHRUnique", deleter );
47711 }
47712#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
47713#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
47714#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
47715
47716 template<typename Dispatch>
47718 {
47719 return static_cast<Result>( d.vkCreateDisplayPlaneSurfaceKHR( m_instance, reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
47720 }
47721#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47722 template<typename Dispatch>
47724 {
47726 Result result = static_cast<Result>( d.vkCreateDisplayPlaneSurfaceKHR( m_instance, reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
47727 return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createDisplayPlaneSurfaceKHR" );
47728 }
47729#ifndef VULKAN_HPP_NO_SMART_HANDLE
47730 template<typename Dispatch>
47732 {
47734 Result result = static_cast<Result>( d.vkCreateDisplayPlaneSurfaceKHR( m_instance, reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
47735
47736 ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
47737 return createResultValue<SurfaceKHR,Dispatch>( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createDisplayPlaneSurfaceKHRUnique", deleter );
47738 }
47739#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
47740#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
47741
47742 template<typename Dispatch>
47744 {
47745 d.vkDestroySurfaceKHR( m_instance, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
47746 }
47747#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47748 template<typename Dispatch>
47750 {
47751 d.vkDestroySurfaceKHR( m_instance, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
47752 }
47753#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
47754
47755 template<typename Dispatch>
47756 VULKAN_HPP_INLINE void Instance::destroy( SurfaceKHR surface, const AllocationCallbacks* pAllocator, Dispatch const &d) const
47757 {
47758 d.vkDestroySurfaceKHR( m_instance, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
47759 }
47760#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47761 template<typename Dispatch>
47763 {
47764 d.vkDestroySurfaceKHR( m_instance, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
47765 }
47766#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
47767
47768#ifdef VK_USE_PLATFORM_VI_NN
47769 template<typename Dispatch>
47770 VULKAN_HPP_INLINE Result Instance::createViSurfaceNN( const ViSurfaceCreateInfoNN* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
47771 {
47772 return static_cast<Result>( d.vkCreateViSurfaceNN( m_instance, reinterpret_cast<const VkViSurfaceCreateInfoNN*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
47773 }
47774#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47775 template<typename Dispatch>
47776 VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createViSurfaceNN( const ViSurfaceCreateInfoNN & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
47777 {
47778 SurfaceKHR surface;
47779 Result result = static_cast<Result>( d.vkCreateViSurfaceNN( m_instance, reinterpret_cast<const VkViSurfaceCreateInfoNN*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
47780 return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createViSurfaceNN" );
47781 }
47782#ifndef VULKAN_HPP_NO_SMART_HANDLE
47783 template<typename Dispatch>
47784 VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createViSurfaceNNUnique( const ViSurfaceCreateInfoNN & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
47785 {
47786 SurfaceKHR surface;
47787 Result result = static_cast<Result>( d.vkCreateViSurfaceNN( m_instance, reinterpret_cast<const VkViSurfaceCreateInfoNN*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
47788
47789 ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
47790 return createResultValue<SurfaceKHR,Dispatch>( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createViSurfaceNNUnique", deleter );
47791 }
47792#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
47793#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
47794#endif /*VK_USE_PLATFORM_VI_NN*/
47795
47796#ifdef VK_USE_PLATFORM_WAYLAND_KHR
47797 template<typename Dispatch>
47798 VULKAN_HPP_INLINE Result Instance::createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
47799 {
47800 return static_cast<Result>( d.vkCreateWaylandSurfaceKHR( m_instance, reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
47801 }
47802#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47803 template<typename Dispatch>
47804 VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
47805 {
47806 SurfaceKHR surface;
47807 Result result = static_cast<Result>( d.vkCreateWaylandSurfaceKHR( m_instance, reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
47808 return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createWaylandSurfaceKHR" );
47809 }
47810#ifndef VULKAN_HPP_NO_SMART_HANDLE
47811 template<typename Dispatch>
47812 VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createWaylandSurfaceKHRUnique( const WaylandSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
47813 {
47814 SurfaceKHR surface;
47815 Result result = static_cast<Result>( d.vkCreateWaylandSurfaceKHR( m_instance, reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
47816
47817 ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
47818 return createResultValue<SurfaceKHR,Dispatch>( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createWaylandSurfaceKHRUnique", deleter );
47819 }
47820#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
47821#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
47822#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
47823
47824#ifdef VK_USE_PLATFORM_WIN32_KHR
47825 template<typename Dispatch>
47826 VULKAN_HPP_INLINE Result Instance::createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
47827 {
47828 return static_cast<Result>( d.vkCreateWin32SurfaceKHR( m_instance, reinterpret_cast<const VkWin32SurfaceCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
47829 }
47830#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47831 template<typename Dispatch>
47832 VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
47833 {
47834 SurfaceKHR surface;
47835 Result result = static_cast<Result>( d.vkCreateWin32SurfaceKHR( m_instance, reinterpret_cast<const VkWin32SurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
47836 return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createWin32SurfaceKHR" );
47837 }
47838#ifndef VULKAN_HPP_NO_SMART_HANDLE
47839 template<typename Dispatch>
47840 VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createWin32SurfaceKHRUnique( const Win32SurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
47841 {
47842 SurfaceKHR surface;
47843 Result result = static_cast<Result>( d.vkCreateWin32SurfaceKHR( m_instance, reinterpret_cast<const VkWin32SurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
47844
47845 ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
47846 return createResultValue<SurfaceKHR,Dispatch>( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createWin32SurfaceKHRUnique", deleter );
47847 }
47848#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
47849#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
47850#endif /*VK_USE_PLATFORM_WIN32_KHR*/
47851
47852#ifdef VK_USE_PLATFORM_XLIB_KHR
47853 template<typename Dispatch>
47854 VULKAN_HPP_INLINE Result Instance::createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
47855 {
47856 return static_cast<Result>( d.vkCreateXlibSurfaceKHR( m_instance, reinterpret_cast<const VkXlibSurfaceCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
47857 }
47858#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47859 template<typename Dispatch>
47860 VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
47861 {
47862 SurfaceKHR surface;
47863 Result result = static_cast<Result>( d.vkCreateXlibSurfaceKHR( m_instance, reinterpret_cast<const VkXlibSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
47864 return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createXlibSurfaceKHR" );
47865 }
47866#ifndef VULKAN_HPP_NO_SMART_HANDLE
47867 template<typename Dispatch>
47868 VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createXlibSurfaceKHRUnique( const XlibSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
47869 {
47870 SurfaceKHR surface;
47871 Result result = static_cast<Result>( d.vkCreateXlibSurfaceKHR( m_instance, reinterpret_cast<const VkXlibSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
47872
47873 ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
47874 return createResultValue<SurfaceKHR,Dispatch>( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createXlibSurfaceKHRUnique", deleter );
47875 }
47876#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
47877#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
47878#endif /*VK_USE_PLATFORM_XLIB_KHR*/
47879
47880#ifdef VK_USE_PLATFORM_XCB_KHR
47881 template<typename Dispatch>
47882 VULKAN_HPP_INLINE Result Instance::createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
47883 {
47884 return static_cast<Result>( d.vkCreateXcbSurfaceKHR( m_instance, reinterpret_cast<const VkXcbSurfaceCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
47885 }
47886#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47887 template<typename Dispatch>
47888 VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
47889 {
47890 SurfaceKHR surface;
47891 Result result = static_cast<Result>( d.vkCreateXcbSurfaceKHR( m_instance, reinterpret_cast<const VkXcbSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
47892 return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createXcbSurfaceKHR" );
47893 }
47894#ifndef VULKAN_HPP_NO_SMART_HANDLE
47895 template<typename Dispatch>
47896 VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createXcbSurfaceKHRUnique( const XcbSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
47897 {
47898 SurfaceKHR surface;
47899 Result result = static_cast<Result>( d.vkCreateXcbSurfaceKHR( m_instance, reinterpret_cast<const VkXcbSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
47900
47901 ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
47902 return createResultValue<SurfaceKHR,Dispatch>( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createXcbSurfaceKHRUnique", deleter );
47903 }
47904#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
47905#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
47906#endif /*VK_USE_PLATFORM_XCB_KHR*/
47907
47908#ifdef VK_USE_PLATFORM_FUCHSIA_FUCHSIA
47909 template<typename Dispatch>
47910 VULKAN_HPP_INLINE Result Instance::createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
47911 {
47912 return static_cast<Result>( d.vkCreateImagePipeSurfaceFUCHSIA( m_instance, reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
47913 }
47914#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47915 template<typename Dispatch>
47916 VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
47917 {
47918 SurfaceKHR surface;
47919 Result result = static_cast<Result>( d.vkCreateImagePipeSurfaceFUCHSIA( m_instance, reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
47920 return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createImagePipeSurfaceFUCHSIA" );
47921 }
47922#ifndef VULKAN_HPP_NO_SMART_HANDLE
47923 template<typename Dispatch>
47924 VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createImagePipeSurfaceFUCHSIAUnique( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
47925 {
47926 SurfaceKHR surface;
47927 Result result = static_cast<Result>( d.vkCreateImagePipeSurfaceFUCHSIA( m_instance, reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
47928
47929 ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
47930 return createResultValue<SurfaceKHR,Dispatch>( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createImagePipeSurfaceFUCHSIAUnique", deleter );
47931 }
47932#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
47933#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
47934#endif /*VK_USE_PLATFORM_FUCHSIA_FUCHSIA*/
47935
47936 template<typename Dispatch>
47938 {
47939 return static_cast<Result>( d.vkCreateDebugReportCallbackEXT( m_instance, reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDebugReportCallbackEXT*>( pCallback ) ) );
47940 }
47941#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47942 template<typename Dispatch>
47944 {
47946 Result result = static_cast<Result>( d.vkCreateDebugReportCallbackEXT( m_instance, reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDebugReportCallbackEXT*>( &callback ) ) );
47947 return createResultValue( result, callback, VULKAN_HPP_NAMESPACE_STRING"::Instance::createDebugReportCallbackEXT" );
47948 }
47949#ifndef VULKAN_HPP_NO_SMART_HANDLE
47950 template<typename Dispatch>
47952 {
47954 Result result = static_cast<Result>( d.vkCreateDebugReportCallbackEXT( m_instance, reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDebugReportCallbackEXT*>( &callback ) ) );
47955
47956 ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
47957 return createResultValue<DebugReportCallbackEXT,Dispatch>( result, callback, VULKAN_HPP_NAMESPACE_STRING"::Instance::createDebugReportCallbackEXTUnique", deleter );
47958 }
47959#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
47960#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
47961
47962 template<typename Dispatch>
47964 {
47965 d.vkDestroyDebugReportCallbackEXT( m_instance, static_cast<VkDebugReportCallbackEXT>( callback ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
47966 }
47967#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47968 template<typename Dispatch>
47970 {
47971 d.vkDestroyDebugReportCallbackEXT( m_instance, static_cast<VkDebugReportCallbackEXT>( callback ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
47972 }
47973#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
47974
47975 template<typename Dispatch>
47977 {
47978 d.vkDestroyDebugReportCallbackEXT( m_instance, static_cast<VkDebugReportCallbackEXT>( callback ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
47979 }
47980#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47981 template<typename Dispatch>
47983 {
47984 d.vkDestroyDebugReportCallbackEXT( m_instance, static_cast<VkDebugReportCallbackEXT>( callback ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
47985 }
47986#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
47987
47988 template<typename Dispatch>
47989 VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( DebugReportFlagsEXT flags, DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage, Dispatch const &d) const
47990 {
47991 d.vkDebugReportMessageEXT( m_instance, static_cast<VkDebugReportFlagsEXT>( flags ), static_cast<VkDebugReportObjectTypeEXT>( objectType ), object, location, messageCode, pLayerPrefix, pMessage );
47992 }
47993#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
47994 template<typename Dispatch>
47996 {
47997#ifdef VULKAN_HPP_NO_EXCEPTIONS
47998 VULKAN_HPP_ASSERT( layerPrefix.size() == message.size() );
47999#else
48000 if ( layerPrefix.size() != message.size() )
48001 {
48002 throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Instance::debugReportMessageEXT: layerPrefix.size() != message.size()" );
48003 }
48004#endif // VULKAN_HPP_NO_EXCEPTIONS
48005 d.vkDebugReportMessageEXT( m_instance, static_cast<VkDebugReportFlagsEXT>( flags ), static_cast<VkDebugReportObjectTypeEXT>( objectType ), object, location, messageCode, layerPrefix.c_str(), message.c_str() );
48006 }
48007#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
48008
48009 template<typename Dispatch>
48010 VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDeviceGroups( uint32_t* pPhysicalDeviceGroupCount, PhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, Dispatch const &d) const
48011 {
48012 return static_cast<Result>( d.vkEnumeratePhysicalDeviceGroups( m_instance, pPhysicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupProperties*>( pPhysicalDeviceGroupProperties ) ) );
48013 }
48014#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
48015 template <typename Allocator, typename Dispatch>
48017 {
48018 std::vector<PhysicalDeviceGroupProperties,Allocator> physicalDeviceGroupProperties;
48019 uint32_t physicalDeviceGroupCount;
48020 Result result;
48021 do
48022 {
48023 result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroups( m_instance, &physicalDeviceGroupCount, nullptr ) );
48024 if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount )
48025 {
48026 physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
48027 result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroups( m_instance, &physicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupProperties*>( physicalDeviceGroupProperties.data() ) ) );
48028 }
48029 } while ( result == Result::eIncomplete );
48030 VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() );
48031 physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
48032 return createResultValue( result, physicalDeviceGroupProperties, VULKAN_HPP_NAMESPACE_STRING"::Instance::enumeratePhysicalDeviceGroups" );
48033 }
48034 template <typename Allocator, typename Dispatch>
48036 {
48037 std::vector<PhysicalDeviceGroupProperties,Allocator> physicalDeviceGroupProperties( vectorAllocator );
48038 uint32_t physicalDeviceGroupCount;
48039 Result result;
48040 do
48041 {
48042 result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroups( m_instance, &physicalDeviceGroupCount, nullptr ) );
48043 if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount )
48044 {
48045 physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
48046 result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroups( m_instance, &physicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupProperties*>( physicalDeviceGroupProperties.data() ) ) );
48047 }
48048 } while ( result == Result::eIncomplete );
48049 VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() );
48050 physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
48051 return createResultValue( result, physicalDeviceGroupProperties, VULKAN_HPP_NAMESPACE_STRING"::Instance::enumeratePhysicalDeviceGroups" );
48052 }
48053#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
48054
48055 template<typename Dispatch>
48056 VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDeviceGroupsKHR( uint32_t* pPhysicalDeviceGroupCount, PhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, Dispatch const &d) const
48057 {
48058 return static_cast<Result>( d.vkEnumeratePhysicalDeviceGroupsKHR( m_instance, pPhysicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupProperties*>( pPhysicalDeviceGroupProperties ) ) );
48059 }
48060#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
48061 template <typename Allocator, typename Dispatch>
48063 {
48064 std::vector<PhysicalDeviceGroupProperties,Allocator> physicalDeviceGroupProperties;
48065 uint32_t physicalDeviceGroupCount;
48066 Result result;
48067 do
48068 {
48069 result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroupsKHR( m_instance, &physicalDeviceGroupCount, nullptr ) );
48070 if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount )
48071 {
48072 physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
48073 result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroupsKHR( m_instance, &physicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupProperties*>( physicalDeviceGroupProperties.data() ) ) );
48074 }
48075 } while ( result == Result::eIncomplete );
48076 VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() );
48077 physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
48078 return createResultValue( result, physicalDeviceGroupProperties, VULKAN_HPP_NAMESPACE_STRING"::Instance::enumeratePhysicalDeviceGroupsKHR" );
48079 }
48080 template <typename Allocator, typename Dispatch>
48082 {
48083 std::vector<PhysicalDeviceGroupProperties,Allocator> physicalDeviceGroupProperties( vectorAllocator );
48084 uint32_t physicalDeviceGroupCount;
48085 Result result;
48086 do
48087 {
48088 result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroupsKHR( m_instance, &physicalDeviceGroupCount, nullptr ) );
48089 if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount )
48090 {
48091 physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
48092 result = static_cast<Result>( d.vkEnumeratePhysicalDeviceGroupsKHR( m_instance, &physicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupProperties*>( physicalDeviceGroupProperties.data() ) ) );
48093 }
48094 } while ( result == Result::eIncomplete );
48095 VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() );
48096 physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
48097 return createResultValue( result, physicalDeviceGroupProperties, VULKAN_HPP_NAMESPACE_STRING"::Instance::enumeratePhysicalDeviceGroupsKHR" );
48098 }
48099#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
48100
48101#ifdef VK_USE_PLATFORM_IOS_MVK
48102 template<typename Dispatch>
48103 VULKAN_HPP_INLINE Result Instance::createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
48104 {
48105 return static_cast<Result>( d.vkCreateIOSSurfaceMVK( m_instance, reinterpret_cast<const VkIOSSurfaceCreateInfoMVK*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
48106 }
48107#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
48108 template<typename Dispatch>
48109 VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
48110 {
48111 SurfaceKHR surface;
48112 Result result = static_cast<Result>( d.vkCreateIOSSurfaceMVK( m_instance, reinterpret_cast<const VkIOSSurfaceCreateInfoMVK*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
48113 return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createIOSSurfaceMVK" );
48114 }
48115#ifndef VULKAN_HPP_NO_SMART_HANDLE
48116 template<typename Dispatch>
48117 VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createIOSSurfaceMVKUnique( const IOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
48118 {
48119 SurfaceKHR surface;
48120 Result result = static_cast<Result>( d.vkCreateIOSSurfaceMVK( m_instance, reinterpret_cast<const VkIOSSurfaceCreateInfoMVK*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
48121
48122 ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
48123 return createResultValue<SurfaceKHR,Dispatch>( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createIOSSurfaceMVKUnique", deleter );
48124 }
48125#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
48126#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
48127#endif /*VK_USE_PLATFORM_IOS_MVK*/
48128
48129#ifdef VK_USE_PLATFORM_MACOS_MVK
48130 template<typename Dispatch>
48131 VULKAN_HPP_INLINE Result Instance::createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface, Dispatch const &d) const
48132 {
48133 return static_cast<Result>( d.vkCreateMacOSSurfaceMVK( m_instance, reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
48134 }
48135#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
48136 template<typename Dispatch>
48137 VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
48138 {
48139 SurfaceKHR surface;
48140 Result result = static_cast<Result>( d.vkCreateMacOSSurfaceMVK( m_instance, reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
48141 return createResultValue( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createMacOSSurfaceMVK" );
48142 }
48143#ifndef VULKAN_HPP_NO_SMART_HANDLE
48144 template<typename Dispatch>
48145 VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<SurfaceKHR,Dispatch>>::type Instance::createMacOSSurfaceMVKUnique( const MacOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator, Dispatch const &d ) const
48146 {
48147 SurfaceKHR surface;
48148 Result result = static_cast<Result>( d.vkCreateMacOSSurfaceMVK( m_instance, reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
48149
48150 ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
48151 return createResultValue<SurfaceKHR,Dispatch>( result, surface, VULKAN_HPP_NAMESPACE_STRING"::Instance::createMacOSSurfaceMVKUnique", deleter );
48152 }
48153#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
48154#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
48155#endif /*VK_USE_PLATFORM_MACOS_MVK*/
48156
48157 template<typename Dispatch>
48159 {
48160 return static_cast<Result>( d.vkCreateDebugUtilsMessengerEXT( m_instance, reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDebugUtilsMessengerEXT*>( pMessenger ) ) );
48161 }
48162#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
48163 template<typename Dispatch>
48165 {
48166 DebugUtilsMessengerEXT messenger;
48167 Result result = static_cast<Result>( d.vkCreateDebugUtilsMessengerEXT( m_instance, reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDebugUtilsMessengerEXT*>( &messenger ) ) );
48168 return createResultValue( result, messenger, VULKAN_HPP_NAMESPACE_STRING"::Instance::createDebugUtilsMessengerEXT" );
48169 }
48170#ifndef VULKAN_HPP_NO_SMART_HANDLE
48171 template<typename Dispatch>
48173 {
48174 DebugUtilsMessengerEXT messenger;
48175 Result result = static_cast<Result>( d.vkCreateDebugUtilsMessengerEXT( m_instance, reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDebugUtilsMessengerEXT*>( &messenger ) ) );
48176
48177 ObjectDestroy<Instance,Dispatch> deleter( *this, allocator, d );
48178 return createResultValue<DebugUtilsMessengerEXT,Dispatch>( result, messenger, VULKAN_HPP_NAMESPACE_STRING"::Instance::createDebugUtilsMessengerEXTUnique", deleter );
48179 }
48180#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
48181#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
48182
48183 template<typename Dispatch>
48185 {
48186 d.vkDestroyDebugUtilsMessengerEXT( m_instance, static_cast<VkDebugUtilsMessengerEXT>( messenger ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
48187 }
48188#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
48189 template<typename Dispatch>
48191 {
48192 d.vkDestroyDebugUtilsMessengerEXT( m_instance, static_cast<VkDebugUtilsMessengerEXT>( messenger ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
48193 }
48194#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
48195
48196 template<typename Dispatch>
48197 VULKAN_HPP_INLINE void Instance::destroy( DebugUtilsMessengerEXT messenger, const AllocationCallbacks* pAllocator, Dispatch const &d) const
48198 {
48199 d.vkDestroyDebugUtilsMessengerEXT( m_instance, static_cast<VkDebugUtilsMessengerEXT>( messenger ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
48200 }
48201#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
48202 template<typename Dispatch>
48204 {
48205 d.vkDestroyDebugUtilsMessengerEXT( m_instance, static_cast<VkDebugUtilsMessengerEXT>( messenger ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
48206 }
48207#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
48208
48209 template<typename Dispatch>
48211 {
48212 d.vkSubmitDebugUtilsMessageEXT( m_instance, static_cast<VkDebugUtilsMessageSeverityFlagBitsEXT>( messageSeverity ), static_cast<VkDebugUtilsMessageTypeFlagsEXT>( messageTypes ), reinterpret_cast<const VkDebugUtilsMessengerCallbackDataEXT*>( pCallbackData ) );
48213 }
48214#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
48215 template<typename Dispatch>
48217 {
48218 d.vkSubmitDebugUtilsMessageEXT( m_instance, static_cast<VkDebugUtilsMessageSeverityFlagBitsEXT>( messageSeverity ), static_cast<VkDebugUtilsMessageTypeFlagsEXT>( messageTypes ), reinterpret_cast<const VkDebugUtilsMessengerCallbackDataEXT*>( &callbackData ) );
48219 }
48220#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
48221
48223 {
48224 DeviceGroupDeviceCreateInfo( uint32_t physicalDeviceCount_ = 0,
48225 const PhysicalDevice* pPhysicalDevices_ = nullptr )
48226 : physicalDeviceCount( physicalDeviceCount_ )
48227 , pPhysicalDevices( pPhysicalDevices_ )
48228 {
48229 }
48230
48232 {
48233 memcpy( this, &rhs, sizeof( DeviceGroupDeviceCreateInfo ) );
48234 }
48235
48237 {
48238 memcpy( this, &rhs, sizeof( DeviceGroupDeviceCreateInfo ) );
48239 return *this;
48240 }
48242 {
48243 pNext = pNext_;
48244 return *this;
48245 }
48246
48248 {
48249 physicalDeviceCount = physicalDeviceCount_;
48250 return *this;
48251 }
48252
48254 {
48255 pPhysicalDevices = pPhysicalDevices_;
48256 return *this;
48257 }
48258
48259 operator VkDeviceGroupDeviceCreateInfo const&() const
48260 {
48261 return *reinterpret_cast<const VkDeviceGroupDeviceCreateInfo*>(this);
48262 }
48263
48265 {
48266 return *reinterpret_cast<VkDeviceGroupDeviceCreateInfo*>(this);
48267 }
48268
48270 {
48271 return ( sType == rhs.sType )
48272 && ( pNext == rhs.pNext )
48274 && ( pPhysicalDevices == rhs.pPhysicalDevices );
48275 }
48276
48278 {
48279 return !operator==( rhs );
48280 }
48281
48282 private:
48284
48285 public:
48286 const void* pNext = nullptr;
48289 };
48290 static_assert( sizeof( DeviceGroupDeviceCreateInfo ) == sizeof( VkDeviceGroupDeviceCreateInfo ), "struct and wrapper have different size!" );
48291
48293
48294#ifndef VULKAN_HPP_NO_SMART_HANDLE
48295
48296 template <typename Dispatch> class UniqueHandleTraits<Instance,Dispatch> {public: using deleter = ObjectDestroy<NoParent,Dispatch>; };
48298#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
48299
48300 template<typename Dispatch = DispatchLoaderStatic>
48301 Result createInstance( const InstanceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Instance* pInstance, Dispatch const &d = Dispatch() );
48302#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
48303 template<typename Dispatch = DispatchLoaderStatic>
48304 ResultValueType<Instance>::type createInstance( const InstanceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() );
48305#ifndef VULKAN_HPP_NO_SMART_HANDLE
48306 template<typename Dispatch = DispatchLoaderStatic>
48307 typename ResultValueType<UniqueHandle<Instance,Dispatch>>::type createInstanceUnique( const InstanceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr, Dispatch const &d = Dispatch() );
48308#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
48309#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
48310
48311 template<typename Dispatch>
48312 VULKAN_HPP_INLINE Result createInstance( const InstanceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Instance* pInstance, Dispatch const &d)
48313 {
48314 return static_cast<Result>( d.vkCreateInstance( reinterpret_cast<const VkInstanceCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkInstance*>( pInstance ) ) );
48315 }
48316#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
48317 template<typename Dispatch>
48319 {
48320 Instance instance;
48321 Result result = static_cast<Result>( d.vkCreateInstance( reinterpret_cast<const VkInstanceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkInstance*>( &instance ) ) );
48322 return createResultValue( result, instance, VULKAN_HPP_NAMESPACE_STRING"::createInstance" );
48323 }
48324#ifndef VULKAN_HPP_NO_SMART_HANDLE
48325 template<typename Dispatch>
48327 {
48328 Instance instance;
48329 Result result = static_cast<Result>( d.vkCreateInstance( reinterpret_cast<const VkInstanceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkInstance*>( &instance ) ) );
48330
48331 ObjectDestroy<NoParent,Dispatch> deleter( allocator, d );
48332 return createResultValue<Instance,Dispatch>( result, instance, VULKAN_HPP_NAMESPACE_STRING"::createInstanceUnique", deleter );
48333 }
48334#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
48335#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
48336
48337
48339 {
48341 {
48342 }
48343
48345 {
48346 memcpy( this, &rhs, sizeof( BaseOutStructure ) );
48347 }
48348
48350 {
48351 memcpy( this, &rhs, sizeof( BaseOutStructure ) );
48352 return *this;
48353 }
48355 {
48356 pNext = pNext_;
48357 return *this;
48358 }
48359
48360 operator VkBaseOutStructure const&() const
48361 {
48362 return *reinterpret_cast<const VkBaseOutStructure*>(this);
48363 }
48364
48366 {
48367 return *reinterpret_cast<VkBaseOutStructure*>(this);
48368 }
48369
48370 bool operator==( BaseOutStructure const& rhs ) const
48371 {
48372 return ( sType == rhs.sType )
48373 && ( pNext == rhs.pNext );
48374 }
48375
48376 bool operator!=( BaseOutStructure const& rhs ) const
48377 {
48378 return !operator==( rhs );
48379 }
48380
48382 struct BaseOutStructure* pNext = nullptr;
48383 };
48384 static_assert( sizeof( BaseOutStructure ) == sizeof( VkBaseOutStructure ), "struct and wrapper have different size!" );
48385
48387 {
48389 {
48390 }
48391
48393 {
48394 memcpy( this, &rhs, sizeof( BaseInStructure ) );
48395 }
48396
48398 {
48399 memcpy( this, &rhs, sizeof( BaseInStructure ) );
48400 return *this;
48401 }
48403 {
48404 pNext = pNext_;
48405 return *this;
48406 }
48407
48408 operator VkBaseInStructure const&() const
48409 {
48410 return *reinterpret_cast<const VkBaseInStructure*>(this);
48411 }
48412
48414 {
48415 return *reinterpret_cast<VkBaseInStructure*>(this);
48416 }
48417
48418 bool operator==( BaseInStructure const& rhs ) const
48419 {
48420 return ( sType == rhs.sType )
48421 && ( pNext == rhs.pNext );
48422 }
48423
48424 bool operator!=( BaseInStructure const& rhs ) const
48425 {
48426 return !operator==( rhs );
48427 }
48428
48430 const struct BaseInStructure* pNext = nullptr;
48431 };
48432 static_assert( sizeof( BaseInStructure ) == sizeof( VkBaseInStructure ), "struct and wrapper have different size!" );
48433
48434 template <> struct isStructureChainValid<PresentInfoKHR, DisplayPresentInfoKHR>{ enum { value = true }; };
48438#ifdef VK_USE_PLATFORM_WIN32_NV
48439 template <> struct isStructureChainValid<MemoryAllocateInfo, ExportMemoryWin32HandleInfoNV>{ enum { value = true }; };
48440#endif /*VK_USE_PLATFORM_WIN32_NV*/
48441#ifdef VK_USE_PLATFORM_WIN32_NV
48442 template <> struct isStructureChainValid<SubmitInfo, Win32KeyedMutexAcquireReleaseInfoNV>{ enum { value = true }; };
48443#endif /*VK_USE_PLATFORM_WIN32_NV*/
48446 template <> struct isStructureChainValid<PresentInfoKHR, PresentRegionsKHR>{ enum { value = true }; };
48450#ifdef VK_USE_PLATFORM_WIN32_KHR
48451 template <> struct isStructureChainValid<MemoryAllocateInfo, ExportMemoryWin32HandleInfoKHR>{ enum { value = true }; };
48452#endif /*VK_USE_PLATFORM_WIN32_KHR*/
48453#ifdef VK_USE_PLATFORM_WIN32_KHR
48454 template <> struct isStructureChainValid<SubmitInfo, Win32KeyedMutexAcquireReleaseInfoKHR>{ enum { value = true }; };
48455#endif /*VK_USE_PLATFORM_WIN32_KHR*/
48456#ifdef VK_USE_PLATFORM_WIN32_KHR
48457 template <> struct isStructureChainValid<SemaphoreCreateInfo, ExportSemaphoreWin32HandleInfoKHR>{ enum { value = true }; };
48458#endif /*VK_USE_PLATFORM_WIN32_KHR*/
48459#ifdef VK_USE_PLATFORM_WIN32_KHR
48460 template <> struct isStructureChainValid<SubmitInfo, D3D12FenceSubmitInfoKHR>{ enum { value = true }; };
48461#endif /*VK_USE_PLATFORM_WIN32_KHR*/
48462#ifdef VK_USE_PLATFORM_WIN32_KHR
48463 template <> struct isStructureChainValid<FenceCreateInfo, ExportFenceWin32HandleInfoKHR>{ enum { value = true }; };
48464#endif /*VK_USE_PLATFORM_WIN32_KHR*/
48473 template <> struct isStructureChainValid<SubmitInfo, DeviceGroupSubmitInfo>{ enum { value = true }; };
48477 template <> struct isStructureChainValid<PresentInfoKHR, PresentTimesInfoGOOGLE>{ enum { value = true }; };
48491 template <> struct isStructureChainValid<SubmitInfo, ProtectedSubmitInfo>{ enum { value = true }; };
48522#ifdef VK_USE_PLATFORM_ANDROID_ANDROID
48523 template <> struct isStructureChainValid<MemoryAllocateInfo, ImportAndroidHardwareBufferInfoANDROID>{ enum { value = true }; };
48524#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/
48525#ifdef VK_USE_PLATFORM_ANDROID_ANDROID
48526 template <> struct isStructureChainValid<ImageFormatProperties2, AndroidHardwareBufferUsageANDROID>{ enum { value = true }; };
48527#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/
48529#ifdef VK_USE_PLATFORM_ANDROID_ANDROID
48530 template <> struct isStructureChainValid<ImageCreateInfo, ExternalFormatANDROID>{ enum { value = true }; };
48531 template <> struct isStructureChainValid<SamplerYcbcrConversionCreateInfo, ExternalFormatANDROID>{ enum { value = true }; };
48532#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/
48590#ifdef VK_USE_PLATFORM_WIN32_NV
48591 template <> struct isStructureChainValid<MemoryAllocateInfo, ImportMemoryWin32HandleInfoNV>{ enum { value = true }; };
48592#endif /*VK_USE_PLATFORM_WIN32_NV*/
48593 template <> struct isStructureChainValid<InstanceCreateInfo, ValidationFlagsEXT>{ enum { value = true }; };
48599#ifdef VK_USE_PLATFORM_WIN32_KHR
48600 template <> struct isStructureChainValid<MemoryAllocateInfo, ImportMemoryWin32HandleInfoKHR>{ enum { value = true }; };
48601#endif /*VK_USE_PLATFORM_WIN32_KHR*/
48606 template <> struct isStructureChainValid<FenceCreateInfo, ExportFenceCreateInfo>{ enum { value = true }; };
48616#ifdef VK_USE_PLATFORM_ANDROID_ANDROID
48617#ifdef VK_USE_PLATFORM_ANDROID_ANDROID
48618 template <> struct isStructureChainValid<AndroidHardwareBufferPropertiesANDROID, AndroidHardwareBufferFormatPropertiesANDROID>{ enum { value = true }; };
48619#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/
48620#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/
48633 {
48634 return "(void)";
48635 }
48636
48638 {
48639 return "{}";
48640 }
48641
48643 {
48644 return "(void)";
48645 }
48646
48648 {
48649 return "{}";
48650 }
48651
48653 {
48654 return "(void)";
48655 }
48656
48658 {
48659 return "{}";
48660 }
48661
48663 {
48664 return "(void)";
48665 }
48666
48668 {
48669 return "{}";
48670 }
48671
48673 {
48674 return "(void)";
48675 }
48676
48678 {
48679 return "{}";
48680 }
48681
48683 {
48684 return "(void)";
48685 }
48686
48688 {
48689 return "{}";
48690 }
48691
48693 {
48694 return "(void)";
48695 }
48696
48698 {
48699 return "{}";
48700 }
48701
48703 {
48704 return "(void)";
48705 }
48706
48708 {
48709 return "{}";
48710 }
48711
48713 {
48714 return "(void)";
48715 }
48716
48718 {
48719 return "{}";
48720 }
48721
48723 {
48724 return "(void)";
48725 }
48726
48728 {
48729 return "{}";
48730 }
48731
48733 {
48734 return "(void)";
48735 }
48736
48738 {
48739 return "{}";
48740 }
48741
48743 {
48744 return "(void)";
48745 }
48746
48748 {
48749 return "{}";
48750 }
48751
48753 {
48754 return "(void)";
48755 }
48756
48758 {
48759 return "{}";
48760 }
48761
48763 {
48764 return "(void)";
48765 }
48766
48768 {
48769 return "{}";
48770 }
48771
48773 {
48774 return "(void)";
48775 }
48776
48778 {
48779 return "{}";
48780 }
48781
48783 {
48784 return "(void)";
48785 }
48786
48788 {
48789 return "{}";
48790 }
48791
48793 {
48794 return "(void)";
48795 }
48796
48798 {
48799 return "{}";
48800 }
48801
48803 {
48804 return "(void)";
48805 }
48806
48808 {
48809 return "{}";
48810 }
48811
48813 {
48814 return "(void)";
48815 }
48816
48818 {
48819 return "{}";
48820 }
48821
48823 {
48824 return "(void)";
48825 }
48826
48828 {
48829 return "{}";
48830 }
48831
48833 {
48834 return "(void)";
48835 }
48836
48838 {
48839 return "{}";
48840 }
48841
48843 {
48844 return "(void)";
48845 }
48846
48848 {
48849 return "{}";
48850 }
48851
48853 {
48854 return "(void)";
48855 }
48856
48858 {
48859 return "{}";
48860 }
48861
48863 {
48864 return "(void)";
48865 }
48866
48868 {
48869 return "{}";
48870 }
48871
48873 {
48874 return "(void)";
48875 }
48876
48878 {
48879 return "{}";
48880 }
48881
48883 {
48884 return "(void)";
48885 }
48886
48888 {
48889 return "{}";
48890 }
48891
48893 {
48894 return "(void)";
48895 }
48896
48898 {
48899 return "{}";
48900 }
48901
48903 {
48904 return "(void)";
48905 }
48906
48908 {
48909 return "{}";
48910 }
48911
48912#ifdef VK_USE_PLATFORM_ANDROID_KHR
48913 VULKAN_HPP_INLINE std::string to_string(AndroidSurfaceCreateFlagBitsKHR)
48914 {
48915 return "(void)";
48916 }
48917#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
48918
48919#ifdef VK_USE_PLATFORM_ANDROID_KHR
48920 VULKAN_HPP_INLINE std::string to_string(AndroidSurfaceCreateFlagsKHR)
48921 {
48922 return "{}";
48923 }
48924#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
48925
48926#ifdef VK_USE_PLATFORM_VI_NN
48927 VULKAN_HPP_INLINE std::string to_string(ViSurfaceCreateFlagBitsNN)
48928 {
48929 return "(void)";
48930 }
48931#endif /*VK_USE_PLATFORM_VI_NN*/
48932
48933#ifdef VK_USE_PLATFORM_VI_NN
48934 VULKAN_HPP_INLINE std::string to_string(ViSurfaceCreateFlagsNN)
48935 {
48936 return "{}";
48937 }
48938#endif /*VK_USE_PLATFORM_VI_NN*/
48939
48940#ifdef VK_USE_PLATFORM_WAYLAND_KHR
48941 VULKAN_HPP_INLINE std::string to_string(WaylandSurfaceCreateFlagBitsKHR)
48942 {
48943 return "(void)";
48944 }
48945#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
48946
48947#ifdef VK_USE_PLATFORM_WAYLAND_KHR
48948 VULKAN_HPP_INLINE std::string to_string(WaylandSurfaceCreateFlagsKHR)
48949 {
48950 return "{}";
48951 }
48952#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
48953
48954#ifdef VK_USE_PLATFORM_WIN32_KHR
48955 VULKAN_HPP_INLINE std::string to_string(Win32SurfaceCreateFlagBitsKHR)
48956 {
48957 return "(void)";
48958 }
48959#endif /*VK_USE_PLATFORM_WIN32_KHR*/
48960
48961#ifdef VK_USE_PLATFORM_WIN32_KHR
48962 VULKAN_HPP_INLINE std::string to_string(Win32SurfaceCreateFlagsKHR)
48963 {
48964 return "{}";
48965 }
48966#endif /*VK_USE_PLATFORM_WIN32_KHR*/
48967
48968#ifdef VK_USE_PLATFORM_XLIB_KHR
48969 VULKAN_HPP_INLINE std::string to_string(XlibSurfaceCreateFlagBitsKHR)
48970 {
48971 return "(void)";
48972 }
48973#endif /*VK_USE_PLATFORM_XLIB_KHR*/
48974
48975#ifdef VK_USE_PLATFORM_XLIB_KHR
48976 VULKAN_HPP_INLINE std::string to_string(XlibSurfaceCreateFlagsKHR)
48977 {
48978 return "{}";
48979 }
48980#endif /*VK_USE_PLATFORM_XLIB_KHR*/
48981
48982#ifdef VK_USE_PLATFORM_XCB_KHR
48983 VULKAN_HPP_INLINE std::string to_string(XcbSurfaceCreateFlagBitsKHR)
48984 {
48985 return "(void)";
48986 }
48987#endif /*VK_USE_PLATFORM_XCB_KHR*/
48988
48989#ifdef VK_USE_PLATFORM_XCB_KHR
48990 VULKAN_HPP_INLINE std::string to_string(XcbSurfaceCreateFlagsKHR)
48991 {
48992 return "{}";
48993 }
48994#endif /*VK_USE_PLATFORM_XCB_KHR*/
48995
48996#ifdef VK_USE_PLATFORM_IOS_MVK
48997 VULKAN_HPP_INLINE std::string to_string(IOSSurfaceCreateFlagBitsMVK)
48998 {
48999 return "(void)";
49000 }
49001#endif /*VK_USE_PLATFORM_IOS_MVK*/
49002
49003#ifdef VK_USE_PLATFORM_IOS_MVK
49004 VULKAN_HPP_INLINE std::string to_string(IOSSurfaceCreateFlagsMVK)
49005 {
49006 return "{}";
49007 }
49008#endif /*VK_USE_PLATFORM_IOS_MVK*/
49009
49010#ifdef VK_USE_PLATFORM_MACOS_MVK
49011 VULKAN_HPP_INLINE std::string to_string(MacOSSurfaceCreateFlagBitsMVK)
49012 {
49013 return "(void)";
49014 }
49015#endif /*VK_USE_PLATFORM_MACOS_MVK*/
49016
49017#ifdef VK_USE_PLATFORM_MACOS_MVK
49018 VULKAN_HPP_INLINE std::string to_string(MacOSSurfaceCreateFlagsMVK)
49019 {
49020 return "{}";
49021 }
49022#endif /*VK_USE_PLATFORM_MACOS_MVK*/
49023
49024#ifdef VK_USE_PLATFORM_FUCHSIA_FUCHSIA
49025 VULKAN_HPP_INLINE std::string to_string(ImagePipeSurfaceCreateFlagBitsFUCHSIA)
49026 {
49027 return "(void)";
49028 }
49029#endif /*VK_USE_PLATFORM_FUCHSIA_FUCHSIA*/
49030
49031#ifdef VK_USE_PLATFORM_FUCHSIA_FUCHSIA
49032 VULKAN_HPP_INLINE std::string to_string(ImagePipeSurfaceCreateFlagsFUCHSIA)
49033 {
49034 return "{}";
49035 }
49036#endif /*VK_USE_PLATFORM_FUCHSIA_FUCHSIA*/
49037
49039 {
49040 return "(void)";
49041 }
49042
49044 {
49045 return "{}";
49046 }
49047
49049 {
49050 return "(void)";
49051 }
49052
49054 {
49055 return "{}";
49056 }
49057
49059 {
49060 return "(void)";
49061 }
49062
49064 {
49065 return "{}";
49066 }
49067
49069 {
49070 return "(void)";
49071 }
49072
49074 {
49075 return "{}";
49076 }
49077
49079 {
49080 return "(void)";
49081 }
49082
49084 {
49085 return "{}";
49086 }
49087
49089 {
49090 return "(void)";
49091 }
49092
49094 {
49095 return "{}";
49096 }
49097
49099 {
49100 return "(void)";
49101 }
49102
49104 {
49105 return "{}";
49106 }
49107
49109 {
49110 return "(void)";
49111 }
49112
49114 {
49115 return "{}";
49116 }
49117
49119 {
49120 return "(void)";
49121 }
49122
49124 {
49125 return "{}";
49126 }
49127
49129 {
49130 return "(void)";
49131 }
49132
49134 {
49135 return "{}";
49136 }
49137
49139 {
49140 switch (value)
49141 {
49142 case ImageLayout::eUndefined: return "Undefined";
49143 case ImageLayout::eGeneral: return "General";
49144 case ImageLayout::eColorAttachmentOptimal: return "ColorAttachmentOptimal";
49145 case ImageLayout::eDepthStencilAttachmentOptimal: return "DepthStencilAttachmentOptimal";
49146 case ImageLayout::eDepthStencilReadOnlyOptimal: return "DepthStencilReadOnlyOptimal";
49147 case ImageLayout::eShaderReadOnlyOptimal: return "ShaderReadOnlyOptimal";
49148 case ImageLayout::eTransferSrcOptimal: return "TransferSrcOptimal";
49149 case ImageLayout::eTransferDstOptimal: return "TransferDstOptimal";
49150 case ImageLayout::ePreinitialized: return "Preinitialized";
49151 case ImageLayout::eDepthReadOnlyStencilAttachmentOptimal: return "DepthReadOnlyStencilAttachmentOptimal";
49152 case ImageLayout::eDepthAttachmentStencilReadOnlyOptimal: return "DepthAttachmentStencilReadOnlyOptimal";
49153 case ImageLayout::ePresentSrcKHR: return "PresentSrcKHR";
49154 case ImageLayout::eSharedPresentKHR: return "SharedPresentKHR";
49155 case ImageLayout::eShadingRateOptimalNV: return "ShadingRateOptimalNV";
49156 default: return "invalid";
49157 }
49158 }
49159
49161 {
49162 switch (value)
49163 {
49164 case AttachmentLoadOp::eLoad: return "Load";
49165 case AttachmentLoadOp::eClear: return "Clear";
49166 case AttachmentLoadOp::eDontCare: return "DontCare";
49167 default: return "invalid";
49168 }
49169 }
49170
49172 {
49173 switch (value)
49174 {
49175 case AttachmentStoreOp::eStore: return "Store";
49176 case AttachmentStoreOp::eDontCare: return "DontCare";
49177 default: return "invalid";
49178 }
49179 }
49180
49182 {
49183 switch (value)
49184 {
49185 case ImageType::e1D: return "1D";
49186 case ImageType::e2D: return "2D";
49187 case ImageType::e3D: return "3D";
49188 default: return "invalid";
49189 }
49190 }
49191
49193 {
49194 switch (value)
49195 {
49196 case ImageTiling::eOptimal: return "Optimal";
49197 case ImageTiling::eLinear: return "Linear";
49198 case ImageTiling::eDrmFormatModifierEXT: return "DrmFormatModifierEXT";
49199 default: return "invalid";
49200 }
49201 }
49202
49204 {
49205 switch (value)
49206 {
49207 case ImageViewType::e1D: return "1D";
49208 case ImageViewType::e2D: return "2D";
49209 case ImageViewType::e3D: return "3D";
49210 case ImageViewType::eCube: return "Cube";
49211 case ImageViewType::e1DArray: return "1DArray";
49212 case ImageViewType::e2DArray: return "2DArray";
49213 case ImageViewType::eCubeArray: return "CubeArray";
49214 default: return "invalid";
49215 }
49216 }
49217
49219 {
49220 switch (value)
49221 {
49222 case CommandBufferLevel::ePrimary: return "Primary";
49223 case CommandBufferLevel::eSecondary: return "Secondary";
49224 default: return "invalid";
49225 }
49226 }
49227
49229 {
49230 switch (value)
49231 {
49232 case ComponentSwizzle::eIdentity: return "Identity";
49233 case ComponentSwizzle::eZero: return "Zero";
49234 case ComponentSwizzle::eOne: return "One";
49235 case ComponentSwizzle::eR: return "R";
49236 case ComponentSwizzle::eG: return "G";
49237 case ComponentSwizzle::eB: return "B";
49238 case ComponentSwizzle::eA: return "A";
49239 default: return "invalid";
49240 }
49241 }
49242
49244 {
49245 switch (value)
49246 {
49247 case DescriptorType::eSampler: return "Sampler";
49248 case DescriptorType::eCombinedImageSampler: return "CombinedImageSampler";
49249 case DescriptorType::eSampledImage: return "SampledImage";
49250 case DescriptorType::eStorageImage: return "StorageImage";
49251 case DescriptorType::eUniformTexelBuffer: return "UniformTexelBuffer";
49252 case DescriptorType::eStorageTexelBuffer: return "StorageTexelBuffer";
49253 case DescriptorType::eUniformBuffer: return "UniformBuffer";
49254 case DescriptorType::eStorageBuffer: return "StorageBuffer";
49255 case DescriptorType::eUniformBufferDynamic: return "UniformBufferDynamic";
49256 case DescriptorType::eStorageBufferDynamic: return "StorageBufferDynamic";
49257 case DescriptorType::eInputAttachment: return "InputAttachment";
49258 case DescriptorType::eInlineUniformBlockEXT: return "InlineUniformBlockEXT";
49259 case DescriptorType::eAccelerationStructureNV: return "AccelerationStructureNV";
49260 default: return "invalid";
49261 }
49262 }
49263
49265 {
49266 switch (value)
49267 {
49268 case QueryType::eOcclusion: return "Occlusion";
49269 case QueryType::ePipelineStatistics: return "PipelineStatistics";
49270 case QueryType::eTimestamp: return "Timestamp";
49271 case QueryType::eTransformFeedbackStreamEXT: return "TransformFeedbackStreamEXT";
49272 case QueryType::eAccelerationStructureCompactedSizeNV: return "AccelerationStructureCompactedSizeNV";
49273 default: return "invalid";
49274 }
49275 }
49276
49278 {
49279 switch (value)
49280 {
49281 case BorderColor::eFloatTransparentBlack: return "FloatTransparentBlack";
49282 case BorderColor::eIntTransparentBlack: return "IntTransparentBlack";
49283 case BorderColor::eFloatOpaqueBlack: return "FloatOpaqueBlack";
49284 case BorderColor::eIntOpaqueBlack: return "IntOpaqueBlack";
49285 case BorderColor::eFloatOpaqueWhite: return "FloatOpaqueWhite";
49286 case BorderColor::eIntOpaqueWhite: return "IntOpaqueWhite";
49287 default: return "invalid";
49288 }
49289 }
49290
49292 {
49293 switch (value)
49294 {
49295 case PipelineBindPoint::eGraphics: return "Graphics";
49296 case PipelineBindPoint::eCompute: return "Compute";
49297 case PipelineBindPoint::eRayTracingNV: return "RayTracingNV";
49298 default: return "invalid";
49299 }
49300 }
49301
49303 {
49304 switch (value)
49305 {
49306 case PipelineCacheHeaderVersion::eOne: return "One";
49307 default: return "invalid";
49308 }
49309 }
49310
49312 {
49313 switch (value)
49314 {
49315 case PrimitiveTopology::ePointList: return "PointList";
49316 case PrimitiveTopology::eLineList: return "LineList";
49317 case PrimitiveTopology::eLineStrip: return "LineStrip";
49318 case PrimitiveTopology::eTriangleList: return "TriangleList";
49319 case PrimitiveTopology::eTriangleStrip: return "TriangleStrip";
49320 case PrimitiveTopology::eTriangleFan: return "TriangleFan";
49321 case PrimitiveTopology::eLineListWithAdjacency: return "LineListWithAdjacency";
49322 case PrimitiveTopology::eLineStripWithAdjacency: return "LineStripWithAdjacency";
49323 case PrimitiveTopology::eTriangleListWithAdjacency: return "TriangleListWithAdjacency";
49324 case PrimitiveTopology::eTriangleStripWithAdjacency: return "TriangleStripWithAdjacency";
49325 case PrimitiveTopology::ePatchList: return "PatchList";
49326 default: return "invalid";
49327 }
49328 }
49329
49331 {
49332 switch (value)
49333 {
49334 case SharingMode::eExclusive: return "Exclusive";
49335 case SharingMode::eConcurrent: return "Concurrent";
49336 default: return "invalid";
49337 }
49338 }
49339
49341 {
49342 switch (value)
49343 {
49344 case IndexType::eUint16: return "Uint16";
49345 case IndexType::eUint32: return "Uint32";
49346 case IndexType::eNoneNV: return "NoneNV";
49347 default: return "invalid";
49348 }
49349 }
49350
49352 {
49353 switch (value)
49354 {
49355 case Filter::eNearest: return "Nearest";
49356 case Filter::eLinear: return "Linear";
49357 case Filter::eCubicIMG: return "CubicIMG";
49358 default: return "invalid";
49359 }
49360 }
49361
49363 {
49364 switch (value)
49365 {
49366 case SamplerMipmapMode::eNearest: return "Nearest";
49367 case SamplerMipmapMode::eLinear: return "Linear";
49368 default: return "invalid";
49369 }
49370 }
49371
49373 {
49374 switch (value)
49375 {
49376 case SamplerAddressMode::eRepeat: return "Repeat";
49377 case SamplerAddressMode::eMirroredRepeat: return "MirroredRepeat";
49378 case SamplerAddressMode::eClampToEdge: return "ClampToEdge";
49379 case SamplerAddressMode::eClampToBorder: return "ClampToBorder";
49380 case SamplerAddressMode::eMirrorClampToEdge: return "MirrorClampToEdge";
49381 default: return "invalid";
49382 }
49383 }
49384
49386 {
49387 switch (value)
49388 {
49389 case CompareOp::eNever: return "Never";
49390 case CompareOp::eLess: return "Less";
49391 case CompareOp::eEqual: return "Equal";
49392 case CompareOp::eLessOrEqual: return "LessOrEqual";
49393 case CompareOp::eGreater: return "Greater";
49394 case CompareOp::eNotEqual: return "NotEqual";
49395 case CompareOp::eGreaterOrEqual: return "GreaterOrEqual";
49396 case CompareOp::eAlways: return "Always";
49397 default: return "invalid";
49398 }
49399 }
49400
49402 {
49403 switch (value)
49404 {
49405 case PolygonMode::eFill: return "Fill";
49406 case PolygonMode::eLine: return "Line";
49407 case PolygonMode::ePoint: return "Point";
49408 case PolygonMode::eFillRectangleNV: return "FillRectangleNV";
49409 default: return "invalid";
49410 }
49411 }
49412
49414 {
49415 switch (value)
49416 {
49417 case CullModeFlagBits::eNone: return "None";
49418 case CullModeFlagBits::eFront: return "Front";
49419 case CullModeFlagBits::eBack: return "Back";
49420 case CullModeFlagBits::eFrontAndBack: return "FrontAndBack";
49421 default: return "invalid";
49422 }
49423 }
49424
49426 {
49427 if (!value) return "{}";
49429 if (value & CullModeFlagBits::eNone) result += "None | ";
49430 if (value & CullModeFlagBits::eFront) result += "Front | ";
49431 if (value & CullModeFlagBits::eBack) result += "Back | ";
49432 if (value & CullModeFlagBits::eFrontAndBack) result += "FrontAndBack | ";
49433 return "{" + result.substr(0, result.size() - 3) + "}";
49434 }
49435
49437 {
49438 switch (value)
49439 {
49440 case FrontFace::eCounterClockwise: return "CounterClockwise";
49441 case FrontFace::eClockwise: return "Clockwise";
49442 default: return "invalid";
49443 }
49444 }
49445
49447 {
49448 switch (value)
49449 {
49450 case BlendFactor::eZero: return "Zero";
49451 case BlendFactor::eOne: return "One";
49452 case BlendFactor::eSrcColor: return "SrcColor";
49453 case BlendFactor::eOneMinusSrcColor: return "OneMinusSrcColor";
49454 case BlendFactor::eDstColor: return "DstColor";
49455 case BlendFactor::eOneMinusDstColor: return "OneMinusDstColor";
49456 case BlendFactor::eSrcAlpha: return "SrcAlpha";
49457 case BlendFactor::eOneMinusSrcAlpha: return "OneMinusSrcAlpha";
49458 case BlendFactor::eDstAlpha: return "DstAlpha";
49459 case BlendFactor::eOneMinusDstAlpha: return "OneMinusDstAlpha";
49460 case BlendFactor::eConstantColor: return "ConstantColor";
49461 case BlendFactor::eOneMinusConstantColor: return "OneMinusConstantColor";
49462 case BlendFactor::eConstantAlpha: return "ConstantAlpha";
49463 case BlendFactor::eOneMinusConstantAlpha: return "OneMinusConstantAlpha";
49464 case BlendFactor::eSrcAlphaSaturate: return "SrcAlphaSaturate";
49465 case BlendFactor::eSrc1Color: return "Src1Color";
49466 case BlendFactor::eOneMinusSrc1Color: return "OneMinusSrc1Color";
49467 case BlendFactor::eSrc1Alpha: return "Src1Alpha";
49468 case BlendFactor::eOneMinusSrc1Alpha: return "OneMinusSrc1Alpha";
49469 default: return "invalid";
49470 }
49471 }
49472
49474 {
49475 switch (value)
49476 {
49477 case BlendOp::eAdd: return "Add";
49478 case BlendOp::eSubtract: return "Subtract";
49479 case BlendOp::eReverseSubtract: return "ReverseSubtract";
49480 case BlendOp::eMin: return "Min";
49481 case BlendOp::eMax: return "Max";
49482 case BlendOp::eZeroEXT: return "ZeroEXT";
49483 case BlendOp::eSrcEXT: return "SrcEXT";
49484 case BlendOp::eDstEXT: return "DstEXT";
49485 case BlendOp::eSrcOverEXT: return "SrcOverEXT";
49486 case BlendOp::eDstOverEXT: return "DstOverEXT";
49487 case BlendOp::eSrcInEXT: return "SrcInEXT";
49488 case BlendOp::eDstInEXT: return "DstInEXT";
49489 case BlendOp::eSrcOutEXT: return "SrcOutEXT";
49490 case BlendOp::eDstOutEXT: return "DstOutEXT";
49491 case BlendOp::eSrcAtopEXT: return "SrcAtopEXT";
49492 case BlendOp::eDstAtopEXT: return "DstAtopEXT";
49493 case BlendOp::eXorEXT: return "XorEXT";
49494 case BlendOp::eMultiplyEXT: return "MultiplyEXT";
49495 case BlendOp::eScreenEXT: return "ScreenEXT";
49496 case BlendOp::eOverlayEXT: return "OverlayEXT";
49497 case BlendOp::eDarkenEXT: return "DarkenEXT";
49498 case BlendOp::eLightenEXT: return "LightenEXT";
49499 case BlendOp::eColordodgeEXT: return "ColordodgeEXT";
49500 case BlendOp::eColorburnEXT: return "ColorburnEXT";
49501 case BlendOp::eHardlightEXT: return "HardlightEXT";
49502 case BlendOp::eSoftlightEXT: return "SoftlightEXT";
49503 case BlendOp::eDifferenceEXT: return "DifferenceEXT";
49504 case BlendOp::eExclusionEXT: return "ExclusionEXT";
49505 case BlendOp::eInvertEXT: return "InvertEXT";
49506 case BlendOp::eInvertRgbEXT: return "InvertRgbEXT";
49507 case BlendOp::eLineardodgeEXT: return "LineardodgeEXT";
49508 case BlendOp::eLinearburnEXT: return "LinearburnEXT";
49509 case BlendOp::eVividlightEXT: return "VividlightEXT";
49510 case BlendOp::eLinearlightEXT: return "LinearlightEXT";
49511 case BlendOp::ePinlightEXT: return "PinlightEXT";
49512 case BlendOp::eHardmixEXT: return "HardmixEXT";
49513 case BlendOp::eHslHueEXT: return "HslHueEXT";
49514 case BlendOp::eHslSaturationEXT: return "HslSaturationEXT";
49515 case BlendOp::eHslColorEXT: return "HslColorEXT";
49516 case BlendOp::eHslLuminosityEXT: return "HslLuminosityEXT";
49517 case BlendOp::ePlusEXT: return "PlusEXT";
49518 case BlendOp::ePlusClampedEXT: return "PlusClampedEXT";
49519 case BlendOp::ePlusClampedAlphaEXT: return "PlusClampedAlphaEXT";
49520 case BlendOp::ePlusDarkerEXT: return "PlusDarkerEXT";
49521 case BlendOp::eMinusEXT: return "MinusEXT";
49522 case BlendOp::eMinusClampedEXT: return "MinusClampedEXT";
49523 case BlendOp::eContrastEXT: return "ContrastEXT";
49524 case BlendOp::eInvertOvgEXT: return "InvertOvgEXT";
49525 case BlendOp::eRedEXT: return "RedEXT";
49526 case BlendOp::eGreenEXT: return "GreenEXT";
49527 case BlendOp::eBlueEXT: return "BlueEXT";
49528 default: return "invalid";
49529 }
49530 }
49531
49533 {
49534 switch (value)
49535 {
49536 case StencilOp::eKeep: return "Keep";
49537 case StencilOp::eZero: return "Zero";
49538 case StencilOp::eReplace: return "Replace";
49539 case StencilOp::eIncrementAndClamp: return "IncrementAndClamp";
49540 case StencilOp::eDecrementAndClamp: return "DecrementAndClamp";
49541 case StencilOp::eInvert: return "Invert";
49542 case StencilOp::eIncrementAndWrap: return "IncrementAndWrap";
49543 case StencilOp::eDecrementAndWrap: return "DecrementAndWrap";
49544 default: return "invalid";
49545 }
49546 }
49547
49549 {
49550 switch (value)
49551 {
49552 case LogicOp::eClear: return "Clear";
49553 case LogicOp::eAnd: return "And";
49554 case LogicOp::eAndReverse: return "AndReverse";
49555 case LogicOp::eCopy: return "Copy";
49556 case LogicOp::eAndInverted: return "AndInverted";
49557 case LogicOp::eNoOp: return "NoOp";
49558 case LogicOp::eXor: return "Xor";
49559 case LogicOp::eOr: return "Or";
49560 case LogicOp::eNor: return "Nor";
49561 case LogicOp::eEquivalent: return "Equivalent";
49562 case LogicOp::eInvert: return "Invert";
49563 case LogicOp::eOrReverse: return "OrReverse";
49564 case LogicOp::eCopyInverted: return "CopyInverted";
49565 case LogicOp::eOrInverted: return "OrInverted";
49566 case LogicOp::eNand: return "Nand";
49567 case LogicOp::eSet: return "Set";
49568 default: return "invalid";
49569 }
49570 }
49571
49573 {
49574 switch (value)
49575 {
49576 case InternalAllocationType::eExecutable: return "Executable";
49577 default: return "invalid";
49578 }
49579 }
49580
49582 {
49583 switch (value)
49584 {
49585 case SystemAllocationScope::eCommand: return "Command";
49586 case SystemAllocationScope::eObject: return "Object";
49587 case SystemAllocationScope::eCache: return "Cache";
49588 case SystemAllocationScope::eDevice: return "Device";
49589 case SystemAllocationScope::eInstance: return "Instance";
49590 default: return "invalid";
49591 }
49592 }
49593
49595 {
49596 switch (value)
49597 {
49598 case PhysicalDeviceType::eOther: return "Other";
49599 case PhysicalDeviceType::eIntegratedGpu: return "IntegratedGpu";
49600 case PhysicalDeviceType::eDiscreteGpu: return "DiscreteGpu";
49601 case PhysicalDeviceType::eVirtualGpu: return "VirtualGpu";
49602 case PhysicalDeviceType::eCpu: return "Cpu";
49603 default: return "invalid";
49604 }
49605 }
49606
49608 {
49609 switch (value)
49610 {
49611 case VertexInputRate::eVertex: return "Vertex";
49612 case VertexInputRate::eInstance: return "Instance";
49613 default: return "invalid";
49614 }
49615 }
49616
49618 {
49619 switch (value)
49620 {
49621 case Format::eUndefined: return "Undefined";
49622 case Format::eR4G4UnormPack8: return "R4G4UnormPack8";
49623 case Format::eR4G4B4A4UnormPack16: return "R4G4B4A4UnormPack16";
49624 case Format::eB4G4R4A4UnormPack16: return "B4G4R4A4UnormPack16";
49625 case Format::eR5G6B5UnormPack16: return "R5G6B5UnormPack16";
49626 case Format::eB5G6R5UnormPack16: return "B5G6R5UnormPack16";
49627 case Format::eR5G5B5A1UnormPack16: return "R5G5B5A1UnormPack16";
49628 case Format::eB5G5R5A1UnormPack16: return "B5G5R5A1UnormPack16";
49629 case Format::eA1R5G5B5UnormPack16: return "A1R5G5B5UnormPack16";
49630 case Format::eR8Unorm: return "R8Unorm";
49631 case Format::eR8Snorm: return "R8Snorm";
49632 case Format::eR8Uscaled: return "R8Uscaled";
49633 case Format::eR8Sscaled: return "R8Sscaled";
49634 case Format::eR8Uint: return "R8Uint";
49635 case Format::eR8Sint: return "R8Sint";
49636 case Format::eR8Srgb: return "R8Srgb";
49637 case Format::eR8G8Unorm: return "R8G8Unorm";
49638 case Format::eR8G8Snorm: return "R8G8Snorm";
49639 case Format::eR8G8Uscaled: return "R8G8Uscaled";
49640 case Format::eR8G8Sscaled: return "R8G8Sscaled";
49641 case Format::eR8G8Uint: return "R8G8Uint";
49642 case Format::eR8G8Sint: return "R8G8Sint";
49643 case Format::eR8G8Srgb: return "R8G8Srgb";
49644 case Format::eR8G8B8Unorm: return "R8G8B8Unorm";
49645 case Format::eR8G8B8Snorm: return "R8G8B8Snorm";
49646 case Format::eR8G8B8Uscaled: return "R8G8B8Uscaled";
49647 case Format::eR8G8B8Sscaled: return "R8G8B8Sscaled";
49648 case Format::eR8G8B8Uint: return "R8G8B8Uint";
49649 case Format::eR8G8B8Sint: return "R8G8B8Sint";
49650 case Format::eR8G8B8Srgb: return "R8G8B8Srgb";
49651 case Format::eB8G8R8Unorm: return "B8G8R8Unorm";
49652 case Format::eB8G8R8Snorm: return "B8G8R8Snorm";
49653 case Format::eB8G8R8Uscaled: return "B8G8R8Uscaled";
49654 case Format::eB8G8R8Sscaled: return "B8G8R8Sscaled";
49655 case Format::eB8G8R8Uint: return "B8G8R8Uint";
49656 case Format::eB8G8R8Sint: return "B8G8R8Sint";
49657 case Format::eB8G8R8Srgb: return "B8G8R8Srgb";
49658 case Format::eR8G8B8A8Unorm: return "R8G8B8A8Unorm";
49659 case Format::eR8G8B8A8Snorm: return "R8G8B8A8Snorm";
49660 case Format::eR8G8B8A8Uscaled: return "R8G8B8A8Uscaled";
49661 case Format::eR8G8B8A8Sscaled: return "R8G8B8A8Sscaled";
49662 case Format::eR8G8B8A8Uint: return "R8G8B8A8Uint";
49663 case Format::eR8G8B8A8Sint: return "R8G8B8A8Sint";
49664 case Format::eR8G8B8A8Srgb: return "R8G8B8A8Srgb";
49665 case Format::eB8G8R8A8Unorm: return "B8G8R8A8Unorm";
49666 case Format::eB8G8R8A8Snorm: return "B8G8R8A8Snorm";
49667 case Format::eB8G8R8A8Uscaled: return "B8G8R8A8Uscaled";
49668 case Format::eB8G8R8A8Sscaled: return "B8G8R8A8Sscaled";
49669 case Format::eB8G8R8A8Uint: return "B8G8R8A8Uint";
49670 case Format::eB8G8R8A8Sint: return "B8G8R8A8Sint";
49671 case Format::eB8G8R8A8Srgb: return "B8G8R8A8Srgb";
49672 case Format::eA8B8G8R8UnormPack32: return "A8B8G8R8UnormPack32";
49673 case Format::eA8B8G8R8SnormPack32: return "A8B8G8R8SnormPack32";
49674 case Format::eA8B8G8R8UscaledPack32: return "A8B8G8R8UscaledPack32";
49675 case Format::eA8B8G8R8SscaledPack32: return "A8B8G8R8SscaledPack32";
49676 case Format::eA8B8G8R8UintPack32: return "A8B8G8R8UintPack32";
49677 case Format::eA8B8G8R8SintPack32: return "A8B8G8R8SintPack32";
49678 case Format::eA8B8G8R8SrgbPack32: return "A8B8G8R8SrgbPack32";
49679 case Format::eA2R10G10B10UnormPack32: return "A2R10G10B10UnormPack32";
49680 case Format::eA2R10G10B10SnormPack32: return "A2R10G10B10SnormPack32";
49681 case Format::eA2R10G10B10UscaledPack32: return "A2R10G10B10UscaledPack32";
49682 case Format::eA2R10G10B10SscaledPack32: return "A2R10G10B10SscaledPack32";
49683 case Format::eA2R10G10B10UintPack32: return "A2R10G10B10UintPack32";
49684 case Format::eA2R10G10B10SintPack32: return "A2R10G10B10SintPack32";
49685 case Format::eA2B10G10R10UnormPack32: return "A2B10G10R10UnormPack32";
49686 case Format::eA2B10G10R10SnormPack32: return "A2B10G10R10SnormPack32";
49687 case Format::eA2B10G10R10UscaledPack32: return "A2B10G10R10UscaledPack32";
49688 case Format::eA2B10G10R10SscaledPack32: return "A2B10G10R10SscaledPack32";
49689 case Format::eA2B10G10R10UintPack32: return "A2B10G10R10UintPack32";
49690 case Format::eA2B10G10R10SintPack32: return "A2B10G10R10SintPack32";
49691 case Format::eR16Unorm: return "R16Unorm";
49692 case Format::eR16Snorm: return "R16Snorm";
49693 case Format::eR16Uscaled: return "R16Uscaled";
49694 case Format::eR16Sscaled: return "R16Sscaled";
49695 case Format::eR16Uint: return "R16Uint";
49696 case Format::eR16Sint: return "R16Sint";
49697 case Format::eR16Sfloat: return "R16Sfloat";
49698 case Format::eR16G16Unorm: return "R16G16Unorm";
49699 case Format::eR16G16Snorm: return "R16G16Snorm";
49700 case Format::eR16G16Uscaled: return "R16G16Uscaled";
49701 case Format::eR16G16Sscaled: return "R16G16Sscaled";
49702 case Format::eR16G16Uint: return "R16G16Uint";
49703 case Format::eR16G16Sint: return "R16G16Sint";
49704 case Format::eR16G16Sfloat: return "R16G16Sfloat";
49705 case Format::eR16G16B16Unorm: return "R16G16B16Unorm";
49706 case Format::eR16G16B16Snorm: return "R16G16B16Snorm";
49707 case Format::eR16G16B16Uscaled: return "R16G16B16Uscaled";
49708 case Format::eR16G16B16Sscaled: return "R16G16B16Sscaled";
49709 case Format::eR16G16B16Uint: return "R16G16B16Uint";
49710 case Format::eR16G16B16Sint: return "R16G16B16Sint";
49711 case Format::eR16G16B16Sfloat: return "R16G16B16Sfloat";
49712 case Format::eR16G16B16A16Unorm: return "R16G16B16A16Unorm";
49713 case Format::eR16G16B16A16Snorm: return "R16G16B16A16Snorm";
49714 case Format::eR16G16B16A16Uscaled: return "R16G16B16A16Uscaled";
49715 case Format::eR16G16B16A16Sscaled: return "R16G16B16A16Sscaled";
49716 case Format::eR16G16B16A16Uint: return "R16G16B16A16Uint";
49717 case Format::eR16G16B16A16Sint: return "R16G16B16A16Sint";
49718 case Format::eR16G16B16A16Sfloat: return "R16G16B16A16Sfloat";
49719 case Format::eR32Uint: return "R32Uint";
49720 case Format::eR32Sint: return "R32Sint";
49721 case Format::eR32Sfloat: return "R32Sfloat";
49722 case Format::eR32G32Uint: return "R32G32Uint";
49723 case Format::eR32G32Sint: return "R32G32Sint";
49724 case Format::eR32G32Sfloat: return "R32G32Sfloat";
49725 case Format::eR32G32B32Uint: return "R32G32B32Uint";
49726 case Format::eR32G32B32Sint: return "R32G32B32Sint";
49727 case Format::eR32G32B32Sfloat: return "R32G32B32Sfloat";
49728 case Format::eR32G32B32A32Uint: return "R32G32B32A32Uint";
49729 case Format::eR32G32B32A32Sint: return "R32G32B32A32Sint";
49730 case Format::eR32G32B32A32Sfloat: return "R32G32B32A32Sfloat";
49731 case Format::eR64Uint: return "R64Uint";
49732 case Format::eR64Sint: return "R64Sint";
49733 case Format::eR64Sfloat: return "R64Sfloat";
49734 case Format::eR64G64Uint: return "R64G64Uint";
49735 case Format::eR64G64Sint: return "R64G64Sint";
49736 case Format::eR64G64Sfloat: return "R64G64Sfloat";
49737 case Format::eR64G64B64Uint: return "R64G64B64Uint";
49738 case Format::eR64G64B64Sint: return "R64G64B64Sint";
49739 case Format::eR64G64B64Sfloat: return "R64G64B64Sfloat";
49740 case Format::eR64G64B64A64Uint: return "R64G64B64A64Uint";
49741 case Format::eR64G64B64A64Sint: return "R64G64B64A64Sint";
49742 case Format::eR64G64B64A64Sfloat: return "R64G64B64A64Sfloat";
49743 case Format::eB10G11R11UfloatPack32: return "B10G11R11UfloatPack32";
49744 case Format::eE5B9G9R9UfloatPack32: return "E5B9G9R9UfloatPack32";
49745 case Format::eD16Unorm: return "D16Unorm";
49746 case Format::eX8D24UnormPack32: return "X8D24UnormPack32";
49747 case Format::eD32Sfloat: return "D32Sfloat";
49748 case Format::eS8Uint: return "S8Uint";
49749 case Format::eD16UnormS8Uint: return "D16UnormS8Uint";
49750 case Format::eD24UnormS8Uint: return "D24UnormS8Uint";
49751 case Format::eD32SfloatS8Uint: return "D32SfloatS8Uint";
49752 case Format::eBc1RgbUnormBlock: return "Bc1RgbUnormBlock";
49753 case Format::eBc1RgbSrgbBlock: return "Bc1RgbSrgbBlock";
49754 case Format::eBc1RgbaUnormBlock: return "Bc1RgbaUnormBlock";
49755 case Format::eBc1RgbaSrgbBlock: return "Bc1RgbaSrgbBlock";
49756 case Format::eBc2UnormBlock: return "Bc2UnormBlock";
49757 case Format::eBc2SrgbBlock: return "Bc2SrgbBlock";
49758 case Format::eBc3UnormBlock: return "Bc3UnormBlock";
49759 case Format::eBc3SrgbBlock: return "Bc3SrgbBlock";
49760 case Format::eBc4UnormBlock: return "Bc4UnormBlock";
49761 case Format::eBc4SnormBlock: return "Bc4SnormBlock";
49762 case Format::eBc5UnormBlock: return "Bc5UnormBlock";
49763 case Format::eBc5SnormBlock: return "Bc5SnormBlock";
49764 case Format::eBc6HUfloatBlock: return "Bc6HUfloatBlock";
49765 case Format::eBc6HSfloatBlock: return "Bc6HSfloatBlock";
49766 case Format::eBc7UnormBlock: return "Bc7UnormBlock";
49767 case Format::eBc7SrgbBlock: return "Bc7SrgbBlock";
49768 case Format::eEtc2R8G8B8UnormBlock: return "Etc2R8G8B8UnormBlock";
49769 case Format::eEtc2R8G8B8SrgbBlock: return "Etc2R8G8B8SrgbBlock";
49770 case Format::eEtc2R8G8B8A1UnormBlock: return "Etc2R8G8B8A1UnormBlock";
49771 case Format::eEtc2R8G8B8A1SrgbBlock: return "Etc2R8G8B8A1SrgbBlock";
49772 case Format::eEtc2R8G8B8A8UnormBlock: return "Etc2R8G8B8A8UnormBlock";
49773 case Format::eEtc2R8G8B8A8SrgbBlock: return "Etc2R8G8B8A8SrgbBlock";
49774 case Format::eEacR11UnormBlock: return "EacR11UnormBlock";
49775 case Format::eEacR11SnormBlock: return "EacR11SnormBlock";
49776 case Format::eEacR11G11UnormBlock: return "EacR11G11UnormBlock";
49777 case Format::eEacR11G11SnormBlock: return "EacR11G11SnormBlock";
49778 case Format::eAstc4x4UnormBlock: return "Astc4x4UnormBlock";
49779 case Format::eAstc4x4SrgbBlock: return "Astc4x4SrgbBlock";
49780 case Format::eAstc5x4UnormBlock: return "Astc5x4UnormBlock";
49781 case Format::eAstc5x4SrgbBlock: return "Astc5x4SrgbBlock";
49782 case Format::eAstc5x5UnormBlock: return "Astc5x5UnormBlock";
49783 case Format::eAstc5x5SrgbBlock: return "Astc5x5SrgbBlock";
49784 case Format::eAstc6x5UnormBlock: return "Astc6x5UnormBlock";
49785 case Format::eAstc6x5SrgbBlock: return "Astc6x5SrgbBlock";
49786 case Format::eAstc6x6UnormBlock: return "Astc6x6UnormBlock";
49787 case Format::eAstc6x6SrgbBlock: return "Astc6x6SrgbBlock";
49788 case Format::eAstc8x5UnormBlock: return "Astc8x5UnormBlock";
49789 case Format::eAstc8x5SrgbBlock: return "Astc8x5SrgbBlock";
49790 case Format::eAstc8x6UnormBlock: return "Astc8x6UnormBlock";
49791 case Format::eAstc8x6SrgbBlock: return "Astc8x6SrgbBlock";
49792 case Format::eAstc8x8UnormBlock: return "Astc8x8UnormBlock";
49793 case Format::eAstc8x8SrgbBlock: return "Astc8x8SrgbBlock";
49794 case Format::eAstc10x5UnormBlock: return "Astc10x5UnormBlock";
49795 case Format::eAstc10x5SrgbBlock: return "Astc10x5SrgbBlock";
49796 case Format::eAstc10x6UnormBlock: return "Astc10x6UnormBlock";
49797 case Format::eAstc10x6SrgbBlock: return "Astc10x6SrgbBlock";
49798 case Format::eAstc10x8UnormBlock: return "Astc10x8UnormBlock";
49799 case Format::eAstc10x8SrgbBlock: return "Astc10x8SrgbBlock";
49800 case Format::eAstc10x10UnormBlock: return "Astc10x10UnormBlock";
49801 case Format::eAstc10x10SrgbBlock: return "Astc10x10SrgbBlock";
49802 case Format::eAstc12x10UnormBlock: return "Astc12x10UnormBlock";
49803 case Format::eAstc12x10SrgbBlock: return "Astc12x10SrgbBlock";
49804 case Format::eAstc12x12UnormBlock: return "Astc12x12UnormBlock";
49805 case Format::eAstc12x12SrgbBlock: return "Astc12x12SrgbBlock";
49806 case Format::eG8B8G8R8422Unorm: return "G8B8G8R8422Unorm";
49807 case Format::eB8G8R8G8422Unorm: return "B8G8R8G8422Unorm";
49808 case Format::eG8B8R83Plane420Unorm: return "G8B8R83Plane420Unorm";
49809 case Format::eG8B8R82Plane420Unorm: return "G8B8R82Plane420Unorm";
49810 case Format::eG8B8R83Plane422Unorm: return "G8B8R83Plane422Unorm";
49811 case Format::eG8B8R82Plane422Unorm: return "G8B8R82Plane422Unorm";
49812 case Format::eG8B8R83Plane444Unorm: return "G8B8R83Plane444Unorm";
49813 case Format::eR10X6UnormPack16: return "R10X6UnormPack16";
49814 case Format::eR10X6G10X6Unorm2Pack16: return "R10X6G10X6Unorm2Pack16";
49815 case Format::eR10X6G10X6B10X6A10X6Unorm4Pack16: return "R10X6G10X6B10X6A10X6Unorm4Pack16";
49816 case Format::eG10X6B10X6G10X6R10X6422Unorm4Pack16: return "G10X6B10X6G10X6R10X6422Unorm4Pack16";
49817 case Format::eB10X6G10X6R10X6G10X6422Unorm4Pack16: return "B10X6G10X6R10X6G10X6422Unorm4Pack16";
49818 case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16: return "G10X6B10X6R10X63Plane420Unorm3Pack16";
49819 case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16: return "G10X6B10X6R10X62Plane420Unorm3Pack16";
49820 case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16: return "G10X6B10X6R10X63Plane422Unorm3Pack16";
49821 case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16: return "G10X6B10X6R10X62Plane422Unorm3Pack16";
49822 case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16: return "G10X6B10X6R10X63Plane444Unorm3Pack16";
49823 case Format::eR12X4UnormPack16: return "R12X4UnormPack16";
49824 case Format::eR12X4G12X4Unorm2Pack16: return "R12X4G12X4Unorm2Pack16";
49825 case Format::eR12X4G12X4B12X4A12X4Unorm4Pack16: return "R12X4G12X4B12X4A12X4Unorm4Pack16";
49826 case Format::eG12X4B12X4G12X4R12X4422Unorm4Pack16: return "G12X4B12X4G12X4R12X4422Unorm4Pack16";
49827 case Format::eB12X4G12X4R12X4G12X4422Unorm4Pack16: return "B12X4G12X4R12X4G12X4422Unorm4Pack16";
49828 case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16: return "G12X4B12X4R12X43Plane420Unorm3Pack16";
49829 case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16: return "G12X4B12X4R12X42Plane420Unorm3Pack16";
49830 case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16: return "G12X4B12X4R12X43Plane422Unorm3Pack16";
49831 case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16: return "G12X4B12X4R12X42Plane422Unorm3Pack16";
49832 case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16: return "G12X4B12X4R12X43Plane444Unorm3Pack16";
49833 case Format::eG16B16G16R16422Unorm: return "G16B16G16R16422Unorm";
49834 case Format::eB16G16R16G16422Unorm: return "B16G16R16G16422Unorm";
49835 case Format::eG16B16R163Plane420Unorm: return "G16B16R163Plane420Unorm";
49836 case Format::eG16B16R162Plane420Unorm: return "G16B16R162Plane420Unorm";
49837 case Format::eG16B16R163Plane422Unorm: return "G16B16R163Plane422Unorm";
49838 case Format::eG16B16R162Plane422Unorm: return "G16B16R162Plane422Unorm";
49839 case Format::eG16B16R163Plane444Unorm: return "G16B16R163Plane444Unorm";
49840 case Format::ePvrtc12BppUnormBlockIMG: return "Pvrtc12BppUnormBlockIMG";
49841 case Format::ePvrtc14BppUnormBlockIMG: return "Pvrtc14BppUnormBlockIMG";
49842 case Format::ePvrtc22BppUnormBlockIMG: return "Pvrtc22BppUnormBlockIMG";
49843 case Format::ePvrtc24BppUnormBlockIMG: return "Pvrtc24BppUnormBlockIMG";
49844 case Format::ePvrtc12BppSrgbBlockIMG: return "Pvrtc12BppSrgbBlockIMG";
49845 case Format::ePvrtc14BppSrgbBlockIMG: return "Pvrtc14BppSrgbBlockIMG";
49846 case Format::ePvrtc22BppSrgbBlockIMG: return "Pvrtc22BppSrgbBlockIMG";
49847 case Format::ePvrtc24BppSrgbBlockIMG: return "Pvrtc24BppSrgbBlockIMG";
49848 default: return "invalid";
49849 }
49850 }
49851
49853 {
49854 switch (value)
49855 {
49856 case StructureType::eApplicationInfo: return "ApplicationInfo";
49857 case StructureType::eInstanceCreateInfo: return "InstanceCreateInfo";
49858 case StructureType::eDeviceQueueCreateInfo: return "DeviceQueueCreateInfo";
49859 case StructureType::eDeviceCreateInfo: return "DeviceCreateInfo";
49860 case StructureType::eSubmitInfo: return "SubmitInfo";
49861 case StructureType::eMemoryAllocateInfo: return "MemoryAllocateInfo";
49862 case StructureType::eMappedMemoryRange: return "MappedMemoryRange";
49863 case StructureType::eBindSparseInfo: return "BindSparseInfo";
49864 case StructureType::eFenceCreateInfo: return "FenceCreateInfo";
49865 case StructureType::eSemaphoreCreateInfo: return "SemaphoreCreateInfo";
49866 case StructureType::eEventCreateInfo: return "EventCreateInfo";
49867 case StructureType::eQueryPoolCreateInfo: return "QueryPoolCreateInfo";
49868 case StructureType::eBufferCreateInfo: return "BufferCreateInfo";
49869 case StructureType::eBufferViewCreateInfo: return "BufferViewCreateInfo";
49870 case StructureType::eImageCreateInfo: return "ImageCreateInfo";
49871 case StructureType::eImageViewCreateInfo: return "ImageViewCreateInfo";
49872 case StructureType::eShaderModuleCreateInfo: return "ShaderModuleCreateInfo";
49873 case StructureType::ePipelineCacheCreateInfo: return "PipelineCacheCreateInfo";
49874 case StructureType::ePipelineShaderStageCreateInfo: return "PipelineShaderStageCreateInfo";
49875 case StructureType::ePipelineVertexInputStateCreateInfo: return "PipelineVertexInputStateCreateInfo";
49876 case StructureType::ePipelineInputAssemblyStateCreateInfo: return "PipelineInputAssemblyStateCreateInfo";
49877 case StructureType::ePipelineTessellationStateCreateInfo: return "PipelineTessellationStateCreateInfo";
49878 case StructureType::ePipelineViewportStateCreateInfo: return "PipelineViewportStateCreateInfo";
49879 case StructureType::ePipelineRasterizationStateCreateInfo: return "PipelineRasterizationStateCreateInfo";
49880 case StructureType::ePipelineMultisampleStateCreateInfo: return "PipelineMultisampleStateCreateInfo";
49881 case StructureType::ePipelineDepthStencilStateCreateInfo: return "PipelineDepthStencilStateCreateInfo";
49882 case StructureType::ePipelineColorBlendStateCreateInfo: return "PipelineColorBlendStateCreateInfo";
49883 case StructureType::ePipelineDynamicStateCreateInfo: return "PipelineDynamicStateCreateInfo";
49884 case StructureType::eGraphicsPipelineCreateInfo: return "GraphicsPipelineCreateInfo";
49885 case StructureType::eComputePipelineCreateInfo: return "ComputePipelineCreateInfo";
49886 case StructureType::ePipelineLayoutCreateInfo: return "PipelineLayoutCreateInfo";
49887 case StructureType::eSamplerCreateInfo: return "SamplerCreateInfo";
49888 case StructureType::eDescriptorSetLayoutCreateInfo: return "DescriptorSetLayoutCreateInfo";
49889 case StructureType::eDescriptorPoolCreateInfo: return "DescriptorPoolCreateInfo";
49890 case StructureType::eDescriptorSetAllocateInfo: return "DescriptorSetAllocateInfo";
49891 case StructureType::eWriteDescriptorSet: return "WriteDescriptorSet";
49892 case StructureType::eCopyDescriptorSet: return "CopyDescriptorSet";
49893 case StructureType::eFramebufferCreateInfo: return "FramebufferCreateInfo";
49894 case StructureType::eRenderPassCreateInfo: return "RenderPassCreateInfo";
49895 case StructureType::eCommandPoolCreateInfo: return "CommandPoolCreateInfo";
49896 case StructureType::eCommandBufferAllocateInfo: return "CommandBufferAllocateInfo";
49897 case StructureType::eCommandBufferInheritanceInfo: return "CommandBufferInheritanceInfo";
49898 case StructureType::eCommandBufferBeginInfo: return "CommandBufferBeginInfo";
49899 case StructureType::eRenderPassBeginInfo: return "RenderPassBeginInfo";
49900 case StructureType::eBufferMemoryBarrier: return "BufferMemoryBarrier";
49901 case StructureType::eImageMemoryBarrier: return "ImageMemoryBarrier";
49902 case StructureType::eMemoryBarrier: return "MemoryBarrier";
49903 case StructureType::eLoaderInstanceCreateInfo: return "LoaderInstanceCreateInfo";
49904 case StructureType::eLoaderDeviceCreateInfo: return "LoaderDeviceCreateInfo";
49905 case StructureType::ePhysicalDeviceSubgroupProperties: return "PhysicalDeviceSubgroupProperties";
49906 case StructureType::eBindBufferMemoryInfo: return "BindBufferMemoryInfo";
49907 case StructureType::eBindImageMemoryInfo: return "BindImageMemoryInfo";
49908 case StructureType::ePhysicalDevice16BitStorageFeatures: return "PhysicalDevice16BitStorageFeatures";
49909 case StructureType::eMemoryDedicatedRequirements: return "MemoryDedicatedRequirements";
49910 case StructureType::eMemoryDedicatedAllocateInfo: return "MemoryDedicatedAllocateInfo";
49911 case StructureType::eMemoryAllocateFlagsInfo: return "MemoryAllocateFlagsInfo";
49912 case StructureType::eDeviceGroupRenderPassBeginInfo: return "DeviceGroupRenderPassBeginInfo";
49913 case StructureType::eDeviceGroupCommandBufferBeginInfo: return "DeviceGroupCommandBufferBeginInfo";
49914 case StructureType::eDeviceGroupSubmitInfo: return "DeviceGroupSubmitInfo";
49915 case StructureType::eDeviceGroupBindSparseInfo: return "DeviceGroupBindSparseInfo";
49916 case StructureType::eBindBufferMemoryDeviceGroupInfo: return "BindBufferMemoryDeviceGroupInfo";
49917 case StructureType::eBindImageMemoryDeviceGroupInfo: return "BindImageMemoryDeviceGroupInfo";
49918 case StructureType::ePhysicalDeviceGroupProperties: return "PhysicalDeviceGroupProperties";
49919 case StructureType::eDeviceGroupDeviceCreateInfo: return "DeviceGroupDeviceCreateInfo";
49920 case StructureType::eBufferMemoryRequirementsInfo2: return "BufferMemoryRequirementsInfo2";
49921 case StructureType::eImageMemoryRequirementsInfo2: return "ImageMemoryRequirementsInfo2";
49922 case StructureType::eImageSparseMemoryRequirementsInfo2: return "ImageSparseMemoryRequirementsInfo2";
49923 case StructureType::eMemoryRequirements2: return "MemoryRequirements2";
49924 case StructureType::eSparseImageMemoryRequirements2: return "SparseImageMemoryRequirements2";
49925 case StructureType::ePhysicalDeviceFeatures2: return "PhysicalDeviceFeatures2";
49926 case StructureType::ePhysicalDeviceProperties2: return "PhysicalDeviceProperties2";
49927 case StructureType::eFormatProperties2: return "FormatProperties2";
49928 case StructureType::eImageFormatProperties2: return "ImageFormatProperties2";
49929 case StructureType::ePhysicalDeviceImageFormatInfo2: return "PhysicalDeviceImageFormatInfo2";
49930 case StructureType::eQueueFamilyProperties2: return "QueueFamilyProperties2";
49931 case StructureType::ePhysicalDeviceMemoryProperties2: return "PhysicalDeviceMemoryProperties2";
49932 case StructureType::eSparseImageFormatProperties2: return "SparseImageFormatProperties2";
49933 case StructureType::ePhysicalDeviceSparseImageFormatInfo2: return "PhysicalDeviceSparseImageFormatInfo2";
49934 case StructureType::ePhysicalDevicePointClippingProperties: return "PhysicalDevicePointClippingProperties";
49935 case StructureType::eRenderPassInputAttachmentAspectCreateInfo: return "RenderPassInputAttachmentAspectCreateInfo";
49936 case StructureType::eImageViewUsageCreateInfo: return "ImageViewUsageCreateInfo";
49937 case StructureType::ePipelineTessellationDomainOriginStateCreateInfo: return "PipelineTessellationDomainOriginStateCreateInfo";
49938 case StructureType::eRenderPassMultiviewCreateInfo: return "RenderPassMultiviewCreateInfo";
49939 case StructureType::ePhysicalDeviceMultiviewFeatures: return "PhysicalDeviceMultiviewFeatures";
49940 case StructureType::ePhysicalDeviceMultiviewProperties: return "PhysicalDeviceMultiviewProperties";
49941 case StructureType::ePhysicalDeviceVariablePointerFeatures: return "PhysicalDeviceVariablePointerFeatures";
49942 case StructureType::eProtectedSubmitInfo: return "ProtectedSubmitInfo";
49943 case StructureType::ePhysicalDeviceProtectedMemoryFeatures: return "PhysicalDeviceProtectedMemoryFeatures";
49944 case StructureType::ePhysicalDeviceProtectedMemoryProperties: return "PhysicalDeviceProtectedMemoryProperties";
49945 case StructureType::eDeviceQueueInfo2: return "DeviceQueueInfo2";
49946 case StructureType::eSamplerYcbcrConversionCreateInfo: return "SamplerYcbcrConversionCreateInfo";
49947 case StructureType::eSamplerYcbcrConversionInfo: return "SamplerYcbcrConversionInfo";
49948 case StructureType::eBindImagePlaneMemoryInfo: return "BindImagePlaneMemoryInfo";
49949 case StructureType::eImagePlaneMemoryRequirementsInfo: return "ImagePlaneMemoryRequirementsInfo";
49950 case StructureType::ePhysicalDeviceSamplerYcbcrConversionFeatures: return "PhysicalDeviceSamplerYcbcrConversionFeatures";
49951 case StructureType::eSamplerYcbcrConversionImageFormatProperties: return "SamplerYcbcrConversionImageFormatProperties";
49952 case StructureType::eDescriptorUpdateTemplateCreateInfo: return "DescriptorUpdateTemplateCreateInfo";
49953 case StructureType::ePhysicalDeviceExternalImageFormatInfo: return "PhysicalDeviceExternalImageFormatInfo";
49954 case StructureType::eExternalImageFormatProperties: return "ExternalImageFormatProperties";
49955 case StructureType::ePhysicalDeviceExternalBufferInfo: return "PhysicalDeviceExternalBufferInfo";
49956 case StructureType::eExternalBufferProperties: return "ExternalBufferProperties";
49957 case StructureType::ePhysicalDeviceIdProperties: return "PhysicalDeviceIdProperties";
49958 case StructureType::eExternalMemoryBufferCreateInfo: return "ExternalMemoryBufferCreateInfo";
49959 case StructureType::eExternalMemoryImageCreateInfo: return "ExternalMemoryImageCreateInfo";
49960 case StructureType::eExportMemoryAllocateInfo: return "ExportMemoryAllocateInfo";
49961 case StructureType::ePhysicalDeviceExternalFenceInfo: return "PhysicalDeviceExternalFenceInfo";
49962 case StructureType::eExternalFenceProperties: return "ExternalFenceProperties";
49963 case StructureType::eExportFenceCreateInfo: return "ExportFenceCreateInfo";
49964 case StructureType::eExportSemaphoreCreateInfo: return "ExportSemaphoreCreateInfo";
49965 case StructureType::ePhysicalDeviceExternalSemaphoreInfo: return "PhysicalDeviceExternalSemaphoreInfo";
49966 case StructureType::eExternalSemaphoreProperties: return "ExternalSemaphoreProperties";
49967 case StructureType::ePhysicalDeviceMaintenance3Properties: return "PhysicalDeviceMaintenance3Properties";
49968 case StructureType::eDescriptorSetLayoutSupport: return "DescriptorSetLayoutSupport";
49969 case StructureType::ePhysicalDeviceShaderDrawParameterFeatures: return "PhysicalDeviceShaderDrawParameterFeatures";
49970 case StructureType::eSwapchainCreateInfoKHR: return "SwapchainCreateInfoKHR";
49971 case StructureType::ePresentInfoKHR: return "PresentInfoKHR";
49972 case StructureType::eDeviceGroupPresentCapabilitiesKHR: return "DeviceGroupPresentCapabilitiesKHR";
49973 case StructureType::eImageSwapchainCreateInfoKHR: return "ImageSwapchainCreateInfoKHR";
49974 case StructureType::eBindImageMemorySwapchainInfoKHR: return "BindImageMemorySwapchainInfoKHR";
49975 case StructureType::eAcquireNextImageInfoKHR: return "AcquireNextImageInfoKHR";
49976 case StructureType::eDeviceGroupPresentInfoKHR: return "DeviceGroupPresentInfoKHR";
49977 case StructureType::eDeviceGroupSwapchainCreateInfoKHR: return "DeviceGroupSwapchainCreateInfoKHR";
49978 case StructureType::eDisplayModeCreateInfoKHR: return "DisplayModeCreateInfoKHR";
49979 case StructureType::eDisplaySurfaceCreateInfoKHR: return "DisplaySurfaceCreateInfoKHR";
49980 case StructureType::eDisplayPresentInfoKHR: return "DisplayPresentInfoKHR";
49981 case StructureType::eXlibSurfaceCreateInfoKHR: return "XlibSurfaceCreateInfoKHR";
49982 case StructureType::eXcbSurfaceCreateInfoKHR: return "XcbSurfaceCreateInfoKHR";
49983 case StructureType::eWaylandSurfaceCreateInfoKHR: return "WaylandSurfaceCreateInfoKHR";
49984 case StructureType::eAndroidSurfaceCreateInfoKHR: return "AndroidSurfaceCreateInfoKHR";
49985 case StructureType::eWin32SurfaceCreateInfoKHR: return "Win32SurfaceCreateInfoKHR";
49986 case StructureType::eDebugReportCallbackCreateInfoEXT: return "DebugReportCallbackCreateInfoEXT";
49987 case StructureType::ePipelineRasterizationStateRasterizationOrderAMD: return "PipelineRasterizationStateRasterizationOrderAMD";
49988 case StructureType::eDebugMarkerObjectNameInfoEXT: return "DebugMarkerObjectNameInfoEXT";
49989 case StructureType::eDebugMarkerObjectTagInfoEXT: return "DebugMarkerObjectTagInfoEXT";
49990 case StructureType::eDebugMarkerMarkerInfoEXT: return "DebugMarkerMarkerInfoEXT";
49991 case StructureType::eDedicatedAllocationImageCreateInfoNV: return "DedicatedAllocationImageCreateInfoNV";
49992 case StructureType::eDedicatedAllocationBufferCreateInfoNV: return "DedicatedAllocationBufferCreateInfoNV";
49993 case StructureType::eDedicatedAllocationMemoryAllocateInfoNV: return "DedicatedAllocationMemoryAllocateInfoNV";
49994 case StructureType::ePhysicalDeviceTransformFeedbackFeaturesEXT: return "PhysicalDeviceTransformFeedbackFeaturesEXT";
49995 case StructureType::ePhysicalDeviceTransformFeedbackPropertiesEXT: return "PhysicalDeviceTransformFeedbackPropertiesEXT";
49996 case StructureType::ePipelineRasterizationStateStreamCreateInfoEXT: return "PipelineRasterizationStateStreamCreateInfoEXT";
49997 case StructureType::eTextureLodGatherFormatPropertiesAMD: return "TextureLodGatherFormatPropertiesAMD";
49998 case StructureType::ePhysicalDeviceCornerSampledImageFeaturesNV: return "PhysicalDeviceCornerSampledImageFeaturesNV";
49999 case StructureType::eExternalMemoryImageCreateInfoNV: return "ExternalMemoryImageCreateInfoNV";
50000 case StructureType::eExportMemoryAllocateInfoNV: return "ExportMemoryAllocateInfoNV";
50001 case StructureType::eImportMemoryWin32HandleInfoNV: return "ImportMemoryWin32HandleInfoNV";
50002 case StructureType::eExportMemoryWin32HandleInfoNV: return "ExportMemoryWin32HandleInfoNV";
50003 case StructureType::eWin32KeyedMutexAcquireReleaseInfoNV: return "Win32KeyedMutexAcquireReleaseInfoNV";
50004 case StructureType::eValidationFlagsEXT: return "ValidationFlagsEXT";
50005 case StructureType::eViSurfaceCreateInfoNN: return "ViSurfaceCreateInfoNN";
50006 case StructureType::eImageViewAstcDecodeModeEXT: return "ImageViewAstcDecodeModeEXT";
50007 case StructureType::ePhysicalDeviceAstcDecodeFeaturesEXT: return "PhysicalDeviceAstcDecodeFeaturesEXT";
50008 case StructureType::eImportMemoryWin32HandleInfoKHR: return "ImportMemoryWin32HandleInfoKHR";
50009 case StructureType::eExportMemoryWin32HandleInfoKHR: return "ExportMemoryWin32HandleInfoKHR";
50010 case StructureType::eMemoryWin32HandlePropertiesKHR: return "MemoryWin32HandlePropertiesKHR";
50011 case StructureType::eMemoryGetWin32HandleInfoKHR: return "MemoryGetWin32HandleInfoKHR";
50012 case StructureType::eImportMemoryFdInfoKHR: return "ImportMemoryFdInfoKHR";
50013 case StructureType::eMemoryFdPropertiesKHR: return "MemoryFdPropertiesKHR";
50014 case StructureType::eMemoryGetFdInfoKHR: return "MemoryGetFdInfoKHR";
50015 case StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR: return "Win32KeyedMutexAcquireReleaseInfoKHR";
50016 case StructureType::eImportSemaphoreWin32HandleInfoKHR: return "ImportSemaphoreWin32HandleInfoKHR";
50017 case StructureType::eExportSemaphoreWin32HandleInfoKHR: return "ExportSemaphoreWin32HandleInfoKHR";
50018 case StructureType::eD3D12FenceSubmitInfoKHR: return "D3D12FenceSubmitInfoKHR";
50019 case StructureType::eSemaphoreGetWin32HandleInfoKHR: return "SemaphoreGetWin32HandleInfoKHR";
50020 case StructureType::eImportSemaphoreFdInfoKHR: return "ImportSemaphoreFdInfoKHR";
50021 case StructureType::eSemaphoreGetFdInfoKHR: return "SemaphoreGetFdInfoKHR";
50022 case StructureType::ePhysicalDevicePushDescriptorPropertiesKHR: return "PhysicalDevicePushDescriptorPropertiesKHR";
50023 case StructureType::eCommandBufferInheritanceConditionalRenderingInfoEXT: return "CommandBufferInheritanceConditionalRenderingInfoEXT";
50024 case StructureType::ePhysicalDeviceConditionalRenderingFeaturesEXT: return "PhysicalDeviceConditionalRenderingFeaturesEXT";
50025 case StructureType::eConditionalRenderingBeginInfoEXT: return "ConditionalRenderingBeginInfoEXT";
50026 case StructureType::ePresentRegionsKHR: return "PresentRegionsKHR";
50027 case StructureType::eObjectTableCreateInfoNVX: return "ObjectTableCreateInfoNVX";
50028 case StructureType::eIndirectCommandsLayoutCreateInfoNVX: return "IndirectCommandsLayoutCreateInfoNVX";
50029 case StructureType::eCmdProcessCommandsInfoNVX: return "CmdProcessCommandsInfoNVX";
50030 case StructureType::eCmdReserveSpaceForCommandsInfoNVX: return "CmdReserveSpaceForCommandsInfoNVX";
50031 case StructureType::eDeviceGeneratedCommandsLimitsNVX: return "DeviceGeneratedCommandsLimitsNVX";
50032 case StructureType::eDeviceGeneratedCommandsFeaturesNVX: return "DeviceGeneratedCommandsFeaturesNVX";
50033 case StructureType::ePipelineViewportWScalingStateCreateInfoNV: return "PipelineViewportWScalingStateCreateInfoNV";
50034 case StructureType::eSurfaceCapabilities2EXT: return "SurfaceCapabilities2EXT";
50035 case StructureType::eDisplayPowerInfoEXT: return "DisplayPowerInfoEXT";
50036 case StructureType::eDeviceEventInfoEXT: return "DeviceEventInfoEXT";
50037 case StructureType::eDisplayEventInfoEXT: return "DisplayEventInfoEXT";
50038 case StructureType::eSwapchainCounterCreateInfoEXT: return "SwapchainCounterCreateInfoEXT";
50039 case StructureType::ePresentTimesInfoGOOGLE: return "PresentTimesInfoGOOGLE";
50040 case StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX: return "PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX";
50041 case StructureType::ePipelineViewportSwizzleStateCreateInfoNV: return "PipelineViewportSwizzleStateCreateInfoNV";
50042 case StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT: return "PhysicalDeviceDiscardRectanglePropertiesEXT";
50043 case StructureType::ePipelineDiscardRectangleStateCreateInfoEXT: return "PipelineDiscardRectangleStateCreateInfoEXT";
50044 case StructureType::ePhysicalDeviceConservativeRasterizationPropertiesEXT: return "PhysicalDeviceConservativeRasterizationPropertiesEXT";
50045 case StructureType::ePipelineRasterizationConservativeStateCreateInfoEXT: return "PipelineRasterizationConservativeStateCreateInfoEXT";
50046 case StructureType::eHdrMetadataEXT: return "HdrMetadataEXT";
50047 case StructureType::eAttachmentDescription2KHR: return "AttachmentDescription2KHR";
50048 case StructureType::eAttachmentReference2KHR: return "AttachmentReference2KHR";
50049 case StructureType::eSubpassDescription2KHR: return "SubpassDescription2KHR";
50050 case StructureType::eSubpassDependency2KHR: return "SubpassDependency2KHR";
50051 case StructureType::eRenderPassCreateInfo2KHR: return "RenderPassCreateInfo2KHR";
50052 case StructureType::eSubpassBeginInfoKHR: return "SubpassBeginInfoKHR";
50053 case StructureType::eSubpassEndInfoKHR: return "SubpassEndInfoKHR";
50054 case StructureType::eSharedPresentSurfaceCapabilitiesKHR: return "SharedPresentSurfaceCapabilitiesKHR";
50055 case StructureType::eImportFenceWin32HandleInfoKHR: return "ImportFenceWin32HandleInfoKHR";
50056 case StructureType::eExportFenceWin32HandleInfoKHR: return "ExportFenceWin32HandleInfoKHR";
50057 case StructureType::eFenceGetWin32HandleInfoKHR: return "FenceGetWin32HandleInfoKHR";
50058 case StructureType::eImportFenceFdInfoKHR: return "ImportFenceFdInfoKHR";
50059 case StructureType::eFenceGetFdInfoKHR: return "FenceGetFdInfoKHR";
50060 case StructureType::ePhysicalDeviceSurfaceInfo2KHR: return "PhysicalDeviceSurfaceInfo2KHR";
50061 case StructureType::eSurfaceCapabilities2KHR: return "SurfaceCapabilities2KHR";
50062 case StructureType::eSurfaceFormat2KHR: return "SurfaceFormat2KHR";
50063 case StructureType::eDisplayProperties2KHR: return "DisplayProperties2KHR";
50064 case StructureType::eDisplayPlaneProperties2KHR: return "DisplayPlaneProperties2KHR";
50065 case StructureType::eDisplayModeProperties2KHR: return "DisplayModeProperties2KHR";
50066 case StructureType::eDisplayPlaneInfo2KHR: return "DisplayPlaneInfo2KHR";
50067 case StructureType::eDisplayPlaneCapabilities2KHR: return "DisplayPlaneCapabilities2KHR";
50068 case StructureType::eIosSurfaceCreateInfoMVK: return "IosSurfaceCreateInfoMVK";
50069 case StructureType::eMacosSurfaceCreateInfoMVK: return "MacosSurfaceCreateInfoMVK";
50070 case StructureType::eDebugUtilsObjectNameInfoEXT: return "DebugUtilsObjectNameInfoEXT";
50071 case StructureType::eDebugUtilsObjectTagInfoEXT: return "DebugUtilsObjectTagInfoEXT";
50072 case StructureType::eDebugUtilsLabelEXT: return "DebugUtilsLabelEXT";
50073 case StructureType::eDebugUtilsMessengerCallbackDataEXT: return "DebugUtilsMessengerCallbackDataEXT";
50074 case StructureType::eDebugUtilsMessengerCreateInfoEXT: return "DebugUtilsMessengerCreateInfoEXT";
50075 case StructureType::eAndroidHardwareBufferUsageANDROID: return "AndroidHardwareBufferUsageANDROID";
50076 case StructureType::eAndroidHardwareBufferPropertiesANDROID: return "AndroidHardwareBufferPropertiesANDROID";
50077 case StructureType::eAndroidHardwareBufferFormatPropertiesANDROID: return "AndroidHardwareBufferFormatPropertiesANDROID";
50078 case StructureType::eImportAndroidHardwareBufferInfoANDROID: return "ImportAndroidHardwareBufferInfoANDROID";
50079 case StructureType::eMemoryGetAndroidHardwareBufferInfoANDROID: return "MemoryGetAndroidHardwareBufferInfoANDROID";
50080 case StructureType::eExternalFormatANDROID: return "ExternalFormatANDROID";
50081 case StructureType::ePhysicalDeviceSamplerFilterMinmaxPropertiesEXT: return "PhysicalDeviceSamplerFilterMinmaxPropertiesEXT";
50082 case StructureType::eSamplerReductionModeCreateInfoEXT: return "SamplerReductionModeCreateInfoEXT";
50083 case StructureType::ePhysicalDeviceInlineUniformBlockFeaturesEXT: return "PhysicalDeviceInlineUniformBlockFeaturesEXT";
50084 case StructureType::ePhysicalDeviceInlineUniformBlockPropertiesEXT: return "PhysicalDeviceInlineUniformBlockPropertiesEXT";
50085 case StructureType::eWriteDescriptorSetInlineUniformBlockEXT: return "WriteDescriptorSetInlineUniformBlockEXT";
50086 case StructureType::eDescriptorPoolInlineUniformBlockCreateInfoEXT: return "DescriptorPoolInlineUniformBlockCreateInfoEXT";
50087 case StructureType::eSampleLocationsInfoEXT: return "SampleLocationsInfoEXT";
50088 case StructureType::eRenderPassSampleLocationsBeginInfoEXT: return "RenderPassSampleLocationsBeginInfoEXT";
50089 case StructureType::ePipelineSampleLocationsStateCreateInfoEXT: return "PipelineSampleLocationsStateCreateInfoEXT";
50090 case StructureType::ePhysicalDeviceSampleLocationsPropertiesEXT: return "PhysicalDeviceSampleLocationsPropertiesEXT";
50091 case StructureType::eMultisamplePropertiesEXT: return "MultisamplePropertiesEXT";
50092 case StructureType::eImageFormatListCreateInfoKHR: return "ImageFormatListCreateInfoKHR";
50093 case StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT: return "PhysicalDeviceBlendOperationAdvancedFeaturesEXT";
50094 case StructureType::ePhysicalDeviceBlendOperationAdvancedPropertiesEXT: return "PhysicalDeviceBlendOperationAdvancedPropertiesEXT";
50095 case StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT: return "PipelineColorBlendAdvancedStateCreateInfoEXT";
50096 case StructureType::ePipelineCoverageToColorStateCreateInfoNV: return "PipelineCoverageToColorStateCreateInfoNV";
50097 case StructureType::ePipelineCoverageModulationStateCreateInfoNV: return "PipelineCoverageModulationStateCreateInfoNV";
50098 case StructureType::eDrmFormatModifierPropertiesListEXT: return "DrmFormatModifierPropertiesListEXT";
50099 case StructureType::eDrmFormatModifierPropertiesEXT: return "DrmFormatModifierPropertiesEXT";
50100 case StructureType::ePhysicalDeviceImageDrmFormatModifierInfoEXT: return "PhysicalDeviceImageDrmFormatModifierInfoEXT";
50101 case StructureType::eImageDrmFormatModifierListCreateInfoEXT: return "ImageDrmFormatModifierListCreateInfoEXT";
50102 case StructureType::eImageDrmFormatModifierExplicitCreateInfoEXT: return "ImageDrmFormatModifierExplicitCreateInfoEXT";
50103 case StructureType::eImageDrmFormatModifierPropertiesEXT: return "ImageDrmFormatModifierPropertiesEXT";
50104 case StructureType::eValidationCacheCreateInfoEXT: return "ValidationCacheCreateInfoEXT";
50105 case StructureType::eShaderModuleValidationCacheCreateInfoEXT: return "ShaderModuleValidationCacheCreateInfoEXT";
50106 case StructureType::eDescriptorSetLayoutBindingFlagsCreateInfoEXT: return "DescriptorSetLayoutBindingFlagsCreateInfoEXT";
50107 case StructureType::ePhysicalDeviceDescriptorIndexingFeaturesEXT: return "PhysicalDeviceDescriptorIndexingFeaturesEXT";
50108 case StructureType::ePhysicalDeviceDescriptorIndexingPropertiesEXT: return "PhysicalDeviceDescriptorIndexingPropertiesEXT";
50109 case StructureType::eDescriptorSetVariableDescriptorCountAllocateInfoEXT: return "DescriptorSetVariableDescriptorCountAllocateInfoEXT";
50110 case StructureType::eDescriptorSetVariableDescriptorCountLayoutSupportEXT: return "DescriptorSetVariableDescriptorCountLayoutSupportEXT";
50111 case StructureType::ePipelineViewportShadingRateImageStateCreateInfoNV: return "PipelineViewportShadingRateImageStateCreateInfoNV";
50112 case StructureType::ePhysicalDeviceShadingRateImageFeaturesNV: return "PhysicalDeviceShadingRateImageFeaturesNV";
50113 case StructureType::ePhysicalDeviceShadingRateImagePropertiesNV: return "PhysicalDeviceShadingRateImagePropertiesNV";
50114 case StructureType::ePipelineViewportCoarseSampleOrderStateCreateInfoNV: return "PipelineViewportCoarseSampleOrderStateCreateInfoNV";
50115 case StructureType::eRayTracingPipelineCreateInfoNV: return "RayTracingPipelineCreateInfoNV";
50116 case StructureType::eAccelerationStructureCreateInfoNV: return "AccelerationStructureCreateInfoNV";
50117 case StructureType::eGeometryNV: return "GeometryNV";
50118 case StructureType::eGeometryTrianglesNV: return "GeometryTrianglesNV";
50119 case StructureType::eGeometryAabbNV: return "GeometryAabbNV";
50120 case StructureType::eBindAccelerationStructureMemoryInfoNV: return "BindAccelerationStructureMemoryInfoNV";
50121 case StructureType::eWriteDescriptorSetAccelerationStructureNV: return "WriteDescriptorSetAccelerationStructureNV";
50122 case StructureType::eAccelerationStructureMemoryRequirementsInfoNV: return "AccelerationStructureMemoryRequirementsInfoNV";
50123 case StructureType::ePhysicalDeviceRayTracingPropertiesNV: return "PhysicalDeviceRayTracingPropertiesNV";
50124 case StructureType::eRayTracingShaderGroupCreateInfoNV: return "RayTracingShaderGroupCreateInfoNV";
50125 case StructureType::eAccelerationStructureInfoNV: return "AccelerationStructureInfoNV";
50126 case StructureType::ePhysicalDeviceRepresentativeFragmentTestFeaturesNV: return "PhysicalDeviceRepresentativeFragmentTestFeaturesNV";
50127 case StructureType::ePipelineRepresentativeFragmentTestStateCreateInfoNV: return "PipelineRepresentativeFragmentTestStateCreateInfoNV";
50128 case StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT: return "DeviceQueueGlobalPriorityCreateInfoEXT";
50129 case StructureType::ePhysicalDevice8BitStorageFeaturesKHR: return "PhysicalDevice8BitStorageFeaturesKHR";
50130 case StructureType::eImportMemoryHostPointerInfoEXT: return "ImportMemoryHostPointerInfoEXT";
50131 case StructureType::eMemoryHostPointerPropertiesEXT: return "MemoryHostPointerPropertiesEXT";
50132 case StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT: return "PhysicalDeviceExternalMemoryHostPropertiesEXT";
50133 case StructureType::ePhysicalDeviceShaderAtomicInt64FeaturesKHR: return "PhysicalDeviceShaderAtomicInt64FeaturesKHR";
50134 case StructureType::eCalibratedTimestampInfoEXT: return "CalibratedTimestampInfoEXT";
50135 case StructureType::ePhysicalDeviceShaderCorePropertiesAMD: return "PhysicalDeviceShaderCorePropertiesAMD";
50136 case StructureType::eDeviceMemoryOverallocationCreateInfoAMD: return "DeviceMemoryOverallocationCreateInfoAMD";
50137 case StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT: return "PhysicalDeviceVertexAttributeDivisorPropertiesEXT";
50138 case StructureType::ePipelineVertexInputDivisorStateCreateInfoEXT: return "PipelineVertexInputDivisorStateCreateInfoEXT";
50139 case StructureType::ePhysicalDeviceVertexAttributeDivisorFeaturesEXT: return "PhysicalDeviceVertexAttributeDivisorFeaturesEXT";
50140 case StructureType::ePhysicalDeviceDriverPropertiesKHR: return "PhysicalDeviceDriverPropertiesKHR";
50141 case StructureType::ePhysicalDeviceComputeShaderDerivativesFeaturesNV: return "PhysicalDeviceComputeShaderDerivativesFeaturesNV";
50142 case StructureType::ePhysicalDeviceMeshShaderFeaturesNV: return "PhysicalDeviceMeshShaderFeaturesNV";
50143 case StructureType::ePhysicalDeviceMeshShaderPropertiesNV: return "PhysicalDeviceMeshShaderPropertiesNV";
50144 case StructureType::ePhysicalDeviceFragmentShaderBarycentricFeaturesNV: return "PhysicalDeviceFragmentShaderBarycentricFeaturesNV";
50145 case StructureType::ePhysicalDeviceShaderImageFootprintFeaturesNV: return "PhysicalDeviceShaderImageFootprintFeaturesNV";
50146 case StructureType::ePipelineViewportExclusiveScissorStateCreateInfoNV: return "PipelineViewportExclusiveScissorStateCreateInfoNV";
50147 case StructureType::ePhysicalDeviceExclusiveScissorFeaturesNV: return "PhysicalDeviceExclusiveScissorFeaturesNV";
50148 case StructureType::eCheckpointDataNV: return "CheckpointDataNV";
50149 case StructureType::eQueueFamilyCheckpointPropertiesNV: return "QueueFamilyCheckpointPropertiesNV";
50150 case StructureType::ePhysicalDeviceVulkanMemoryModelFeaturesKHR: return "PhysicalDeviceVulkanMemoryModelFeaturesKHR";
50151 case StructureType::ePhysicalDevicePciBusInfoPropertiesEXT: return "PhysicalDevicePciBusInfoPropertiesEXT";
50152 case StructureType::eImagepipeSurfaceCreateInfoFUCHSIA: return "ImagepipeSurfaceCreateInfoFUCHSIA";
50153 default: return "invalid";
50154 }
50155 }
50156
50158 {
50159 switch (value)
50160 {
50161 case SubpassContents::eInline: return "Inline";
50162 case SubpassContents::eSecondaryCommandBuffers: return "SecondaryCommandBuffers";
50163 default: return "invalid";
50164 }
50165 }
50166
50168 {
50169 switch (value)
50170 {
50171 case DynamicState::eViewport: return "Viewport";
50172 case DynamicState::eScissor: return "Scissor";
50173 case DynamicState::eLineWidth: return "LineWidth";
50174 case DynamicState::eDepthBias: return "DepthBias";
50175 case DynamicState::eBlendConstants: return "BlendConstants";
50176 case DynamicState::eDepthBounds: return "DepthBounds";
50177 case DynamicState::eStencilCompareMask: return "StencilCompareMask";
50178 case DynamicState::eStencilWriteMask: return "StencilWriteMask";
50179 case DynamicState::eStencilReference: return "StencilReference";
50180 case DynamicState::eViewportWScalingNV: return "ViewportWScalingNV";
50181 case DynamicState::eDiscardRectangleEXT: return "DiscardRectangleEXT";
50182 case DynamicState::eSampleLocationsEXT: return "SampleLocationsEXT";
50183 case DynamicState::eViewportShadingRatePaletteNV: return "ViewportShadingRatePaletteNV";
50184 case DynamicState::eViewportCoarseSampleOrderNV: return "ViewportCoarseSampleOrderNV";
50185 case DynamicState::eExclusiveScissorNV: return "ExclusiveScissorNV";
50186 default: return "invalid";
50187 }
50188 }
50189
50191 {
50192 switch (value)
50193 {
50194 case DescriptorUpdateTemplateType::eDescriptorSet: return "DescriptorSet";
50195 case DescriptorUpdateTemplateType::ePushDescriptorsKHR: return "PushDescriptorsKHR";
50196 default: return "invalid";
50197 }
50198 }
50199
50201 {
50202 switch (value)
50203 {
50204 case ObjectType::eUnknown: return "Unknown";
50205 case ObjectType::eInstance: return "Instance";
50206 case ObjectType::ePhysicalDevice: return "PhysicalDevice";
50207 case ObjectType::eDevice: return "Device";
50208 case ObjectType::eQueue: return "Queue";
50209 case ObjectType::eSemaphore: return "Semaphore";
50210 case ObjectType::eCommandBuffer: return "CommandBuffer";
50211 case ObjectType::eFence: return "Fence";
50212 case ObjectType::eDeviceMemory: return "DeviceMemory";
50213 case ObjectType::eBuffer: return "Buffer";
50214 case ObjectType::eImage: return "Image";
50215 case ObjectType::eEvent: return "Event";
50216 case ObjectType::eQueryPool: return "QueryPool";
50217 case ObjectType::eBufferView: return "BufferView";
50218 case ObjectType::eImageView: return "ImageView";
50219 case ObjectType::eShaderModule: return "ShaderModule";
50220 case ObjectType::ePipelineCache: return "PipelineCache";
50221 case ObjectType::ePipelineLayout: return "PipelineLayout";
50222 case ObjectType::eRenderPass: return "RenderPass";
50223 case ObjectType::ePipeline: return "Pipeline";
50224 case ObjectType::eDescriptorSetLayout: return "DescriptorSetLayout";
50225 case ObjectType::eSampler: return "Sampler";
50226 case ObjectType::eDescriptorPool: return "DescriptorPool";
50227 case ObjectType::eDescriptorSet: return "DescriptorSet";
50228 case ObjectType::eFramebuffer: return "Framebuffer";
50229 case ObjectType::eCommandPool: return "CommandPool";
50230 case ObjectType::eSamplerYcbcrConversion: return "SamplerYcbcrConversion";
50231 case ObjectType::eDescriptorUpdateTemplate: return "DescriptorUpdateTemplate";
50232 case ObjectType::eSurfaceKHR: return "SurfaceKHR";
50233 case ObjectType::eSwapchainKHR: return "SwapchainKHR";
50234 case ObjectType::eDisplayKHR: return "DisplayKHR";
50235 case ObjectType::eDisplayModeKHR: return "DisplayModeKHR";
50236 case ObjectType::eDebugReportCallbackEXT: return "DebugReportCallbackEXT";
50237 case ObjectType::eObjectTableNVX: return "ObjectTableNVX";
50238 case ObjectType::eIndirectCommandsLayoutNVX: return "IndirectCommandsLayoutNVX";
50239 case ObjectType::eDebugUtilsMessengerEXT: return "DebugUtilsMessengerEXT";
50240 case ObjectType::eValidationCacheEXT: return "ValidationCacheEXT";
50241 case ObjectType::eAccelerationStructureNV: return "AccelerationStructureNV";
50242 default: return "invalid";
50243 }
50244 }
50245
50247 {
50248 switch (value)
50249 {
50250 case QueueFlagBits::eGraphics: return "Graphics";
50251 case QueueFlagBits::eCompute: return "Compute";
50252 case QueueFlagBits::eTransfer: return "Transfer";
50253 case QueueFlagBits::eSparseBinding: return "SparseBinding";
50254 case QueueFlagBits::eProtected: return "Protected";
50255 default: return "invalid";
50256 }
50257 }
50258
50260 {
50261 if (!value) return "{}";
50263 if (value & QueueFlagBits::eGraphics) result += "Graphics | ";
50264 if (value & QueueFlagBits::eCompute) result += "Compute | ";
50265 if (value & QueueFlagBits::eTransfer) result += "Transfer | ";
50266 if (value & QueueFlagBits::eSparseBinding) result += "SparseBinding | ";
50267 if (value & QueueFlagBits::eProtected) result += "Protected | ";
50268 return "{" + result.substr(0, result.size() - 3) + "}";
50269 }
50270
50272 {
50273 switch (value)
50274 {
50275 case DeviceQueueCreateFlagBits::eProtected: return "Protected";
50276 default: return "invalid";
50277 }
50278 }
50279
50281 {
50282 if (!value) return "{}";
50284 if (value & DeviceQueueCreateFlagBits::eProtected) result += "Protected | ";
50285 return "{" + result.substr(0, result.size() - 3) + "}";
50286 }
50287
50289 {
50290 switch (value)
50291 {
50292 case MemoryPropertyFlagBits::eDeviceLocal: return "DeviceLocal";
50293 case MemoryPropertyFlagBits::eHostVisible: return "HostVisible";
50294 case MemoryPropertyFlagBits::eHostCoherent: return "HostCoherent";
50295 case MemoryPropertyFlagBits::eHostCached: return "HostCached";
50296 case MemoryPropertyFlagBits::eLazilyAllocated: return "LazilyAllocated";
50297 case MemoryPropertyFlagBits::eProtected: return "Protected";
50298 default: return "invalid";
50299 }
50300 }
50301
50303 {
50304 if (!value) return "{}";
50306 if (value & MemoryPropertyFlagBits::eDeviceLocal) result += "DeviceLocal | ";
50307 if (value & MemoryPropertyFlagBits::eHostVisible) result += "HostVisible | ";
50308 if (value & MemoryPropertyFlagBits::eHostCoherent) result += "HostCoherent | ";
50309 if (value & MemoryPropertyFlagBits::eHostCached) result += "HostCached | ";
50310 if (value & MemoryPropertyFlagBits::eLazilyAllocated) result += "LazilyAllocated | ";
50311 if (value & MemoryPropertyFlagBits::eProtected) result += "Protected | ";
50312 return "{" + result.substr(0, result.size() - 3) + "}";
50313 }
50314
50316 {
50317 switch (value)
50318 {
50319 case MemoryHeapFlagBits::eDeviceLocal: return "DeviceLocal";
50320 case MemoryHeapFlagBits::eMultiInstance: return "MultiInstance";
50321 default: return "invalid";
50322 }
50323 }
50324
50326 {
50327 if (!value) return "{}";
50329 if (value & MemoryHeapFlagBits::eDeviceLocal) result += "DeviceLocal | ";
50330 if (value & MemoryHeapFlagBits::eMultiInstance) result += "MultiInstance | ";
50331 return "{" + result.substr(0, result.size() - 3) + "}";
50332 }
50333
50335 {
50336 switch (value)
50337 {
50338 case AccessFlagBits::eIndirectCommandRead: return "IndirectCommandRead";
50339 case AccessFlagBits::eIndexRead: return "IndexRead";
50340 case AccessFlagBits::eVertexAttributeRead: return "VertexAttributeRead";
50341 case AccessFlagBits::eUniformRead: return "UniformRead";
50342 case AccessFlagBits::eInputAttachmentRead: return "InputAttachmentRead";
50343 case AccessFlagBits::eShaderRead: return "ShaderRead";
50344 case AccessFlagBits::eShaderWrite: return "ShaderWrite";
50345 case AccessFlagBits::eColorAttachmentRead: return "ColorAttachmentRead";
50346 case AccessFlagBits::eColorAttachmentWrite: return "ColorAttachmentWrite";
50347 case AccessFlagBits::eDepthStencilAttachmentRead: return "DepthStencilAttachmentRead";
50348 case AccessFlagBits::eDepthStencilAttachmentWrite: return "DepthStencilAttachmentWrite";
50349 case AccessFlagBits::eTransferRead: return "TransferRead";
50350 case AccessFlagBits::eTransferWrite: return "TransferWrite";
50351 case AccessFlagBits::eHostRead: return "HostRead";
50352 case AccessFlagBits::eHostWrite: return "HostWrite";
50353 case AccessFlagBits::eMemoryRead: return "MemoryRead";
50354 case AccessFlagBits::eMemoryWrite: return "MemoryWrite";
50355 case AccessFlagBits::eTransformFeedbackWriteEXT: return "TransformFeedbackWriteEXT";
50356 case AccessFlagBits::eTransformFeedbackCounterReadEXT: return "TransformFeedbackCounterReadEXT";
50357 case AccessFlagBits::eTransformFeedbackCounterWriteEXT: return "TransformFeedbackCounterWriteEXT";
50358 case AccessFlagBits::eConditionalRenderingReadEXT: return "ConditionalRenderingReadEXT";
50359 case AccessFlagBits::eCommandProcessReadNVX: return "CommandProcessReadNVX";
50360 case AccessFlagBits::eCommandProcessWriteNVX: return "CommandProcessWriteNVX";
50361 case AccessFlagBits::eColorAttachmentReadNoncoherentEXT: return "ColorAttachmentReadNoncoherentEXT";
50362 case AccessFlagBits::eShadingRateImageReadNV: return "ShadingRateImageReadNV";
50363 case AccessFlagBits::eAccelerationStructureReadNV: return "AccelerationStructureReadNV";
50364 case AccessFlagBits::eAccelerationStructureWriteNV: return "AccelerationStructureWriteNV";
50365 default: return "invalid";
50366 }
50367 }
50368
50370 {
50371 if (!value) return "{}";
50373 if (value & AccessFlagBits::eIndirectCommandRead) result += "IndirectCommandRead | ";
50374 if (value & AccessFlagBits::eIndexRead) result += "IndexRead | ";
50375 if (value & AccessFlagBits::eVertexAttributeRead) result += "VertexAttributeRead | ";
50376 if (value & AccessFlagBits::eUniformRead) result += "UniformRead | ";
50377 if (value & AccessFlagBits::eInputAttachmentRead) result += "InputAttachmentRead | ";
50378 if (value & AccessFlagBits::eShaderRead) result += "ShaderRead | ";
50379 if (value & AccessFlagBits::eShaderWrite) result += "ShaderWrite | ";
50380 if (value & AccessFlagBits::eColorAttachmentRead) result += "ColorAttachmentRead | ";
50381 if (value & AccessFlagBits::eColorAttachmentWrite) result += "ColorAttachmentWrite | ";
50382 if (value & AccessFlagBits::eDepthStencilAttachmentRead) result += "DepthStencilAttachmentRead | ";
50383 if (value & AccessFlagBits::eDepthStencilAttachmentWrite) result += "DepthStencilAttachmentWrite | ";
50384 if (value & AccessFlagBits::eTransferRead) result += "TransferRead | ";
50385 if (value & AccessFlagBits::eTransferWrite) result += "TransferWrite | ";
50386 if (value & AccessFlagBits::eHostRead) result += "HostRead | ";
50387 if (value & AccessFlagBits::eHostWrite) result += "HostWrite | ";
50388 if (value & AccessFlagBits::eMemoryRead) result += "MemoryRead | ";
50389 if (value & AccessFlagBits::eMemoryWrite) result += "MemoryWrite | ";
50390 if (value & AccessFlagBits::eTransformFeedbackWriteEXT) result += "TransformFeedbackWriteEXT | ";
50391 if (value & AccessFlagBits::eTransformFeedbackCounterReadEXT) result += "TransformFeedbackCounterReadEXT | ";
50392 if (value & AccessFlagBits::eTransformFeedbackCounterWriteEXT) result += "TransformFeedbackCounterWriteEXT | ";
50393 if (value & AccessFlagBits::eConditionalRenderingReadEXT) result += "ConditionalRenderingReadEXT | ";
50394 if (value & AccessFlagBits::eCommandProcessReadNVX) result += "CommandProcessReadNVX | ";
50395 if (value & AccessFlagBits::eCommandProcessWriteNVX) result += "CommandProcessWriteNVX | ";
50396 if (value & AccessFlagBits::eColorAttachmentReadNoncoherentEXT) result += "ColorAttachmentReadNoncoherentEXT | ";
50397 if (value & AccessFlagBits::eShadingRateImageReadNV) result += "ShadingRateImageReadNV | ";
50398 if (value & AccessFlagBits::eAccelerationStructureReadNV) result += "AccelerationStructureReadNV | ";
50399 if (value & AccessFlagBits::eAccelerationStructureWriteNV) result += "AccelerationStructureWriteNV | ";
50400 return "{" + result.substr(0, result.size() - 3) + "}";
50401 }
50402
50404 {
50405 switch (value)
50406 {
50407 case BufferUsageFlagBits::eTransferSrc: return "TransferSrc";
50408 case BufferUsageFlagBits::eTransferDst: return "TransferDst";
50409 case BufferUsageFlagBits::eUniformTexelBuffer: return "UniformTexelBuffer";
50410 case BufferUsageFlagBits::eStorageTexelBuffer: return "StorageTexelBuffer";
50411 case BufferUsageFlagBits::eUniformBuffer: return "UniformBuffer";
50412 case BufferUsageFlagBits::eStorageBuffer: return "StorageBuffer";
50413 case BufferUsageFlagBits::eIndexBuffer: return "IndexBuffer";
50414 case BufferUsageFlagBits::eVertexBuffer: return "VertexBuffer";
50415 case BufferUsageFlagBits::eIndirectBuffer: return "IndirectBuffer";
50416 case BufferUsageFlagBits::eTransformFeedbackBufferEXT: return "TransformFeedbackBufferEXT";
50417 case BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT: return "TransformFeedbackCounterBufferEXT";
50418 case BufferUsageFlagBits::eConditionalRenderingEXT: return "ConditionalRenderingEXT";
50419 case BufferUsageFlagBits::eRayTracingNV: return "RayTracingNV";
50420 default: return "invalid";
50421 }
50422 }
50423
50425 {
50426 if (!value) return "{}";
50428 if (value & BufferUsageFlagBits::eTransferSrc) result += "TransferSrc | ";
50429 if (value & BufferUsageFlagBits::eTransferDst) result += "TransferDst | ";
50430 if (value & BufferUsageFlagBits::eUniformTexelBuffer) result += "UniformTexelBuffer | ";
50431 if (value & BufferUsageFlagBits::eStorageTexelBuffer) result += "StorageTexelBuffer | ";
50432 if (value & BufferUsageFlagBits::eUniformBuffer) result += "UniformBuffer | ";
50433 if (value & BufferUsageFlagBits::eStorageBuffer) result += "StorageBuffer | ";
50434 if (value & BufferUsageFlagBits::eIndexBuffer) result += "IndexBuffer | ";
50435 if (value & BufferUsageFlagBits::eVertexBuffer) result += "VertexBuffer | ";
50436 if (value & BufferUsageFlagBits::eIndirectBuffer) result += "IndirectBuffer | ";
50437 if (value & BufferUsageFlagBits::eTransformFeedbackBufferEXT) result += "TransformFeedbackBufferEXT | ";
50438 if (value & BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT) result += "TransformFeedbackCounterBufferEXT | ";
50439 if (value & BufferUsageFlagBits::eConditionalRenderingEXT) result += "ConditionalRenderingEXT | ";
50440 if (value & BufferUsageFlagBits::eRayTracingNV) result += "RayTracingNV | ";
50441 return "{" + result.substr(0, result.size() - 3) + "}";
50442 }
50443
50445 {
50446 switch (value)
50447 {
50448 case BufferCreateFlagBits::eSparseBinding: return "SparseBinding";
50449 case BufferCreateFlagBits::eSparseResidency: return "SparseResidency";
50450 case BufferCreateFlagBits::eSparseAliased: return "SparseAliased";
50451 case BufferCreateFlagBits::eProtected: return "Protected";
50452 default: return "invalid";
50453 }
50454 }
50455
50457 {
50458 if (!value) return "{}";
50460 if (value & BufferCreateFlagBits::eSparseBinding) result += "SparseBinding | ";
50461 if (value & BufferCreateFlagBits::eSparseResidency) result += "SparseResidency | ";
50462 if (value & BufferCreateFlagBits::eSparseAliased) result += "SparseAliased | ";
50463 if (value & BufferCreateFlagBits::eProtected) result += "Protected | ";
50464 return "{" + result.substr(0, result.size() - 3) + "}";
50465 }
50466
50468 {
50469 switch (value)
50470 {
50471 case ShaderStageFlagBits::eVertex: return "Vertex";
50472 case ShaderStageFlagBits::eTessellationControl: return "TessellationControl";
50473 case ShaderStageFlagBits::eTessellationEvaluation: return "TessellationEvaluation";
50474 case ShaderStageFlagBits::eGeometry: return "Geometry";
50475 case ShaderStageFlagBits::eFragment: return "Fragment";
50476 case ShaderStageFlagBits::eCompute: return "Compute";
50477 case ShaderStageFlagBits::eAllGraphics: return "AllGraphics";
50478 case ShaderStageFlagBits::eAll: return "All";
50479 case ShaderStageFlagBits::eRaygenNV: return "RaygenNV";
50480 case ShaderStageFlagBits::eAnyHitNV: return "AnyHitNV";
50481 case ShaderStageFlagBits::eClosestHitNV: return "ClosestHitNV";
50482 case ShaderStageFlagBits::eMissNV: return "MissNV";
50483 case ShaderStageFlagBits::eIntersectionNV: return "IntersectionNV";
50484 case ShaderStageFlagBits::eCallableNV: return "CallableNV";
50485 case ShaderStageFlagBits::eTaskNV: return "TaskNV";
50486 case ShaderStageFlagBits::eMeshNV: return "MeshNV";
50487 default: return "invalid";
50488 }
50489 }
50490
50492 {
50493 if (!value) return "{}";
50495 if (value & ShaderStageFlagBits::eVertex) result += "Vertex | ";
50496 if (value & ShaderStageFlagBits::eTessellationControl) result += "TessellationControl | ";
50497 if (value & ShaderStageFlagBits::eTessellationEvaluation) result += "TessellationEvaluation | ";
50498 if (value & ShaderStageFlagBits::eGeometry) result += "Geometry | ";
50499 if (value & ShaderStageFlagBits::eFragment) result += "Fragment | ";
50500 if (value & ShaderStageFlagBits::eCompute) result += "Compute | ";
50501 if (value & ShaderStageFlagBits::eAllGraphics) result += "AllGraphics | ";
50502 if (value & ShaderStageFlagBits::eAll) result += "All | ";
50503 if (value & ShaderStageFlagBits::eRaygenNV) result += "RaygenNV | ";
50504 if (value & ShaderStageFlagBits::eAnyHitNV) result += "AnyHitNV | ";
50505 if (value & ShaderStageFlagBits::eClosestHitNV) result += "ClosestHitNV | ";
50506 if (value & ShaderStageFlagBits::eMissNV) result += "MissNV | ";
50507 if (value & ShaderStageFlagBits::eIntersectionNV) result += "IntersectionNV | ";
50508 if (value & ShaderStageFlagBits::eCallableNV) result += "CallableNV | ";
50509 if (value & ShaderStageFlagBits::eTaskNV) result += "TaskNV | ";
50510 if (value & ShaderStageFlagBits::eMeshNV) result += "MeshNV | ";
50511 return "{" + result.substr(0, result.size() - 3) + "}";
50512 }
50513
50515 {
50516 switch (value)
50517 {
50518 case ImageUsageFlagBits::eTransferSrc: return "TransferSrc";
50519 case ImageUsageFlagBits::eTransferDst: return "TransferDst";
50520 case ImageUsageFlagBits::eSampled: return "Sampled";
50521 case ImageUsageFlagBits::eStorage: return "Storage";
50522 case ImageUsageFlagBits::eColorAttachment: return "ColorAttachment";
50523 case ImageUsageFlagBits::eDepthStencilAttachment: return "DepthStencilAttachment";
50524 case ImageUsageFlagBits::eTransientAttachment: return "TransientAttachment";
50525 case ImageUsageFlagBits::eInputAttachment: return "InputAttachment";
50526 case ImageUsageFlagBits::eShadingRateImageNV: return "ShadingRateImageNV";
50527 default: return "invalid";
50528 }
50529 }
50530
50532 {
50533 if (!value) return "{}";
50535 if (value & ImageUsageFlagBits::eTransferSrc) result += "TransferSrc | ";
50536 if (value & ImageUsageFlagBits::eTransferDst) result += "TransferDst | ";
50537 if (value & ImageUsageFlagBits::eSampled) result += "Sampled | ";
50538 if (value & ImageUsageFlagBits::eStorage) result += "Storage | ";
50539 if (value & ImageUsageFlagBits::eColorAttachment) result += "ColorAttachment | ";
50540 if (value & ImageUsageFlagBits::eDepthStencilAttachment) result += "DepthStencilAttachment | ";
50541 if (value & ImageUsageFlagBits::eTransientAttachment) result += "TransientAttachment | ";
50542 if (value & ImageUsageFlagBits::eInputAttachment) result += "InputAttachment | ";
50543 if (value & ImageUsageFlagBits::eShadingRateImageNV) result += "ShadingRateImageNV | ";
50544 return "{" + result.substr(0, result.size() - 3) + "}";
50545 }
50546
50548 {
50549 switch (value)
50550 {
50551 case ImageCreateFlagBits::eSparseBinding: return "SparseBinding";
50552 case ImageCreateFlagBits::eSparseResidency: return "SparseResidency";
50553 case ImageCreateFlagBits::eSparseAliased: return "SparseAliased";
50554 case ImageCreateFlagBits::eMutableFormat: return "MutableFormat";
50555 case ImageCreateFlagBits::eCubeCompatible: return "CubeCompatible";
50556 case ImageCreateFlagBits::eAlias: return "Alias";
50557 case ImageCreateFlagBits::eSplitInstanceBindRegions: return "SplitInstanceBindRegions";
50558 case ImageCreateFlagBits::e2DArrayCompatible: return "2DArrayCompatible";
50559 case ImageCreateFlagBits::eBlockTexelViewCompatible: return "BlockTexelViewCompatible";
50560 case ImageCreateFlagBits::eExtendedUsage: return "ExtendedUsage";
50561 case ImageCreateFlagBits::eProtected: return "Protected";
50562 case ImageCreateFlagBits::eDisjoint: return "Disjoint";
50563 case ImageCreateFlagBits::eCornerSampledNV: return "CornerSampledNV";
50564 case ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT: return "SampleLocationsCompatibleDepthEXT";
50565 default: return "invalid";
50566 }
50567 }
50568
50570 {
50571 if (!value) return "{}";
50573 if (value & ImageCreateFlagBits::eSparseBinding) result += "SparseBinding | ";
50574 if (value & ImageCreateFlagBits::eSparseResidency) result += "SparseResidency | ";
50575 if (value & ImageCreateFlagBits::eSparseAliased) result += "SparseAliased | ";
50576 if (value & ImageCreateFlagBits::eMutableFormat) result += "MutableFormat | ";
50577 if (value & ImageCreateFlagBits::eCubeCompatible) result += "CubeCompatible | ";
50578 if (value & ImageCreateFlagBits::eAlias) result += "Alias | ";
50579 if (value & ImageCreateFlagBits::eSplitInstanceBindRegions) result += "SplitInstanceBindRegions | ";
50580 if (value & ImageCreateFlagBits::e2DArrayCompatible) result += "2DArrayCompatible | ";
50581 if (value & ImageCreateFlagBits::eBlockTexelViewCompatible) result += "BlockTexelViewCompatible | ";
50582 if (value & ImageCreateFlagBits::eExtendedUsage) result += "ExtendedUsage | ";
50583 if (value & ImageCreateFlagBits::eProtected) result += "Protected | ";
50584 if (value & ImageCreateFlagBits::eDisjoint) result += "Disjoint | ";
50585 if (value & ImageCreateFlagBits::eCornerSampledNV) result += "CornerSampledNV | ";
50586 if (value & ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT) result += "SampleLocationsCompatibleDepthEXT | ";
50587 return "{" + result.substr(0, result.size() - 3) + "}";
50588 }
50589
50591 {
50592 switch (value)
50593 {
50594 case PipelineCreateFlagBits::eDisableOptimization: return "DisableOptimization";
50595 case PipelineCreateFlagBits::eAllowDerivatives: return "AllowDerivatives";
50596 case PipelineCreateFlagBits::eDerivative: return "Derivative";
50597 case PipelineCreateFlagBits::eViewIndexFromDeviceIndex: return "ViewIndexFromDeviceIndex";
50598 case PipelineCreateFlagBits::eDispatchBase: return "DispatchBase";
50599 case PipelineCreateFlagBits::eDeferCompileNV: return "DeferCompileNV";
50600 default: return "invalid";
50601 }
50602 }
50603
50605 {
50606 if (!value) return "{}";
50608 if (value & PipelineCreateFlagBits::eDisableOptimization) result += "DisableOptimization | ";
50609 if (value & PipelineCreateFlagBits::eAllowDerivatives) result += "AllowDerivatives | ";
50610 if (value & PipelineCreateFlagBits::eDerivative) result += "Derivative | ";
50611 if (value & PipelineCreateFlagBits::eViewIndexFromDeviceIndex) result += "ViewIndexFromDeviceIndex | ";
50612 if (value & PipelineCreateFlagBits::eDispatchBase) result += "DispatchBase | ";
50613 if (value & PipelineCreateFlagBits::eDeferCompileNV) result += "DeferCompileNV | ";
50614 return "{" + result.substr(0, result.size() - 3) + "}";
50615 }
50616
50618 {
50619 switch (value)
50620 {
50621 case ColorComponentFlagBits::eR: return "R";
50622 case ColorComponentFlagBits::eG: return "G";
50623 case ColorComponentFlagBits::eB: return "B";
50624 case ColorComponentFlagBits::eA: return "A";
50625 default: return "invalid";
50626 }
50627 }
50628
50630 {
50631 if (!value) return "{}";
50633 if (value & ColorComponentFlagBits::eR) result += "R | ";
50634 if (value & ColorComponentFlagBits::eG) result += "G | ";
50635 if (value & ColorComponentFlagBits::eB) result += "B | ";
50636 if (value & ColorComponentFlagBits::eA) result += "A | ";
50637 return "{" + result.substr(0, result.size() - 3) + "}";
50638 }
50639
50641 {
50642 switch (value)
50643 {
50644 case FenceCreateFlagBits::eSignaled: return "Signaled";
50645 default: return "invalid";
50646 }
50647 }
50648
50650 {
50651 if (!value) return "{}";
50653 if (value & FenceCreateFlagBits::eSignaled) result += "Signaled | ";
50654 return "{" + result.substr(0, result.size() - 3) + "}";
50655 }
50656
50658 {
50659 switch (value)
50660 {
50661 case FormatFeatureFlagBits::eSampledImage: return "SampledImage";
50662 case FormatFeatureFlagBits::eStorageImage: return "StorageImage";
50663 case FormatFeatureFlagBits::eStorageImageAtomic: return "StorageImageAtomic";
50664 case FormatFeatureFlagBits::eUniformTexelBuffer: return "UniformTexelBuffer";
50665 case FormatFeatureFlagBits::eStorageTexelBuffer: return "StorageTexelBuffer";
50666 case FormatFeatureFlagBits::eStorageTexelBufferAtomic: return "StorageTexelBufferAtomic";
50667 case FormatFeatureFlagBits::eVertexBuffer: return "VertexBuffer";
50668 case FormatFeatureFlagBits::eColorAttachment: return "ColorAttachment";
50669 case FormatFeatureFlagBits::eColorAttachmentBlend: return "ColorAttachmentBlend";
50670 case FormatFeatureFlagBits::eDepthStencilAttachment: return "DepthStencilAttachment";
50671 case FormatFeatureFlagBits::eBlitSrc: return "BlitSrc";
50672 case FormatFeatureFlagBits::eBlitDst: return "BlitDst";
50673 case FormatFeatureFlagBits::eSampledImageFilterLinear: return "SampledImageFilterLinear";
50674 case FormatFeatureFlagBits::eTransferSrc: return "TransferSrc";
50675 case FormatFeatureFlagBits::eTransferDst: return "TransferDst";
50676 case FormatFeatureFlagBits::eMidpointChromaSamples: return "MidpointChromaSamples";
50677 case FormatFeatureFlagBits::eSampledImageYcbcrConversionLinearFilter: return "SampledImageYcbcrConversionLinearFilter";
50678 case FormatFeatureFlagBits::eSampledImageYcbcrConversionSeparateReconstructionFilter: return "SampledImageYcbcrConversionSeparateReconstructionFilter";
50679 case FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicit: return "SampledImageYcbcrConversionChromaReconstructionExplicit";
50680 case FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable: return "SampledImageYcbcrConversionChromaReconstructionExplicitForceable";
50681 case FormatFeatureFlagBits::eDisjoint: return "Disjoint";
50682 case FormatFeatureFlagBits::eCositedChromaSamples: return "CositedChromaSamples";
50683 case FormatFeatureFlagBits::eSampledImageFilterCubicIMG: return "SampledImageFilterCubicIMG";
50684 case FormatFeatureFlagBits::eSampledImageFilterMinmaxEXT: return "SampledImageFilterMinmaxEXT";
50685 default: return "invalid";
50686 }
50687 }
50688
50690 {
50691 if (!value) return "{}";
50693 if (value & FormatFeatureFlagBits::eSampledImage) result += "SampledImage | ";
50694 if (value & FormatFeatureFlagBits::eStorageImage) result += "StorageImage | ";
50695 if (value & FormatFeatureFlagBits::eStorageImageAtomic) result += "StorageImageAtomic | ";
50696 if (value & FormatFeatureFlagBits::eUniformTexelBuffer) result += "UniformTexelBuffer | ";
50697 if (value & FormatFeatureFlagBits::eStorageTexelBuffer) result += "StorageTexelBuffer | ";
50698 if (value & FormatFeatureFlagBits::eStorageTexelBufferAtomic) result += "StorageTexelBufferAtomic | ";
50699 if (value & FormatFeatureFlagBits::eVertexBuffer) result += "VertexBuffer | ";
50700 if (value & FormatFeatureFlagBits::eColorAttachment) result += "ColorAttachment | ";
50701 if (value & FormatFeatureFlagBits::eColorAttachmentBlend) result += "ColorAttachmentBlend | ";
50702 if (value & FormatFeatureFlagBits::eDepthStencilAttachment) result += "DepthStencilAttachment | ";
50703 if (value & FormatFeatureFlagBits::eBlitSrc) result += "BlitSrc | ";
50704 if (value & FormatFeatureFlagBits::eBlitDst) result += "BlitDst | ";
50705 if (value & FormatFeatureFlagBits::eSampledImageFilterLinear) result += "SampledImageFilterLinear | ";
50706 if (value & FormatFeatureFlagBits::eTransferSrc) result += "TransferSrc | ";
50707 if (value & FormatFeatureFlagBits::eTransferDst) result += "TransferDst | ";
50708 if (value & FormatFeatureFlagBits::eMidpointChromaSamples) result += "MidpointChromaSamples | ";
50709 if (value & FormatFeatureFlagBits::eSampledImageYcbcrConversionLinearFilter) result += "SampledImageYcbcrConversionLinearFilter | ";
50710 if (value & FormatFeatureFlagBits::eSampledImageYcbcrConversionSeparateReconstructionFilter) result += "SampledImageYcbcrConversionSeparateReconstructionFilter | ";
50711 if (value & FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicit) result += "SampledImageYcbcrConversionChromaReconstructionExplicit | ";
50712 if (value & FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable) result += "SampledImageYcbcrConversionChromaReconstructionExplicitForceable | ";
50713 if (value & FormatFeatureFlagBits::eDisjoint) result += "Disjoint | ";
50714 if (value & FormatFeatureFlagBits::eCositedChromaSamples) result += "CositedChromaSamples | ";
50715 if (value & FormatFeatureFlagBits::eSampledImageFilterCubicIMG) result += "SampledImageFilterCubicIMG | ";
50716 if (value & FormatFeatureFlagBits::eSampledImageFilterMinmaxEXT) result += "SampledImageFilterMinmaxEXT | ";
50717 return "{" + result.substr(0, result.size() - 3) + "}";
50718 }
50719
50721 {
50722 switch (value)
50723 {
50724 case QueryControlFlagBits::ePrecise: return "Precise";
50725 default: return "invalid";
50726 }
50727 }
50728
50730 {
50731 if (!value) return "{}";
50733 if (value & QueryControlFlagBits::ePrecise) result += "Precise | ";
50734 return "{" + result.substr(0, result.size() - 3) + "}";
50735 }
50736
50738 {
50739 switch (value)
50740 {
50741 case QueryResultFlagBits::e64: return "64";
50742 case QueryResultFlagBits::eWait: return "Wait";
50743 case QueryResultFlagBits::eWithAvailability: return "WithAvailability";
50744 case QueryResultFlagBits::ePartial: return "Partial";
50745 default: return "invalid";
50746 }
50747 }
50748
50750 {
50751 if (!value) return "{}";
50753 if (value & QueryResultFlagBits::e64) result += "64 | ";
50754 if (value & QueryResultFlagBits::eWait) result += "Wait | ";
50755 if (value & QueryResultFlagBits::eWithAvailability) result += "WithAvailability | ";
50756 if (value & QueryResultFlagBits::ePartial) result += "Partial | ";
50757 return "{" + result.substr(0, result.size() - 3) + "}";
50758 }
50759
50761 {
50762 switch (value)
50763 {
50764 case CommandBufferUsageFlagBits::eOneTimeSubmit: return "OneTimeSubmit";
50765 case CommandBufferUsageFlagBits::eRenderPassContinue: return "RenderPassContinue";
50766 case CommandBufferUsageFlagBits::eSimultaneousUse: return "SimultaneousUse";
50767 default: return "invalid";
50768 }
50769 }
50770
50772 {
50773 if (!value) return "{}";
50775 if (value & CommandBufferUsageFlagBits::eOneTimeSubmit) result += "OneTimeSubmit | ";
50776 if (value & CommandBufferUsageFlagBits::eRenderPassContinue) result += "RenderPassContinue | ";
50777 if (value & CommandBufferUsageFlagBits::eSimultaneousUse) result += "SimultaneousUse | ";
50778 return "{" + result.substr(0, result.size() - 3) + "}";
50779 }
50780
50782 {
50783 switch (value)
50784 {
50785 case QueryPipelineStatisticFlagBits::eInputAssemblyVertices: return "InputAssemblyVertices";
50786 case QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives: return "InputAssemblyPrimitives";
50787 case QueryPipelineStatisticFlagBits::eVertexShaderInvocations: return "VertexShaderInvocations";
50788 case QueryPipelineStatisticFlagBits::eGeometryShaderInvocations: return "GeometryShaderInvocations";
50789 case QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives: return "GeometryShaderPrimitives";
50790 case QueryPipelineStatisticFlagBits::eClippingInvocations: return "ClippingInvocations";
50791 case QueryPipelineStatisticFlagBits::eClippingPrimitives: return "ClippingPrimitives";
50792 case QueryPipelineStatisticFlagBits::eFragmentShaderInvocations: return "FragmentShaderInvocations";
50793 case QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches: return "TessellationControlShaderPatches";
50794 case QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations: return "TessellationEvaluationShaderInvocations";
50795 case QueryPipelineStatisticFlagBits::eComputeShaderInvocations: return "ComputeShaderInvocations";
50796 default: return "invalid";
50797 }
50798 }
50799
50801 {
50802 if (!value) return "{}";
50804 if (value & QueryPipelineStatisticFlagBits::eInputAssemblyVertices) result += "InputAssemblyVertices | ";
50805 if (value & QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives) result += "InputAssemblyPrimitives | ";
50806 if (value & QueryPipelineStatisticFlagBits::eVertexShaderInvocations) result += "VertexShaderInvocations | ";
50807 if (value & QueryPipelineStatisticFlagBits::eGeometryShaderInvocations) result += "GeometryShaderInvocations | ";
50808 if (value & QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives) result += "GeometryShaderPrimitives | ";
50809 if (value & QueryPipelineStatisticFlagBits::eClippingInvocations) result += "ClippingInvocations | ";
50810 if (value & QueryPipelineStatisticFlagBits::eClippingPrimitives) result += "ClippingPrimitives | ";
50811 if (value & QueryPipelineStatisticFlagBits::eFragmentShaderInvocations) result += "FragmentShaderInvocations | ";
50812 if (value & QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches) result += "TessellationControlShaderPatches | ";
50813 if (value & QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations) result += "TessellationEvaluationShaderInvocations | ";
50814 if (value & QueryPipelineStatisticFlagBits::eComputeShaderInvocations) result += "ComputeShaderInvocations | ";
50815 return "{" + result.substr(0, result.size() - 3) + "}";
50816 }
50817
50819 {
50820 switch (value)
50821 {
50822 case ImageAspectFlagBits::eColor: return "Color";
50823 case ImageAspectFlagBits::eDepth: return "Depth";
50824 case ImageAspectFlagBits::eStencil: return "Stencil";
50825 case ImageAspectFlagBits::eMetadata: return "Metadata";
50826 case ImageAspectFlagBits::ePlane0: return "Plane0";
50827 case ImageAspectFlagBits::ePlane1: return "Plane1";
50828 case ImageAspectFlagBits::ePlane2: return "Plane2";
50829 case ImageAspectFlagBits::eMemoryPlane0EXT: return "MemoryPlane0EXT";
50830 case ImageAspectFlagBits::eMemoryPlane1EXT: return "MemoryPlane1EXT";
50831 case ImageAspectFlagBits::eMemoryPlane2EXT: return "MemoryPlane2EXT";
50832 case ImageAspectFlagBits::eMemoryPlane3EXT: return "MemoryPlane3EXT";
50833 default: return "invalid";
50834 }
50835 }
50836
50838 {
50839 if (!value) return "{}";
50841 if (value & ImageAspectFlagBits::eColor) result += "Color | ";
50842 if (value & ImageAspectFlagBits::eDepth) result += "Depth | ";
50843 if (value & ImageAspectFlagBits::eStencil) result += "Stencil | ";
50844 if (value & ImageAspectFlagBits::eMetadata) result += "Metadata | ";
50845 if (value & ImageAspectFlagBits::ePlane0) result += "Plane0 | ";
50846 if (value & ImageAspectFlagBits::ePlane1) result += "Plane1 | ";
50847 if (value & ImageAspectFlagBits::ePlane2) result += "Plane2 | ";
50848 if (value & ImageAspectFlagBits::eMemoryPlane0EXT) result += "MemoryPlane0EXT | ";
50849 if (value & ImageAspectFlagBits::eMemoryPlane1EXT) result += "MemoryPlane1EXT | ";
50850 if (value & ImageAspectFlagBits::eMemoryPlane2EXT) result += "MemoryPlane2EXT | ";
50851 if (value & ImageAspectFlagBits::eMemoryPlane3EXT) result += "MemoryPlane3EXT | ";
50852 return "{" + result.substr(0, result.size() - 3) + "}";
50853 }
50854
50856 {
50857 switch (value)
50858 {
50859 case SparseImageFormatFlagBits::eSingleMiptail: return "SingleMiptail";
50860 case SparseImageFormatFlagBits::eAlignedMipSize: return "AlignedMipSize";
50861 case SparseImageFormatFlagBits::eNonstandardBlockSize: return "NonstandardBlockSize";
50862 default: return "invalid";
50863 }
50864 }
50865
50867 {
50868 if (!value) return "{}";
50870 if (value & SparseImageFormatFlagBits::eSingleMiptail) result += "SingleMiptail | ";
50871 if (value & SparseImageFormatFlagBits::eAlignedMipSize) result += "AlignedMipSize | ";
50872 if (value & SparseImageFormatFlagBits::eNonstandardBlockSize) result += "NonstandardBlockSize | ";
50873 return "{" + result.substr(0, result.size() - 3) + "}";
50874 }
50875
50877 {
50878 switch (value)
50879 {
50880 case SparseMemoryBindFlagBits::eMetadata: return "Metadata";
50881 default: return "invalid";
50882 }
50883 }
50884
50886 {
50887 if (!value) return "{}";
50889 if (value & SparseMemoryBindFlagBits::eMetadata) result += "Metadata | ";
50890 return "{" + result.substr(0, result.size() - 3) + "}";
50891 }
50892
50894 {
50895 switch (value)
50896 {
50897 case PipelineStageFlagBits::eTopOfPipe: return "TopOfPipe";
50898 case PipelineStageFlagBits::eDrawIndirect: return "DrawIndirect";
50899 case PipelineStageFlagBits::eVertexInput: return "VertexInput";
50900 case PipelineStageFlagBits::eVertexShader: return "VertexShader";
50901 case PipelineStageFlagBits::eTessellationControlShader: return "TessellationControlShader";
50902 case PipelineStageFlagBits::eTessellationEvaluationShader: return "TessellationEvaluationShader";
50903 case PipelineStageFlagBits::eGeometryShader: return "GeometryShader";
50904 case PipelineStageFlagBits::eFragmentShader: return "FragmentShader";
50905 case PipelineStageFlagBits::eEarlyFragmentTests: return "EarlyFragmentTests";
50906 case PipelineStageFlagBits::eLateFragmentTests: return "LateFragmentTests";
50907 case PipelineStageFlagBits::eColorAttachmentOutput: return "ColorAttachmentOutput";
50908 case PipelineStageFlagBits::eComputeShader: return "ComputeShader";
50909 case PipelineStageFlagBits::eTransfer: return "Transfer";
50910 case PipelineStageFlagBits::eBottomOfPipe: return "BottomOfPipe";
50911 case PipelineStageFlagBits::eHost: return "Host";
50912 case PipelineStageFlagBits::eAllGraphics: return "AllGraphics";
50913 case PipelineStageFlagBits::eAllCommands: return "AllCommands";
50914 case PipelineStageFlagBits::eTransformFeedbackEXT: return "TransformFeedbackEXT";
50915 case PipelineStageFlagBits::eConditionalRenderingEXT: return "ConditionalRenderingEXT";
50916 case PipelineStageFlagBits::eCommandProcessNVX: return "CommandProcessNVX";
50917 case PipelineStageFlagBits::eShadingRateImageNV: return "ShadingRateImageNV";
50918 case PipelineStageFlagBits::eRayTracingShaderNV: return "RayTracingShaderNV";
50919 case PipelineStageFlagBits::eAccelerationStructureBuildNV: return "AccelerationStructureBuildNV";
50920 case PipelineStageFlagBits::eTaskShaderNV: return "TaskShaderNV";
50921 case PipelineStageFlagBits::eMeshShaderNV: return "MeshShaderNV";
50922 default: return "invalid";
50923 }
50924 }
50925
50927 {
50928 if (!value) return "{}";
50930 if (value & PipelineStageFlagBits::eTopOfPipe) result += "TopOfPipe | ";
50931 if (value & PipelineStageFlagBits::eDrawIndirect) result += "DrawIndirect | ";
50932 if (value & PipelineStageFlagBits::eVertexInput) result += "VertexInput | ";
50933 if (value & PipelineStageFlagBits::eVertexShader) result += "VertexShader | ";
50934 if (value & PipelineStageFlagBits::eTessellationControlShader) result += "TessellationControlShader | ";
50935 if (value & PipelineStageFlagBits::eTessellationEvaluationShader) result += "TessellationEvaluationShader | ";
50936 if (value & PipelineStageFlagBits::eGeometryShader) result += "GeometryShader | ";
50937 if (value & PipelineStageFlagBits::eFragmentShader) result += "FragmentShader | ";
50938 if (value & PipelineStageFlagBits::eEarlyFragmentTests) result += "EarlyFragmentTests | ";
50939 if (value & PipelineStageFlagBits::eLateFragmentTests) result += "LateFragmentTests | ";
50940 if (value & PipelineStageFlagBits::eColorAttachmentOutput) result += "ColorAttachmentOutput | ";
50941 if (value & PipelineStageFlagBits::eComputeShader) result += "ComputeShader | ";
50942 if (value & PipelineStageFlagBits::eTransfer) result += "Transfer | ";
50943 if (value & PipelineStageFlagBits::eBottomOfPipe) result += "BottomOfPipe | ";
50944 if (value & PipelineStageFlagBits::eHost) result += "Host | ";
50945 if (value & PipelineStageFlagBits::eAllGraphics) result += "AllGraphics | ";
50946 if (value & PipelineStageFlagBits::eAllCommands) result += "AllCommands | ";
50947 if (value & PipelineStageFlagBits::eTransformFeedbackEXT) result += "TransformFeedbackEXT | ";
50948 if (value & PipelineStageFlagBits::eConditionalRenderingEXT) result += "ConditionalRenderingEXT | ";
50949 if (value & PipelineStageFlagBits::eCommandProcessNVX) result += "CommandProcessNVX | ";
50950 if (value & PipelineStageFlagBits::eShadingRateImageNV) result += "ShadingRateImageNV | ";
50951 if (value & PipelineStageFlagBits::eRayTracingShaderNV) result += "RayTracingShaderNV | ";
50952 if (value & PipelineStageFlagBits::eAccelerationStructureBuildNV) result += "AccelerationStructureBuildNV | ";
50953 if (value & PipelineStageFlagBits::eTaskShaderNV) result += "TaskShaderNV | ";
50954 if (value & PipelineStageFlagBits::eMeshShaderNV) result += "MeshShaderNV | ";
50955 return "{" + result.substr(0, result.size() - 3) + "}";
50956 }
50957
50959 {
50960 switch (value)
50961 {
50962 case CommandPoolCreateFlagBits::eTransient: return "Transient";
50963 case CommandPoolCreateFlagBits::eResetCommandBuffer: return "ResetCommandBuffer";
50964 case CommandPoolCreateFlagBits::eProtected: return "Protected";
50965 default: return "invalid";
50966 }
50967 }
50968
50970 {
50971 if (!value) return "{}";
50973 if (value & CommandPoolCreateFlagBits::eTransient) result += "Transient | ";
50974 if (value & CommandPoolCreateFlagBits::eResetCommandBuffer) result += "ResetCommandBuffer | ";
50975 if (value & CommandPoolCreateFlagBits::eProtected) result += "Protected | ";
50976 return "{" + result.substr(0, result.size() - 3) + "}";
50977 }
50978
50980 {
50981 switch (value)
50982 {
50983 case CommandPoolResetFlagBits::eReleaseResources: return "ReleaseResources";
50984 default: return "invalid";
50985 }
50986 }
50987
50989 {
50990 if (!value) return "{}";
50992 if (value & CommandPoolResetFlagBits::eReleaseResources) result += "ReleaseResources | ";
50993 return "{" + result.substr(0, result.size() - 3) + "}";
50994 }
50995
50997 {
50998 switch (value)
50999 {
51000 case CommandBufferResetFlagBits::eReleaseResources: return "ReleaseResources";
51001 default: return "invalid";
51002 }
51003 }
51004
51006 {
51007 if (!value) return "{}";
51009 if (value & CommandBufferResetFlagBits::eReleaseResources) result += "ReleaseResources | ";
51010 return "{" + result.substr(0, result.size() - 3) + "}";
51011 }
51012
51014 {
51015 switch (value)
51016 {
51017 case SampleCountFlagBits::e1: return "1";
51018 case SampleCountFlagBits::e2: return "2";
51019 case SampleCountFlagBits::e4: return "4";
51020 case SampleCountFlagBits::e8: return "8";
51021 case SampleCountFlagBits::e16: return "16";
51022 case SampleCountFlagBits::e32: return "32";
51023 case SampleCountFlagBits::e64: return "64";
51024 default: return "invalid";
51025 }
51026 }
51027
51029 {
51030 if (!value) return "{}";
51032 if (value & SampleCountFlagBits::e1) result += "1 | ";
51033 if (value & SampleCountFlagBits::e2) result += "2 | ";
51034 if (value & SampleCountFlagBits::e4) result += "4 | ";
51035 if (value & SampleCountFlagBits::e8) result += "8 | ";
51036 if (value & SampleCountFlagBits::e16) result += "16 | ";
51037 if (value & SampleCountFlagBits::e32) result += "32 | ";
51038 if (value & SampleCountFlagBits::e64) result += "64 | ";
51039 return "{" + result.substr(0, result.size() - 3) + "}";
51040 }
51041
51043 {
51044 switch (value)
51045 {
51046 case AttachmentDescriptionFlagBits::eMayAlias: return "MayAlias";
51047 default: return "invalid";
51048 }
51049 }
51050
51052 {
51053 if (!value) return "{}";
51056 return "{" + result.substr(0, result.size() - 3) + "}";
51057 }
51058
51060 {
51061 switch (value)
51062 {
51063 case StencilFaceFlagBits::eFront: return "Front";
51064 case StencilFaceFlagBits::eBack: return "Back";
51065 case StencilFaceFlagBits::eVkStencilFrontAndBack: return "VkStencilFrontAndBack";
51066 default: return "invalid";
51067 }
51068 }
51069
51071 {
51072 if (!value) return "{}";
51074 if (value & StencilFaceFlagBits::eFront) result += "Front | ";
51075 if (value & StencilFaceFlagBits::eBack) result += "Back | ";
51076 if (value & StencilFaceFlagBits::eVkStencilFrontAndBack) result += "VkStencilFrontAndBack | ";
51077 return "{" + result.substr(0, result.size() - 3) + "}";
51078 }
51079
51081 {
51082 switch (value)
51083 {
51084 case DescriptorPoolCreateFlagBits::eFreeDescriptorSet: return "FreeDescriptorSet";
51085 case DescriptorPoolCreateFlagBits::eUpdateAfterBindEXT: return "UpdateAfterBindEXT";
51086 default: return "invalid";
51087 }
51088 }
51089
51091 {
51092 if (!value) return "{}";
51094 if (value & DescriptorPoolCreateFlagBits::eFreeDescriptorSet) result += "FreeDescriptorSet | ";
51095 if (value & DescriptorPoolCreateFlagBits::eUpdateAfterBindEXT) result += "UpdateAfterBindEXT | ";
51096 return "{" + result.substr(0, result.size() - 3) + "}";
51097 }
51098
51100 {
51101 switch (value)
51102 {
51103 case DependencyFlagBits::eByRegion: return "ByRegion";
51104 case DependencyFlagBits::eDeviceGroup: return "DeviceGroup";
51105 case DependencyFlagBits::eViewLocal: return "ViewLocal";
51106 default: return "invalid";
51107 }
51108 }
51109
51111 {
51112 if (!value) return "{}";
51114 if (value & DependencyFlagBits::eByRegion) result += "ByRegion | ";
51115 if (value & DependencyFlagBits::eDeviceGroup) result += "DeviceGroup | ";
51116 if (value & DependencyFlagBits::eViewLocal) result += "ViewLocal | ";
51117 return "{" + result.substr(0, result.size() - 3) + "}";
51118 }
51119
51121 {
51122 switch (value)
51123 {
51124 case PresentModeKHR::eImmediate: return "Immediate";
51125 case PresentModeKHR::eMailbox: return "Mailbox";
51126 case PresentModeKHR::eFifo: return "Fifo";
51127 case PresentModeKHR::eFifoRelaxed: return "FifoRelaxed";
51128 case PresentModeKHR::eSharedDemandRefresh: return "SharedDemandRefresh";
51129 case PresentModeKHR::eSharedContinuousRefresh: return "SharedContinuousRefresh";
51130 default: return "invalid";
51131 }
51132 }
51133
51135 {
51136 switch (value)
51137 {
51138 case ColorSpaceKHR::eSrgbNonlinear: return "SrgbNonlinear";
51139 case ColorSpaceKHR::eDisplayP3NonlinearEXT: return "DisplayP3NonlinearEXT";
51140 case ColorSpaceKHR::eExtendedSrgbLinearEXT: return "ExtendedSrgbLinearEXT";
51141 case ColorSpaceKHR::eDciP3LinearEXT: return "DciP3LinearEXT";
51142 case ColorSpaceKHR::eDciP3NonlinearEXT: return "DciP3NonlinearEXT";
51143 case ColorSpaceKHR::eBt709LinearEXT: return "Bt709LinearEXT";
51144 case ColorSpaceKHR::eBt709NonlinearEXT: return "Bt709NonlinearEXT";
51145 case ColorSpaceKHR::eBt2020LinearEXT: return "Bt2020LinearEXT";
51146 case ColorSpaceKHR::eHdr10St2084EXT: return "Hdr10St2084EXT";
51147 case ColorSpaceKHR::eDolbyvisionEXT: return "DolbyvisionEXT";
51148 case ColorSpaceKHR::eHdr10HlgEXT: return "Hdr10HlgEXT";
51149 case ColorSpaceKHR::eAdobergbLinearEXT: return "AdobergbLinearEXT";
51150 case ColorSpaceKHR::eAdobergbNonlinearEXT: return "AdobergbNonlinearEXT";
51151 case ColorSpaceKHR::ePassThroughEXT: return "PassThroughEXT";
51152 case ColorSpaceKHR::eExtendedSrgbNonlinearEXT: return "ExtendedSrgbNonlinearEXT";
51153 default: return "invalid";
51154 }
51155 }
51156
51158 {
51159 switch (value)
51160 {
51161 case DisplayPlaneAlphaFlagBitsKHR::eOpaque: return "Opaque";
51162 case DisplayPlaneAlphaFlagBitsKHR::eGlobal: return "Global";
51163 case DisplayPlaneAlphaFlagBitsKHR::ePerPixel: return "PerPixel";
51164 case DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied: return "PerPixelPremultiplied";
51165 default: return "invalid";
51166 }
51167 }
51168
51170 {
51171 if (!value) return "{}";
51176 if (value & DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied) result += "PerPixelPremultiplied | ";
51177 return "{" + result.substr(0, result.size() - 3) + "}";
51178 }
51179
51181 {
51182 switch (value)
51183 {
51184 case CompositeAlphaFlagBitsKHR::eOpaque: return "Opaque";
51185 case CompositeAlphaFlagBitsKHR::ePreMultiplied: return "PreMultiplied";
51186 case CompositeAlphaFlagBitsKHR::ePostMultiplied: return "PostMultiplied";
51187 case CompositeAlphaFlagBitsKHR::eInherit: return "Inherit";
51188 default: return "invalid";
51189 }
51190 }
51191
51193 {
51194 if (!value) return "{}";
51196 if (value & CompositeAlphaFlagBitsKHR::eOpaque) result += "Opaque | ";
51197 if (value & CompositeAlphaFlagBitsKHR::ePreMultiplied) result += "PreMultiplied | ";
51198 if (value & CompositeAlphaFlagBitsKHR::ePostMultiplied) result += "PostMultiplied | ";
51199 if (value & CompositeAlphaFlagBitsKHR::eInherit) result += "Inherit | ";
51200 return "{" + result.substr(0, result.size() - 3) + "}";
51201 }
51202
51204 {
51205 switch (value)
51206 {
51207 case SurfaceTransformFlagBitsKHR::eIdentity: return "Identity";
51208 case SurfaceTransformFlagBitsKHR::eRotate90: return "Rotate90";
51209 case SurfaceTransformFlagBitsKHR::eRotate180: return "Rotate180";
51210 case SurfaceTransformFlagBitsKHR::eRotate270: return "Rotate270";
51211 case SurfaceTransformFlagBitsKHR::eHorizontalMirror: return "HorizontalMirror";
51212 case SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90: return "HorizontalMirrorRotate90";
51213 case SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180: return "HorizontalMirrorRotate180";
51214 case SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270: return "HorizontalMirrorRotate270";
51215 case SurfaceTransformFlagBitsKHR::eInherit: return "Inherit";
51216 default: return "invalid";
51217 }
51218 }
51219
51221 {
51222 if (!value) return "{}";
51224 if (value & SurfaceTransformFlagBitsKHR::eIdentity) result += "Identity | ";
51225 if (value & SurfaceTransformFlagBitsKHR::eRotate90) result += "Rotate90 | ";
51226 if (value & SurfaceTransformFlagBitsKHR::eRotate180) result += "Rotate180 | ";
51227 if (value & SurfaceTransformFlagBitsKHR::eRotate270) result += "Rotate270 | ";
51228 if (value & SurfaceTransformFlagBitsKHR::eHorizontalMirror) result += "HorizontalMirror | ";
51229 if (value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90) result += "HorizontalMirrorRotate90 | ";
51230 if (value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180) result += "HorizontalMirrorRotate180 | ";
51231 if (value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270) result += "HorizontalMirrorRotate270 | ";
51232 if (value & SurfaceTransformFlagBitsKHR::eInherit) result += "Inherit | ";
51233 return "{" + result.substr(0, result.size() - 3) + "}";
51234 }
51235
51237 {
51238 switch (value)
51239 {
51240 case TimeDomainEXT::eDevice: return "Device";
51241 case TimeDomainEXT::eClockMonotonic: return "ClockMonotonic";
51242 case TimeDomainEXT::eClockMonotonicRaw: return "ClockMonotonicRaw";
51243 case TimeDomainEXT::eQueryPerformanceCounter: return "QueryPerformanceCounter";
51244 default: return "invalid";
51245 }
51246 }
51247
51249 {
51250 switch (value)
51251 {
51252 case DebugReportFlagBitsEXT::eInformation: return "Information";
51253 case DebugReportFlagBitsEXT::eWarning: return "Warning";
51254 case DebugReportFlagBitsEXT::ePerformanceWarning: return "PerformanceWarning";
51255 case DebugReportFlagBitsEXT::eError: return "Error";
51256 case DebugReportFlagBitsEXT::eDebug: return "Debug";
51257 default: return "invalid";
51258 }
51259 }
51260
51262 {
51263 if (!value) return "{}";
51265 if (value & DebugReportFlagBitsEXT::eInformation) result += "Information | ";
51266 if (value & DebugReportFlagBitsEXT::eWarning) result += "Warning | ";
51267 if (value & DebugReportFlagBitsEXT::ePerformanceWarning) result += "PerformanceWarning | ";
51268 if (value & DebugReportFlagBitsEXT::eError) result += "Error | ";
51269 if (value & DebugReportFlagBitsEXT::eDebug) result += "Debug | ";
51270 return "{" + result.substr(0, result.size() - 3) + "}";
51271 }
51272
51274 {
51275 switch (value)
51276 {
51277 case DebugReportObjectTypeEXT::eUnknown: return "Unknown";
51278 case DebugReportObjectTypeEXT::eInstance: return "Instance";
51279 case DebugReportObjectTypeEXT::ePhysicalDevice: return "PhysicalDevice";
51280 case DebugReportObjectTypeEXT::eDevice: return "Device";
51281 case DebugReportObjectTypeEXT::eQueue: return "Queue";
51282 case DebugReportObjectTypeEXT::eSemaphore: return "Semaphore";
51283 case DebugReportObjectTypeEXT::eCommandBuffer: return "CommandBuffer";
51284 case DebugReportObjectTypeEXT::eFence: return "Fence";
51285 case DebugReportObjectTypeEXT::eDeviceMemory: return "DeviceMemory";
51286 case DebugReportObjectTypeEXT::eBuffer: return "Buffer";
51287 case DebugReportObjectTypeEXT::eImage: return "Image";
51288 case DebugReportObjectTypeEXT::eEvent: return "Event";
51289 case DebugReportObjectTypeEXT::eQueryPool: return "QueryPool";
51290 case DebugReportObjectTypeEXT::eBufferView: return "BufferView";
51291 case DebugReportObjectTypeEXT::eImageView: return "ImageView";
51292 case DebugReportObjectTypeEXT::eShaderModule: return "ShaderModule";
51293 case DebugReportObjectTypeEXT::ePipelineCache: return "PipelineCache";
51294 case DebugReportObjectTypeEXT::ePipelineLayout: return "PipelineLayout";
51295 case DebugReportObjectTypeEXT::eRenderPass: return "RenderPass";
51296 case DebugReportObjectTypeEXT::ePipeline: return "Pipeline";
51297 case DebugReportObjectTypeEXT::eDescriptorSetLayout: return "DescriptorSetLayout";
51298 case DebugReportObjectTypeEXT::eSampler: return "Sampler";
51299 case DebugReportObjectTypeEXT::eDescriptorPool: return "DescriptorPool";
51300 case DebugReportObjectTypeEXT::eDescriptorSet: return "DescriptorSet";
51301 case DebugReportObjectTypeEXT::eFramebuffer: return "Framebuffer";
51302 case DebugReportObjectTypeEXT::eCommandPool: return "CommandPool";
51303 case DebugReportObjectTypeEXT::eSurfaceKhr: return "SurfaceKhr";
51304 case DebugReportObjectTypeEXT::eSwapchainKhr: return "SwapchainKhr";
51305 case DebugReportObjectTypeEXT::eDebugReportCallbackExt: return "DebugReportCallbackExt";
51306 case DebugReportObjectTypeEXT::eDisplayKhr: return "DisplayKhr";
51307 case DebugReportObjectTypeEXT::eDisplayModeKhr: return "DisplayModeKhr";
51308 case DebugReportObjectTypeEXT::eObjectTableNvx: return "ObjectTableNvx";
51309 case DebugReportObjectTypeEXT::eIndirectCommandsLayoutNvx: return "IndirectCommandsLayoutNvx";
51310 case DebugReportObjectTypeEXT::eValidationCacheExt: return "ValidationCacheExt";
51311 case DebugReportObjectTypeEXT::eSamplerYcbcrConversion: return "SamplerYcbcrConversion";
51312 case DebugReportObjectTypeEXT::eDescriptorUpdateTemplate: return "DescriptorUpdateTemplate";
51313 case DebugReportObjectTypeEXT::eAccelerationStructureNV: return "AccelerationStructureNV";
51314 default: return "invalid";
51315 }
51316 }
51317
51319 {
51320 switch (value)
51321 {
51322 case RasterizationOrderAMD::eStrict: return "Strict";
51323 case RasterizationOrderAMD::eRelaxed: return "Relaxed";
51324 default: return "invalid";
51325 }
51326 }
51327
51329 {
51330 switch (value)
51331 {
51332 case ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32: return "OpaqueWin32";
51333 case ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt: return "OpaqueWin32Kmt";
51334 case ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image: return "D3D11Image";
51335 case ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt: return "D3D11ImageKmt";
51336 default: return "invalid";
51337 }
51338 }
51339
51341 {
51342 if (!value) return "{}";
51348 return "{" + result.substr(0, result.size() - 3) + "}";
51349 }
51350
51352 {
51353 switch (value)
51354 {
51355 case ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly: return "DedicatedOnly";
51356 case ExternalMemoryFeatureFlagBitsNV::eExportable: return "Exportable";
51357 case ExternalMemoryFeatureFlagBitsNV::eImportable: return "Importable";
51358 default: return "invalid";
51359 }
51360 }
51361
51363 {
51364 if (!value) return "{}";
51369 return "{" + result.substr(0, result.size() - 3) + "}";
51370 }
51371
51373 {
51374 switch (value)
51375 {
51376 case ValidationCheckEXT::eAll: return "All";
51377 case ValidationCheckEXT::eShaders: return "Shaders";
51378 default: return "invalid";
51379 }
51380 }
51381
51383 {
51384 switch (value)
51385 {
51386 case SubgroupFeatureFlagBits::eBasic: return "Basic";
51387 case SubgroupFeatureFlagBits::eVote: return "Vote";
51388 case SubgroupFeatureFlagBits::eArithmetic: return "Arithmetic";
51389 case SubgroupFeatureFlagBits::eBallot: return "Ballot";
51390 case SubgroupFeatureFlagBits::eShuffle: return "Shuffle";
51391 case SubgroupFeatureFlagBits::eShuffleRelative: return "ShuffleRelative";
51392 case SubgroupFeatureFlagBits::eClustered: return "Clustered";
51393 case SubgroupFeatureFlagBits::eQuad: return "Quad";
51394 case SubgroupFeatureFlagBits::ePartitionedNV: return "PartitionedNV";
51395 default: return "invalid";
51396 }
51397 }
51398
51400 {
51401 if (!value) return "{}";
51403 if (value & SubgroupFeatureFlagBits::eBasic) result += "Basic | ";
51404 if (value & SubgroupFeatureFlagBits::eVote) result += "Vote | ";
51405 if (value & SubgroupFeatureFlagBits::eArithmetic) result += "Arithmetic | ";
51406 if (value & SubgroupFeatureFlagBits::eBallot) result += "Ballot | ";
51407 if (value & SubgroupFeatureFlagBits::eShuffle) result += "Shuffle | ";
51408 if (value & SubgroupFeatureFlagBits::eShuffleRelative) result += "ShuffleRelative | ";
51409 if (value & SubgroupFeatureFlagBits::eClustered) result += "Clustered | ";
51410 if (value & SubgroupFeatureFlagBits::eQuad) result += "Quad | ";
51411 if (value & SubgroupFeatureFlagBits::ePartitionedNV) result += "PartitionedNV | ";
51412 return "{" + result.substr(0, result.size() - 3) + "}";
51413 }
51414
51416 {
51417 switch (value)
51418 {
51419 case IndirectCommandsLayoutUsageFlagBitsNVX::eUnorderedSequences: return "UnorderedSequences";
51420 case IndirectCommandsLayoutUsageFlagBitsNVX::eSparseSequences: return "SparseSequences";
51421 case IndirectCommandsLayoutUsageFlagBitsNVX::eEmptyExecutions: return "EmptyExecutions";
51422 case IndirectCommandsLayoutUsageFlagBitsNVX::eIndexedSequences: return "IndexedSequences";
51423 default: return "invalid";
51424 }
51425 }
51426
51428 {
51429 if (!value) return "{}";
51435 return "{" + result.substr(0, result.size() - 3) + "}";
51436 }
51437
51439 {
51440 switch (value)
51441 {
51442 case ObjectEntryUsageFlagBitsNVX::eGraphics: return "Graphics";
51443 case ObjectEntryUsageFlagBitsNVX::eCompute: return "Compute";
51444 default: return "invalid";
51445 }
51446 }
51447
51449 {
51450 if (!value) return "{}";
51452 if (value & ObjectEntryUsageFlagBitsNVX::eGraphics) result += "Graphics | ";
51453 if (value & ObjectEntryUsageFlagBitsNVX::eCompute) result += "Compute | ";
51454 return "{" + result.substr(0, result.size() - 3) + "}";
51455 }
51456
51458 {
51459 switch (value)
51460 {
51461 case IndirectCommandsTokenTypeNVX::ePipeline: return "Pipeline";
51462 case IndirectCommandsTokenTypeNVX::eDescriptorSet: return "DescriptorSet";
51463 case IndirectCommandsTokenTypeNVX::eIndexBuffer: return "IndexBuffer";
51464 case IndirectCommandsTokenTypeNVX::eVertexBuffer: return "VertexBuffer";
51465 case IndirectCommandsTokenTypeNVX::ePushConstant: return "PushConstant";
51466 case IndirectCommandsTokenTypeNVX::eDrawIndexed: return "DrawIndexed";
51467 case IndirectCommandsTokenTypeNVX::eDraw: return "Draw";
51468 case IndirectCommandsTokenTypeNVX::eDispatch: return "Dispatch";
51469 default: return "invalid";
51470 }
51471 }
51472
51474 {
51475 switch (value)
51476 {
51477 case ObjectEntryTypeNVX::eDescriptorSet: return "DescriptorSet";
51478 case ObjectEntryTypeNVX::ePipeline: return "Pipeline";
51479 case ObjectEntryTypeNVX::eIndexBuffer: return "IndexBuffer";
51480 case ObjectEntryTypeNVX::eVertexBuffer: return "VertexBuffer";
51481 case ObjectEntryTypeNVX::ePushConstant: return "PushConstant";
51482 default: return "invalid";
51483 }
51484 }
51485
51487 {
51488 switch (value)
51489 {
51490 case DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR: return "PushDescriptorKHR";
51491 case DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPoolEXT: return "UpdateAfterBindPoolEXT";
51492 default: return "invalid";
51493 }
51494 }
51495
51497 {
51498 if (!value) return "{}";
51501 if (value & DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPoolEXT) result += "UpdateAfterBindPoolEXT | ";
51502 return "{" + result.substr(0, result.size() - 3) + "}";
51503 }
51504
51506 {
51507 switch (value)
51508 {
51509 case ExternalMemoryHandleTypeFlagBits::eOpaqueFd: return "OpaqueFd";
51510 case ExternalMemoryHandleTypeFlagBits::eOpaqueWin32: return "OpaqueWin32";
51511 case ExternalMemoryHandleTypeFlagBits::eOpaqueWin32Kmt: return "OpaqueWin32Kmt";
51512 case ExternalMemoryHandleTypeFlagBits::eD3D11Texture: return "D3D11Texture";
51513 case ExternalMemoryHandleTypeFlagBits::eD3D11TextureKmt: return "D3D11TextureKmt";
51514 case ExternalMemoryHandleTypeFlagBits::eD3D12Heap: return "D3D12Heap";
51515 case ExternalMemoryHandleTypeFlagBits::eD3D12Resource: return "D3D12Resource";
51516 case ExternalMemoryHandleTypeFlagBits::eDmaBufEXT: return "DmaBufEXT";
51517 case ExternalMemoryHandleTypeFlagBits::eAndroidHardwareBufferANDROID: return "AndroidHardwareBufferANDROID";
51518 case ExternalMemoryHandleTypeFlagBits::eHostAllocationEXT: return "HostAllocationEXT";
51519 case ExternalMemoryHandleTypeFlagBits::eHostMappedForeignMemoryEXT: return "HostMappedForeignMemoryEXT";
51520 default: return "invalid";
51521 }
51522 }
51523
51525 {
51526 if (!value) return "{}";
51536 if (value & ExternalMemoryHandleTypeFlagBits::eAndroidHardwareBufferANDROID) result += "AndroidHardwareBufferANDROID | ";
51537 if (value & ExternalMemoryHandleTypeFlagBits::eHostAllocationEXT) result += "HostAllocationEXT | ";
51538 if (value & ExternalMemoryHandleTypeFlagBits::eHostMappedForeignMemoryEXT) result += "HostMappedForeignMemoryEXT | ";
51539 return "{" + result.substr(0, result.size() - 3) + "}";
51540 }
51541
51543 {
51544 switch (value)
51545 {
51546 case ExternalMemoryFeatureFlagBits::eDedicatedOnly: return "DedicatedOnly";
51547 case ExternalMemoryFeatureFlagBits::eExportable: return "Exportable";
51548 case ExternalMemoryFeatureFlagBits::eImportable: return "Importable";
51549 default: return "invalid";
51550 }
51551 }
51552
51554 {
51555 if (!value) return "{}";
51557 if (value & ExternalMemoryFeatureFlagBits::eDedicatedOnly) result += "DedicatedOnly | ";
51560 return "{" + result.substr(0, result.size() - 3) + "}";
51561 }
51562
51564 {
51565 switch (value)
51566 {
51567 case ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd: return "OpaqueFd";
51568 case ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32: return "OpaqueWin32";
51569 case ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32Kmt: return "OpaqueWin32Kmt";
51570 case ExternalSemaphoreHandleTypeFlagBits::eD3D12Fence: return "D3D12Fence";
51572 default: return "invalid";
51573 }
51574 }
51575
51577 {
51578 if (!value) return "{}";
51585 return "{" + result.substr(0, result.size() - 3) + "}";
51586 }
51587
51589 {
51590 switch (value)
51591 {
51592 case ExternalSemaphoreFeatureFlagBits::eExportable: return "Exportable";
51593 case ExternalSemaphoreFeatureFlagBits::eImportable: return "Importable";
51594 default: return "invalid";
51595 }
51596 }
51597
51599 {
51600 if (!value) return "{}";
51604 return "{" + result.substr(0, result.size() - 3) + "}";
51605 }
51606
51608 {
51609 switch (value)
51610 {
51611 case SemaphoreImportFlagBits::eTemporary: return "Temporary";
51612 default: return "invalid";
51613 }
51614 }
51615
51617 {
51618 if (!value) return "{}";
51620 if (value & SemaphoreImportFlagBits::eTemporary) result += "Temporary | ";
51621 return "{" + result.substr(0, result.size() - 3) + "}";
51622 }
51623
51625 {
51626 switch (value)
51627 {
51628 case ExternalFenceHandleTypeFlagBits::eOpaqueFd: return "OpaqueFd";
51629 case ExternalFenceHandleTypeFlagBits::eOpaqueWin32: return "OpaqueWin32";
51630 case ExternalFenceHandleTypeFlagBits::eOpaqueWin32Kmt: return "OpaqueWin32Kmt";
51631 case ExternalFenceHandleTypeFlagBits::eSyncFd: return "SyncFd";
51632 default: return "invalid";
51633 }
51634 }
51635
51637 {
51638 if (!value) return "{}";
51644 return "{" + result.substr(0, result.size() - 3) + "}";
51645 }
51646
51648 {
51649 switch (value)
51650 {
51651 case ExternalFenceFeatureFlagBits::eExportable: return "Exportable";
51652 case ExternalFenceFeatureFlagBits::eImportable: return "Importable";
51653 default: return "invalid";
51654 }
51655 }
51656
51658 {
51659 if (!value) return "{}";
51661 if (value & ExternalFenceFeatureFlagBits::eExportable) result += "Exportable | ";
51662 if (value & ExternalFenceFeatureFlagBits::eImportable) result += "Importable | ";
51663 return "{" + result.substr(0, result.size() - 3) + "}";
51664 }
51665
51667 {
51668 switch (value)
51669 {
51670 case FenceImportFlagBits::eTemporary: return "Temporary";
51671 default: return "invalid";
51672 }
51673 }
51674
51676 {
51677 if (!value) return "{}";
51679 if (value & FenceImportFlagBits::eTemporary) result += "Temporary | ";
51680 return "{" + result.substr(0, result.size() - 3) + "}";
51681 }
51682
51684 {
51685 switch (value)
51686 {
51687 case SurfaceCounterFlagBitsEXT::eVblank: return "Vblank";
51688 default: return "invalid";
51689 }
51690 }
51691
51693 {
51694 if (!value) return "{}";
51696 if (value & SurfaceCounterFlagBitsEXT::eVblank) result += "Vblank | ";
51697 return "{" + result.substr(0, result.size() - 3) + "}";
51698 }
51699
51701 {
51702 switch (value)
51703 {
51704 case DisplayPowerStateEXT::eOff: return "Off";
51705 case DisplayPowerStateEXT::eSuspend: return "Suspend";
51706 case DisplayPowerStateEXT::eOn: return "On";
51707 default: return "invalid";
51708 }
51709 }
51710
51712 {
51713 switch (value)
51714 {
51715 case DeviceEventTypeEXT::eDisplayHotplug: return "DisplayHotplug";
51716 default: return "invalid";
51717 }
51718 }
51719
51721 {
51722 switch (value)
51723 {
51724 case DisplayEventTypeEXT::eFirstPixelOut: return "FirstPixelOut";
51725 default: return "invalid";
51726 }
51727 }
51728
51730 {
51731 switch (value)
51732 {
51733 case PeerMemoryFeatureFlagBits::eCopySrc: return "CopySrc";
51734 case PeerMemoryFeatureFlagBits::eCopyDst: return "CopyDst";
51735 case PeerMemoryFeatureFlagBits::eGenericSrc: return "GenericSrc";
51736 case PeerMemoryFeatureFlagBits::eGenericDst: return "GenericDst";
51737 default: return "invalid";
51738 }
51739 }
51740
51742 {
51743 if (!value) return "{}";
51745 if (value & PeerMemoryFeatureFlagBits::eCopySrc) result += "CopySrc | ";
51746 if (value & PeerMemoryFeatureFlagBits::eCopyDst) result += "CopyDst | ";
51747 if (value & PeerMemoryFeatureFlagBits::eGenericSrc) result += "GenericSrc | ";
51748 if (value & PeerMemoryFeatureFlagBits::eGenericDst) result += "GenericDst | ";
51749 return "{" + result.substr(0, result.size() - 3) + "}";
51750 }
51751
51753 {
51754 switch (value)
51755 {
51756 case MemoryAllocateFlagBits::eDeviceMask: return "DeviceMask";
51757 default: return "invalid";
51758 }
51759 }
51760
51762 {
51763 if (!value) return "{}";
51765 if (value & MemoryAllocateFlagBits::eDeviceMask) result += "DeviceMask | ";
51766 return "{" + result.substr(0, result.size() - 3) + "}";
51767 }
51768
51770 {
51771 switch (value)
51772 {
51773 case DeviceGroupPresentModeFlagBitsKHR::eLocal: return "Local";
51774 case DeviceGroupPresentModeFlagBitsKHR::eRemote: return "Remote";
51775 case DeviceGroupPresentModeFlagBitsKHR::eSum: return "Sum";
51776 case DeviceGroupPresentModeFlagBitsKHR::eLocalMultiDevice: return "LocalMultiDevice";
51777 default: return "invalid";
51778 }
51779 }
51780
51782 {
51783 if (!value) return "{}";
51789 return "{" + result.substr(0, result.size() - 3) + "}";
51790 }
51791
51793 {
51794 switch (value)
51795 {
51796 case SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions: return "SplitInstanceBindRegions";
51797 case SwapchainCreateFlagBitsKHR::eProtected: return "Protected";
51798 default: return "invalid";
51799 }
51800 }
51801
51803 {
51804 if (!value) return "{}";
51806 if (value & SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions) result += "SplitInstanceBindRegions | ";
51807 if (value & SwapchainCreateFlagBitsKHR::eProtected) result += "Protected | ";
51808 return "{" + result.substr(0, result.size() - 3) + "}";
51809 }
51810
51812 {
51813 switch (value)
51814 {
51815 case ViewportCoordinateSwizzleNV::ePositiveX: return "PositiveX";
51816 case ViewportCoordinateSwizzleNV::eNegativeX: return "NegativeX";
51817 case ViewportCoordinateSwizzleNV::ePositiveY: return "PositiveY";
51818 case ViewportCoordinateSwizzleNV::eNegativeY: return "NegativeY";
51819 case ViewportCoordinateSwizzleNV::ePositiveZ: return "PositiveZ";
51820 case ViewportCoordinateSwizzleNV::eNegativeZ: return "NegativeZ";
51821 case ViewportCoordinateSwizzleNV::ePositiveW: return "PositiveW";
51822 case ViewportCoordinateSwizzleNV::eNegativeW: return "NegativeW";
51823 default: return "invalid";
51824 }
51825 }
51826
51828 {
51829 switch (value)
51830 {
51831 case DiscardRectangleModeEXT::eInclusive: return "Inclusive";
51832 case DiscardRectangleModeEXT::eExclusive: return "Exclusive";
51833 default: return "invalid";
51834 }
51835 }
51836
51838 {
51839 switch (value)
51840 {
51841 case SubpassDescriptionFlagBits::ePerViewAttributesNVX: return "PerViewAttributesNVX";
51842 case SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX: return "PerViewPositionXOnlyNVX";
51843 default: return "invalid";
51844 }
51845 }
51846
51848 {
51849 if (!value) return "{}";
51851 if (value & SubpassDescriptionFlagBits::ePerViewAttributesNVX) result += "PerViewAttributesNVX | ";
51852 if (value & SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX) result += "PerViewPositionXOnlyNVX | ";
51853 return "{" + result.substr(0, result.size() - 3) + "}";
51854 }
51855
51857 {
51858 switch (value)
51859 {
51860 case PointClippingBehavior::eAllClipPlanes: return "AllClipPlanes";
51861 case PointClippingBehavior::eUserClipPlanesOnly: return "UserClipPlanesOnly";
51862 default: return "invalid";
51863 }
51864 }
51865
51867 {
51868 switch (value)
51869 {
51870 case SamplerReductionModeEXT::eWeightedAverage: return "WeightedAverage";
51871 case SamplerReductionModeEXT::eMin: return "Min";
51872 case SamplerReductionModeEXT::eMax: return "Max";
51873 default: return "invalid";
51874 }
51875 }
51876
51878 {
51879 switch (value)
51880 {
51881 case TessellationDomainOrigin::eUpperLeft: return "UpperLeft";
51882 case TessellationDomainOrigin::eLowerLeft: return "LowerLeft";
51883 default: return "invalid";
51884 }
51885 }
51886
51888 {
51889 switch (value)
51890 {
51891 case SamplerYcbcrModelConversion::eRgbIdentity: return "RgbIdentity";
51892 case SamplerYcbcrModelConversion::eYcbcrIdentity: return "YcbcrIdentity";
51893 case SamplerYcbcrModelConversion::eYcbcr709: return "Ycbcr709";
51894 case SamplerYcbcrModelConversion::eYcbcr601: return "Ycbcr601";
51895 case SamplerYcbcrModelConversion::eYcbcr2020: return "Ycbcr2020";
51896 default: return "invalid";
51897 }
51898 }
51899
51901 {
51902 switch (value)
51903 {
51904 case SamplerYcbcrRange::eItuFull: return "ItuFull";
51905 case SamplerYcbcrRange::eItuNarrow: return "ItuNarrow";
51906 default: return "invalid";
51907 }
51908 }
51909
51911 {
51912 switch (value)
51913 {
51914 case ChromaLocation::eCositedEven: return "CositedEven";
51915 case ChromaLocation::eMidpoint: return "Midpoint";
51916 default: return "invalid";
51917 }
51918 }
51919
51921 {
51922 switch (value)
51923 {
51924 case BlendOverlapEXT::eUncorrelated: return "Uncorrelated";
51925 case BlendOverlapEXT::eDisjoint: return "Disjoint";
51926 case BlendOverlapEXT::eConjoint: return "Conjoint";
51927 default: return "invalid";
51928 }
51929 }
51930
51932 {
51933 switch (value)
51934 {
51935 case CoverageModulationModeNV::eNone: return "None";
51936 case CoverageModulationModeNV::eRgb: return "Rgb";
51937 case CoverageModulationModeNV::eAlpha: return "Alpha";
51938 case CoverageModulationModeNV::eRgba: return "Rgba";
51939 default: return "invalid";
51940 }
51941 }
51942
51944 {
51945 switch (value)
51946 {
51947 case ValidationCacheHeaderVersionEXT::eOne: return "One";
51948 default: return "invalid";
51949 }
51950 }
51951
51953 {
51954 switch (value)
51955 {
51956 case ShaderInfoTypeAMD::eStatistics: return "Statistics";
51957 case ShaderInfoTypeAMD::eBinary: return "Binary";
51958 case ShaderInfoTypeAMD::eDisassembly: return "Disassembly";
51959 default: return "invalid";
51960 }
51961 }
51962
51964 {
51965 switch (value)
51966 {
51967 case QueueGlobalPriorityEXT::eLow: return "Low";
51968 case QueueGlobalPriorityEXT::eMedium: return "Medium";
51969 case QueueGlobalPriorityEXT::eHigh: return "High";
51970 case QueueGlobalPriorityEXT::eRealtime: return "Realtime";
51971 default: return "invalid";
51972 }
51973 }
51974
51976 {
51977 switch (value)
51978 {
51983 default: return "invalid";
51984 }
51985 }
51986
51988 {
51989 if (!value) return "{}";
51995 return "{" + result.substr(0, result.size() - 3) + "}";
51996 }
51997
51999 {
52000 switch (value)
52001 {
52002 case DebugUtilsMessageTypeFlagBitsEXT::eGeneral: return "General";
52003 case DebugUtilsMessageTypeFlagBitsEXT::eValidation: return "Validation";
52004 case DebugUtilsMessageTypeFlagBitsEXT::ePerformance: return "Performance";
52005 default: return "invalid";
52006 }
52007 }
52008
52010 {
52011 if (!value) return "{}";
52016 return "{" + result.substr(0, result.size() - 3) + "}";
52017 }
52018
52020 {
52021 switch (value)
52022 {
52023 case ConservativeRasterizationModeEXT::eDisabled: return "Disabled";
52024 case ConservativeRasterizationModeEXT::eOverestimate: return "Overestimate";
52025 case ConservativeRasterizationModeEXT::eUnderestimate: return "Underestimate";
52026 default: return "invalid";
52027 }
52028 }
52029
52031 {
52032 switch (value)
52033 {
52034 case DescriptorBindingFlagBitsEXT::eUpdateAfterBind: return "UpdateAfterBind";
52035 case DescriptorBindingFlagBitsEXT::eUpdateUnusedWhilePending: return "UpdateUnusedWhilePending";
52036 case DescriptorBindingFlagBitsEXT::ePartiallyBound: return "PartiallyBound";
52037 case DescriptorBindingFlagBitsEXT::eVariableDescriptorCount: return "VariableDescriptorCount";
52038 default: return "invalid";
52039 }
52040 }
52041
52043 {
52044 if (!value) return "{}";
52046 if (value & DescriptorBindingFlagBitsEXT::eUpdateAfterBind) result += "UpdateAfterBind | ";
52047 if (value & DescriptorBindingFlagBitsEXT::eUpdateUnusedWhilePending) result += "UpdateUnusedWhilePending | ";
52048 if (value & DescriptorBindingFlagBitsEXT::ePartiallyBound) result += "PartiallyBound | ";
52049 if (value & DescriptorBindingFlagBitsEXT::eVariableDescriptorCount) result += "VariableDescriptorCount | ";
52050 return "{" + result.substr(0, result.size() - 3) + "}";
52051 }
52052
52054 {
52055 switch (value)
52056 {
52057 case VendorId::eViv: return "Viv";
52058 case VendorId::eVsi: return "Vsi";
52059 case VendorId::eKazan: return "Kazan";
52060 default: return "invalid";
52061 }
52062 }
52063
52065 {
52066 switch (value)
52067 {
52068 case DriverIdKHR::eAmdProprietary: return "AmdProprietary";
52069 case DriverIdKHR::eAmdOpenSource: return "AmdOpenSource";
52070 case DriverIdKHR::eMesaRadv: return "MesaRadv";
52071 case DriverIdKHR::eNvidiaProprietary: return "NvidiaProprietary";
52072 case DriverIdKHR::eIntelProprietaryWindows: return "IntelProprietaryWindows";
52073 case DriverIdKHR::eIntelOpenSourceMesa: return "IntelOpenSourceMesa";
52074 case DriverIdKHR::eImaginationProprietary: return "ImaginationProprietary";
52075 case DriverIdKHR::eQualcommProprietary: return "QualcommProprietary";
52076 case DriverIdKHR::eArmProprietary: return "ArmProprietary";
52077 default: return "invalid";
52078 }
52079 }
52080
52082 {
52083 switch (value)
52084 {
52085 case ConditionalRenderingFlagBitsEXT::eInverted: return "Inverted";
52086 default: return "invalid";
52087 }
52088 }
52089
52091 {
52092 if (!value) return "{}";
52095 return "{" + result.substr(0, result.size() - 3) + "}";
52096 }
52097
52099 {
52100 switch (value)
52101 {
52102 case ShadingRatePaletteEntryNV::eNoInvocations: return "NoInvocations";
52103 case ShadingRatePaletteEntryNV::e16InvocationsPerPixel: return "16InvocationsPerPixel";
52104 case ShadingRatePaletteEntryNV::e8InvocationsPerPixel: return "8InvocationsPerPixel";
52105 case ShadingRatePaletteEntryNV::e4InvocationsPerPixel: return "4InvocationsPerPixel";
52106 case ShadingRatePaletteEntryNV::e2InvocationsPerPixel: return "2InvocationsPerPixel";
52107 case ShadingRatePaletteEntryNV::e1InvocationPerPixel: return "1InvocationPerPixel";
52108 case ShadingRatePaletteEntryNV::e1InvocationPer2X1Pixels: return "1InvocationPer2X1Pixels";
52109 case ShadingRatePaletteEntryNV::e1InvocationPer1X2Pixels: return "1InvocationPer1X2Pixels";
52110 case ShadingRatePaletteEntryNV::e1InvocationPer2X2Pixels: return "1InvocationPer2X2Pixels";
52111 case ShadingRatePaletteEntryNV::e1InvocationPer4X2Pixels: return "1InvocationPer4X2Pixels";
52112 case ShadingRatePaletteEntryNV::e1InvocationPer2X4Pixels: return "1InvocationPer2X4Pixels";
52113 case ShadingRatePaletteEntryNV::e1InvocationPer4X4Pixels: return "1InvocationPer4X4Pixels";
52114 default: return "invalid";
52115 }
52116 }
52117
52119 {
52120 switch (value)
52121 {
52122 case CoarseSampleOrderTypeNV::eDefault: return "Default";
52123 case CoarseSampleOrderTypeNV::eCustom: return "Custom";
52124 case CoarseSampleOrderTypeNV::ePixelMajor: return "PixelMajor";
52125 case CoarseSampleOrderTypeNV::eSampleMajor: return "SampleMajor";
52126 default: return "invalid";
52127 }
52128 }
52129
52131 {
52132 switch (value)
52133 {
52134 case GeometryInstanceFlagBitsNV::eTriangleCullDisable: return "TriangleCullDisable";
52135 case GeometryInstanceFlagBitsNV::eTriangleFrontCounterclockwise: return "TriangleFrontCounterclockwise";
52136 case GeometryInstanceFlagBitsNV::eForceOpaque: return "ForceOpaque";
52137 case GeometryInstanceFlagBitsNV::eForceNoOpaque: return "ForceNoOpaque";
52138 default: return "invalid";
52139 }
52140 }
52141
52143 {
52144 if (!value) return "{}";
52146 if (value & GeometryInstanceFlagBitsNV::eTriangleCullDisable) result += "TriangleCullDisable | ";
52147 if (value & GeometryInstanceFlagBitsNV::eTriangleFrontCounterclockwise) result += "TriangleFrontCounterclockwise | ";
52148 if (value & GeometryInstanceFlagBitsNV::eForceOpaque) result += "ForceOpaque | ";
52149 if (value & GeometryInstanceFlagBitsNV::eForceNoOpaque) result += "ForceNoOpaque | ";
52150 return "{" + result.substr(0, result.size() - 3) + "}";
52151 }
52152
52154 {
52155 switch (value)
52156 {
52157 case GeometryFlagBitsNV::eOpaque: return "Opaque";
52158 case GeometryFlagBitsNV::eNoDuplicateAnyHitInvocation: return "NoDuplicateAnyHitInvocation";
52159 default: return "invalid";
52160 }
52161 }
52162
52164 {
52165 if (!value) return "{}";
52167 if (value & GeometryFlagBitsNV::eOpaque) result += "Opaque | ";
52168 if (value & GeometryFlagBitsNV::eNoDuplicateAnyHitInvocation) result += "NoDuplicateAnyHitInvocation | ";
52169 return "{" + result.substr(0, result.size() - 3) + "}";
52170 }
52171
52173 {
52174 switch (value)
52175 {
52176 case BuildAccelerationStructureFlagBitsNV::eAllowUpdate: return "AllowUpdate";
52177 case BuildAccelerationStructureFlagBitsNV::eAllowCompaction: return "AllowCompaction";
52178 case BuildAccelerationStructureFlagBitsNV::ePreferFastTrace: return "PreferFastTrace";
52179 case BuildAccelerationStructureFlagBitsNV::ePreferFastBuild: return "PreferFastBuild";
52180 case BuildAccelerationStructureFlagBitsNV::eLowMemory: return "LowMemory";
52181 default: return "invalid";
52182 }
52183 }
52184
52186 {
52187 if (!value) return "{}";
52194 return "{" + result.substr(0, result.size() - 3) + "}";
52195 }
52196
52198 {
52199 switch (value)
52200 {
52201 case CopyAccelerationStructureModeNV::eClone: return "Clone";
52202 case CopyAccelerationStructureModeNV::eCompact: return "Compact";
52203 default: return "invalid";
52204 }
52205 }
52206
52208 {
52209 switch (value)
52210 {
52211 case AccelerationStructureTypeNV::eTopLevel: return "TopLevel";
52212 case AccelerationStructureTypeNV::eBottomLevel: return "BottomLevel";
52213 default: return "invalid";
52214 }
52215 }
52216
52218 {
52219 switch (value)
52220 {
52221 case GeometryTypeNV::eTriangles: return "Triangles";
52222 case GeometryTypeNV::eAabbs: return "Aabbs";
52223 default: return "invalid";
52224 }
52225 }
52226
52228 {
52229 switch (value)
52230 {
52234 default: return "invalid";
52235 }
52236 }
52237
52239 {
52240 switch (value)
52241 {
52242 case RayTracingShaderGroupTypeNV::eGeneral: return "General";
52243 case RayTracingShaderGroupTypeNV::eTrianglesHitGroup: return "TrianglesHitGroup";
52244 case RayTracingShaderGroupTypeNV::eProceduralHitGroup: return "ProceduralHitGroup";
52245 default: return "invalid";
52246 }
52247 }
52248
52250 {
52251 switch (value)
52252 {
52253 case MemoryOverallocationBehaviorAMD::eDefault: return "Default";
52254 case MemoryOverallocationBehaviorAMD::eAllowed: return "Allowed";
52255 case MemoryOverallocationBehaviorAMD::eDisallowed: return "Disallowed";
52256 default: return "invalid";
52257 }
52258 }
52259
52261 {
52262 public:
52265#ifdef VK_USE_PLATFORM_XLIB_XRANDR_NV
52267#endif /*VK_USE_PLATFORM_XLIB_XRANDR_NV*/
52370#ifdef VK_USE_PLATFORM_ANDROID_KHR
52372#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
52390#ifdef VK_USE_PLATFORM_IOS_MVK
52392#endif /*VK_USE_PLATFORM_IOS_MVK*/
52394#ifdef VK_USE_PLATFORM_FUCHSIA_FUCHSIA
52396#endif /*VK_USE_PLATFORM_FUCHSIA_FUCHSIA*/
52400#ifdef VK_USE_PLATFORM_MACOS_MVK
52402#endif /*VK_USE_PLATFORM_MACOS_MVK*/
52418#ifdef VK_USE_PLATFORM_VI_NN
52420#endif /*VK_USE_PLATFORM_VI_NN*/
52421#ifdef VK_USE_PLATFORM_WAYLAND_KHR
52423#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
52424#ifdef VK_USE_PLATFORM_WIN32_KHR
52426#endif /*VK_USE_PLATFORM_WIN32_KHR*/
52427#ifdef VK_USE_PLATFORM_XCB_KHR
52429#endif /*VK_USE_PLATFORM_XCB_KHR*/
52430#ifdef VK_USE_PLATFORM_XLIB_KHR
52432#endif /*VK_USE_PLATFORM_XLIB_KHR*/
52485#ifdef VK_USE_PLATFORM_ANDROID_ANDROID
52487#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/
52510#ifdef VK_USE_PLATFORM_WIN32_KHR
52512#endif /*VK_USE_PLATFORM_WIN32_KHR*/
52522#ifdef VK_USE_PLATFORM_ANDROID_ANDROID
52524#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/
52528#ifdef VK_USE_PLATFORM_WIN32_KHR
52530#endif /*VK_USE_PLATFORM_WIN32_KHR*/
52531#ifdef VK_USE_PLATFORM_WIN32_NV
52533#endif /*VK_USE_PLATFORM_WIN32_NV*/
52534#ifdef VK_USE_PLATFORM_WIN32_KHR
52536#endif /*VK_USE_PLATFORM_WIN32_KHR*/
52581#ifdef VK_USE_PLATFORM_WAYLAND_KHR
52583#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
52584#ifdef VK_USE_PLATFORM_WIN32_KHR
52586#endif /*VK_USE_PLATFORM_WIN32_KHR*/
52587#ifdef VK_USE_PLATFORM_XCB_KHR
52589#endif /*VK_USE_PLATFORM_XCB_KHR*/
52590#ifdef VK_USE_PLATFORM_XLIB_KHR
52592#endif /*VK_USE_PLATFORM_XLIB_KHR*/
52596#ifdef VK_USE_PLATFORM_XLIB_XRANDR_NV
52598#endif /*VK_USE_PLATFORM_XLIB_XRANDR_NV*/
52603#ifdef VK_USE_PLATFORM_WIN32_KHR
52605#endif /*VK_USE_PLATFORM_WIN32_KHR*/
52612#ifdef VK_USE_PLATFORM_WIN32_KHR
52614#endif /*VK_USE_PLATFORM_WIN32_KHR*/
52616#ifdef VK_USE_PLATFORM_WIN32_KHR
52618#endif /*VK_USE_PLATFORM_WIN32_KHR*/
52652 public:
52654 {
52655 if (instance)
52656 {
52657 init(instance, device);
52658 }
52659 }
52660
52661 void init(Instance instance, Device device = Device())
52662 {
52663 vkAcquireNextImage2KHR = PFN_vkAcquireNextImage2KHR(device ? device.getProcAddr( "vkAcquireNextImage2KHR") : instance.getProcAddr( "vkAcquireNextImage2KHR"));
52664 vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR(device ? device.getProcAddr( "vkAcquireNextImageKHR") : instance.getProcAddr( "vkAcquireNextImageKHR"));
52665#ifdef VK_USE_PLATFORM_XLIB_XRANDR_NV
52666 vkAcquireXlibDisplayEXT = PFN_vkAcquireXlibDisplayEXT(instance.getProcAddr( "vkAcquireXlibDisplayEXT"));
52667#endif /*VK_USE_PLATFORM_XLIB_XRANDR_NV*/
52668 vkAllocateCommandBuffers = PFN_vkAllocateCommandBuffers(device ? device.getProcAddr( "vkAllocateCommandBuffers") : instance.getProcAddr( "vkAllocateCommandBuffers"));
52669 vkAllocateDescriptorSets = PFN_vkAllocateDescriptorSets(device ? device.getProcAddr( "vkAllocateDescriptorSets") : instance.getProcAddr( "vkAllocateDescriptorSets"));
52670 vkAllocateMemory = PFN_vkAllocateMemory(device ? device.getProcAddr( "vkAllocateMemory") : instance.getProcAddr( "vkAllocateMemory"));
52671 vkBeginCommandBuffer = PFN_vkBeginCommandBuffer(device ? device.getProcAddr( "vkBeginCommandBuffer") : instance.getProcAddr( "vkBeginCommandBuffer"));
52672 vkBindAccelerationStructureMemoryNV = PFN_vkBindAccelerationStructureMemoryNV(device ? device.getProcAddr( "vkBindAccelerationStructureMemoryNV") : instance.getProcAddr( "vkBindAccelerationStructureMemoryNV"));
52673 vkBindBufferMemory = PFN_vkBindBufferMemory(device ? device.getProcAddr( "vkBindBufferMemory") : instance.getProcAddr( "vkBindBufferMemory"));
52674 vkBindBufferMemory2 = PFN_vkBindBufferMemory2(device ? device.getProcAddr( "vkBindBufferMemory2") : instance.getProcAddr( "vkBindBufferMemory2"));
52675 vkBindBufferMemory2KHR = PFN_vkBindBufferMemory2KHR(device ? device.getProcAddr( "vkBindBufferMemory2KHR") : instance.getProcAddr( "vkBindBufferMemory2KHR"));
52676 vkBindImageMemory = PFN_vkBindImageMemory(device ? device.getProcAddr( "vkBindImageMemory") : instance.getProcAddr( "vkBindImageMemory"));
52677 vkBindImageMemory2 = PFN_vkBindImageMemory2(device ? device.getProcAddr( "vkBindImageMemory2") : instance.getProcAddr( "vkBindImageMemory2"));
52678 vkBindImageMemory2KHR = PFN_vkBindImageMemory2KHR(device ? device.getProcAddr( "vkBindImageMemory2KHR") : instance.getProcAddr( "vkBindImageMemory2KHR"));
52679 vkCmdBeginConditionalRenderingEXT = PFN_vkCmdBeginConditionalRenderingEXT(device ? device.getProcAddr( "vkCmdBeginConditionalRenderingEXT") : instance.getProcAddr( "vkCmdBeginConditionalRenderingEXT"));
52680 vkCmdBeginDebugUtilsLabelEXT = PFN_vkCmdBeginDebugUtilsLabelEXT(device ? device.getProcAddr( "vkCmdBeginDebugUtilsLabelEXT") : instance.getProcAddr( "vkCmdBeginDebugUtilsLabelEXT"));
52681 vkCmdBeginQuery = PFN_vkCmdBeginQuery(device ? device.getProcAddr( "vkCmdBeginQuery") : instance.getProcAddr( "vkCmdBeginQuery"));
52682 vkCmdBeginQueryIndexedEXT = PFN_vkCmdBeginQueryIndexedEXT(device ? device.getProcAddr( "vkCmdBeginQueryIndexedEXT") : instance.getProcAddr( "vkCmdBeginQueryIndexedEXT"));
52683 vkCmdBeginRenderPass = PFN_vkCmdBeginRenderPass(device ? device.getProcAddr( "vkCmdBeginRenderPass") : instance.getProcAddr( "vkCmdBeginRenderPass"));
52684 vkCmdBeginRenderPass2KHR = PFN_vkCmdBeginRenderPass2KHR(device ? device.getProcAddr( "vkCmdBeginRenderPass2KHR") : instance.getProcAddr( "vkCmdBeginRenderPass2KHR"));
52685 vkCmdBeginTransformFeedbackEXT = PFN_vkCmdBeginTransformFeedbackEXT(device ? device.getProcAddr( "vkCmdBeginTransformFeedbackEXT") : instance.getProcAddr( "vkCmdBeginTransformFeedbackEXT"));
52686 vkCmdBindDescriptorSets = PFN_vkCmdBindDescriptorSets(device ? device.getProcAddr( "vkCmdBindDescriptorSets") : instance.getProcAddr( "vkCmdBindDescriptorSets"));
52687 vkCmdBindIndexBuffer = PFN_vkCmdBindIndexBuffer(device ? device.getProcAddr( "vkCmdBindIndexBuffer") : instance.getProcAddr( "vkCmdBindIndexBuffer"));
52688 vkCmdBindPipeline = PFN_vkCmdBindPipeline(device ? device.getProcAddr( "vkCmdBindPipeline") : instance.getProcAddr( "vkCmdBindPipeline"));
52689 vkCmdBindShadingRateImageNV = PFN_vkCmdBindShadingRateImageNV(device ? device.getProcAddr( "vkCmdBindShadingRateImageNV") : instance.getProcAddr( "vkCmdBindShadingRateImageNV"));
52690 vkCmdBindTransformFeedbackBuffersEXT = PFN_vkCmdBindTransformFeedbackBuffersEXT(device ? device.getProcAddr( "vkCmdBindTransformFeedbackBuffersEXT") : instance.getProcAddr( "vkCmdBindTransformFeedbackBuffersEXT"));
52691 vkCmdBindVertexBuffers = PFN_vkCmdBindVertexBuffers(device ? device.getProcAddr( "vkCmdBindVertexBuffers") : instance.getProcAddr( "vkCmdBindVertexBuffers"));
52692 vkCmdBlitImage = PFN_vkCmdBlitImage(device ? device.getProcAddr( "vkCmdBlitImage") : instance.getProcAddr( "vkCmdBlitImage"));
52693 vkCmdBuildAccelerationStructureNV = PFN_vkCmdBuildAccelerationStructureNV(device ? device.getProcAddr( "vkCmdBuildAccelerationStructureNV") : instance.getProcAddr( "vkCmdBuildAccelerationStructureNV"));
52694 vkCmdClearAttachments = PFN_vkCmdClearAttachments(device ? device.getProcAddr( "vkCmdClearAttachments") : instance.getProcAddr( "vkCmdClearAttachments"));
52695 vkCmdClearColorImage = PFN_vkCmdClearColorImage(device ? device.getProcAddr( "vkCmdClearColorImage") : instance.getProcAddr( "vkCmdClearColorImage"));
52696 vkCmdClearDepthStencilImage = PFN_vkCmdClearDepthStencilImage(device ? device.getProcAddr( "vkCmdClearDepthStencilImage") : instance.getProcAddr( "vkCmdClearDepthStencilImage"));
52697 vkCmdCopyAccelerationStructureNV = PFN_vkCmdCopyAccelerationStructureNV(device ? device.getProcAddr( "vkCmdCopyAccelerationStructureNV") : instance.getProcAddr( "vkCmdCopyAccelerationStructureNV"));
52698 vkCmdCopyBuffer = PFN_vkCmdCopyBuffer(device ? device.getProcAddr( "vkCmdCopyBuffer") : instance.getProcAddr( "vkCmdCopyBuffer"));
52699 vkCmdCopyBufferToImage = PFN_vkCmdCopyBufferToImage(device ? device.getProcAddr( "vkCmdCopyBufferToImage") : instance.getProcAddr( "vkCmdCopyBufferToImage"));
52700 vkCmdCopyImage = PFN_vkCmdCopyImage(device ? device.getProcAddr( "vkCmdCopyImage") : instance.getProcAddr( "vkCmdCopyImage"));
52701 vkCmdCopyImageToBuffer = PFN_vkCmdCopyImageToBuffer(device ? device.getProcAddr( "vkCmdCopyImageToBuffer") : instance.getProcAddr( "vkCmdCopyImageToBuffer"));
52702 vkCmdCopyQueryPoolResults = PFN_vkCmdCopyQueryPoolResults(device ? device.getProcAddr( "vkCmdCopyQueryPoolResults") : instance.getProcAddr( "vkCmdCopyQueryPoolResults"));
52703 vkCmdDebugMarkerBeginEXT = PFN_vkCmdDebugMarkerBeginEXT(device ? device.getProcAddr( "vkCmdDebugMarkerBeginEXT") : instance.getProcAddr( "vkCmdDebugMarkerBeginEXT"));
52704 vkCmdDebugMarkerEndEXT = PFN_vkCmdDebugMarkerEndEXT(device ? device.getProcAddr( "vkCmdDebugMarkerEndEXT") : instance.getProcAddr( "vkCmdDebugMarkerEndEXT"));
52705 vkCmdDebugMarkerInsertEXT = PFN_vkCmdDebugMarkerInsertEXT(device ? device.getProcAddr( "vkCmdDebugMarkerInsertEXT") : instance.getProcAddr( "vkCmdDebugMarkerInsertEXT"));
52706 vkCmdDispatch = PFN_vkCmdDispatch(device ? device.getProcAddr( "vkCmdDispatch") : instance.getProcAddr( "vkCmdDispatch"));
52707 vkCmdDispatchBase = PFN_vkCmdDispatchBase(device ? device.getProcAddr( "vkCmdDispatchBase") : instance.getProcAddr( "vkCmdDispatchBase"));
52708 vkCmdDispatchBaseKHR = PFN_vkCmdDispatchBaseKHR(device ? device.getProcAddr( "vkCmdDispatchBaseKHR") : instance.getProcAddr( "vkCmdDispatchBaseKHR"));
52709 vkCmdDispatchIndirect = PFN_vkCmdDispatchIndirect(device ? device.getProcAddr( "vkCmdDispatchIndirect") : instance.getProcAddr( "vkCmdDispatchIndirect"));
52710 vkCmdDraw = PFN_vkCmdDraw(device ? device.getProcAddr( "vkCmdDraw") : instance.getProcAddr( "vkCmdDraw"));
52711 vkCmdDrawIndexed = PFN_vkCmdDrawIndexed(device ? device.getProcAddr( "vkCmdDrawIndexed") : instance.getProcAddr( "vkCmdDrawIndexed"));
52712 vkCmdDrawIndexedIndirect = PFN_vkCmdDrawIndexedIndirect(device ? device.getProcAddr( "vkCmdDrawIndexedIndirect") : instance.getProcAddr( "vkCmdDrawIndexedIndirect"));
52713 vkCmdDrawIndexedIndirectCountAMD = PFN_vkCmdDrawIndexedIndirectCountAMD(device ? device.getProcAddr( "vkCmdDrawIndexedIndirectCountAMD") : instance.getProcAddr( "vkCmdDrawIndexedIndirectCountAMD"));
52714 vkCmdDrawIndexedIndirectCountKHR = PFN_vkCmdDrawIndexedIndirectCountKHR(device ? device.getProcAddr( "vkCmdDrawIndexedIndirectCountKHR") : instance.getProcAddr( "vkCmdDrawIndexedIndirectCountKHR"));
52715 vkCmdDrawIndirect = PFN_vkCmdDrawIndirect(device ? device.getProcAddr( "vkCmdDrawIndirect") : instance.getProcAddr( "vkCmdDrawIndirect"));
52716 vkCmdDrawIndirectByteCountEXT = PFN_vkCmdDrawIndirectByteCountEXT(device ? device.getProcAddr( "vkCmdDrawIndirectByteCountEXT") : instance.getProcAddr( "vkCmdDrawIndirectByteCountEXT"));
52717 vkCmdDrawIndirectCountAMD = PFN_vkCmdDrawIndirectCountAMD(device ? device.getProcAddr( "vkCmdDrawIndirectCountAMD") : instance.getProcAddr( "vkCmdDrawIndirectCountAMD"));
52718 vkCmdDrawIndirectCountKHR = PFN_vkCmdDrawIndirectCountKHR(device ? device.getProcAddr( "vkCmdDrawIndirectCountKHR") : instance.getProcAddr( "vkCmdDrawIndirectCountKHR"));
52719 vkCmdDrawMeshTasksIndirectCountNV = PFN_vkCmdDrawMeshTasksIndirectCountNV(device ? device.getProcAddr( "vkCmdDrawMeshTasksIndirectCountNV") : instance.getProcAddr( "vkCmdDrawMeshTasksIndirectCountNV"));
52720 vkCmdDrawMeshTasksIndirectNV = PFN_vkCmdDrawMeshTasksIndirectNV(device ? device.getProcAddr( "vkCmdDrawMeshTasksIndirectNV") : instance.getProcAddr( "vkCmdDrawMeshTasksIndirectNV"));
52721 vkCmdDrawMeshTasksNV = PFN_vkCmdDrawMeshTasksNV(device ? device.getProcAddr( "vkCmdDrawMeshTasksNV") : instance.getProcAddr( "vkCmdDrawMeshTasksNV"));
52722 vkCmdEndConditionalRenderingEXT = PFN_vkCmdEndConditionalRenderingEXT(device ? device.getProcAddr( "vkCmdEndConditionalRenderingEXT") : instance.getProcAddr( "vkCmdEndConditionalRenderingEXT"));
52723 vkCmdEndDebugUtilsLabelEXT = PFN_vkCmdEndDebugUtilsLabelEXT(device ? device.getProcAddr( "vkCmdEndDebugUtilsLabelEXT") : instance.getProcAddr( "vkCmdEndDebugUtilsLabelEXT"));
52724 vkCmdEndQuery = PFN_vkCmdEndQuery(device ? device.getProcAddr( "vkCmdEndQuery") : instance.getProcAddr( "vkCmdEndQuery"));
52725 vkCmdEndQueryIndexedEXT = PFN_vkCmdEndQueryIndexedEXT(device ? device.getProcAddr( "vkCmdEndQueryIndexedEXT") : instance.getProcAddr( "vkCmdEndQueryIndexedEXT"));
52726 vkCmdEndRenderPass = PFN_vkCmdEndRenderPass(device ? device.getProcAddr( "vkCmdEndRenderPass") : instance.getProcAddr( "vkCmdEndRenderPass"));
52727 vkCmdEndRenderPass2KHR = PFN_vkCmdEndRenderPass2KHR(device ? device.getProcAddr( "vkCmdEndRenderPass2KHR") : instance.getProcAddr( "vkCmdEndRenderPass2KHR"));
52728 vkCmdEndTransformFeedbackEXT = PFN_vkCmdEndTransformFeedbackEXT(device ? device.getProcAddr( "vkCmdEndTransformFeedbackEXT") : instance.getProcAddr( "vkCmdEndTransformFeedbackEXT"));
52729 vkCmdExecuteCommands = PFN_vkCmdExecuteCommands(device ? device.getProcAddr( "vkCmdExecuteCommands") : instance.getProcAddr( "vkCmdExecuteCommands"));
52730 vkCmdFillBuffer = PFN_vkCmdFillBuffer(device ? device.getProcAddr( "vkCmdFillBuffer") : instance.getProcAddr( "vkCmdFillBuffer"));
52731 vkCmdInsertDebugUtilsLabelEXT = PFN_vkCmdInsertDebugUtilsLabelEXT(device ? device.getProcAddr( "vkCmdInsertDebugUtilsLabelEXT") : instance.getProcAddr( "vkCmdInsertDebugUtilsLabelEXT"));
52732 vkCmdNextSubpass = PFN_vkCmdNextSubpass(device ? device.getProcAddr( "vkCmdNextSubpass") : instance.getProcAddr( "vkCmdNextSubpass"));
52733 vkCmdNextSubpass2KHR = PFN_vkCmdNextSubpass2KHR(device ? device.getProcAddr( "vkCmdNextSubpass2KHR") : instance.getProcAddr( "vkCmdNextSubpass2KHR"));
52734 vkCmdPipelineBarrier = PFN_vkCmdPipelineBarrier(device ? device.getProcAddr( "vkCmdPipelineBarrier") : instance.getProcAddr( "vkCmdPipelineBarrier"));
52735 vkCmdProcessCommandsNVX = PFN_vkCmdProcessCommandsNVX(device ? device.getProcAddr( "vkCmdProcessCommandsNVX") : instance.getProcAddr( "vkCmdProcessCommandsNVX"));
52736 vkCmdPushConstants = PFN_vkCmdPushConstants(device ? device.getProcAddr( "vkCmdPushConstants") : instance.getProcAddr( "vkCmdPushConstants"));
52737 vkCmdPushDescriptorSetKHR = PFN_vkCmdPushDescriptorSetKHR(device ? device.getProcAddr( "vkCmdPushDescriptorSetKHR") : instance.getProcAddr( "vkCmdPushDescriptorSetKHR"));
52738 vkCmdPushDescriptorSetWithTemplateKHR = PFN_vkCmdPushDescriptorSetWithTemplateKHR(device ? device.getProcAddr( "vkCmdPushDescriptorSetWithTemplateKHR") : instance.getProcAddr( "vkCmdPushDescriptorSetWithTemplateKHR"));
52739 vkCmdReserveSpaceForCommandsNVX = PFN_vkCmdReserveSpaceForCommandsNVX(device ? device.getProcAddr( "vkCmdReserveSpaceForCommandsNVX") : instance.getProcAddr( "vkCmdReserveSpaceForCommandsNVX"));
52740 vkCmdResetEvent = PFN_vkCmdResetEvent(device ? device.getProcAddr( "vkCmdResetEvent") : instance.getProcAddr( "vkCmdResetEvent"));
52741 vkCmdResetQueryPool = PFN_vkCmdResetQueryPool(device ? device.getProcAddr( "vkCmdResetQueryPool") : instance.getProcAddr( "vkCmdResetQueryPool"));
52742 vkCmdResolveImage = PFN_vkCmdResolveImage(device ? device.getProcAddr( "vkCmdResolveImage") : instance.getProcAddr( "vkCmdResolveImage"));
52743 vkCmdSetBlendConstants = PFN_vkCmdSetBlendConstants(device ? device.getProcAddr( "vkCmdSetBlendConstants") : instance.getProcAddr( "vkCmdSetBlendConstants"));
52744 vkCmdSetCheckpointNV = PFN_vkCmdSetCheckpointNV(device ? device.getProcAddr( "vkCmdSetCheckpointNV") : instance.getProcAddr( "vkCmdSetCheckpointNV"));
52745 vkCmdSetCoarseSampleOrderNV = PFN_vkCmdSetCoarseSampleOrderNV(device ? device.getProcAddr( "vkCmdSetCoarseSampleOrderNV") : instance.getProcAddr( "vkCmdSetCoarseSampleOrderNV"));
52746 vkCmdSetDepthBias = PFN_vkCmdSetDepthBias(device ? device.getProcAddr( "vkCmdSetDepthBias") : instance.getProcAddr( "vkCmdSetDepthBias"));
52747 vkCmdSetDepthBounds = PFN_vkCmdSetDepthBounds(device ? device.getProcAddr( "vkCmdSetDepthBounds") : instance.getProcAddr( "vkCmdSetDepthBounds"));
52748 vkCmdSetDeviceMask = PFN_vkCmdSetDeviceMask(device ? device.getProcAddr( "vkCmdSetDeviceMask") : instance.getProcAddr( "vkCmdSetDeviceMask"));
52749 vkCmdSetDeviceMaskKHR = PFN_vkCmdSetDeviceMaskKHR(device ? device.getProcAddr( "vkCmdSetDeviceMaskKHR") : instance.getProcAddr( "vkCmdSetDeviceMaskKHR"));
52750 vkCmdSetDiscardRectangleEXT = PFN_vkCmdSetDiscardRectangleEXT(device ? device.getProcAddr( "vkCmdSetDiscardRectangleEXT") : instance.getProcAddr( "vkCmdSetDiscardRectangleEXT"));
52751 vkCmdSetEvent = PFN_vkCmdSetEvent(device ? device.getProcAddr( "vkCmdSetEvent") : instance.getProcAddr( "vkCmdSetEvent"));
52752 vkCmdSetExclusiveScissorNV = PFN_vkCmdSetExclusiveScissorNV(device ? device.getProcAddr( "vkCmdSetExclusiveScissorNV") : instance.getProcAddr( "vkCmdSetExclusiveScissorNV"));
52753 vkCmdSetLineWidth = PFN_vkCmdSetLineWidth(device ? device.getProcAddr( "vkCmdSetLineWidth") : instance.getProcAddr( "vkCmdSetLineWidth"));
52754 vkCmdSetSampleLocationsEXT = PFN_vkCmdSetSampleLocationsEXT(device ? device.getProcAddr( "vkCmdSetSampleLocationsEXT") : instance.getProcAddr( "vkCmdSetSampleLocationsEXT"));
52755 vkCmdSetScissor = PFN_vkCmdSetScissor(device ? device.getProcAddr( "vkCmdSetScissor") : instance.getProcAddr( "vkCmdSetScissor"));
52756 vkCmdSetStencilCompareMask = PFN_vkCmdSetStencilCompareMask(device ? device.getProcAddr( "vkCmdSetStencilCompareMask") : instance.getProcAddr( "vkCmdSetStencilCompareMask"));
52757 vkCmdSetStencilReference = PFN_vkCmdSetStencilReference(device ? device.getProcAddr( "vkCmdSetStencilReference") : instance.getProcAddr( "vkCmdSetStencilReference"));
52758 vkCmdSetStencilWriteMask = PFN_vkCmdSetStencilWriteMask(device ? device.getProcAddr( "vkCmdSetStencilWriteMask") : instance.getProcAddr( "vkCmdSetStencilWriteMask"));
52759 vkCmdSetViewport = PFN_vkCmdSetViewport(device ? device.getProcAddr( "vkCmdSetViewport") : instance.getProcAddr( "vkCmdSetViewport"));
52760 vkCmdSetViewportShadingRatePaletteNV = PFN_vkCmdSetViewportShadingRatePaletteNV(device ? device.getProcAddr( "vkCmdSetViewportShadingRatePaletteNV") : instance.getProcAddr( "vkCmdSetViewportShadingRatePaletteNV"));
52761 vkCmdSetViewportWScalingNV = PFN_vkCmdSetViewportWScalingNV(device ? device.getProcAddr( "vkCmdSetViewportWScalingNV") : instance.getProcAddr( "vkCmdSetViewportWScalingNV"));
52762 vkCmdTraceRaysNV = PFN_vkCmdTraceRaysNV(device ? device.getProcAddr( "vkCmdTraceRaysNV") : instance.getProcAddr( "vkCmdTraceRaysNV"));
52763 vkCmdUpdateBuffer = PFN_vkCmdUpdateBuffer(device ? device.getProcAddr( "vkCmdUpdateBuffer") : instance.getProcAddr( "vkCmdUpdateBuffer"));
52764 vkCmdWaitEvents = PFN_vkCmdWaitEvents(device ? device.getProcAddr( "vkCmdWaitEvents") : instance.getProcAddr( "vkCmdWaitEvents"));
52765 vkCmdWriteAccelerationStructuresPropertiesNV = PFN_vkCmdWriteAccelerationStructuresPropertiesNV(device ? device.getProcAddr( "vkCmdWriteAccelerationStructuresPropertiesNV") : instance.getProcAddr( "vkCmdWriteAccelerationStructuresPropertiesNV"));
52766 vkCmdWriteBufferMarkerAMD = PFN_vkCmdWriteBufferMarkerAMD(device ? device.getProcAddr( "vkCmdWriteBufferMarkerAMD") : instance.getProcAddr( "vkCmdWriteBufferMarkerAMD"));
52767 vkCmdWriteTimestamp = PFN_vkCmdWriteTimestamp(device ? device.getProcAddr( "vkCmdWriteTimestamp") : instance.getProcAddr( "vkCmdWriteTimestamp"));
52768 vkCompileDeferredNV = PFN_vkCompileDeferredNV(device ? device.getProcAddr( "vkCompileDeferredNV") : instance.getProcAddr( "vkCompileDeferredNV"));
52769 vkCreateAccelerationStructureNV = PFN_vkCreateAccelerationStructureNV(device ? device.getProcAddr( "vkCreateAccelerationStructureNV") : instance.getProcAddr( "vkCreateAccelerationStructureNV"));
52770#ifdef VK_USE_PLATFORM_ANDROID_KHR
52771 vkCreateAndroidSurfaceKHR = PFN_vkCreateAndroidSurfaceKHR(instance.getProcAddr( "vkCreateAndroidSurfaceKHR"));
52772#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
52773 vkCreateBuffer = PFN_vkCreateBuffer(device ? device.getProcAddr( "vkCreateBuffer") : instance.getProcAddr( "vkCreateBuffer"));
52774 vkCreateBufferView = PFN_vkCreateBufferView(device ? device.getProcAddr( "vkCreateBufferView") : instance.getProcAddr( "vkCreateBufferView"));
52775 vkCreateCommandPool = PFN_vkCreateCommandPool(device ? device.getProcAddr( "vkCreateCommandPool") : instance.getProcAddr( "vkCreateCommandPool"));
52776 vkCreateComputePipelines = PFN_vkCreateComputePipelines(device ? device.getProcAddr( "vkCreateComputePipelines") : instance.getProcAddr( "vkCreateComputePipelines"));
52777 vkCreateDebugReportCallbackEXT = PFN_vkCreateDebugReportCallbackEXT(instance.getProcAddr( "vkCreateDebugReportCallbackEXT"));
52778 vkCreateDebugUtilsMessengerEXT = PFN_vkCreateDebugUtilsMessengerEXT(instance.getProcAddr( "vkCreateDebugUtilsMessengerEXT"));
52779 vkCreateDescriptorPool = PFN_vkCreateDescriptorPool(device ? device.getProcAddr( "vkCreateDescriptorPool") : instance.getProcAddr( "vkCreateDescriptorPool"));
52780 vkCreateDescriptorSetLayout = PFN_vkCreateDescriptorSetLayout(device ? device.getProcAddr( "vkCreateDescriptorSetLayout") : instance.getProcAddr( "vkCreateDescriptorSetLayout"));
52781 vkCreateDescriptorUpdateTemplate = PFN_vkCreateDescriptorUpdateTemplate(device ? device.getProcAddr( "vkCreateDescriptorUpdateTemplate") : instance.getProcAddr( "vkCreateDescriptorUpdateTemplate"));
52782 vkCreateDescriptorUpdateTemplateKHR = PFN_vkCreateDescriptorUpdateTemplateKHR(device ? device.getProcAddr( "vkCreateDescriptorUpdateTemplateKHR") : instance.getProcAddr( "vkCreateDescriptorUpdateTemplateKHR"));
52783 vkCreateDevice = PFN_vkCreateDevice(instance.getProcAddr( "vkCreateDevice"));
52784 vkCreateDisplayModeKHR = PFN_vkCreateDisplayModeKHR(instance.getProcAddr( "vkCreateDisplayModeKHR"));
52785 vkCreateDisplayPlaneSurfaceKHR = PFN_vkCreateDisplayPlaneSurfaceKHR(instance.getProcAddr( "vkCreateDisplayPlaneSurfaceKHR"));
52786 vkCreateEvent = PFN_vkCreateEvent(device ? device.getProcAddr( "vkCreateEvent") : instance.getProcAddr( "vkCreateEvent"));
52787 vkCreateFence = PFN_vkCreateFence(device ? device.getProcAddr( "vkCreateFence") : instance.getProcAddr( "vkCreateFence"));
52788 vkCreateFramebuffer = PFN_vkCreateFramebuffer(device ? device.getProcAddr( "vkCreateFramebuffer") : instance.getProcAddr( "vkCreateFramebuffer"));
52789 vkCreateGraphicsPipelines = PFN_vkCreateGraphicsPipelines(device ? device.getProcAddr( "vkCreateGraphicsPipelines") : instance.getProcAddr( "vkCreateGraphicsPipelines"));
52790#ifdef VK_USE_PLATFORM_IOS_MVK
52791 vkCreateIOSSurfaceMVK = PFN_vkCreateIOSSurfaceMVK(instance.getProcAddr( "vkCreateIOSSurfaceMVK"));
52792#endif /*VK_USE_PLATFORM_IOS_MVK*/
52793 vkCreateImage = PFN_vkCreateImage(device ? device.getProcAddr( "vkCreateImage") : instance.getProcAddr( "vkCreateImage"));
52794#ifdef VK_USE_PLATFORM_FUCHSIA_FUCHSIA
52795 vkCreateImagePipeSurfaceFUCHSIA = PFN_vkCreateImagePipeSurfaceFUCHSIA(instance.getProcAddr( "vkCreateImagePipeSurfaceFUCHSIA"));
52796#endif /*VK_USE_PLATFORM_FUCHSIA_FUCHSIA*/
52797 vkCreateImageView = PFN_vkCreateImageView(device ? device.getProcAddr( "vkCreateImageView") : instance.getProcAddr( "vkCreateImageView"));
52798 vkCreateIndirectCommandsLayoutNVX = PFN_vkCreateIndirectCommandsLayoutNVX(device ? device.getProcAddr( "vkCreateIndirectCommandsLayoutNVX") : instance.getProcAddr( "vkCreateIndirectCommandsLayoutNVX"));
52799 vkCreateInstance = PFN_vkCreateInstance(instance.getProcAddr( "vkCreateInstance"));
52800#ifdef VK_USE_PLATFORM_MACOS_MVK
52801 vkCreateMacOSSurfaceMVK = PFN_vkCreateMacOSSurfaceMVK(instance.getProcAddr( "vkCreateMacOSSurfaceMVK"));
52802#endif /*VK_USE_PLATFORM_MACOS_MVK*/
52803 vkCreateObjectTableNVX = PFN_vkCreateObjectTableNVX(device ? device.getProcAddr( "vkCreateObjectTableNVX") : instance.getProcAddr( "vkCreateObjectTableNVX"));
52804 vkCreatePipelineCache = PFN_vkCreatePipelineCache(device ? device.getProcAddr( "vkCreatePipelineCache") : instance.getProcAddr( "vkCreatePipelineCache"));
52805 vkCreatePipelineLayout = PFN_vkCreatePipelineLayout(device ? device.getProcAddr( "vkCreatePipelineLayout") : instance.getProcAddr( "vkCreatePipelineLayout"));
52806 vkCreateQueryPool = PFN_vkCreateQueryPool(device ? device.getProcAddr( "vkCreateQueryPool") : instance.getProcAddr( "vkCreateQueryPool"));
52807 vkCreateRayTracingPipelinesNV = PFN_vkCreateRayTracingPipelinesNV(device ? device.getProcAddr( "vkCreateRayTracingPipelinesNV") : instance.getProcAddr( "vkCreateRayTracingPipelinesNV"));
52808 vkCreateRenderPass = PFN_vkCreateRenderPass(device ? device.getProcAddr( "vkCreateRenderPass") : instance.getProcAddr( "vkCreateRenderPass"));
52809 vkCreateRenderPass2KHR = PFN_vkCreateRenderPass2KHR(device ? device.getProcAddr( "vkCreateRenderPass2KHR") : instance.getProcAddr( "vkCreateRenderPass2KHR"));
52810 vkCreateSampler = PFN_vkCreateSampler(device ? device.getProcAddr( "vkCreateSampler") : instance.getProcAddr( "vkCreateSampler"));
52811 vkCreateSamplerYcbcrConversion = PFN_vkCreateSamplerYcbcrConversion(device ? device.getProcAddr( "vkCreateSamplerYcbcrConversion") : instance.getProcAddr( "vkCreateSamplerYcbcrConversion"));
52812 vkCreateSamplerYcbcrConversionKHR = PFN_vkCreateSamplerYcbcrConversionKHR(device ? device.getProcAddr( "vkCreateSamplerYcbcrConversionKHR") : instance.getProcAddr( "vkCreateSamplerYcbcrConversionKHR"));
52813 vkCreateSemaphore = PFN_vkCreateSemaphore(device ? device.getProcAddr( "vkCreateSemaphore") : instance.getProcAddr( "vkCreateSemaphore"));
52814 vkCreateShaderModule = PFN_vkCreateShaderModule(device ? device.getProcAddr( "vkCreateShaderModule") : instance.getProcAddr( "vkCreateShaderModule"));
52815 vkCreateSharedSwapchainsKHR = PFN_vkCreateSharedSwapchainsKHR(device ? device.getProcAddr( "vkCreateSharedSwapchainsKHR") : instance.getProcAddr( "vkCreateSharedSwapchainsKHR"));
52816 vkCreateSwapchainKHR = PFN_vkCreateSwapchainKHR(device ? device.getProcAddr( "vkCreateSwapchainKHR") : instance.getProcAddr( "vkCreateSwapchainKHR"));
52817 vkCreateValidationCacheEXT = PFN_vkCreateValidationCacheEXT(device ? device.getProcAddr( "vkCreateValidationCacheEXT") : instance.getProcAddr( "vkCreateValidationCacheEXT"));
52818#ifdef VK_USE_PLATFORM_VI_NN
52819 vkCreateViSurfaceNN = PFN_vkCreateViSurfaceNN(instance.getProcAddr( "vkCreateViSurfaceNN"));
52820#endif /*VK_USE_PLATFORM_VI_NN*/
52821#ifdef VK_USE_PLATFORM_WAYLAND_KHR
52822 vkCreateWaylandSurfaceKHR = PFN_vkCreateWaylandSurfaceKHR(instance.getProcAddr( "vkCreateWaylandSurfaceKHR"));
52823#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
52824#ifdef VK_USE_PLATFORM_WIN32_KHR
52825 vkCreateWin32SurfaceKHR = PFN_vkCreateWin32SurfaceKHR(instance.getProcAddr( "vkCreateWin32SurfaceKHR"));
52826#endif /*VK_USE_PLATFORM_WIN32_KHR*/
52827#ifdef VK_USE_PLATFORM_XCB_KHR
52828 vkCreateXcbSurfaceKHR = PFN_vkCreateXcbSurfaceKHR(instance.getProcAddr( "vkCreateXcbSurfaceKHR"));
52829#endif /*VK_USE_PLATFORM_XCB_KHR*/
52830#ifdef VK_USE_PLATFORM_XLIB_KHR
52831 vkCreateXlibSurfaceKHR = PFN_vkCreateXlibSurfaceKHR(instance.getProcAddr( "vkCreateXlibSurfaceKHR"));
52832#endif /*VK_USE_PLATFORM_XLIB_KHR*/
52833 vkDebugMarkerSetObjectNameEXT = PFN_vkDebugMarkerSetObjectNameEXT(device ? device.getProcAddr( "vkDebugMarkerSetObjectNameEXT") : instance.getProcAddr( "vkDebugMarkerSetObjectNameEXT"));
52834 vkDebugMarkerSetObjectTagEXT = PFN_vkDebugMarkerSetObjectTagEXT(device ? device.getProcAddr( "vkDebugMarkerSetObjectTagEXT") : instance.getProcAddr( "vkDebugMarkerSetObjectTagEXT"));
52835 vkDebugReportMessageEXT = PFN_vkDebugReportMessageEXT(instance.getProcAddr( "vkDebugReportMessageEXT"));
52836 vkDestroyAccelerationStructureNV = PFN_vkDestroyAccelerationStructureNV(device ? device.getProcAddr( "vkDestroyAccelerationStructureNV") : instance.getProcAddr( "vkDestroyAccelerationStructureNV"));
52837 vkDestroyBuffer = PFN_vkDestroyBuffer(device ? device.getProcAddr( "vkDestroyBuffer") : instance.getProcAddr( "vkDestroyBuffer"));
52838 vkDestroyBufferView = PFN_vkDestroyBufferView(device ? device.getProcAddr( "vkDestroyBufferView") : instance.getProcAddr( "vkDestroyBufferView"));
52839 vkDestroyCommandPool = PFN_vkDestroyCommandPool(device ? device.getProcAddr( "vkDestroyCommandPool") : instance.getProcAddr( "vkDestroyCommandPool"));
52840 vkDestroyDebugReportCallbackEXT = PFN_vkDestroyDebugReportCallbackEXT(instance.getProcAddr( "vkDestroyDebugReportCallbackEXT"));
52841 vkDestroyDebugUtilsMessengerEXT = PFN_vkDestroyDebugUtilsMessengerEXT(instance.getProcAddr( "vkDestroyDebugUtilsMessengerEXT"));
52842 vkDestroyDescriptorPool = PFN_vkDestroyDescriptorPool(device ? device.getProcAddr( "vkDestroyDescriptorPool") : instance.getProcAddr( "vkDestroyDescriptorPool"));
52843 vkDestroyDescriptorSetLayout = PFN_vkDestroyDescriptorSetLayout(device ? device.getProcAddr( "vkDestroyDescriptorSetLayout") : instance.getProcAddr( "vkDestroyDescriptorSetLayout"));
52844 vkDestroyDescriptorUpdateTemplate = PFN_vkDestroyDescriptorUpdateTemplate(device ? device.getProcAddr( "vkDestroyDescriptorUpdateTemplate") : instance.getProcAddr( "vkDestroyDescriptorUpdateTemplate"));
52845 vkDestroyDescriptorUpdateTemplateKHR = PFN_vkDestroyDescriptorUpdateTemplateKHR(device ? device.getProcAddr( "vkDestroyDescriptorUpdateTemplateKHR") : instance.getProcAddr( "vkDestroyDescriptorUpdateTemplateKHR"));
52846 vkDestroyDevice = PFN_vkDestroyDevice(device ? device.getProcAddr( "vkDestroyDevice") : instance.getProcAddr( "vkDestroyDevice"));
52847 vkDestroyEvent = PFN_vkDestroyEvent(device ? device.getProcAddr( "vkDestroyEvent") : instance.getProcAddr( "vkDestroyEvent"));
52848 vkDestroyFence = PFN_vkDestroyFence(device ? device.getProcAddr( "vkDestroyFence") : instance.getProcAddr( "vkDestroyFence"));
52849 vkDestroyFramebuffer = PFN_vkDestroyFramebuffer(device ? device.getProcAddr( "vkDestroyFramebuffer") : instance.getProcAddr( "vkDestroyFramebuffer"));
52850 vkDestroyImage = PFN_vkDestroyImage(device ? device.getProcAddr( "vkDestroyImage") : instance.getProcAddr( "vkDestroyImage"));
52851 vkDestroyImageView = PFN_vkDestroyImageView(device ? device.getProcAddr( "vkDestroyImageView") : instance.getProcAddr( "vkDestroyImageView"));
52852 vkDestroyIndirectCommandsLayoutNVX = PFN_vkDestroyIndirectCommandsLayoutNVX(device ? device.getProcAddr( "vkDestroyIndirectCommandsLayoutNVX") : instance.getProcAddr( "vkDestroyIndirectCommandsLayoutNVX"));
52853 vkDestroyInstance = PFN_vkDestroyInstance(instance.getProcAddr( "vkDestroyInstance"));
52854 vkDestroyObjectTableNVX = PFN_vkDestroyObjectTableNVX(device ? device.getProcAddr( "vkDestroyObjectTableNVX") : instance.getProcAddr( "vkDestroyObjectTableNVX"));
52855 vkDestroyPipeline = PFN_vkDestroyPipeline(device ? device.getProcAddr( "vkDestroyPipeline") : instance.getProcAddr( "vkDestroyPipeline"));
52856 vkDestroyPipelineCache = PFN_vkDestroyPipelineCache(device ? device.getProcAddr( "vkDestroyPipelineCache") : instance.getProcAddr( "vkDestroyPipelineCache"));
52857 vkDestroyPipelineLayout = PFN_vkDestroyPipelineLayout(device ? device.getProcAddr( "vkDestroyPipelineLayout") : instance.getProcAddr( "vkDestroyPipelineLayout"));
52858 vkDestroyQueryPool = PFN_vkDestroyQueryPool(device ? device.getProcAddr( "vkDestroyQueryPool") : instance.getProcAddr( "vkDestroyQueryPool"));
52859 vkDestroyRenderPass = PFN_vkDestroyRenderPass(device ? device.getProcAddr( "vkDestroyRenderPass") : instance.getProcAddr( "vkDestroyRenderPass"));
52860 vkDestroySampler = PFN_vkDestroySampler(device ? device.getProcAddr( "vkDestroySampler") : instance.getProcAddr( "vkDestroySampler"));
52861 vkDestroySamplerYcbcrConversion = PFN_vkDestroySamplerYcbcrConversion(device ? device.getProcAddr( "vkDestroySamplerYcbcrConversion") : instance.getProcAddr( "vkDestroySamplerYcbcrConversion"));
52862 vkDestroySamplerYcbcrConversionKHR = PFN_vkDestroySamplerYcbcrConversionKHR(device ? device.getProcAddr( "vkDestroySamplerYcbcrConversionKHR") : instance.getProcAddr( "vkDestroySamplerYcbcrConversionKHR"));
52863 vkDestroySemaphore = PFN_vkDestroySemaphore(device ? device.getProcAddr( "vkDestroySemaphore") : instance.getProcAddr( "vkDestroySemaphore"));
52864 vkDestroyShaderModule = PFN_vkDestroyShaderModule(device ? device.getProcAddr( "vkDestroyShaderModule") : instance.getProcAddr( "vkDestroyShaderModule"));
52865 vkDestroySurfaceKHR = PFN_vkDestroySurfaceKHR(instance.getProcAddr( "vkDestroySurfaceKHR"));
52866 vkDestroySwapchainKHR = PFN_vkDestroySwapchainKHR(device ? device.getProcAddr( "vkDestroySwapchainKHR") : instance.getProcAddr( "vkDestroySwapchainKHR"));
52867 vkDestroyValidationCacheEXT = PFN_vkDestroyValidationCacheEXT(device ? device.getProcAddr( "vkDestroyValidationCacheEXT") : instance.getProcAddr( "vkDestroyValidationCacheEXT"));
52868 vkDeviceWaitIdle = PFN_vkDeviceWaitIdle(device ? device.getProcAddr( "vkDeviceWaitIdle") : instance.getProcAddr( "vkDeviceWaitIdle"));
52869 vkDisplayPowerControlEXT = PFN_vkDisplayPowerControlEXT(device ? device.getProcAddr( "vkDisplayPowerControlEXT") : instance.getProcAddr( "vkDisplayPowerControlEXT"));
52870 vkEndCommandBuffer = PFN_vkEndCommandBuffer(device ? device.getProcAddr( "vkEndCommandBuffer") : instance.getProcAddr( "vkEndCommandBuffer"));
52871 vkEnumerateDeviceExtensionProperties = PFN_vkEnumerateDeviceExtensionProperties(instance.getProcAddr( "vkEnumerateDeviceExtensionProperties"));
52872 vkEnumerateDeviceLayerProperties = PFN_vkEnumerateDeviceLayerProperties(instance.getProcAddr( "vkEnumerateDeviceLayerProperties"));
52873 vkEnumerateInstanceExtensionProperties = PFN_vkEnumerateInstanceExtensionProperties(instance.getProcAddr( "vkEnumerateInstanceExtensionProperties"));
52874 vkEnumerateInstanceLayerProperties = PFN_vkEnumerateInstanceLayerProperties(instance.getProcAddr( "vkEnumerateInstanceLayerProperties"));
52875 vkEnumerateInstanceVersion = PFN_vkEnumerateInstanceVersion(instance.getProcAddr( "vkEnumerateInstanceVersion"));
52876 vkEnumeratePhysicalDeviceGroups = PFN_vkEnumeratePhysicalDeviceGroups(instance.getProcAddr( "vkEnumeratePhysicalDeviceGroups"));
52877 vkEnumeratePhysicalDeviceGroupsKHR = PFN_vkEnumeratePhysicalDeviceGroupsKHR(instance.getProcAddr( "vkEnumeratePhysicalDeviceGroupsKHR"));
52878 vkEnumeratePhysicalDevices = PFN_vkEnumeratePhysicalDevices(instance.getProcAddr( "vkEnumeratePhysicalDevices"));
52879 vkFlushMappedMemoryRanges = PFN_vkFlushMappedMemoryRanges(device ? device.getProcAddr( "vkFlushMappedMemoryRanges") : instance.getProcAddr( "vkFlushMappedMemoryRanges"));
52880 vkFreeCommandBuffers = PFN_vkFreeCommandBuffers(device ? device.getProcAddr( "vkFreeCommandBuffers") : instance.getProcAddr( "vkFreeCommandBuffers"));
52881 vkFreeDescriptorSets = PFN_vkFreeDescriptorSets(device ? device.getProcAddr( "vkFreeDescriptorSets") : instance.getProcAddr( "vkFreeDescriptorSets"));
52882 vkFreeMemory = PFN_vkFreeMemory(device ? device.getProcAddr( "vkFreeMemory") : instance.getProcAddr( "vkFreeMemory"));
52883 vkGetAccelerationStructureHandleNV = PFN_vkGetAccelerationStructureHandleNV(device ? device.getProcAddr( "vkGetAccelerationStructureHandleNV") : instance.getProcAddr( "vkGetAccelerationStructureHandleNV"));
52884 vkGetAccelerationStructureMemoryRequirementsNV = PFN_vkGetAccelerationStructureMemoryRequirementsNV(device ? device.getProcAddr( "vkGetAccelerationStructureMemoryRequirementsNV") : instance.getProcAddr( "vkGetAccelerationStructureMemoryRequirementsNV"));
52885#ifdef VK_USE_PLATFORM_ANDROID_ANDROID
52886 vkGetAndroidHardwareBufferPropertiesANDROID = PFN_vkGetAndroidHardwareBufferPropertiesANDROID(device ? device.getProcAddr( "vkGetAndroidHardwareBufferPropertiesANDROID") : instance.getProcAddr( "vkGetAndroidHardwareBufferPropertiesANDROID"));
52887#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/
52888 vkGetBufferMemoryRequirements = PFN_vkGetBufferMemoryRequirements(device ? device.getProcAddr( "vkGetBufferMemoryRequirements") : instance.getProcAddr( "vkGetBufferMemoryRequirements"));
52889 vkGetBufferMemoryRequirements2 = PFN_vkGetBufferMemoryRequirements2(device ? device.getProcAddr( "vkGetBufferMemoryRequirements2") : instance.getProcAddr( "vkGetBufferMemoryRequirements2"));
52890 vkGetBufferMemoryRequirements2KHR = PFN_vkGetBufferMemoryRequirements2KHR(device ? device.getProcAddr( "vkGetBufferMemoryRequirements2KHR") : instance.getProcAddr( "vkGetBufferMemoryRequirements2KHR"));
52891 vkGetCalibratedTimestampsEXT = PFN_vkGetCalibratedTimestampsEXT(device ? device.getProcAddr( "vkGetCalibratedTimestampsEXT") : instance.getProcAddr( "vkGetCalibratedTimestampsEXT"));
52892 vkGetDescriptorSetLayoutSupport = PFN_vkGetDescriptorSetLayoutSupport(device ? device.getProcAddr( "vkGetDescriptorSetLayoutSupport") : instance.getProcAddr( "vkGetDescriptorSetLayoutSupport"));
52893 vkGetDescriptorSetLayoutSupportKHR = PFN_vkGetDescriptorSetLayoutSupportKHR(device ? device.getProcAddr( "vkGetDescriptorSetLayoutSupportKHR") : instance.getProcAddr( "vkGetDescriptorSetLayoutSupportKHR"));
52894 vkGetDeviceGroupPeerMemoryFeatures = PFN_vkGetDeviceGroupPeerMemoryFeatures(device ? device.getProcAddr( "vkGetDeviceGroupPeerMemoryFeatures") : instance.getProcAddr( "vkGetDeviceGroupPeerMemoryFeatures"));
52895 vkGetDeviceGroupPeerMemoryFeaturesKHR = PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR(device ? device.getProcAddr( "vkGetDeviceGroupPeerMemoryFeaturesKHR") : instance.getProcAddr( "vkGetDeviceGroupPeerMemoryFeaturesKHR"));
52896 vkGetDeviceGroupPresentCapabilitiesKHR = PFN_vkGetDeviceGroupPresentCapabilitiesKHR(device ? device.getProcAddr( "vkGetDeviceGroupPresentCapabilitiesKHR") : instance.getProcAddr( "vkGetDeviceGroupPresentCapabilitiesKHR"));
52897 vkGetDeviceGroupSurfacePresentModesKHR = PFN_vkGetDeviceGroupSurfacePresentModesKHR(device ? device.getProcAddr( "vkGetDeviceGroupSurfacePresentModesKHR") : instance.getProcAddr( "vkGetDeviceGroupSurfacePresentModesKHR"));
52898 vkGetDeviceMemoryCommitment = PFN_vkGetDeviceMemoryCommitment(device ? device.getProcAddr( "vkGetDeviceMemoryCommitment") : instance.getProcAddr( "vkGetDeviceMemoryCommitment"));
52899 vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr(device ? device.getProcAddr( "vkGetDeviceProcAddr") : instance.getProcAddr( "vkGetDeviceProcAddr"));
52900 vkGetDeviceQueue = PFN_vkGetDeviceQueue(device ? device.getProcAddr( "vkGetDeviceQueue") : instance.getProcAddr( "vkGetDeviceQueue"));
52901 vkGetDeviceQueue2 = PFN_vkGetDeviceQueue2(device ? device.getProcAddr( "vkGetDeviceQueue2") : instance.getProcAddr( "vkGetDeviceQueue2"));
52902 vkGetDisplayModeProperties2KHR = PFN_vkGetDisplayModeProperties2KHR(instance.getProcAddr( "vkGetDisplayModeProperties2KHR"));
52903 vkGetDisplayModePropertiesKHR = PFN_vkGetDisplayModePropertiesKHR(instance.getProcAddr( "vkGetDisplayModePropertiesKHR"));
52904 vkGetDisplayPlaneCapabilities2KHR = PFN_vkGetDisplayPlaneCapabilities2KHR(instance.getProcAddr( "vkGetDisplayPlaneCapabilities2KHR"));
52905 vkGetDisplayPlaneCapabilitiesKHR = PFN_vkGetDisplayPlaneCapabilitiesKHR(instance.getProcAddr( "vkGetDisplayPlaneCapabilitiesKHR"));
52906 vkGetDisplayPlaneSupportedDisplaysKHR = PFN_vkGetDisplayPlaneSupportedDisplaysKHR(instance.getProcAddr( "vkGetDisplayPlaneSupportedDisplaysKHR"));
52907 vkGetEventStatus = PFN_vkGetEventStatus(device ? device.getProcAddr( "vkGetEventStatus") : instance.getProcAddr( "vkGetEventStatus"));
52908 vkGetFenceFdKHR = PFN_vkGetFenceFdKHR(device ? device.getProcAddr( "vkGetFenceFdKHR") : instance.getProcAddr( "vkGetFenceFdKHR"));
52909 vkGetFenceStatus = PFN_vkGetFenceStatus(device ? device.getProcAddr( "vkGetFenceStatus") : instance.getProcAddr( "vkGetFenceStatus"));
52910#ifdef VK_USE_PLATFORM_WIN32_KHR
52911 vkGetFenceWin32HandleKHR = PFN_vkGetFenceWin32HandleKHR(device ? device.getProcAddr( "vkGetFenceWin32HandleKHR") : instance.getProcAddr( "vkGetFenceWin32HandleKHR"));
52912#endif /*VK_USE_PLATFORM_WIN32_KHR*/
52913 vkGetImageDrmFormatModifierPropertiesEXT = PFN_vkGetImageDrmFormatModifierPropertiesEXT(device ? device.getProcAddr( "vkGetImageDrmFormatModifierPropertiesEXT") : instance.getProcAddr( "vkGetImageDrmFormatModifierPropertiesEXT"));
52914 vkGetImageMemoryRequirements = PFN_vkGetImageMemoryRequirements(device ? device.getProcAddr( "vkGetImageMemoryRequirements") : instance.getProcAddr( "vkGetImageMemoryRequirements"));
52915 vkGetImageMemoryRequirements2 = PFN_vkGetImageMemoryRequirements2(device ? device.getProcAddr( "vkGetImageMemoryRequirements2") : instance.getProcAddr( "vkGetImageMemoryRequirements2"));
52916 vkGetImageMemoryRequirements2KHR = PFN_vkGetImageMemoryRequirements2KHR(device ? device.getProcAddr( "vkGetImageMemoryRequirements2KHR") : instance.getProcAddr( "vkGetImageMemoryRequirements2KHR"));
52917 vkGetImageSparseMemoryRequirements = PFN_vkGetImageSparseMemoryRequirements(device ? device.getProcAddr( "vkGetImageSparseMemoryRequirements") : instance.getProcAddr( "vkGetImageSparseMemoryRequirements"));
52918 vkGetImageSparseMemoryRequirements2 = PFN_vkGetImageSparseMemoryRequirements2(device ? device.getProcAddr( "vkGetImageSparseMemoryRequirements2") : instance.getProcAddr( "vkGetImageSparseMemoryRequirements2"));
52919 vkGetImageSparseMemoryRequirements2KHR = PFN_vkGetImageSparseMemoryRequirements2KHR(device ? device.getProcAddr( "vkGetImageSparseMemoryRequirements2KHR") : instance.getProcAddr( "vkGetImageSparseMemoryRequirements2KHR"));
52920 vkGetImageSubresourceLayout = PFN_vkGetImageSubresourceLayout(device ? device.getProcAddr( "vkGetImageSubresourceLayout") : instance.getProcAddr( "vkGetImageSubresourceLayout"));
52921 vkGetInstanceProcAddr = PFN_vkGetInstanceProcAddr(instance.getProcAddr( "vkGetInstanceProcAddr"));
52922#ifdef VK_USE_PLATFORM_ANDROID_ANDROID
52923 vkGetMemoryAndroidHardwareBufferANDROID = PFN_vkGetMemoryAndroidHardwareBufferANDROID(device ? device.getProcAddr( "vkGetMemoryAndroidHardwareBufferANDROID") : instance.getProcAddr( "vkGetMemoryAndroidHardwareBufferANDROID"));
52924#endif /*VK_USE_PLATFORM_ANDROID_ANDROID*/
52925 vkGetMemoryFdKHR = PFN_vkGetMemoryFdKHR(device ? device.getProcAddr( "vkGetMemoryFdKHR") : instance.getProcAddr( "vkGetMemoryFdKHR"));
52926 vkGetMemoryFdPropertiesKHR = PFN_vkGetMemoryFdPropertiesKHR(device ? device.getProcAddr( "vkGetMemoryFdPropertiesKHR") : instance.getProcAddr( "vkGetMemoryFdPropertiesKHR"));
52927 vkGetMemoryHostPointerPropertiesEXT = PFN_vkGetMemoryHostPointerPropertiesEXT(device ? device.getProcAddr( "vkGetMemoryHostPointerPropertiesEXT") : instance.getProcAddr( "vkGetMemoryHostPointerPropertiesEXT"));
52928#ifdef VK_USE_PLATFORM_WIN32_KHR
52929 vkGetMemoryWin32HandleKHR = PFN_vkGetMemoryWin32HandleKHR(device ? device.getProcAddr( "vkGetMemoryWin32HandleKHR") : instance.getProcAddr( "vkGetMemoryWin32HandleKHR"));
52930#endif /*VK_USE_PLATFORM_WIN32_KHR*/
52931#ifdef VK_USE_PLATFORM_WIN32_NV
52932 vkGetMemoryWin32HandleNV = PFN_vkGetMemoryWin32HandleNV(device ? device.getProcAddr( "vkGetMemoryWin32HandleNV") : instance.getProcAddr( "vkGetMemoryWin32HandleNV"));
52933#endif /*VK_USE_PLATFORM_WIN32_NV*/
52934#ifdef VK_USE_PLATFORM_WIN32_KHR
52935 vkGetMemoryWin32HandlePropertiesKHR = PFN_vkGetMemoryWin32HandlePropertiesKHR(device ? device.getProcAddr( "vkGetMemoryWin32HandlePropertiesKHR") : instance.getProcAddr( "vkGetMemoryWin32HandlePropertiesKHR"));
52936#endif /*VK_USE_PLATFORM_WIN32_KHR*/
52937 vkGetPastPresentationTimingGOOGLE = PFN_vkGetPastPresentationTimingGOOGLE(device ? device.getProcAddr( "vkGetPastPresentationTimingGOOGLE") : instance.getProcAddr( "vkGetPastPresentationTimingGOOGLE"));
52938 vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(instance.getProcAddr( "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT"));
52939 vkGetPhysicalDeviceDisplayPlaneProperties2KHR = PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(instance.getProcAddr( "vkGetPhysicalDeviceDisplayPlaneProperties2KHR"));
52940 vkGetPhysicalDeviceDisplayPlanePropertiesKHR = PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(instance.getProcAddr( "vkGetPhysicalDeviceDisplayPlanePropertiesKHR"));
52941 vkGetPhysicalDeviceDisplayProperties2KHR = PFN_vkGetPhysicalDeviceDisplayProperties2KHR(instance.getProcAddr( "vkGetPhysicalDeviceDisplayProperties2KHR"));
52942 vkGetPhysicalDeviceDisplayPropertiesKHR = PFN_vkGetPhysicalDeviceDisplayPropertiesKHR(instance.getProcAddr( "vkGetPhysicalDeviceDisplayPropertiesKHR"));
52943 vkGetPhysicalDeviceExternalBufferProperties = PFN_vkGetPhysicalDeviceExternalBufferProperties(instance.getProcAddr( "vkGetPhysicalDeviceExternalBufferProperties"));
52944 vkGetPhysicalDeviceExternalBufferPropertiesKHR = PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR(instance.getProcAddr( "vkGetPhysicalDeviceExternalBufferPropertiesKHR"));
52945 vkGetPhysicalDeviceExternalFenceProperties = PFN_vkGetPhysicalDeviceExternalFenceProperties(instance.getProcAddr( "vkGetPhysicalDeviceExternalFenceProperties"));
52946 vkGetPhysicalDeviceExternalFencePropertiesKHR = PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR(instance.getProcAddr( "vkGetPhysicalDeviceExternalFencePropertiesKHR"));
52948 vkGetPhysicalDeviceExternalSemaphoreProperties = PFN_vkGetPhysicalDeviceExternalSemaphoreProperties(instance.getProcAddr( "vkGetPhysicalDeviceExternalSemaphoreProperties"));
52950 vkGetPhysicalDeviceFeatures = PFN_vkGetPhysicalDeviceFeatures(instance.getProcAddr( "vkGetPhysicalDeviceFeatures"));
52951 vkGetPhysicalDeviceFeatures2 = PFN_vkGetPhysicalDeviceFeatures2(instance.getProcAddr( "vkGetPhysicalDeviceFeatures2"));
52952 vkGetPhysicalDeviceFeatures2KHR = PFN_vkGetPhysicalDeviceFeatures2KHR(instance.getProcAddr( "vkGetPhysicalDeviceFeatures2KHR"));
52953 vkGetPhysicalDeviceFormatProperties = PFN_vkGetPhysicalDeviceFormatProperties(instance.getProcAddr( "vkGetPhysicalDeviceFormatProperties"));
52954 vkGetPhysicalDeviceFormatProperties2 = PFN_vkGetPhysicalDeviceFormatProperties2(instance.getProcAddr( "vkGetPhysicalDeviceFormatProperties2"));
52955 vkGetPhysicalDeviceFormatProperties2KHR = PFN_vkGetPhysicalDeviceFormatProperties2KHR(instance.getProcAddr( "vkGetPhysicalDeviceFormatProperties2KHR"));
52957 vkGetPhysicalDeviceImageFormatProperties = PFN_vkGetPhysicalDeviceImageFormatProperties(instance.getProcAddr( "vkGetPhysicalDeviceImageFormatProperties"));
52958 vkGetPhysicalDeviceImageFormatProperties2 = PFN_vkGetPhysicalDeviceImageFormatProperties2(instance.getProcAddr( "vkGetPhysicalDeviceImageFormatProperties2"));
52959 vkGetPhysicalDeviceImageFormatProperties2KHR = PFN_vkGetPhysicalDeviceImageFormatProperties2KHR(instance.getProcAddr( "vkGetPhysicalDeviceImageFormatProperties2KHR"));
52960 vkGetPhysicalDeviceMemoryProperties = PFN_vkGetPhysicalDeviceMemoryProperties(instance.getProcAddr( "vkGetPhysicalDeviceMemoryProperties"));
52961 vkGetPhysicalDeviceMemoryProperties2 = PFN_vkGetPhysicalDeviceMemoryProperties2(instance.getProcAddr( "vkGetPhysicalDeviceMemoryProperties2"));
52962 vkGetPhysicalDeviceMemoryProperties2KHR = PFN_vkGetPhysicalDeviceMemoryProperties2KHR(instance.getProcAddr( "vkGetPhysicalDeviceMemoryProperties2KHR"));
52963 vkGetPhysicalDeviceMultisamplePropertiesEXT = PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT(instance.getProcAddr( "vkGetPhysicalDeviceMultisamplePropertiesEXT"));
52964 vkGetPhysicalDevicePresentRectanglesKHR = PFN_vkGetPhysicalDevicePresentRectanglesKHR(instance.getProcAddr( "vkGetPhysicalDevicePresentRectanglesKHR"));
52965 vkGetPhysicalDeviceProperties = PFN_vkGetPhysicalDeviceProperties(instance.getProcAddr( "vkGetPhysicalDeviceProperties"));
52966 vkGetPhysicalDeviceProperties2 = PFN_vkGetPhysicalDeviceProperties2(instance.getProcAddr( "vkGetPhysicalDeviceProperties2"));
52967 vkGetPhysicalDeviceProperties2KHR = PFN_vkGetPhysicalDeviceProperties2KHR(instance.getProcAddr( "vkGetPhysicalDeviceProperties2KHR"));
52968 vkGetPhysicalDeviceQueueFamilyProperties = PFN_vkGetPhysicalDeviceQueueFamilyProperties(instance.getProcAddr( "vkGetPhysicalDeviceQueueFamilyProperties"));
52969 vkGetPhysicalDeviceQueueFamilyProperties2 = PFN_vkGetPhysicalDeviceQueueFamilyProperties2(instance.getProcAddr( "vkGetPhysicalDeviceQueueFamilyProperties2"));
52970 vkGetPhysicalDeviceQueueFamilyProperties2KHR = PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR(instance.getProcAddr( "vkGetPhysicalDeviceQueueFamilyProperties2KHR"));
52971 vkGetPhysicalDeviceSparseImageFormatProperties = PFN_vkGetPhysicalDeviceSparseImageFormatProperties(instance.getProcAddr( "vkGetPhysicalDeviceSparseImageFormatProperties"));
52972 vkGetPhysicalDeviceSparseImageFormatProperties2 = PFN_vkGetPhysicalDeviceSparseImageFormatProperties2(instance.getProcAddr( "vkGetPhysicalDeviceSparseImageFormatProperties2"));
52974 vkGetPhysicalDeviceSurfaceCapabilities2EXT = PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT(instance.getProcAddr( "vkGetPhysicalDeviceSurfaceCapabilities2EXT"));
52975 vkGetPhysicalDeviceSurfaceCapabilities2KHR = PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR(instance.getProcAddr( "vkGetPhysicalDeviceSurfaceCapabilities2KHR"));
52976 vkGetPhysicalDeviceSurfaceCapabilitiesKHR = PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(instance.getProcAddr( "vkGetPhysicalDeviceSurfaceCapabilitiesKHR"));
52977 vkGetPhysicalDeviceSurfaceFormats2KHR = PFN_vkGetPhysicalDeviceSurfaceFormats2KHR(instance.getProcAddr( "vkGetPhysicalDeviceSurfaceFormats2KHR"));
52978 vkGetPhysicalDeviceSurfaceFormatsKHR = PFN_vkGetPhysicalDeviceSurfaceFormatsKHR(instance.getProcAddr( "vkGetPhysicalDeviceSurfaceFormatsKHR"));
52979 vkGetPhysicalDeviceSurfacePresentModesKHR = PFN_vkGetPhysicalDeviceSurfacePresentModesKHR(instance.getProcAddr( "vkGetPhysicalDeviceSurfacePresentModesKHR"));
52980 vkGetPhysicalDeviceSurfaceSupportKHR = PFN_vkGetPhysicalDeviceSurfaceSupportKHR(instance.getProcAddr( "vkGetPhysicalDeviceSurfaceSupportKHR"));
52981#ifdef VK_USE_PLATFORM_WAYLAND_KHR
52982 vkGetPhysicalDeviceWaylandPresentationSupportKHR = PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR(instance.getProcAddr( "vkGetPhysicalDeviceWaylandPresentationSupportKHR"));
52983#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
52984#ifdef VK_USE_PLATFORM_WIN32_KHR
52985 vkGetPhysicalDeviceWin32PresentationSupportKHR = PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR(instance.getProcAddr( "vkGetPhysicalDeviceWin32PresentationSupportKHR"));
52986#endif /*VK_USE_PLATFORM_WIN32_KHR*/
52987#ifdef VK_USE_PLATFORM_XCB_KHR
52988 vkGetPhysicalDeviceXcbPresentationSupportKHR = PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR(instance.getProcAddr( "vkGetPhysicalDeviceXcbPresentationSupportKHR"));
52989#endif /*VK_USE_PLATFORM_XCB_KHR*/
52990#ifdef VK_USE_PLATFORM_XLIB_KHR
52991 vkGetPhysicalDeviceXlibPresentationSupportKHR = PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR(instance.getProcAddr( "vkGetPhysicalDeviceXlibPresentationSupportKHR"));
52992#endif /*VK_USE_PLATFORM_XLIB_KHR*/
52993 vkGetPipelineCacheData = PFN_vkGetPipelineCacheData(device ? device.getProcAddr( "vkGetPipelineCacheData") : instance.getProcAddr( "vkGetPipelineCacheData"));
52994 vkGetQueryPoolResults = PFN_vkGetQueryPoolResults(device ? device.getProcAddr( "vkGetQueryPoolResults") : instance.getProcAddr( "vkGetQueryPoolResults"));
52995 vkGetQueueCheckpointDataNV = PFN_vkGetQueueCheckpointDataNV(device ? device.getProcAddr( "vkGetQueueCheckpointDataNV") : instance.getProcAddr( "vkGetQueueCheckpointDataNV"));
52996#ifdef VK_USE_PLATFORM_XLIB_XRANDR_NV
52997 vkGetRandROutputDisplayEXT = PFN_vkGetRandROutputDisplayEXT(instance.getProcAddr( "vkGetRandROutputDisplayEXT"));
52998#endif /*VK_USE_PLATFORM_XLIB_XRANDR_NV*/
52999 vkGetRayTracingShaderGroupHandlesNV = PFN_vkGetRayTracingShaderGroupHandlesNV(device ? device.getProcAddr( "vkGetRayTracingShaderGroupHandlesNV") : instance.getProcAddr( "vkGetRayTracingShaderGroupHandlesNV"));
53000 vkGetRefreshCycleDurationGOOGLE = PFN_vkGetRefreshCycleDurationGOOGLE(device ? device.getProcAddr( "vkGetRefreshCycleDurationGOOGLE") : instance.getProcAddr( "vkGetRefreshCycleDurationGOOGLE"));
53001 vkGetRenderAreaGranularity = PFN_vkGetRenderAreaGranularity(device ? device.getProcAddr( "vkGetRenderAreaGranularity") : instance.getProcAddr( "vkGetRenderAreaGranularity"));
53002 vkGetSemaphoreFdKHR = PFN_vkGetSemaphoreFdKHR(device ? device.getProcAddr( "vkGetSemaphoreFdKHR") : instance.getProcAddr( "vkGetSemaphoreFdKHR"));
53003#ifdef VK_USE_PLATFORM_WIN32_KHR
53004 vkGetSemaphoreWin32HandleKHR = PFN_vkGetSemaphoreWin32HandleKHR(device ? device.getProcAddr( "vkGetSemaphoreWin32HandleKHR") : instance.getProcAddr( "vkGetSemaphoreWin32HandleKHR"));
53005#endif /*VK_USE_PLATFORM_WIN32_KHR*/
53006 vkGetShaderInfoAMD = PFN_vkGetShaderInfoAMD(device ? device.getProcAddr( "vkGetShaderInfoAMD") : instance.getProcAddr( "vkGetShaderInfoAMD"));
53007 vkGetSwapchainCounterEXT = PFN_vkGetSwapchainCounterEXT(device ? device.getProcAddr( "vkGetSwapchainCounterEXT") : instance.getProcAddr( "vkGetSwapchainCounterEXT"));
53008 vkGetSwapchainImagesKHR = PFN_vkGetSwapchainImagesKHR(device ? device.getProcAddr( "vkGetSwapchainImagesKHR") : instance.getProcAddr( "vkGetSwapchainImagesKHR"));
53009 vkGetSwapchainStatusKHR = PFN_vkGetSwapchainStatusKHR(device ? device.getProcAddr( "vkGetSwapchainStatusKHR") : instance.getProcAddr( "vkGetSwapchainStatusKHR"));
53010 vkGetValidationCacheDataEXT = PFN_vkGetValidationCacheDataEXT(device ? device.getProcAddr( "vkGetValidationCacheDataEXT") : instance.getProcAddr( "vkGetValidationCacheDataEXT"));
53011 vkImportFenceFdKHR = PFN_vkImportFenceFdKHR(device ? device.getProcAddr( "vkImportFenceFdKHR") : instance.getProcAddr( "vkImportFenceFdKHR"));
53012#ifdef VK_USE_PLATFORM_WIN32_KHR
53013 vkImportFenceWin32HandleKHR = PFN_vkImportFenceWin32HandleKHR(device ? device.getProcAddr( "vkImportFenceWin32HandleKHR") : instance.getProcAddr( "vkImportFenceWin32HandleKHR"));
53014#endif /*VK_USE_PLATFORM_WIN32_KHR*/
53015 vkImportSemaphoreFdKHR = PFN_vkImportSemaphoreFdKHR(device ? device.getProcAddr( "vkImportSemaphoreFdKHR") : instance.getProcAddr( "vkImportSemaphoreFdKHR"));
53016#ifdef VK_USE_PLATFORM_WIN32_KHR
53017 vkImportSemaphoreWin32HandleKHR = PFN_vkImportSemaphoreWin32HandleKHR(device ? device.getProcAddr( "vkImportSemaphoreWin32HandleKHR") : instance.getProcAddr( "vkImportSemaphoreWin32HandleKHR"));
53018#endif /*VK_USE_PLATFORM_WIN32_KHR*/
53019 vkInvalidateMappedMemoryRanges = PFN_vkInvalidateMappedMemoryRanges(device ? device.getProcAddr( "vkInvalidateMappedMemoryRanges") : instance.getProcAddr( "vkInvalidateMappedMemoryRanges"));
53020 vkMapMemory = PFN_vkMapMemory(device ? device.getProcAddr( "vkMapMemory") : instance.getProcAddr( "vkMapMemory"));
53021 vkMergePipelineCaches = PFN_vkMergePipelineCaches(device ? device.getProcAddr( "vkMergePipelineCaches") : instance.getProcAddr( "vkMergePipelineCaches"));
53022 vkMergeValidationCachesEXT = PFN_vkMergeValidationCachesEXT(device ? device.getProcAddr( "vkMergeValidationCachesEXT") : instance.getProcAddr( "vkMergeValidationCachesEXT"));
53023 vkQueueBeginDebugUtilsLabelEXT = PFN_vkQueueBeginDebugUtilsLabelEXT(device ? device.getProcAddr( "vkQueueBeginDebugUtilsLabelEXT") : instance.getProcAddr( "vkQueueBeginDebugUtilsLabelEXT"));
53024 vkQueueBindSparse = PFN_vkQueueBindSparse(device ? device.getProcAddr( "vkQueueBindSparse") : instance.getProcAddr( "vkQueueBindSparse"));
53025 vkQueueEndDebugUtilsLabelEXT = PFN_vkQueueEndDebugUtilsLabelEXT(device ? device.getProcAddr( "vkQueueEndDebugUtilsLabelEXT") : instance.getProcAddr( "vkQueueEndDebugUtilsLabelEXT"));
53026 vkQueueInsertDebugUtilsLabelEXT = PFN_vkQueueInsertDebugUtilsLabelEXT(device ? device.getProcAddr( "vkQueueInsertDebugUtilsLabelEXT") : instance.getProcAddr( "vkQueueInsertDebugUtilsLabelEXT"));
53027 vkQueuePresentKHR = PFN_vkQueuePresentKHR(device ? device.getProcAddr( "vkQueuePresentKHR") : instance.getProcAddr( "vkQueuePresentKHR"));
53028 vkQueueSubmit = PFN_vkQueueSubmit(device ? device.getProcAddr( "vkQueueSubmit") : instance.getProcAddr( "vkQueueSubmit"));
53029 vkQueueWaitIdle = PFN_vkQueueWaitIdle(device ? device.getProcAddr( "vkQueueWaitIdle") : instance.getProcAddr( "vkQueueWaitIdle"));
53030 vkRegisterDeviceEventEXT = PFN_vkRegisterDeviceEventEXT(device ? device.getProcAddr( "vkRegisterDeviceEventEXT") : instance.getProcAddr( "vkRegisterDeviceEventEXT"));
53031 vkRegisterDisplayEventEXT = PFN_vkRegisterDisplayEventEXT(device ? device.getProcAddr( "vkRegisterDisplayEventEXT") : instance.getProcAddr( "vkRegisterDisplayEventEXT"));
53032 vkRegisterObjectsNVX = PFN_vkRegisterObjectsNVX(device ? device.getProcAddr( "vkRegisterObjectsNVX") : instance.getProcAddr( "vkRegisterObjectsNVX"));
53033 vkReleaseDisplayEXT = PFN_vkReleaseDisplayEXT(instance.getProcAddr( "vkReleaseDisplayEXT"));
53034 vkResetCommandBuffer = PFN_vkResetCommandBuffer(device ? device.getProcAddr( "vkResetCommandBuffer") : instance.getProcAddr( "vkResetCommandBuffer"));
53035 vkResetCommandPool = PFN_vkResetCommandPool(device ? device.getProcAddr( "vkResetCommandPool") : instance.getProcAddr( "vkResetCommandPool"));
53036 vkResetDescriptorPool = PFN_vkResetDescriptorPool(device ? device.getProcAddr( "vkResetDescriptorPool") : instance.getProcAddr( "vkResetDescriptorPool"));
53037 vkResetEvent = PFN_vkResetEvent(device ? device.getProcAddr( "vkResetEvent") : instance.getProcAddr( "vkResetEvent"));
53038 vkResetFences = PFN_vkResetFences(device ? device.getProcAddr( "vkResetFences") : instance.getProcAddr( "vkResetFences"));
53039 vkSetDebugUtilsObjectNameEXT = PFN_vkSetDebugUtilsObjectNameEXT(device ? device.getProcAddr( "vkSetDebugUtilsObjectNameEXT") : instance.getProcAddr( "vkSetDebugUtilsObjectNameEXT"));
53040 vkSetDebugUtilsObjectTagEXT = PFN_vkSetDebugUtilsObjectTagEXT(device ? device.getProcAddr( "vkSetDebugUtilsObjectTagEXT") : instance.getProcAddr( "vkSetDebugUtilsObjectTagEXT"));
53041 vkSetEvent = PFN_vkSetEvent(device ? device.getProcAddr( "vkSetEvent") : instance.getProcAddr( "vkSetEvent"));
53042 vkSetHdrMetadataEXT = PFN_vkSetHdrMetadataEXT(device ? device.getProcAddr( "vkSetHdrMetadataEXT") : instance.getProcAddr( "vkSetHdrMetadataEXT"));
53043 vkSubmitDebugUtilsMessageEXT = PFN_vkSubmitDebugUtilsMessageEXT(instance.getProcAddr( "vkSubmitDebugUtilsMessageEXT"));
53044 vkTrimCommandPool = PFN_vkTrimCommandPool(device ? device.getProcAddr( "vkTrimCommandPool") : instance.getProcAddr( "vkTrimCommandPool"));
53045 vkTrimCommandPoolKHR = PFN_vkTrimCommandPoolKHR(device ? device.getProcAddr( "vkTrimCommandPoolKHR") : instance.getProcAddr( "vkTrimCommandPoolKHR"));
53046 vkUnmapMemory = PFN_vkUnmapMemory(device ? device.getProcAddr( "vkUnmapMemory") : instance.getProcAddr( "vkUnmapMemory"));
53047 vkUnregisterObjectsNVX = PFN_vkUnregisterObjectsNVX(device ? device.getProcAddr( "vkUnregisterObjectsNVX") : instance.getProcAddr( "vkUnregisterObjectsNVX"));
53048 vkUpdateDescriptorSetWithTemplate = PFN_vkUpdateDescriptorSetWithTemplate(device ? device.getProcAddr( "vkUpdateDescriptorSetWithTemplate") : instance.getProcAddr( "vkUpdateDescriptorSetWithTemplate"));
53049 vkUpdateDescriptorSetWithTemplateKHR = PFN_vkUpdateDescriptorSetWithTemplateKHR(device ? device.getProcAddr( "vkUpdateDescriptorSetWithTemplateKHR") : instance.getProcAddr( "vkUpdateDescriptorSetWithTemplateKHR"));
53050 vkUpdateDescriptorSets = PFN_vkUpdateDescriptorSets(device ? device.getProcAddr( "vkUpdateDescriptorSets") : instance.getProcAddr( "vkUpdateDescriptorSets"));
53051 vkWaitForFences = PFN_vkWaitForFences(device ? device.getProcAddr( "vkWaitForFences") : instance.getProcAddr( "vkWaitForFences"));
53052 }
53053 };
53054} // namespace VULKAN_HPP_NAMESPACE
53055
53056#endif
unsigned short uint16_t
unsigned int uint32_t
unsigned long long uint64_t
signed int int32_t
unsigned char uint8_t
SDL_PRINTF_FORMAT_STRING const char int SDL_PRINTF_FORMAT_STRING const char int SDL_PRINTF_FORMAT_STRING const char int SDL_PRINTF_FORMAT_STRING const char const char SDL_SCANF_FORMAT_STRING const char return SDL_ThreadFunction const char void return Uint32 return Uint32 void
SDL_PRINTF_FORMAT_STRING const char int SDL_PRINTF_FORMAT_STRING const char int SDL_PRINTF_FORMAT_STRING const char int SDL_PRINTF_FORMAT_STRING const char const char SDL_SCANF_FORMAT_STRING const char return SDL_ThreadFunction const char void return Uint32 return Uint32 SDL_AssertionHandler void SDL_SpinLock SDL_atomic_t int int return SDL_atomic_t return void void void return void return int return SDL_AudioSpec SDL_AudioSpec return int int return return int SDL_RWops int SDL_AudioSpec Uint8 Uint32 * e
SDL_PRINTF_FORMAT_STRING const char int SDL_PRINTF_FORMAT_STRING const char int SDL_PRINTF_FORMAT_STRING const char int SDL_PRINTF_FORMAT_STRING const char const char SDL_SCANF_FORMAT_STRING const char return SDL_ThreadFunction const char void return Uint32 return Uint32 SDL_AssertionHandler void SDL_SpinLock SDL_atomic_t int int return SDL_atomic_t return void void void return void return int return SDL_AudioSpec SDL_AudioSpec return int int return return int SDL_RWops int SDL_AudioSpec Uint8 ** d
#define memcpy
Definition: SDL_malloc.c:630
GLeglImageOES image
Definition: SDL_opengl.h:2148
GLint GLint GLint GLint GLint GLint y
Definition: SDL_opengl.h:1574
GLint level
Definition: SDL_opengl.h:1572
GLuint GLuint end
Definition: SDL_opengl.h:1571
const GLdouble * v
Definition: SDL_opengl.h:2064
GLuint GLuint GLsizei count
Definition: SDL_opengl.h:1571
GLdouble GLdouble t
Definition: SDL_opengl.h:2071
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: SDL_opengl.h:1974
GLint GLint GLsizei width
Definition: SDL_opengl.h:1572
GLint GLint GLsizei GLsizei GLsizei depth
Definition: SDL_opengl.h:1572
GLdouble GLdouble GLdouble r
Definition: SDL_opengl.h:2079
GLint GLint GLint GLint GLint x
Definition: SDL_opengl.h:1574
GLint GLint GLsizei GLsizei height
Definition: SDL_opengl.h:1572
GLuint GLuint GLsizei GLenum type
Definition: SDL_opengl.h:1571
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: SDL_opengl.h:1572
GLboolean GLboolean GLboolean b
struct _cl_event * event
GLuint GLenum GLenum transform
GLsizei stride
GLenum query
GLuint GLsizei const GLuint const GLintptr * offsets
const GLuint * buffers
GLenum mode
GLsizei samples
GLenum src
const GLuint * pipelines
GLuint64EXT * result
GLenum GLenum GLuint components
GLuint color
GLenum GLsizei dataSize
GLuint sampler
GLenum array
GLintptr offset
GLuint shader
GLuint index
GLuint GLuint GLchar GLuint GLchar GLuint * counterOffset
GLbitfield GLuint64 timeout
GLuint * fences
GLint location
GLenum GLint * range
GLboolean GLboolean GLboolean GLboolean a
GLint reference
GLuint GLsizei const GLchar * message
GLuint buffer
GLenum GLenum dst
GLuint divisor
GLenum GLsizei GLsizei GLint * values
GLint GLint GLint GLint GLint GLint GLint GLbitfield GLenum filter
GLenum GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const void * bits
GLuint const GLchar * name
GLdouble GLdouble z
GLboolean GLboolean g
GLenum GLsizei GLsizei GLsizei GLsizei layers
GLuint GLsizei const GLuint const GLintptr const GLsizeiptr * sizes
GLuint framebuffer
GLsizeiptr size
GLbitfield flags
GLsizei const GLenum * attachments
GLuint object
GLsizei const GLfloat * value
GLenum GLuint GLint GLint layer
const GLchar * marker
const void GLsizei drawCount
GLenum attachment
GLsizei const GLchar *const * string
GLint GLfloat GLint stencil
GLuint counter
GLubyte GLubyte GLubyte GLubyte w
GLsizeiptr const void GLenum usage
return Display return Display Bool Bool int int int return Display XEvent Bool(*) XPointer return Display return Display dpy)
Definition: SDL_x11sym.h:44
return Display return Display Bool Bool int int int return Display XEvent Bool(*) XPointer return Display return Display Drawable _Xconst char unsigned int unsigned int return Display Pixmap Pixmap XColor XColor unsigned int unsigned int return Display _Xconst char char int char return Display Visual unsigned int int int char unsigned int unsigned int in i)
Definition: SDL_x11sym.h:50
bool operator!=(AccelerationStructureNV const &rhs) const
Definition: vulkan.hpp:4657
VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureNV(VkAccelerationStructureNV accelerationStructureNV)
Definition: vulkan.hpp:4634
VkAccelerationStructureNV m_accelerationStructureNV
Definition: vulkan.hpp:4685
VULKAN_HPP_CONSTEXPR AccelerationStructureNV()
Definition: vulkan.hpp:4626
bool operator==(AccelerationStructureNV const &rhs) const
Definition: vulkan.hpp:4652
AccelerationStructureNV & operator=(std::nullptr_t)
Definition: vulkan.hpp:4646
VULKAN_HPP_CONSTEXPR AccelerationStructureNV(std::nullptr_t)
Definition: vulkan.hpp:4630
bool operator<(AccelerationStructureNV const &rhs) const
Definition: vulkan.hpp:4662
VULKAN_HPP_CONSTEXPR ArrayProxy(std::nullptr_t)
Definition: vulkan.hpp:290
ArrayProxy(std::array< typename std::remove_const< T >::type, N > &data)
Definition: vulkan.hpp:306
ArrayProxy(uint32_t count, T *ptr)
Definition: vulkan.hpp:300
ArrayProxy(std::vector< typename std::remove_const< T >::type, Allocator > &data)
Definition: vulkan.hpp:318
ArrayProxy(std::initializer_list< T > const &data)
Definition: vulkan.hpp:329
ArrayProxy(std::vector< typename std::remove_const< T >::type, Allocator > const &data)
Definition: vulkan.hpp:324
ArrayProxy(std::array< typename std::remove_const< T >::type, N > const &data)
Definition: vulkan.hpp:312
Buffer & operator=(std::nullptr_t)
Definition: vulkan.hpp:3101
bool operator==(Buffer const &rhs) const
Definition: vulkan.hpp:3107
VULKAN_HPP_TYPESAFE_EXPLICIT Buffer(VkBuffer buffer)
Definition: vulkan.hpp:3089
bool operator<(Buffer const &rhs) const
Definition: vulkan.hpp:3117
VULKAN_HPP_CONSTEXPR Buffer()
Definition: vulkan.hpp:3081
VULKAN_HPP_CONSTEXPR Buffer(std::nullptr_t)
Definition: vulkan.hpp:3085
bool operator!=(Buffer const &rhs) const
Definition: vulkan.hpp:3112
bool operator<(BufferView const &rhs) const
Definition: vulkan.hpp:3184
bool operator!=(BufferView const &rhs) const
Definition: vulkan.hpp:3179
VULKAN_HPP_CONSTEXPR BufferView()
Definition: vulkan.hpp:3148
BufferView & operator=(std::nullptr_t)
Definition: vulkan.hpp:3168
VULKAN_HPP_TYPESAFE_EXPLICIT BufferView(VkBufferView bufferView)
Definition: vulkan.hpp:3156
VULKAN_HPP_CONSTEXPR BufferView(std::nullptr_t)
Definition: vulkan.hpp:3152
bool operator==(BufferView const &rhs) const
Definition: vulkan.hpp:3174
void drawIndirect(Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d=Dispatch()) const
void endTransformFeedbackEXT(uint32_t firstCounterBuffer, ArrayProxy< const Buffer > counterBuffers, ArrayProxy< const DeviceSize > counterBufferOffsets, Dispatch const &d=Dispatch()) const
void nextSubpass2KHR(const SubpassBeginInfoKHR &subpassBeginInfo, const SubpassEndInfoKHR &subpassEndInfo, Dispatch const &d=Dispatch()) const
void drawIndirectCountKHR(Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d=Dispatch()) const
void clearColorImage(Image image, ImageLayout imageLayout, const ClearColorValue *pColor, uint32_t rangeCount, const ImageSubresourceRange *pRanges, Dispatch const &d=Dispatch()) const
void drawIndexed(uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance, Dispatch const &d=Dispatch()) const
void copyImageToBuffer(Image srcImage, ImageLayout srcImageLayout, Buffer dstBuffer, uint32_t regionCount, const BufferImageCopy *pRegions, Dispatch const &d=Dispatch()) const
void buildAccelerationStructureNV(const AccelerationStructureInfoNV *pInfo, Buffer instanceData, DeviceSize instanceOffset, Bool32 update, AccelerationStructureNV dst, AccelerationStructureNV src, Buffer scratch, DeviceSize scratchOffset, Dispatch const &d=Dispatch()) const
ResultValueType< void >::type begin(const CommandBufferBeginInfo &beginInfo, Dispatch const &d=Dispatch()) const
void bindShadingRateImageNV(ImageView imageView, ImageLayout imageLayout, Dispatch const &d=Dispatch()) const
void bindVertexBuffers(uint32_t firstBinding, uint32_t bindingCount, const Buffer *pBuffers, const DeviceSize *pOffsets, Dispatch const &d=Dispatch()) const
void setScissor(uint32_t firstScissor, uint32_t scissorCount, const Rect2D *pScissors, Dispatch const &d=Dispatch()) const
void dispatchBaseKHR(uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d=Dispatch()) const
void beginTransformFeedbackEXT(uint32_t firstCounterBuffer, ArrayProxy< const Buffer > counterBuffers, ArrayProxy< const DeviceSize > counterBufferOffsets, Dispatch const &d=Dispatch()) const
void setScissor(uint32_t firstScissor, ArrayProxy< const Rect2D > scissors, Dispatch const &d=Dispatch()) const
void endRenderPass(Dispatch const &d=Dispatch()) const
void clearDepthStencilImage(Image image, ImageLayout imageLayout, const ClearDepthStencilValue &depthStencil, ArrayProxy< const ImageSubresourceRange > ranges, Dispatch const &d=Dispatch()) const
void insertDebugUtilsLabelEXT(const DebugUtilsLabelEXT &labelInfo, Dispatch const &d=Dispatch()) const
void bindTransformFeedbackBuffersEXT(uint32_t firstBinding, ArrayProxy< const Buffer > buffers, ArrayProxy< const DeviceSize > offsets, ArrayProxy< const DeviceSize > sizes, Dispatch const &d=Dispatch()) const
void waitEvents(uint32_t eventCount, const Event *pEvents, PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const MemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const BufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const ImageMemoryBarrier *pImageMemoryBarriers, Dispatch const &d=Dispatch()) const
void pushDescriptorSetWithTemplateKHR(DescriptorUpdateTemplate descriptorUpdateTemplate, PipelineLayout layout, uint32_t set, const void *pData, Dispatch const &d=Dispatch()) const
void nextSubpass(SubpassContents contents, Dispatch const &d=Dispatch()) const
void resolveImage(Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageResolve *pRegions, Dispatch const &d=Dispatch()) const
void blitImage(Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy< const ImageBlit > regions, Filter filter, Dispatch const &d=Dispatch()) const
void pipelineBarrier(PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, DependencyFlags dependencyFlags, ArrayProxy< const MemoryBarrier > memoryBarriers, ArrayProxy< const BufferMemoryBarrier > bufferMemoryBarriers, ArrayProxy< const ImageMemoryBarrier > imageMemoryBarriers, Dispatch const &d=Dispatch()) const
void copyImage(Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageCopy *pRegions, Dispatch const &d=Dispatch()) const
void setDepthBias(float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor, Dispatch const &d=Dispatch()) const
void setStencilReference(StencilFaceFlags faceMask, uint32_t reference, Dispatch const &d=Dispatch()) const
void bindIndexBuffer(Buffer buffer, DeviceSize offset, IndexType indexType, Dispatch const &d=Dispatch()) const
void drawIndexedIndirectCountAMD(Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d=Dispatch()) const
void copyBufferToImage(Buffer srcBuffer, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const BufferImageCopy *pRegions, Dispatch const &d=Dispatch()) const
void writeAccelerationStructuresPropertiesNV(uint32_t accelerationStructureCount, const AccelerationStructureNV *pAccelerationStructures, QueryType queryType, QueryPool queryPool, uint32_t firstQuery, Dispatch const &d=Dispatch()) const
void bindPipeline(PipelineBindPoint pipelineBindPoint, Pipeline pipeline, Dispatch const &d=Dispatch()) const
void dispatch(uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d=Dispatch()) const
ResultValueType< void >::type reset(CommandBufferResetFlags flags, Dispatch const &d=Dispatch()) const
VULKAN_HPP_TYPESAFE_EXPLICIT CommandBuffer(VkCommandBuffer commandBuffer)
Definition: vulkan.hpp:37722
void resolveImage(Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy< const ImageResolve > regions, Dispatch const &d=Dispatch()) const
void copyImageToBuffer(Image srcImage, ImageLayout srcImageLayout, Buffer dstBuffer, ArrayProxy< const BufferImageCopy > regions, Dispatch const &d=Dispatch()) const
void setViewportShadingRatePaletteNV(uint32_t firstViewport, uint32_t viewportCount, const ShadingRatePaletteNV *pShadingRatePalettes, Dispatch const &d=Dispatch()) const
void clearDepthStencilImage(Image image, ImageLayout imageLayout, const ClearDepthStencilValue *pDepthStencil, uint32_t rangeCount, const ImageSubresourceRange *pRanges, Dispatch const &d=Dispatch()) const
void updateBuffer(Buffer dstBuffer, DeviceSize dstOffset, DeviceSize dataSize, const void *pData, Dispatch const &d=Dispatch()) const
void setCoarseSampleOrderNV(CoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const CoarseSampleOrderCustomNV *pCustomSampleOrders, Dispatch const &d=Dispatch()) const
void processCommandsNVX(const CmdProcessCommandsInfoNVX &processCommandsInfo, Dispatch const &d=Dispatch()) const
void setViewportWScalingNV(uint32_t firstViewport, uint32_t viewportCount, const ViewportWScalingNV *pViewportWScalings, Dispatch const &d=Dispatch()) const
void debugMarkerBeginEXT(const DebugMarkerMarkerInfoEXT *pMarkerInfo, Dispatch const &d=Dispatch()) const
void reserveSpaceForCommandsNVX(const CmdReserveSpaceForCommandsInfoNVX &reserveSpaceInfo, Dispatch const &d=Dispatch()) const
void endRenderPass2KHR(const SubpassEndInfoKHR &subpassEndInfo, Dispatch const &d=Dispatch()) const
void beginRenderPass2KHR(const RenderPassBeginInfo &renderPassBegin, const SubpassBeginInfoKHR &subpassBeginInfo, Dispatch const &d=Dispatch()) const
void drawMeshTasksIndirectCountNV(Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d=Dispatch()) const
void drawIndirectByteCountEXT(uint32_t instanceCount, uint32_t firstInstance, Buffer counterBuffer, DeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride, Dispatch const &d=Dispatch()) const
void writeBufferMarkerAMD(PipelineStageFlagBits pipelineStage, Buffer dstBuffer, DeviceSize dstOffset, uint32_t marker, Dispatch const &d=Dispatch()) const
void setCheckpointNV(const void *pCheckpointMarker, Dispatch const &d=Dispatch()) const
void setDiscardRectangleEXT(uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const Rect2D *pDiscardRectangles, Dispatch const &d=Dispatch()) const
VULKAN_HPP_CONSTEXPR CommandBuffer(std::nullptr_t)
Definition: vulkan.hpp:37718
void copyQueryPoolResults(QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Buffer dstBuffer, DeviceSize dstOffset, DeviceSize stride, QueryResultFlags flags, Dispatch const &d=Dispatch()) const
void clearColorImage(Image image, ImageLayout imageLayout, const ClearColorValue &color, ArrayProxy< const ImageSubresourceRange > ranges, Dispatch const &d=Dispatch()) const
void beginRenderPass2KHR(const RenderPassBeginInfo *pRenderPassBegin, const SubpassBeginInfoKHR *pSubpassBeginInfo, Dispatch const &d=Dispatch()) const
void clearAttachments(ArrayProxy< const ClearAttachment > attachments, ArrayProxy< const ClearRect > rects, Dispatch const &d=Dispatch()) const
void pushConstants(PipelineLayout layout, ShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void *pValues, Dispatch const &d=Dispatch()) const
void fillBuffer(Buffer dstBuffer, DeviceSize dstOffset, DeviceSize size, uint32_t data, Dispatch const &d=Dispatch()) const
void pushDescriptorSetKHR(PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t set, ArrayProxy< const WriteDescriptorSet > descriptorWrites, Dispatch const &d=Dispatch()) const
void drawIndirectCountAMD(Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d=Dispatch()) const
void setDeviceMask(uint32_t deviceMask, Dispatch const &d=Dispatch()) const
void resetQueryPool(QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const &d=Dispatch()) const
void copyBuffer(Buffer srcBuffer, Buffer dstBuffer, ArrayProxy< const BufferCopy > regions, Dispatch const &d=Dispatch()) const
void debugMarkerBeginEXT(const DebugMarkerMarkerInfoEXT &markerInfo, Dispatch const &d=Dispatch()) const
void draw(uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance, Dispatch const &d=Dispatch()) const
void beginTransformFeedbackEXT(uint32_t firstCounterBuffer, uint32_t counterBufferCount, const Buffer *pCounterBuffers, const DeviceSize *pCounterBufferOffsets, Dispatch const &d=Dispatch()) const
void debugMarkerEndEXT(Dispatch const &d=Dispatch()) const
CommandBuffer & operator=(std::nullptr_t)
Definition: vulkan.hpp:37734
void debugMarkerInsertEXT(const DebugMarkerMarkerInfoEXT &markerInfo, Dispatch const &d=Dispatch()) const
void beginDebugUtilsLabelEXT(const DebugUtilsLabelEXT *pLabelInfo, Dispatch const &d=Dispatch()) const
void bindTransformFeedbackBuffersEXT(uint32_t firstBinding, uint32_t bindingCount, const Buffer *pBuffers, const DeviceSize *pOffsets, const DeviceSize *pSizes, Dispatch const &d=Dispatch()) const
void setStencilCompareMask(StencilFaceFlags faceMask, uint32_t compareMask, Dispatch const &d=Dispatch()) const
void copyBufferToImage(Buffer srcBuffer, Image dstImage, ImageLayout dstImageLayout, ArrayProxy< const BufferImageCopy > regions, Dispatch const &d=Dispatch()) const
void setViewportShadingRatePaletteNV(uint32_t firstViewport, ArrayProxy< const ShadingRatePaletteNV > shadingRatePalettes, Dispatch const &d=Dispatch()) const
void setSampleLocationsEXT(const SampleLocationsInfoEXT &sampleLocationsInfo, Dispatch const &d=Dispatch()) const
bool operator!=(CommandBuffer const &rhs) const
Definition: vulkan.hpp:37745
void beginQueryIndexedEXT(QueryPool queryPool, uint32_t query, QueryControlFlags flags, uint32_t index, Dispatch const &d=Dispatch()) const
void writeAccelerationStructuresPropertiesNV(ArrayProxy< const AccelerationStructureNV > accelerationStructures, QueryType queryType, QueryPool queryPool, uint32_t firstQuery, Dispatch const &d=Dispatch()) const
void setExclusiveScissorNV(uint32_t firstExclusiveScissor, ArrayProxy< const Rect2D > exclusiveScissors, Dispatch const &d=Dispatch()) const
void endDebugUtilsLabelEXT(Dispatch const &d=Dispatch()) const
void copyImage(Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy< const ImageCopy > regions, Dispatch const &d=Dispatch()) const
void resetEvent(Event event, PipelineStageFlags stageMask, Dispatch const &d=Dispatch()) const
void blitImage(Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageBlit *pRegions, Filter filter, Dispatch const &d=Dispatch()) const
void setExclusiveScissorNV(uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const Rect2D *pExclusiveScissors, Dispatch const &d=Dispatch()) const
void beginDebugUtilsLabelEXT(const DebugUtilsLabelEXT &labelInfo, Dispatch const &d=Dispatch()) const
void copyBuffer(Buffer srcBuffer, Buffer dstBuffer, uint32_t regionCount, const BufferCopy *pRegions, Dispatch const &d=Dispatch()) const
void setBlendConstants(const float blendConstants[4], Dispatch const &d=Dispatch()) const
void setViewport(uint32_t firstViewport, ArrayProxy< const Viewport > viewports, Dispatch const &d=Dispatch()) const
void executeCommands(ArrayProxy< const CommandBuffer > commandBuffers, Dispatch const &d=Dispatch()) const
void setLineWidth(float lineWidth, Dispatch const &d=Dispatch()) const
void setDiscardRectangleEXT(uint32_t firstDiscardRectangle, ArrayProxy< const Rect2D > discardRectangles, Dispatch const &d=Dispatch()) const
void clearAttachments(uint32_t attachmentCount, const ClearAttachment *pAttachments, uint32_t rectCount, const ClearRect *pRects, Dispatch const &d=Dispatch()) const
void insertDebugUtilsLabelEXT(const DebugUtilsLabelEXT *pLabelInfo, Dispatch const &d=Dispatch()) const
void dispatchBase(uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const &d=Dispatch()) const
void endQuery(QueryPool queryPool, uint32_t query, Dispatch const &d=Dispatch()) const
void setSampleLocationsEXT(const SampleLocationsInfoEXT *pSampleLocationsInfo, Dispatch const &d=Dispatch()) const
void endQueryIndexedEXT(QueryPool queryPool, uint32_t query, uint32_t index, Dispatch const &d=Dispatch()) const
void beginQuery(QueryPool queryPool, uint32_t query, QueryControlFlags flags, Dispatch const &d=Dispatch()) const
void beginConditionalRenderingEXT(const ConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin, Dispatch const &d=Dispatch()) const
bool operator==(CommandBuffer const &rhs) const
Definition: vulkan.hpp:37740
VULKAN_HPP_CONSTEXPR CommandBuffer()
Definition: vulkan.hpp:37714
void drawIndexedIndirectCountKHR(Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, Dispatch const &d=Dispatch()) const
void pushConstants(PipelineLayout layout, ShaderStageFlags stageFlags, uint32_t offset, ArrayProxy< const T > values, Dispatch const &d=Dispatch()) const
void drawIndexedIndirect(Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d=Dispatch()) const
ResultValueType< void >::type end(Dispatch const &d=Dispatch()) const
void setViewportWScalingNV(uint32_t firstViewport, ArrayProxy< const ViewportWScalingNV > viewportWScalings, Dispatch const &d=Dispatch()) const
bool operator<(CommandBuffer const &rhs) const
Definition: vulkan.hpp:37750
void drawMeshTasksIndirectNV(Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const &d=Dispatch()) const
void bindDescriptorSets(PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const DescriptorSet *pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t *pDynamicOffsets, Dispatch const &d=Dispatch()) const
void setViewport(uint32_t firstViewport, uint32_t viewportCount, const Viewport *pViewports, Dispatch const &d=Dispatch()) const
void beginRenderPass(const RenderPassBeginInfo *pRenderPassBegin, SubpassContents contents, Dispatch const &d=Dispatch()) const
void traceRaysNV(Buffer raygenShaderBindingTableBuffer, DeviceSize raygenShaderBindingOffset, Buffer missShaderBindingTableBuffer, DeviceSize missShaderBindingOffset, DeviceSize missShaderBindingStride, Buffer hitShaderBindingTableBuffer, DeviceSize hitShaderBindingOffset, DeviceSize hitShaderBindingStride, Buffer callableShaderBindingTableBuffer, DeviceSize callableShaderBindingOffset, DeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth, Dispatch const &d=Dispatch()) const
void debugMarkerInsertEXT(const DebugMarkerMarkerInfoEXT *pMarkerInfo, Dispatch const &d=Dispatch()) const
void bindDescriptorSets(PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t firstSet, ArrayProxy< const DescriptorSet > descriptorSets, ArrayProxy< const uint32_t > dynamicOffsets, Dispatch const &d=Dispatch()) const
void processCommandsNVX(const CmdProcessCommandsInfoNVX *pProcessCommandsInfo, Dispatch const &d=Dispatch()) const
void bindVertexBuffers(uint32_t firstBinding, ArrayProxy< const Buffer > buffers, ArrayProxy< const DeviceSize > offsets, Dispatch const &d=Dispatch()) const
void pipelineBarrier(PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, DependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const MemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const BufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const ImageMemoryBarrier *pImageMemoryBarriers, Dispatch const &d=Dispatch()) const
Result begin(const CommandBufferBeginInfo *pBeginInfo, Dispatch const &d=Dispatch()) const
void copyAccelerationStructureNV(AccelerationStructureNV dst, AccelerationStructureNV src, CopyAccelerationStructureModeNV mode, Dispatch const &d=Dispatch()) const
void writeTimestamp(PipelineStageFlagBits pipelineStage, QueryPool queryPool, uint32_t query, Dispatch const &d=Dispatch()) const
void setStencilWriteMask(StencilFaceFlags faceMask, uint32_t writeMask, Dispatch const &d=Dispatch()) const
void beginRenderPass(const RenderPassBeginInfo &renderPassBegin, SubpassContents contents, Dispatch const &d=Dispatch()) const
void setEvent(Event event, PipelineStageFlags stageMask, Dispatch const &d=Dispatch()) const
void endTransformFeedbackEXT(uint32_t firstCounterBuffer, uint32_t counterBufferCount, const Buffer *pCounterBuffers, const DeviceSize *pCounterBufferOffsets, Dispatch const &d=Dispatch()) const
void waitEvents(ArrayProxy< const Event > events, PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, ArrayProxy< const MemoryBarrier > memoryBarriers, ArrayProxy< const BufferMemoryBarrier > bufferMemoryBarriers, ArrayProxy< const ImageMemoryBarrier > imageMemoryBarriers, Dispatch const &d=Dispatch()) const
void dispatchIndirect(Buffer buffer, DeviceSize offset, Dispatch const &d=Dispatch()) const
void pushDescriptorSetKHR(PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const WriteDescriptorSet *pDescriptorWrites, Dispatch const &d=Dispatch()) const
void buildAccelerationStructureNV(const AccelerationStructureInfoNV &info, Buffer instanceData, DeviceSize instanceOffset, Bool32 update, AccelerationStructureNV dst, AccelerationStructureNV src, Buffer scratch, DeviceSize scratchOffset, Dispatch const &d=Dispatch()) const
void beginConditionalRenderingEXT(const ConditionalRenderingBeginInfoEXT &conditionalRenderingBegin, Dispatch const &d=Dispatch()) const
void setCoarseSampleOrderNV(CoarseSampleOrderTypeNV sampleOrderType, ArrayProxy< const CoarseSampleOrderCustomNV > customSampleOrders, Dispatch const &d=Dispatch()) const
void updateBuffer(Buffer dstBuffer, DeviceSize dstOffset, ArrayProxy< const T > data, Dispatch const &d=Dispatch()) const
void drawMeshTasksNV(uint32_t taskCount, uint32_t firstTask, Dispatch const &d=Dispatch()) const
void endRenderPass2KHR(const SubpassEndInfoKHR *pSubpassEndInfo, Dispatch const &d=Dispatch()) const
void nextSubpass2KHR(const SubpassBeginInfoKHR *pSubpassBeginInfo, const SubpassEndInfoKHR *pSubpassEndInfo, Dispatch const &d=Dispatch()) const
void setDeviceMaskKHR(uint32_t deviceMask, Dispatch const &d=Dispatch()) const
void setDepthBounds(float minDepthBounds, float maxDepthBounds, Dispatch const &d=Dispatch()) const
void reserveSpaceForCommandsNVX(const CmdReserveSpaceForCommandsInfoNVX *pReserveSpaceInfo, Dispatch const &d=Dispatch()) const
void executeCommands(uint32_t commandBufferCount, const CommandBuffer *pCommandBuffers, Dispatch const &d=Dispatch()) const
void endConditionalRenderingEXT(Dispatch const &d=Dispatch()) const
bool operator!=(CommandPool const &rhs) const
Definition: vulkan.hpp:3045
CommandPool & operator=(std::nullptr_t)
Definition: vulkan.hpp:3034
VULKAN_HPP_TYPESAFE_EXPLICIT CommandPool(VkCommandPool commandPool)
Definition: vulkan.hpp:3022
VULKAN_HPP_CONSTEXPR CommandPool(std::nullptr_t)
Definition: vulkan.hpp:3018
bool operator<(CommandPool const &rhs) const
Definition: vulkan.hpp:3050
VULKAN_HPP_CONSTEXPR CommandPool()
Definition: vulkan.hpp:3014
bool operator==(CommandPool const &rhs) const
Definition: vulkan.hpp:3040
VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT(std::nullptr_t)
Definition: vulkan.hpp:4965
VkDebugReportCallbackEXT m_debugReportCallbackEXT
Definition: vulkan.hpp:5020
VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT()
Definition: vulkan.hpp:4961
bool operator==(DebugReportCallbackEXT const &rhs) const
Definition: vulkan.hpp:4987
bool operator<(DebugReportCallbackEXT const &rhs) const
Definition: vulkan.hpp:4997
VULKAN_HPP_TYPESAFE_EXPLICIT DebugReportCallbackEXT(VkDebugReportCallbackEXT debugReportCallbackEXT)
Definition: vulkan.hpp:4969
DebugReportCallbackEXT & operator=(std::nullptr_t)
Definition: vulkan.hpp:4981
bool operator!=(DebugReportCallbackEXT const &rhs) const
Definition: vulkan.hpp:4992
bool operator<(DebugUtilsMessengerEXT const &rhs) const
Definition: vulkan.hpp:5064
VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT(std::nullptr_t)
Definition: vulkan.hpp:5032
VULKAN_HPP_TYPESAFE_EXPLICIT DebugUtilsMessengerEXT(VkDebugUtilsMessengerEXT debugUtilsMessengerEXT)
Definition: vulkan.hpp:5036
bool operator!=(DebugUtilsMessengerEXT const &rhs) const
Definition: vulkan.hpp:5059
VkDebugUtilsMessengerEXT m_debugUtilsMessengerEXT
Definition: vulkan.hpp:5087
VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT()
Definition: vulkan.hpp:5028
bool operator==(DebugUtilsMessengerEXT const &rhs) const
Definition: vulkan.hpp:5054
DebugUtilsMessengerEXT & operator=(std::nullptr_t)
Definition: vulkan.hpp:5048
DescriptorPool & operator=(std::nullptr_t)
Definition: vulkan.hpp:3771
VULKAN_HPP_CONSTEXPR DescriptorPool()
Definition: vulkan.hpp:3751
bool operator!=(DescriptorPool const &rhs) const
Definition: vulkan.hpp:3782
bool operator==(DescriptorPool const &rhs) const
Definition: vulkan.hpp:3777
VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorPool(VkDescriptorPool descriptorPool)
Definition: vulkan.hpp:3759
bool operator<(DescriptorPool const &rhs) const
Definition: vulkan.hpp:3787
VULKAN_HPP_CONSTEXPR DescriptorPool(std::nullptr_t)
Definition: vulkan.hpp:3755
bool operator!=(DescriptorSet const &rhs) const
Definition: vulkan.hpp:3648
VULKAN_HPP_CONSTEXPR DescriptorSet(std::nullptr_t)
Definition: vulkan.hpp:3621
DescriptorSet & operator=(std::nullptr_t)
Definition: vulkan.hpp:3637
bool operator<(DescriptorSet const &rhs) const
Definition: vulkan.hpp:3653
VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSet(VkDescriptorSet descriptorSet)
Definition: vulkan.hpp:3625
VULKAN_HPP_CONSTEXPR DescriptorSet()
Definition: vulkan.hpp:3617
bool operator==(DescriptorSet const &rhs) const
Definition: vulkan.hpp:3643
bool operator==(DescriptorSetLayout const &rhs) const
Definition: vulkan.hpp:3710
bool operator<(DescriptorSetLayout const &rhs) const
Definition: vulkan.hpp:3720
bool operator!=(DescriptorSetLayout const &rhs) const
Definition: vulkan.hpp:3715
VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSetLayout(VkDescriptorSetLayout descriptorSetLayout)
Definition: vulkan.hpp:3692
DescriptorSetLayout & operator=(std::nullptr_t)
Definition: vulkan.hpp:3704
VkDescriptorSetLayout m_descriptorSetLayout
Definition: vulkan.hpp:3743
VULKAN_HPP_CONSTEXPR DescriptorSetLayout()
Definition: vulkan.hpp:3684
VULKAN_HPP_CONSTEXPR DescriptorSetLayout(std::nullptr_t)
Definition: vulkan.hpp:3688
bool operator!=(DescriptorUpdateTemplate const &rhs) const
Definition: vulkan.hpp:4452
VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate()
Definition: vulkan.hpp:4421
DescriptorUpdateTemplate & operator=(std::nullptr_t)
Definition: vulkan.hpp:4441
bool operator<(DescriptorUpdateTemplate const &rhs) const
Definition: vulkan.hpp:4457
bool operator==(DescriptorUpdateTemplate const &rhs) const
Definition: vulkan.hpp:4447
VkDescriptorUpdateTemplate m_descriptorUpdateTemplate
Definition: vulkan.hpp:4480
VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate(std::nullptr_t)
Definition: vulkan.hpp:4425
VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorUpdateTemplate(VkDescriptorUpdateTemplate descriptorUpdateTemplate)
Definition: vulkan.hpp:4429
ResultValueType< void >::type bindImageMemory2(ArrayProxy< const BindImageMemoryInfo > bindInfos, Dispatch const &d=Dispatch()) const
void destroyBufferView(BufferView bufferView, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
Result createRayTracingPipelinesNV(PipelineCache pipelineCache, uint32_t createInfoCount, const RayTracingPipelineCreateInfoNV *pCreateInfos, const AllocationCallbacks *pAllocator, Pipeline *pPipelines, Dispatch const &d=Dispatch()) const
ResultValueType< UniqueHandle< ImageView, Dispatch > >::type createImageViewUnique(const ImageViewCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< Fence >::type registerDisplayEventEXT(DisplayKHR display, const DisplayEventInfoEXT &displayEventInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
bool operator==(Device const &rhs) const
Definition: vulkan.hpp:39986
void destroy(BufferView bufferView, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
void destroyPipelineCache(PipelineCache pipelineCache, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
void getMemoryCommitment(DeviceMemory memory, DeviceSize *pCommittedMemoryInBytes, Dispatch const &d=Dispatch()) const
void setHdrMetadataEXT(uint32_t swapchainCount, const SwapchainKHR *pSwapchains, const HdrMetadataEXT *pMetadata, Dispatch const &d=Dispatch()) const
ResultValueType< void >::type compileDeferredNV(Pipeline pipeline, uint32_t shader, Dispatch const &d=Dispatch()) const
void destroyObjectTableNVX(ObjectTableNVX objectTable, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
Result getMemoryHostPointerPropertiesEXT(ExternalMemoryHandleTypeFlagBits handleType, const void *pHostPointer, MemoryHostPointerPropertiesEXT *pMemoryHostPointerProperties, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< Pipeline, Allocator > >::type createComputePipelines(PipelineCache pipelineCache, ArrayProxy< const ComputePipelineCreateInfo > createInfos, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< RenderPass >::type createRenderPass(const RenderPassCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< void >::type bindImageMemory2KHR(ArrayProxy< const BindImageMemoryInfo > bindInfos, Dispatch const &d=Dispatch()) const
ResultValueType< Pipeline >::type createComputePipeline(PipelineCache pipelineCache, const ComputePipelineCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
Result createRenderPass(const RenderPassCreateInfo *pCreateInfo, const AllocationCallbacks *pAllocator, RenderPass *pRenderPass, Dispatch const &d=Dispatch()) const
ResultValueType< UniqueHandle< QueryPool, Dispatch > >::type createQueryPoolUnique(const QueryPoolCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
Result importSemaphoreFdKHR(const ImportSemaphoreFdInfoKHR *pImportSemaphoreFdInfo, Dispatch const &d=Dispatch()) const
Result createSwapchainKHR(const SwapchainCreateInfoKHR *pCreateInfo, const AllocationCallbacks *pAllocator, SwapchainKHR *pSwapchain, Dispatch const &d=Dispatch()) const
void destroyPipeline(Pipeline pipeline, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
Result acquireNextImage2KHR(const AcquireNextImageInfoKHR *pAcquireInfo, uint32_t *pImageIndex, Dispatch const &d=Dispatch()) const
void freeCommandBuffers(CommandPool commandPool, uint32_t commandBufferCount, const CommandBuffer *pCommandBuffers, Dispatch const &d=Dispatch()) const
ResultValueType< Fence >::type registerEventEXT(const DeviceEventInfoEXT &deviceEventInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
void freeMemory(DeviceMemory memory, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
void destroyDescriptorSetLayout(DescriptorSetLayout descriptorSetLayout, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
Result allocateMemory(const MemoryAllocateInfo *pAllocateInfo, const AllocationCallbacks *pAllocator, DeviceMemory *pMemory, Dispatch const &d=Dispatch()) const
Result createBuffer(const BufferCreateInfo *pCreateInfo, const AllocationCallbacks *pAllocator, Buffer *pBuffer, Dispatch const &d=Dispatch()) const
Result createSampler(const SamplerCreateInfo *pCreateInfo, const AllocationCallbacks *pAllocator, Sampler *pSampler, Dispatch const &d=Dispatch()) const
Result createCommandPool(const CommandPoolCreateInfo *pCreateInfo, const AllocationCallbacks *pAllocator, CommandPool *pCommandPool, Dispatch const &d=Dispatch()) const
void destroyFence(Fence fence, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
PFN_vkVoidFunction getProcAddr(const char *pName, Dispatch const &d=Dispatch()) const
void destroy(Event event, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
void destroy(const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
Result importFenceFdKHR(const ImportFenceFdInfoKHR *pImportFenceFdInfo, Dispatch const &d=Dispatch()) const
void destroyObjectTableNVX(ObjectTableNVX objectTable, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< UniqueHandle< BufferView, Dispatch > >::type createBufferViewUnique(const BufferViewCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
SubresourceLayout getImageSubresourceLayout(Image image, const ImageSubresource &subresource, Dispatch const &d=Dispatch()) const
ResultValueType< IndirectCommandsLayoutNVX >::type createIndirectCommandsLayoutNVX(const IndirectCommandsLayoutCreateInfoNVX &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
Result createObjectTableNVX(const ObjectTableCreateInfoNVX *pCreateInfo, const AllocationCallbacks *pAllocator, ObjectTableNVX *pObjectTable, Dispatch const &d=Dispatch()) const
ResultValueType< Image >::type createImage(const ImageCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< CommandBuffer, Allocator > >::type allocateCommandBuffers(const CommandBufferAllocateInfo &allocateInfo, Allocator const &vectorAllocator, Dispatch const &d) const
void destroy(IndirectCommandsLayoutNVX indirectCommandsLayout, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
void destroy(SamplerYcbcrConversion ycbcrConversion, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< void >::type displayPowerControlEXT(DisplayKHR display, const DisplayPowerInfoEXT &displayPowerInfo, Dispatch const &d=Dispatch()) const
ResultValueType< UniqueHandle< Fence, Dispatch > >::type createFenceUnique(const FenceCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< void >::type resetDescriptorPool(DescriptorPool descriptorPool, DescriptorPoolResetFlags flags=DescriptorPoolResetFlags(), Dispatch const &d=Dispatch()) const
void destroy(Sampler sampler, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
std::vector< SparseImageMemoryRequirements2, Allocator > getImageSparseMemoryRequirements2(const ImageSparseMemoryRequirementsInfo2 &info, Dispatch const &d=Dispatch()) const
ResultValueType< UniqueHandle< DescriptorUpdateTemplate, Dispatch > >::type createDescriptorUpdateTemplateUnique(const DescriptorUpdateTemplateCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
Queue getQueue2(const DeviceQueueInfo2 &queueInfo, Dispatch const &d=Dispatch()) const
ResultValueType< DescriptorSetLayout >::type createDescriptorSetLayout(const DescriptorSetLayoutCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
void destroy(ImageView imageView, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
void destroy(DescriptorSetLayout descriptorSetLayout, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
MemoryRequirements2 getImageMemoryRequirements2(const ImageMemoryRequirementsInfo2 &info, Dispatch const &d=Dispatch()) const
void destroyBuffer(Buffer buffer, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
void unmapMemory(DeviceMemory memory, Dispatch const &d=Dispatch()) const
ResultValueType< void >::type mergePipelineCaches(PipelineCache dstCache, ArrayProxy< const PipelineCache > srcCaches, Dispatch const &d=Dispatch()) const
void getAccelerationStructureMemoryRequirementsNV(const AccelerationStructureMemoryRequirementsInfoNV *pInfo, MemoryRequirements2KHR *pMemoryRequirements, Dispatch const &d=Dispatch()) const
MemoryRequirements getBufferMemoryRequirements(Buffer buffer, Dispatch const &d=Dispatch()) const
ResultValueType< UniqueHandle< PipelineLayout, Dispatch > >::type createPipelineLayoutUnique(const PipelineLayoutCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< CommandPool >::type createCommandPool(const CommandPoolCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
void destroySampler(Sampler sampler, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< PipelineCache >::type createPipelineCache(const PipelineCacheCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
void trimCommandPoolKHR(CommandPool commandPool, CommandPoolTrimFlags flags=CommandPoolTrimFlags(), Dispatch const &d=Dispatch()) const
void destroySamplerYcbcrConversionKHR(SamplerYcbcrConversion ycbcrConversion, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< UniqueHandle< SwapchainKHR, Dispatch >, Allocator > >::type createSharedSwapchainsKHRUnique(ArrayProxy< const SwapchainCreateInfoKHR > createInfos, Optional< const AllocationCallbacks > allocator, Allocator const &vectorAllocator, Dispatch const &d) const
Result waitForFences(ArrayProxy< const Fence > fences, Bool32 waitAll, uint64_t timeout, Dispatch const &d=Dispatch()) const
Result createImageView(const ImageViewCreateInfo *pCreateInfo, const AllocationCallbacks *pAllocator, ImageView *pView, Dispatch const &d=Dispatch()) const
ResultValue< uint32_t > acquireNextImageKHR(SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence, Dispatch const &d=Dispatch()) const
void destroyBufferView(BufferView bufferView, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
ResultValueType< DescriptorPool >::type createDescriptorPool(const DescriptorPoolCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
Result bindAccelerationStructureMemoryNV(uint32_t bindInfoCount, const BindAccelerationStructureMemoryInfoNV *pBindInfos, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< PastPresentationTimingGOOGLE, Allocator > >::type getPastPresentationTimingGOOGLE(SwapchainKHR swapchain, Allocator const &vectorAllocator, Dispatch const &d) const
void destroy(RenderPass renderPass, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
Result createSemaphore(const SemaphoreCreateInfo *pCreateInfo, const AllocationCallbacks *pAllocator, Semaphore *pSemaphore, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< UniqueHandle< DescriptorSet, Dispatch >, Allocator > >::type allocateDescriptorSetsUnique(const DescriptorSetAllocateInfo &allocateInfo, Allocator const &vectorAllocator, Dispatch const &d) const
ResultValueType< UniqueHandle< DescriptorPool, Dispatch > >::type createDescriptorPoolUnique(const DescriptorPoolCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< Pipeline, Allocator > >::type createComputePipelines(PipelineCache pipelineCache, ArrayProxy< const ComputePipelineCreateInfo > createInfos, Optional< const AllocationCallbacks > allocator, Allocator const &vectorAllocator, Dispatch const &d) const
Result setDebugUtilsObjectNameEXT(const DebugUtilsObjectNameInfoEXT *pNameInfo, Dispatch const &d=Dispatch()) const
void getGroupPeerMemoryFeatures(uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, PeerMemoryFeatureFlags *pPeerMemoryFeatures, Dispatch const &d=Dispatch()) const
ResultValueType< UniqueHandle< DescriptorSetLayout, Dispatch > >::type createDescriptorSetLayoutUnique(const DescriptorSetLayoutCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
void destroyPipelineLayout(PipelineLayout pipelineLayout, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< UniqueHandle< Sampler, Dispatch > >::type createSamplerUnique(const SamplerCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
DescriptorSetLayoutSupport getDescriptorSetLayoutSupport(const DescriptorSetLayoutCreateInfo &createInfo, Dispatch const &d=Dispatch()) const
void destroy(Semaphore semaphore, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< Pipeline >::type createRayTracingPipelineNV(PipelineCache pipelineCache, const RayTracingPipelineCreateInfoNV &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
Result flushMappedMemoryRanges(uint32_t memoryRangeCount, const MappedMemoryRange *pMemoryRanges, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< SwapchainKHR, Allocator > >::type createSharedSwapchainsKHR(ArrayProxy< const SwapchainCreateInfoKHR > createInfos, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< ValidationCacheEXT >::type createValidationCacheEXT(const ValidationCacheCreateInfoEXT &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< Image, Allocator > >::type getSwapchainImagesKHR(SwapchainKHR swapchain, Dispatch const &d=Dispatch()) const
ResultValueType< void >::type getAccelerationStructureHandleNV(AccelerationStructureNV accelerationStructure, ArrayProxy< T > data, Dispatch const &d=Dispatch()) const
Result displayPowerControlEXT(DisplayKHR display, const DisplayPowerInfoEXT *pDisplayPowerInfo, Dispatch const &d=Dispatch()) const
Result getRefreshCycleDurationGOOGLE(SwapchainKHR swapchain, RefreshCycleDurationGOOGLE *pDisplayTimingProperties, Dispatch const &d=Dispatch()) const
ResultValueType< Pipeline >::type createGraphicsPipeline(PipelineCache pipelineCache, const GraphicsPipelineCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< void * >::type mapMemory(DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags=MemoryMapFlags(), Dispatch const &d=Dispatch()) const
Result getFenceFdKHR(const FenceGetFdInfoKHR *pGetFdInfo, int *pFd, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< uint8_t, Allocator > >::type getPipelineCacheData(PipelineCache pipelineCache, Dispatch const &d=Dispatch()) const
Result allocateCommandBuffers(const CommandBufferAllocateInfo *pAllocateInfo, CommandBuffer *pCommandBuffers, Dispatch const &d=Dispatch()) const
void getImageSubresourceLayout(Image image, const ImageSubresource *pSubresource, SubresourceLayout *pLayout, Dispatch const &d=Dispatch()) const
void getQueue(uint32_t queueFamilyIndex, uint32_t queueIndex, Queue *pQueue, Dispatch const &d=Dispatch()) const
VULKAN_HPP_TYPESAFE_EXPLICIT Device(VkDevice device)
Definition: vulkan.hpp:39968
void getBufferMemoryRequirements2(const BufferMemoryRequirementsInfo2 *pInfo, MemoryRequirements2 *pMemoryRequirements, Dispatch const &d=Dispatch()) const
void destroy(PipelineCache pipelineCache, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
MemoryRequirements getImageMemoryRequirements(Image image, Dispatch const &d=Dispatch()) const
Result createBufferView(const BufferViewCreateInfo *pCreateInfo, const AllocationCallbacks *pAllocator, BufferView *pView, Dispatch const &d=Dispatch()) const
void destroy(Framebuffer framebuffer, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
void destroy(Image image, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
Result getQueryPoolResults(QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void *pData, DeviceSize stride, QueryResultFlags flags, Dispatch const &d=Dispatch()) const
ResultValueType< UniqueHandle< Semaphore, Dispatch > >::type createSemaphoreUnique(const SemaphoreCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< UniqueHandle< Pipeline, Dispatch >, Allocator > >::type createComputePipelinesUnique(PipelineCache pipelineCache, ArrayProxy< const ComputePipelineCreateInfo > createInfos, Optional< const AllocationCallbacks > allocator, Allocator const &vectorAllocator, Dispatch const &d) const
void destroySwapchainKHR(SwapchainKHR swapchain, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< Pipeline, Allocator > >::type createGraphicsPipelines(PipelineCache pipelineCache, ArrayProxy< const GraphicsPipelineCreateInfo > createInfos, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
void destroySampler(Sampler sampler, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
Result getPastPresentationTimingGOOGLE(SwapchainKHR swapchain, uint32_t *pPresentationTimingCount, PastPresentationTimingGOOGLE *pPresentationTimings, Dispatch const &d=Dispatch()) const
void destroy(RenderPass renderPass, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
void updateDescriptorSetWithTemplate(DescriptorSet descriptorSet, DescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData, Dispatch const &d=Dispatch()) const
ResultValueType< UniqueHandle< DeviceMemory, Dispatch > >::type allocateMemoryUnique(const MemoryAllocateInfo &allocateInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< UniqueHandle< SamplerYcbcrConversion, Dispatch > >::type createSamplerYcbcrConversionUnique(const SamplerYcbcrConversionCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
StructureChain< X, Y, Z... > getImageMemoryRequirements2(const ImageMemoryRequirementsInfo2 &info, Dispatch const &d=Dispatch()) const
DescriptorSetLayoutSupport getDescriptorSetLayoutSupportKHR(const DescriptorSetLayoutCreateInfo &createInfo, Dispatch const &d=Dispatch()) const
void destroyFramebuffer(Framebuffer framebuffer, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
ResultValueType< UniqueHandle< CommandPool, Dispatch > >::type createCommandPoolUnique(const CommandPoolCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
void destroyDescriptorUpdateTemplate(DescriptorUpdateTemplate descriptorUpdateTemplate, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< UniqueHandle< SwapchainKHR, Dispatch > >::type createSwapchainKHRUnique(const SwapchainCreateInfoKHR &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
Result getSwapchainImagesKHR(SwapchainKHR swapchain, uint32_t *pSwapchainImageCount, Image *pSwapchainImages, Dispatch const &d=Dispatch()) const
void destroy(Pipeline pipeline, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
PeerMemoryFeatureFlags getGroupPeerMemoryFeatures(uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d=Dispatch()) const
void destroySamplerYcbcrConversion(SamplerYcbcrConversion ycbcrConversion, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
Result allocateDescriptorSets(const DescriptorSetAllocateInfo *pAllocateInfo, DescriptorSet *pDescriptorSets, Dispatch const &d=Dispatch()) const
ResultValueType< void >::type unregisterObjectsNVX(ObjectTableNVX objectTable, ArrayProxy< const ObjectEntryTypeNVX > objectEntryTypes, ArrayProxy< const uint32_t > objectIndices, Dispatch const &d=Dispatch()) const
void destroyDescriptorUpdateTemplateKHR(DescriptorUpdateTemplate descriptorUpdateTemplate, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
Result debugMarkerSetObjectNameEXT(const DebugMarkerObjectNameInfoEXT *pNameInfo, Dispatch const &d=Dispatch()) const
void destroyImageView(ImageView imageView, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
Result createFramebuffer(const FramebufferCreateInfo *pCreateInfo, const AllocationCallbacks *pAllocator, Framebuffer *pFramebuffer, Dispatch const &d=Dispatch()) const
Result createGraphicsPipelines(PipelineCache pipelineCache, uint32_t createInfoCount, const GraphicsPipelineCreateInfo *pCreateInfos, const AllocationCallbacks *pAllocator, Pipeline *pPipelines, Dispatch const &d=Dispatch()) const
void destroyBuffer(Buffer buffer, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
void trimCommandPool(CommandPool commandPool, CommandPoolTrimFlags flags=CommandPoolTrimFlags(), Dispatch const &d=Dispatch()) const
Device & operator=(std::nullptr_t)
Definition: vulkan.hpp:39980
void destroyQueryPool(QueryPool queryPool, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
void destroyRenderPass(RenderPass renderPass, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
Result invalidateMappedMemoryRanges(uint32_t memoryRangeCount, const MappedMemoryRange *pMemoryRanges, Dispatch const &d=Dispatch()) const
void destroyAccelerationStructureNV(AccelerationStructureNV accelerationStructure, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
Result createDescriptorUpdateTemplateKHR(const DescriptorUpdateTemplateCreateInfo *pCreateInfo, const AllocationCallbacks *pAllocator, DescriptorUpdateTemplate *pDescriptorUpdateTemplate, Dispatch const &d=Dispatch()) const
void destroy(ImageView imageView, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
void updateDescriptorSets(uint32_t descriptorWriteCount, const WriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, const CopyDescriptorSet *pDescriptorCopies, Dispatch const &d=Dispatch()) const
void destroy(DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
ResultValueType< void >::type debugMarkerSetObjectTagEXT(const DebugMarkerObjectTagInfoEXT &tagInfo, Dispatch const &d=Dispatch()) const
void destroyPipelineLayout(PipelineLayout pipelineLayout, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
StructureChain< X, Y, Z... > getImageMemoryRequirements2KHR(const ImageMemoryRequirementsInfo2 &info, Dispatch const &d=Dispatch()) const
bool operator<(Device const &rhs) const
Definition: vulkan.hpp:39996
Result getSemaphoreFdKHR(const SemaphoreGetFdInfoKHR *pGetFdInfo, int *pFd, Dispatch const &d=Dispatch()) const
void updateDescriptorSetWithTemplateKHR(DescriptorSet descriptorSet, DescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData, Dispatch const &d=Dispatch()) const
void getGroupPeerMemoryFeaturesKHR(uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, PeerMemoryFeatureFlags *pPeerMemoryFeatures, Dispatch const &d=Dispatch()) const
Result registerEventEXT(const DeviceEventInfoEXT *pDeviceEventInfo, const AllocationCallbacks *pAllocator, Fence *pFence, Dispatch const &d=Dispatch()) const
void destroy(Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< UniqueHandle< Pipeline, Dispatch > >::type createRayTracingPipelineNVUnique(PipelineCache pipelineCache, const RayTracingPipelineCreateInfoNV &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
Result bindBufferMemory2(uint32_t bindInfoCount, const BindBufferMemoryInfo *pBindInfos, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< Pipeline, Allocator > >::type createRayTracingPipelinesNV(PipelineCache pipelineCache, ArrayProxy< const RayTracingPipelineCreateInfoNV > createInfos, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
void getImageMemoryRequirements2KHR(const ImageMemoryRequirementsInfo2 *pInfo, MemoryRequirements2 *pMemoryRequirements, Dispatch const &d=Dispatch()) const
Result getMemoryFdKHR(const MemoryGetFdInfoKHR *pGetFdInfo, int *pFd, Dispatch const &d=Dispatch()) const
ResultValueType< int >::type getFenceFdKHR(const FenceGetFdInfoKHR &getFdInfo, Dispatch const &d=Dispatch()) const
std::vector< SparseImageMemoryRequirements, Allocator > getImageSparseMemoryRequirements(Image image, Allocator const &vectorAllocator, Dispatch const &d) const
Result getShaderInfoAMD(Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, size_t *pInfoSize, void *pInfo, Dispatch const &d=Dispatch()) const
void destroy(PipelineLayout pipelineLayout, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
MemoryRequirements2 getBufferMemoryRequirements2(const BufferMemoryRequirementsInfo2 &info, Dispatch const &d=Dispatch()) const
ResultValueType< void >::type importFenceFdKHR(const ImportFenceFdInfoKHR &importFenceFdInfo, Dispatch const &d=Dispatch()) const
Result getGroupPresentCapabilitiesKHR(DeviceGroupPresentCapabilitiesKHR *pDeviceGroupPresentCapabilities, Dispatch const &d=Dispatch()) const
void destroyValidationCacheEXT(ValidationCacheEXT validationCache, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< MemoryFdPropertiesKHR >::type getMemoryFdPropertiesKHR(ExternalMemoryHandleTypeFlagBits handleType, int fd, Dispatch const &d=Dispatch()) const
Result getGroupSurfacePresentModesKHR(SurfaceKHR surface, DeviceGroupPresentModeFlagsKHR *pModes, Dispatch const &d=Dispatch()) const
ResultValue< uint32_t > acquireNextImage2KHR(const AcquireNextImageInfoKHR &acquireInfo, Dispatch const &d=Dispatch()) const
void destroy(CommandPool commandPool, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
Result getSwapchainStatusKHR(SwapchainKHR swapchain, Dispatch const &d=Dispatch()) const
void destroyIndirectCommandsLayoutNVX(IndirectCommandsLayoutNVX indirectCommandsLayout, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
Result createSharedSwapchainsKHR(uint32_t swapchainCount, const SwapchainCreateInfoKHR *pCreateInfos, const AllocationCallbacks *pAllocator, SwapchainKHR *pSwapchains, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< SwapchainKHR, Allocator > >::type createSharedSwapchainsKHR(ArrayProxy< const SwapchainCreateInfoKHR > createInfos, Optional< const AllocationCallbacks > allocator, Allocator const &vectorAllocator, Dispatch const &d) const
void free(CommandPool commandPool, ArrayProxy< const CommandBuffer > commandBuffers, Dispatch const &d=Dispatch()) const
void destroyShaderModule(ShaderModule shaderModule, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
Result createEvent(const EventCreateInfo *pCreateInfo, const AllocationCallbacks *pAllocator, Event *pEvent, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< UniqueHandle< Pipeline, Dispatch >, Allocator > >::type createComputePipelinesUnique(PipelineCache pipelineCache, ArrayProxy< const ComputePipelineCreateInfo > createInfos, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< uint8_t, Allocator > >::type getValidationCacheDataEXT(ValidationCacheEXT validationCache, Allocator const &vectorAllocator, Dispatch const &d) const
ResultValueType< UniqueHandle< Image, Dispatch > >::type createImageUnique(const ImageCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
Result resetFences(uint32_t fenceCount, const Fence *pFences, Dispatch const &d=Dispatch()) const
DeviceSize getMemoryCommitment(DeviceMemory memory, Dispatch const &d=Dispatch()) const
Result registerObjectsNVX(ObjectTableNVX objectTable, uint32_t objectCount, const ObjectTableEntryNVX *const *ppObjectTableEntries, const uint32_t *pObjectIndices, Dispatch const &d=Dispatch()) const
ResultValueType< UniqueHandle< AccelerationStructureNV, Dispatch > >::type createAccelerationStructureNVUnique(const AccelerationStructureCreateInfoNV &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< QueryPool >::type createQueryPool(const QueryPoolCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
void destroy(Framebuffer framebuffer, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
void free(CommandPool commandPool, uint32_t commandBufferCount, const CommandBuffer *pCommandBuffers, Dispatch const &d=Dispatch()) const
void destroy(ValidationCacheEXT validationCache, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
ResultValueType< SamplerYcbcrConversion >::type createSamplerYcbcrConversion(const SamplerYcbcrConversionCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
Result acquireNextImageKHR(SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence, uint32_t *pImageIndex, Dispatch const &d=Dispatch()) const
VULKAN_HPP_CONSTEXPR Device(std::nullptr_t)
Definition: vulkan.hpp:39964
ResultValueType< std::vector< UniqueHandle< Pipeline, Dispatch >, Allocator > >::type createRayTracingPipelinesNVUnique(PipelineCache pipelineCache, ArrayProxy< const RayTracingPipelineCreateInfoNV > createInfos, Optional< const AllocationCallbacks > allocator, Allocator const &vectorAllocator, Dispatch const &d) const
void destroy(ValidationCacheEXT validationCache, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< RenderPass >::type createRenderPass2KHR(const RenderPassCreateInfo2KHR &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
MemoryRequirements2KHR getAccelerationStructureMemoryRequirementsNV(const AccelerationStructureMemoryRequirementsInfoNV &info, Dispatch const &d=Dispatch()) const
void updateDescriptorSets(ArrayProxy< const WriteDescriptorSet > descriptorWrites, ArrayProxy< const CopyDescriptorSet > descriptorCopies, Dispatch const &d=Dispatch()) const
void destroy(Image image, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
Result createFence(const FenceCreateInfo *pCreateInfo, const AllocationCallbacks *pAllocator, Fence *pFence, Dispatch const &d=Dispatch()) const
ResultValueType< UniqueHandle< Framebuffer, Dispatch > >::type createFramebufferUnique(const FramebufferCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< Fence >::type createFence(const FenceCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< void >::type resetCommandPool(CommandPool commandPool, CommandPoolResetFlags flags, Dispatch const &d=Dispatch()) const
ResultValueType< ImageView >::type createImageView(const ImageViewCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< UniqueHandle< DescriptorUpdateTemplate, Dispatch > >::type createDescriptorUpdateTemplateKHRUnique(const DescriptorUpdateTemplateCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
void getImageSparseMemoryRequirements2(const ImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, SparseImageMemoryRequirements2 *pSparseMemoryRequirements, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< DescriptorSet, Allocator > >::type allocateDescriptorSets(const DescriptorSetAllocateInfo &allocateInfo, Dispatch const &d=Dispatch()) const
Result createSamplerYcbcrConversion(const SamplerYcbcrConversionCreateInfo *pCreateInfo, const AllocationCallbacks *pAllocator, SamplerYcbcrConversion *pYcbcrConversion, Dispatch const &d=Dispatch()) const
Result createPipelineCache(const PipelineCacheCreateInfo *pCreateInfo, const AllocationCallbacks *pAllocator, PipelineCache *pPipelineCache, Dispatch const &d=Dispatch()) const
ResultValueType< ImageDrmFormatModifierPropertiesEXT >::type getImageDrmFormatModifierPropertiesEXT(Image image, Dispatch const &d=Dispatch()) const
MemoryRequirements2 getImageMemoryRequirements2KHR(const ImageMemoryRequirementsInfo2 &info, Dispatch const &d=Dispatch()) const
void getImageSparseMemoryRequirements2KHR(const ImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, SparseImageMemoryRequirements2 *pSparseMemoryRequirements, Dispatch const &d=Dispatch()) const
void destroyCommandPool(CommandPool commandPool, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
void free(DeviceMemory memory, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
void destroy(DescriptorSetLayout descriptorSetLayout, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
Result createComputePipelines(PipelineCache pipelineCache, uint32_t createInfoCount, const ComputePipelineCreateInfo *pCreateInfos, const AllocationCallbacks *pAllocator, Pipeline *pPipelines, Dispatch const &d=Dispatch()) const
void destroy(SwapchainKHR swapchain, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< SamplerYcbcrConversion >::type createSamplerYcbcrConversionKHR(const SamplerYcbcrConversionCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< Sampler >::type createSampler(const SamplerCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
Result createDescriptorUpdateTemplate(const DescriptorUpdateTemplateCreateInfo *pCreateInfo, const AllocationCallbacks *pAllocator, DescriptorUpdateTemplate *pDescriptorUpdateTemplate, Dispatch const &d=Dispatch()) const
void destroy(Fence fence, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
std::vector< SparseImageMemoryRequirements, Allocator > getImageSparseMemoryRequirements(Image image, Dispatch const &d=Dispatch()) const
ResultValueType< void >::type invalidateMappedMemoryRanges(ArrayProxy< const MappedMemoryRange > memoryRanges, Dispatch const &d=Dispatch()) const
void destroyEvent(Event event, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
ResultValueType< void >::type bindImageMemory(Image image, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d=Dispatch()) const
void destroySamplerYcbcrConversionKHR(SamplerYcbcrConversion ycbcrConversion, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
void destroy(Sampler sampler, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
ResultValueType< SwapchainKHR >::type createSharedSwapchainKHR(const SwapchainCreateInfoKHR &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
void destroy(QueryPool queryPool, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< Semaphore >::type createSemaphore(const SemaphoreCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
Result bindBufferMemory2KHR(uint32_t bindInfoCount, const BindBufferMemoryInfo *pBindInfos, Dispatch const &d=Dispatch()) const
ResultValueType< DeviceGroupPresentCapabilitiesKHR >::type getGroupPresentCapabilitiesKHR(Dispatch const &d=Dispatch()) const
void destroyValidationCacheEXT(ValidationCacheEXT validationCache, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
std::vector< SparseImageMemoryRequirements2, Allocator > getImageSparseMemoryRequirements2KHR(const ImageSparseMemoryRequirementsInfo2 &info, Allocator const &vectorAllocator, Dispatch const &d) const
void getBufferMemoryRequirements(Buffer buffer, MemoryRequirements *pMemoryRequirements, Dispatch const &d=Dispatch()) const
void destroySemaphore(Semaphore semaphore, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
ResultValueType< DeviceMemory >::type allocateMemory(const MemoryAllocateInfo &allocateInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
Result createShaderModule(const ShaderModuleCreateInfo *pCreateInfo, const AllocationCallbacks *pAllocator, ShaderModule *pShaderModule, Dispatch const &d=Dispatch()) const
ResultValueType< UniqueHandle< RenderPass, Dispatch > >::type createRenderPassUnique(const RenderPassCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
void freeMemory(DeviceMemory memory, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
ResultValueType< AccelerationStructureNV >::type createAccelerationStructureNV(const AccelerationStructureCreateInfoNV &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
StructureChain< X, Y, Z... > getBufferMemoryRequirements2KHR(const BufferMemoryRequirementsInfo2 &info, Dispatch const &d=Dispatch()) const
Result createDescriptorSetLayout(const DescriptorSetLayoutCreateInfo *pCreateInfo, const AllocationCallbacks *pAllocator, DescriptorSetLayout *pSetLayout, Dispatch const &d=Dispatch()) const
ResultValueType< DescriptorUpdateTemplate >::type createDescriptorUpdateTemplate(const DescriptorUpdateTemplateCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
void destroy(ObjectTableNVX objectTable, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< UniqueHandle< IndirectCommandsLayoutNVX, Dispatch > >::type createIndirectCommandsLayoutNVXUnique(const IndirectCommandsLayoutCreateInfoNVX &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
void destroySamplerYcbcrConversion(SamplerYcbcrConversion ycbcrConversion, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
ResultValueType< uint64_t >::type getSwapchainCounterEXT(SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter, Dispatch const &d=Dispatch()) const
ResultValueType< UniqueHandle< SwapchainKHR, Dispatch > >::type createSharedSwapchainKHRUnique(const SwapchainCreateInfoKHR &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< UniqueHandle< CommandBuffer, Dispatch >, Allocator > >::type allocateCommandBuffersUnique(const CommandBufferAllocateInfo &allocateInfo, Allocator const &vectorAllocator, Dispatch const &d) const
void destroy(IndirectCommandsLayoutNVX indirectCommandsLayout, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
void destroyShaderModule(ShaderModule shaderModule, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
void getImageMemoryRequirements2(const ImageMemoryRequirementsInfo2 *pInfo, MemoryRequirements2 *pMemoryRequirements, Dispatch const &d=Dispatch()) const
void destroyDescriptorUpdateTemplateKHR(DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
Result mapMemory(DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags, void **ppData, Dispatch const &d=Dispatch()) const
ResultValueType< void >::type bindBufferMemory2(ArrayProxy< const BindBufferMemoryInfo > bindInfos, Dispatch const &d=Dispatch()) const
void getImageMemoryRequirements(Image image, MemoryRequirements *pMemoryRequirements, Dispatch const &d=Dispatch()) const
ResultValueType< UniqueHandle< ValidationCacheEXT, Dispatch > >::type createValidationCacheEXTUnique(const ValidationCacheCreateInfoEXT &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
Result getCalibratedTimestampsEXT(uint32_t timestampCount, const CalibratedTimestampInfoEXT *pTimestampInfos, uint64_t *pTimestamps, uint64_t *pMaxDeviation, Dispatch const &d=Dispatch()) const
ResultValueType< int >::type getMemoryFdKHR(const MemoryGetFdInfoKHR &getFdInfo, Dispatch const &d=Dispatch()) const
void destroy(ShaderModule shaderModule, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< uint8_t, Allocator > >::type getShaderInfoAMD(Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, Allocator const &vectorAllocator, Dispatch const &d) const
StructureChain< X, Y, Z... > getDescriptorSetLayoutSupportKHR(const DescriptorSetLayoutCreateInfo &createInfo, Dispatch const &d=Dispatch()) const
ResultValueType< uint64_t >::type getCalibratedTimestampsEXT(ArrayProxy< const CalibratedTimestampInfoEXT > timestampInfos, ArrayProxy< uint64_t > timestamps, Dispatch const &d=Dispatch()) const
void destroyDescriptorPool(DescriptorPool descriptorPool, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< UniqueHandle< Event, Dispatch > >::type createEventUnique(const EventCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
Result getValidationCacheDataEXT(ValidationCacheEXT validationCache, size_t *pDataSize, void *pData, Dispatch const &d=Dispatch()) const
ResultValueType< int >::type getSemaphoreFdKHR(const SemaphoreGetFdInfoKHR &getFdInfo, Dispatch const &d=Dispatch()) const
Result createValidationCacheEXT(const ValidationCacheCreateInfoEXT *pCreateInfo, const AllocationCallbacks *pAllocator, ValidationCacheEXT *pValidationCache, Dispatch const &d=Dispatch()) const
void getRenderAreaGranularity(RenderPass renderPass, Extent2D *pGranularity, Dispatch const &d=Dispatch()) const
void destroyIndirectCommandsLayoutNVX(IndirectCommandsLayoutNVX indirectCommandsLayout, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
void destroyDescriptorSetLayout(DescriptorSetLayout descriptorSetLayout, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
void destroyCommandPool(CommandPool commandPool, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< void >::type getRayTracingShaderGroupHandlesNV(Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, ArrayProxy< T > data, Dispatch const &d=Dispatch()) const
void destroyFramebuffer(Framebuffer framebuffer, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
Result createIndirectCommandsLayoutNVX(const IndirectCommandsLayoutCreateInfoNVX *pCreateInfo, const AllocationCallbacks *pAllocator, IndirectCommandsLayoutNVX *pIndirectCommandsLayout, Dispatch const &d=Dispatch()) const
PFN_vkVoidFunction getProcAddr(const std::string &name, Dispatch const &d=Dispatch()) const
Result getPipelineCacheData(PipelineCache pipelineCache, size_t *pDataSize, void *pData, Dispatch const &d=Dispatch()) const
void destroy(PipelineLayout pipelineLayout, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< UniqueHandle< Pipeline, Dispatch >, Allocator > >::type createGraphicsPipelinesUnique(PipelineCache pipelineCache, ArrayProxy< const GraphicsPipelineCreateInfo > createInfos, Optional< const AllocationCallbacks > allocator, Allocator const &vectorAllocator, Dispatch const &d) const
ResultValueType< UniqueHandle< Pipeline, Dispatch > >::type createComputePipelineUnique(PipelineCache pipelineCache, const ComputePipelineCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
void destroyPipelineCache(PipelineCache pipelineCache, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
void destroyImage(Image image, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
void getBufferMemoryRequirements2KHR(const BufferMemoryRequirementsInfo2 *pInfo, MemoryRequirements2 *pMemoryRequirements, Dispatch const &d=Dispatch()) const
StructureChain< X, Y, Z... > getBufferMemoryRequirements2(const BufferMemoryRequirementsInfo2 &info, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< UniqueHandle< CommandBuffer, Dispatch >, Allocator > >::type allocateCommandBuffersUnique(const CommandBufferAllocateInfo &allocateInfo, Dispatch const &d=Dispatch()) const
ResultValueType< UniqueHandle< Buffer, Dispatch > >::type createBufferUnique(const BufferCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
void destroyRenderPass(RenderPass renderPass, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< RefreshCycleDurationGOOGLE >::type getRefreshCycleDurationGOOGLE(SwapchainKHR swapchain, Dispatch const &d=Dispatch()) const
ResultValueType< DescriptorUpdateTemplate >::type createDescriptorUpdateTemplateKHR(const DescriptorUpdateTemplateCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< void >::type setDebugUtilsObjectTagEXT(const DebugUtilsObjectTagInfoEXT &tagInfo, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< uint8_t, Allocator > >::type getShaderInfoAMD(Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, Dispatch const &d=Dispatch()) const
void getQueue2(const DeviceQueueInfo2 *pQueueInfo, Queue *pQueue, Dispatch const &d=Dispatch()) const
ResultValueType< BufferView >::type createBufferView(const BufferViewCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
Queue getQueue(uint32_t queueFamilyIndex, uint32_t queueIndex, Dispatch const &d=Dispatch()) const
Result createImage(const ImageCreateInfo *pCreateInfo, const AllocationCallbacks *pAllocator, Image *pImage, Dispatch const &d=Dispatch()) const
void destroySemaphore(Semaphore semaphore, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
void destroyDescriptorPool(DescriptorPool descriptorPool, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
ResultValueType< DeviceGroupPresentModeFlagsKHR >::type getGroupSurfacePresentModesKHR(SurfaceKHR surface, Dispatch const &d=Dispatch()) const
void destroyEvent(Event event, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
Result debugMarkerSetObjectTagEXT(const DebugMarkerObjectTagInfoEXT *pTagInfo, Dispatch const &d=Dispatch()) const
Result free(DescriptorPool descriptorPool, uint32_t descriptorSetCount, const DescriptorSet *pDescriptorSets, Dispatch const &d=Dispatch()) const
Result getMemoryFdPropertiesKHR(ExternalMemoryHandleTypeFlagBits handleType, int fd, MemoryFdPropertiesKHR *pMemoryFdProperties, Dispatch const &d=Dispatch()) const
VULKAN_HPP_CONSTEXPR Device()
Definition: vulkan.hpp:39960
Result createAccelerationStructureNV(const AccelerationStructureCreateInfoNV *pCreateInfo, const AllocationCallbacks *pAllocator, AccelerationStructureNV *pAccelerationStructure, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< PastPresentationTimingGOOGLE, Allocator > >::type getPastPresentationTimingGOOGLE(SwapchainKHR swapchain, Dispatch const &d=Dispatch()) const
Result getQueryPoolResults(QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, ArrayProxy< T > data, DeviceSize stride, QueryResultFlags flags, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< Pipeline, Allocator > >::type createRayTracingPipelinesNV(PipelineCache pipelineCache, ArrayProxy< const RayTracingPipelineCreateInfoNV > createInfos, Optional< const AllocationCallbacks > allocator, Allocator const &vectorAllocator, Dispatch const &d) const
void destroy(AccelerationStructureNV accelerationStructure, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
void destroy(Pipeline pipeline, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
Result createDescriptorPool(const DescriptorPoolCreateInfo *pCreateInfo, const AllocationCallbacks *pAllocator, DescriptorPool *pDescriptorPool, Dispatch const &d=Dispatch()) const
void getImageSparseMemoryRequirements(Image image, uint32_t *pSparseMemoryRequirementCount, SparseImageMemoryRequirements *pSparseMemoryRequirements, Dispatch const &d=Dispatch()) const
Result getFenceStatus(Fence fence, Dispatch const &d=Dispatch()) const
ResultValueType< void >::type free(DescriptorPool descriptorPool, ArrayProxy< const DescriptorSet > descriptorSets, Dispatch const &d=Dispatch()) const
ResultValueType< ShaderModule >::type createShaderModule(const ShaderModuleCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
void destroy(Event event, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
ResultValueType< Framebuffer >::type createFramebuffer(const FramebufferCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
Result createQueryPool(const QueryPoolCreateInfo *pCreateInfo, const AllocationCallbacks *pAllocator, QueryPool *pQueryPool, Dispatch const &d=Dispatch()) const
void destroy(DescriptorPool descriptorPool, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
Result createSamplerYcbcrConversionKHR(const SamplerYcbcrConversionCreateInfo *pCreateInfo, const AllocationCallbacks *pAllocator, SamplerYcbcrConversion *pYcbcrConversion, Dispatch const &d=Dispatch()) const
void destroy(Buffer buffer, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< void >::type setDebugUtilsObjectNameEXT(const DebugUtilsObjectNameInfoEXT &nameInfo, Dispatch const &d=Dispatch()) const
Result freeDescriptorSets(DescriptorPool descriptorPool, uint32_t descriptorSetCount, const DescriptorSet *pDescriptorSets, Dispatch const &d=Dispatch()) const
ResultValueType< void >::type flushMappedMemoryRanges(ArrayProxy< const MappedMemoryRange > memoryRanges, Dispatch const &d=Dispatch()) const
void destroyImageView(ImageView imageView, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
void destroyDescriptorUpdateTemplate(DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
void destroy(QueryPool queryPool, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
ResultValueType< void >::type resetFences(ArrayProxy< const Fence > fences, Dispatch const &d=Dispatch()) const
ResultValueType< MemoryHostPointerPropertiesEXT >::type getMemoryHostPointerPropertiesEXT(ExternalMemoryHandleTypeFlagBits handleType, const void *pHostPointer, Dispatch const &d=Dispatch()) const
bool operator!=(Device const &rhs) const
Definition: vulkan.hpp:39991
MemoryRequirements2 getBufferMemoryRequirements2KHR(const BufferMemoryRequirementsInfo2 &info, Dispatch const &d=Dispatch()) const
ResultValueType< void >::type freeDescriptorSets(DescriptorPool descriptorPool, ArrayProxy< const DescriptorSet > descriptorSets, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< Image, Allocator > >::type getSwapchainImagesKHR(SwapchainKHR swapchain, Allocator const &vectorAllocator, Dispatch const &d) const
void destroy(DescriptorUpdateTemplate descriptorUpdateTemplate, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< UniqueHandle< RenderPass, Dispatch > >::type createRenderPass2KHRUnique(const RenderPassCreateInfo2KHR &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< void >::type setEvent(Event event, Dispatch const &d=Dispatch()) const
void destroyAccelerationStructureNV(AccelerationStructureNV accelerationStructure, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
void destroy(ObjectTableNVX objectTable, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
void destroyPipeline(Pipeline pipeline, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
void destroy(AccelerationStructureNV accelerationStructure, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
Result registerDisplayEventEXT(DisplayKHR display, const DisplayEventInfoEXT *pDisplayEventInfo, const AllocationCallbacks *pAllocator, Fence *pFence, Dispatch const &d=Dispatch()) const
void destroy(CommandPool commandPool, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< DescriptorSet, Allocator > >::type allocateDescriptorSets(const DescriptorSetAllocateInfo &allocateInfo, Allocator const &vectorAllocator, Dispatch const &d) const
Result mergePipelineCaches(PipelineCache dstCache, uint32_t srcCacheCount, const PipelineCache *pSrcCaches, Dispatch const &d=Dispatch()) const
ResultValueType< void >::type bindBufferMemory(Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const &d=Dispatch()) const
ResultValueType< PipelineLayout >::type createPipelineLayout(const PipelineLayoutCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< Pipeline, Allocator > >::type createGraphicsPipelines(PipelineCache pipelineCache, ArrayProxy< const GraphicsPipelineCreateInfo > createInfos, Optional< const AllocationCallbacks > allocator, Allocator const &vectorAllocator, Dispatch const &d) const
ResultValueType< void >::type debugMarkerSetObjectNameEXT(const DebugMarkerObjectNameInfoEXT &nameInfo, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< uint8_t, Allocator > >::type getValidationCacheDataEXT(ValidationCacheEXT validationCache, Dispatch const &d=Dispatch()) const
Result bindImageMemory2(uint32_t bindInfoCount, const BindImageMemoryInfo *pBindInfos, Dispatch const &d=Dispatch()) const
void destroyImage(Image image, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< UniqueHandle< DescriptorSet, Dispatch >, Allocator > >::type allocateDescriptorSetsUnique(const DescriptorSetAllocateInfo &allocateInfo, Dispatch const &d=Dispatch()) const
ResultValueType< Buffer >::type createBuffer(const BufferCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< Event >::type createEvent(const EventCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
void getDescriptorSetLayoutSupport(const DescriptorSetLayoutCreateInfo *pCreateInfo, DescriptorSetLayoutSupport *pSupport, Dispatch const &d=Dispatch()) const
Result createRenderPass2KHR(const RenderPassCreateInfo2KHR *pCreateInfo, const AllocationCallbacks *pAllocator, RenderPass *pRenderPass, Dispatch const &d=Dispatch()) const
void destroy(DescriptorPool descriptorPool, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
Result mergeValidationCachesEXT(ValidationCacheEXT dstCache, uint32_t srcCacheCount, const ValidationCacheEXT *pSrcCaches, Dispatch const &d=Dispatch()) const
void getDescriptorSetLayoutSupportKHR(const DescriptorSetLayoutCreateInfo *pCreateInfo, DescriptorSetLayoutSupport *pSupport, Dispatch const &d=Dispatch()) const
Result getImageDrmFormatModifierPropertiesEXT(Image image, ImageDrmFormatModifierPropertiesEXT *pProperties, Dispatch const &d=Dispatch()) const
Result bindImageMemory2KHR(uint32_t bindInfoCount, const BindImageMemoryInfo *pBindInfos, Dispatch const &d=Dispatch()) const
void destroy(Buffer buffer, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
Result waitForFences(uint32_t fenceCount, const Fence *pFences, Bool32 waitAll, uint64_t timeout, Dispatch const &d=Dispatch()) const
void destroy(BufferView bufferView, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< UniqueHandle< Pipeline, Dispatch >, Allocator > >::type createRayTracingPipelinesNVUnique(PipelineCache pipelineCache, ArrayProxy< const RayTracingPipelineCreateInfoNV > createInfos, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< void >::type bindAccelerationStructureMemoryNV(ArrayProxy< const BindAccelerationStructureMemoryInfoNV > bindInfos, Dispatch const &d=Dispatch()) const
void destroy(Semaphore semaphore, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
Extent2D getRenderAreaGranularity(RenderPass renderPass, Dispatch const &d=Dispatch()) const
StructureChain< X, Y, Z... > getDescriptorSetLayoutSupport(const DescriptorSetLayoutCreateInfo &createInfo, Dispatch const &d=Dispatch()) const
PeerMemoryFeatureFlags getGroupPeerMemoryFeaturesKHR(uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, Dispatch const &d=Dispatch()) const
ResultValueType< void >::type resetEvent(Event event, Dispatch const &d=Dispatch()) const
ResultValueType< UniqueHandle< Pipeline, Dispatch > >::type createGraphicsPipelineUnique(PipelineCache pipelineCache, const GraphicsPipelineCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< UniqueHandle< ObjectTableNVX, Dispatch > >::type createObjectTableNVXUnique(const ObjectTableCreateInfoNVX &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< ObjectTableNVX >::type createObjectTableNVX(const ObjectTableCreateInfoNVX &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< UniqueHandle< Pipeline, Dispatch >, Allocator > >::type createGraphicsPipelinesUnique(PipelineCache pipelineCache, ArrayProxy< const GraphicsPipelineCreateInfo > createInfos, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< void >::type mergeValidationCachesEXT(ValidationCacheEXT dstCache, ArrayProxy< const ValidationCacheEXT > srcCaches, Dispatch const &d=Dispatch()) const
ResultValueType< SwapchainKHR >::type createSwapchainKHR(const SwapchainCreateInfoKHR &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
Result unregisterObjectsNVX(ObjectTableNVX objectTable, uint32_t objectCount, const ObjectEntryTypeNVX *pObjectEntryTypes, const uint32_t *pObjectIndices, Dispatch const &d=Dispatch()) const
void freeCommandBuffers(CommandPool commandPool, ArrayProxy< const CommandBuffer > commandBuffers, Dispatch const &d=Dispatch()) const
void destroy(ShaderModule shaderModule, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
void destroyQueryPool(QueryPool queryPool, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
ResultValueType< UniqueHandle< ShaderModule, Dispatch > >::type createShaderModuleUnique(const ShaderModuleCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
void destroySwapchainKHR(SwapchainKHR swapchain, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
void setHdrMetadataEXT(ArrayProxy< const SwapchainKHR > swapchains, ArrayProxy< const HdrMetadataEXT > metadata, Dispatch const &d=Dispatch()) const
ResultValueType< UniqueHandle< SamplerYcbcrConversion, Dispatch > >::type createSamplerYcbcrConversionKHRUnique(const SamplerYcbcrConversionCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< void >::type waitIdle(Dispatch const &d=Dispatch()) const
void free(DeviceMemory memory, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
void destroy(Fence fence, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
Result getSwapchainCounterEXT(SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter, uint64_t *pCounterValue, Dispatch const &d=Dispatch()) const
ResultValueType< void >::type importSemaphoreFdKHR(const ImportSemaphoreFdInfoKHR &importSemaphoreFdInfo, Dispatch const &d=Dispatch()) const
Result createPipelineLayout(const PipelineLayoutCreateInfo *pCreateInfo, const AllocationCallbacks *pAllocator, PipelineLayout *pPipelineLayout, Dispatch const &d=Dispatch()) const
ResultValueType< void >::type registerObjectsNVX(ObjectTableNVX objectTable, ArrayProxy< const ObjectTableEntryNVX *const > pObjectTableEntries, ArrayProxy< const uint32_t > objectIndices, Dispatch const &d=Dispatch()) const
ResultValueType< void >::type bindBufferMemory2KHR(ArrayProxy< const BindBufferMemoryInfo > bindInfos, Dispatch const &d=Dispatch()) const
Result setDebugUtilsObjectTagEXT(const DebugUtilsObjectTagInfoEXT *pTagInfo, Dispatch const &d=Dispatch()) const
ResultValueType< UniqueHandle< PipelineCache, Dispatch > >::type createPipelineCacheUnique(const PipelineCacheCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
std::vector< SparseImageMemoryRequirements2, Allocator > getImageSparseMemoryRequirements2KHR(const ImageSparseMemoryRequirementsInfo2 &info, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< uint8_t, Allocator > >::type getPipelineCacheData(PipelineCache pipelineCache, Allocator const &vectorAllocator, Dispatch const &d) const
ResultValueType< std::vector< CommandBuffer, Allocator > >::type allocateCommandBuffers(const CommandBufferAllocateInfo &allocateInfo, Dispatch const &d=Dispatch()) const
void destroy(PipelineCache pipelineCache, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< UniqueHandle< SwapchainKHR, Dispatch >, Allocator > >::type createSharedSwapchainsKHRUnique(ArrayProxy< const SwapchainCreateInfoKHR > createInfos, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
Result getAccelerationStructureHandleNV(AccelerationStructureNV accelerationStructure, size_t dataSize, void *pData, Dispatch const &d=Dispatch()) const
void destroy(SwapchainKHR swapchain, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
void destroyFence(Fence fence, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
Result getRayTracingShaderGroupHandlesNV(Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData, Dispatch const &d=Dispatch()) const
Result getEventStatus(Event event, Dispatch const &d=Dispatch()) const
std::vector< SparseImageMemoryRequirements2, Allocator > getImageSparseMemoryRequirements2(const ImageSparseMemoryRequirementsInfo2 &info, Allocator const &vectorAllocator, Dispatch const &d) const
void destroy(SamplerYcbcrConversion ycbcrConversion, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
DeviceLostError(char const *message)
Definition: vulkan.hpp:784
DeviceLostError(std::string const &message)
Definition: vulkan.hpp:782
VULKAN_HPP_CONSTEXPR DeviceMemory()
Definition: vulkan.hpp:2947
VULKAN_HPP_CONSTEXPR DeviceMemory(std::nullptr_t)
Definition: vulkan.hpp:2951
bool operator<(DeviceMemory const &rhs) const
Definition: vulkan.hpp:2983
DeviceMemory & operator=(std::nullptr_t)
Definition: vulkan.hpp:2967
bool operator!=(DeviceMemory const &rhs) const
Definition: vulkan.hpp:2978
bool operator==(DeviceMemory const &rhs) const
Definition: vulkan.hpp:2973
VULKAN_HPP_TYPESAFE_EXPLICIT DeviceMemory(VkDeviceMemory deviceMemory)
Definition: vulkan.hpp:2955
PFN_vkCmdWriteAccelerationStructuresPropertiesNV vkCmdWriteAccelerationStructuresPropertiesNV
Definition: vulkan.hpp:52365
PFN_vkGetAccelerationStructureMemoryRequirementsNV vkGetAccelerationStructureMemoryRequirementsNV
Definition: vulkan.hpp:52484
PFN_vkCreateFramebuffer vkCreateFramebuffer
Definition: vulkan.hpp:52388
PFN_vkBeginCommandBuffer vkBeginCommandBuffer
Definition: vulkan.hpp:52271
PFN_vkCreateDescriptorUpdateTemplate vkCreateDescriptorUpdateTemplate
Definition: vulkan.hpp:52381
PFN_vkCmdDebugMarkerBeginEXT vkCmdDebugMarkerBeginEXT
Definition: vulkan.hpp:52303
PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR
Definition: vulkan.hpp:52552
PFN_vkGetImageSubresourceLayout vkGetImageSubresourceLayout
Definition: vulkan.hpp:52520
PFN_vkRegisterObjectsNVX vkRegisterObjectsNVX
Definition: vulkan.hpp:52632
PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV vkGetPhysicalDeviceExternalImageFormatPropertiesNV
Definition: vulkan.hpp:52547
PFN_vkDestroyPipelineCache vkDestroyPipelineCache
Definition: vulkan.hpp:52456
PFN_vkCreateObjectTableNVX vkCreateObjectTableNVX
Definition: vulkan.hpp:52403
PFN_vkCmdBeginRenderPass2KHR vkCmdBeginRenderPass2KHR
Definition: vulkan.hpp:52284
PFN_vkRegisterDeviceEventEXT vkRegisterDeviceEventEXT
Definition: vulkan.hpp:52630
PFN_vkGetSemaphoreFdKHR vkGetSemaphoreFdKHR
Definition: vulkan.hpp:52602
PFN_vkGetPhysicalDeviceQueueFamilyProperties2 vkGetPhysicalDeviceQueueFamilyProperties2
Definition: vulkan.hpp:52569
PFN_vkDestroySwapchainKHR vkDestroySwapchainKHR
Definition: vulkan.hpp:52466
PFN_vkResetDescriptorPool vkResetDescriptorPool
Definition: vulkan.hpp:52636
PFN_vkImportSemaphoreFdKHR vkImportSemaphoreFdKHR
Definition: vulkan.hpp:52615
PFN_vkBindAccelerationStructureMemoryNV vkBindAccelerationStructureMemoryNV
Definition: vulkan.hpp:52272
PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT vkGetPhysicalDeviceCalibrateableTimeDomainsEXT
Definition: vulkan.hpp:52538
PFN_vkGetPhysicalDeviceImageFormatProperties2 vkGetPhysicalDeviceImageFormatProperties2
Definition: vulkan.hpp:52558
PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX
Definition: vulkan.hpp:52556
PFN_vkDestroyRenderPass vkDestroyRenderPass
Definition: vulkan.hpp:52459
PFN_vkCreateDescriptorPool vkCreateDescriptorPool
Definition: vulkan.hpp:52379
PFN_vkUnregisterObjectsNVX vkUnregisterObjectsNVX
Definition: vulkan.hpp:52647
PFN_vkFreeDescriptorSets vkFreeDescriptorSets
Definition: vulkan.hpp:52481
PFN_vkGetDisplayPlaneCapabilitiesKHR vkGetDisplayPlaneCapabilitiesKHR
Definition: vulkan.hpp:52505
PFN_vkEnumerateInstanceVersion vkEnumerateInstanceVersion
Definition: vulkan.hpp:52475
PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool
Definition: vulkan.hpp:52442
PFN_vkCreateValidationCacheEXT vkCreateValidationCacheEXT
Definition: vulkan.hpp:52417
PFN_vkGetPastPresentationTimingGOOGLE vkGetPastPresentationTimingGOOGLE
Definition: vulkan.hpp:52537
PFN_vkCreateRenderPass2KHR vkCreateRenderPass2KHR
Definition: vulkan.hpp:52409
PFN_vkGetRenderAreaGranularity vkGetRenderAreaGranularity
Definition: vulkan.hpp:52601
PFN_vkCmdDrawIndexedIndirectCountAMD vkCmdDrawIndexedIndirectCountAMD
Definition: vulkan.hpp:52313
PFN_vkGetCalibratedTimestampsEXT vkGetCalibratedTimestampsEXT
Definition: vulkan.hpp:52491
PFN_vkGetPhysicalDeviceMemoryProperties2KHR vkGetPhysicalDeviceMemoryProperties2KHR
Definition: vulkan.hpp:52562
PFN_vkDestroyObjectTableNVX vkDestroyObjectTableNVX
Definition: vulkan.hpp:52454
PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties
Definition: vulkan.hpp:52473
PFN_vkGetPhysicalDeviceSparseImageFormatProperties vkGetPhysicalDeviceSparseImageFormatProperties
Definition: vulkan.hpp:52571
DispatchLoaderDynamic(Instance instance=Instance(), Device device=Device())
Definition: vulkan.hpp:52653
PFN_vkDebugMarkerSetObjectNameEXT vkDebugMarkerSetObjectNameEXT
Definition: vulkan.hpp:52433
PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers
Definition: vulkan.hpp:52268
PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT vkGetPhysicalDeviceSurfaceCapabilities2EXT
Definition: vulkan.hpp:52574
PFN_vkCmdClearAttachments vkCmdClearAttachments
Definition: vulkan.hpp:52294
PFN_vkDestroyFramebuffer vkDestroyFramebuffer
Definition: vulkan.hpp:52449
PFN_vkSetDebugUtilsObjectTagEXT vkSetDebugUtilsObjectTagEXT
Definition: vulkan.hpp:52640
PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers
Definition: vulkan.hpp:52291
PFN_vkCmdBindShadingRateImageNV vkCmdBindShadingRateImageNV
Definition: vulkan.hpp:52289
PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR vkGetPhysicalDeviceSparseImageFormatProperties2KHR
Definition: vulkan.hpp:52573
PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR
Definition: vulkan.hpp:52465
PFN_vkGetDeviceGroupSurfacePresentModesKHR vkGetDeviceGroupSurfacePresentModesKHR
Definition: vulkan.hpp:52497
PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR vkGetPhysicalDeviceExternalSemaphorePropertiesKHR
Definition: vulkan.hpp:52549
PFN_vkBindImageMemory2KHR vkBindImageMemory2KHR
Definition: vulkan.hpp:52278
PFN_vkCmdEndRenderPass vkCmdEndRenderPass
Definition: vulkan.hpp:52326
PFN_vkGetSwapchainCounterEXT vkGetSwapchainCounterEXT
Definition: vulkan.hpp:52607
PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR
Definition: vulkan.hpp:52580
PFN_vkCmdClearDepthStencilImage vkCmdClearDepthStencilImage
Definition: vulkan.hpp:52296
PFN_vkCreateSamplerYcbcrConversionKHR vkCreateSamplerYcbcrConversionKHR
Definition: vulkan.hpp:52412
PFN_vkCmdSetCheckpointNV vkCmdSetCheckpointNV
Definition: vulkan.hpp:52344
PFN_vkDebugMarkerSetObjectTagEXT vkDebugMarkerSetObjectTagEXT
Definition: vulkan.hpp:52434
PFN_vkCmdEndRenderPass2KHR vkCmdEndRenderPass2KHR
Definition: vulkan.hpp:52327
PFN_vkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXT
Definition: vulkan.hpp:52350
PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties
Definition: vulkan.hpp:52474
PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr
Definition: vulkan.hpp:52521
PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceCapabilitiesKHR
Definition: vulkan.hpp:52576
PFN_vkBindBufferMemory2KHR vkBindBufferMemory2KHR
Definition: vulkan.hpp:52275
PFN_vkGetPhysicalDeviceExternalFenceProperties vkGetPhysicalDeviceExternalFenceProperties
Definition: vulkan.hpp:52545
PFN_vkCmdSetStencilCompareMask vkCmdSetStencilCompareMask
Definition: vulkan.hpp:52356
PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier
Definition: vulkan.hpp:52334
PFN_vkCmdBeginConditionalRenderingEXT vkCmdBeginConditionalRenderingEXT
Definition: vulkan.hpp:52279
PFN_vkCompileDeferredNV vkCompileDeferredNV
Definition: vulkan.hpp:52368
PFN_vkCmdDrawIndirectByteCountEXT vkCmdDrawIndirectByteCountEXT
Definition: vulkan.hpp:52316
PFN_vkCmdSetDeviceMask vkCmdSetDeviceMask
Definition: vulkan.hpp:52348
PFN_vkCmdResetQueryPool vkCmdResetQueryPool
Definition: vulkan.hpp:52341
PFN_vkCreateAccelerationStructureNV vkCreateAccelerationStructureNV
Definition: vulkan.hpp:52369
PFN_vkDestroySamplerYcbcrConversionKHR vkDestroySamplerYcbcrConversionKHR
Definition: vulkan.hpp:52462
PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties
Definition: vulkan.hpp:52471
PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR
Definition: vulkan.hpp:52516
PFN_vkGetPhysicalDeviceExternalSemaphoreProperties vkGetPhysicalDeviceExternalSemaphoreProperties
Definition: vulkan.hpp:52548
PFN_vkGetRayTracingShaderGroupHandlesNV vkGetRayTracingShaderGroupHandlesNV
Definition: vulkan.hpp:52599
PFN_vkCreateCommandPool vkCreateCommandPool
Definition: vulkan.hpp:52375
PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout
Definition: vulkan.hpp:52380
PFN_vkGetPhysicalDeviceFeatures2 vkGetPhysicalDeviceFeatures2
Definition: vulkan.hpp:52551
PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage
Definition: vulkan.hpp:52299
PFN_vkCmdPushDescriptorSetWithTemplateKHR vkCmdPushDescriptorSetWithTemplateKHR
Definition: vulkan.hpp:52338
PFN_vkCmdCopyQueryPoolResults vkCmdCopyQueryPoolResults
Definition: vulkan.hpp:52302
PFN_vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceImageFormatProperties
Definition: vulkan.hpp:52557
PFN_vkAcquireNextImage2KHR vkAcquireNextImage2KHR
Definition: vulkan.hpp:52263
PFN_vkCreateDisplayModeKHR vkCreateDisplayModeKHR
Definition: vulkan.hpp:52384
PFN_vkCmdBuildAccelerationStructureNV vkCmdBuildAccelerationStructureNV
Definition: vulkan.hpp:52293
PFN_vkBindBufferMemory2 vkBindBufferMemory2
Definition: vulkan.hpp:52274
PFN_vkCmdSetDeviceMaskKHR vkCmdSetDeviceMaskKHR
Definition: vulkan.hpp:52349
PFN_vkCmdDispatchBaseKHR vkCmdDispatchBaseKHR
Definition: vulkan.hpp:52308
PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges
Definition: vulkan.hpp:52619
PFN_vkGetShaderInfoAMD vkGetShaderInfoAMD
Definition: vulkan.hpp:52606
PFN_vkCmdSetCoarseSampleOrderNV vkCmdSetCoarseSampleOrderNV
Definition: vulkan.hpp:52345
PFN_vkGetPhysicalDeviceFormatProperties2KHR vkGetPhysicalDeviceFormatProperties2KHR
Definition: vulkan.hpp:52555
PFN_vkCreatePipelineCache vkCreatePipelineCache
Definition: vulkan.hpp:52404
PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets
Definition: vulkan.hpp:52650
PFN_vkCmdDebugMarkerInsertEXT vkCmdDebugMarkerInsertEXT
Definition: vulkan.hpp:52305
PFN_vkCreateDebugReportCallbackEXT vkCreateDebugReportCallbackEXT
Definition: vulkan.hpp:52377
PFN_vkCreateSwapchainKHR vkCreateSwapchainKHR
Definition: vulkan.hpp:52416
PFN_vkMergePipelineCaches vkMergePipelineCaches
Definition: vulkan.hpp:52621
PFN_vkGetPipelineCacheData vkGetPipelineCacheData
Definition: vulkan.hpp:52593
PFN_vkGetPhysicalDeviceExternalBufferProperties vkGetPhysicalDeviceExternalBufferProperties
Definition: vulkan.hpp:52543
PFN_vkCreatePipelineLayout vkCreatePipelineLayout
Definition: vulkan.hpp:52405
PFN_vkGetDisplayPlaneSupportedDisplaysKHR vkGetDisplayPlaneSupportedDisplaysKHR
Definition: vulkan.hpp:52506
PFN_vkCmdDrawIndirectCountKHR vkCmdDrawIndirectCountKHR
Definition: vulkan.hpp:52318
PFN_vkCmdEndQueryIndexedEXT vkCmdEndQueryIndexedEXT
Definition: vulkan.hpp:52325
void init(Instance instance, Device device=Device())
Definition: vulkan.hpp:52661
PFN_vkCmdProcessCommandsNVX vkCmdProcessCommandsNVX
Definition: vulkan.hpp:52335
PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements
Definition: vulkan.hpp:52514
PFN_vkDestroyDescriptorUpdateTemplate vkDestroyDescriptorUpdateTemplate
Definition: vulkan.hpp:52444
PFN_vkDestroyIndirectCommandsLayoutNVX vkDestroyIndirectCommandsLayoutNVX
Definition: vulkan.hpp:52452
PFN_vkFreeCommandBuffers vkFreeCommandBuffers
Definition: vulkan.hpp:52480
PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR
Definition: vulkan.hpp:52264
PFN_vkSubmitDebugUtilsMessageEXT vkSubmitDebugUtilsMessageEXT
Definition: vulkan.hpp:52643
PFN_vkCmdDrawIndexedIndirectCountKHR vkCmdDrawIndexedIndirectCountKHR
Definition: vulkan.hpp:52314
PFN_vkCmdInsertDebugUtilsLabelEXT vkCmdInsertDebugUtilsLabelEXT
Definition: vulkan.hpp:52331
PFN_vkCmdDrawIndexedIndirect vkCmdDrawIndexedIndirect
Definition: vulkan.hpp:52312
PFN_vkDestroyShaderModule vkDestroyShaderModule
Definition: vulkan.hpp:52464
PFN_vkCreateBufferView vkCreateBufferView
Definition: vulkan.hpp:52374
PFN_vkGetImageSparseMemoryRequirements2KHR vkGetImageSparseMemoryRequirements2KHR
Definition: vulkan.hpp:52519
PFN_vkDestroyCommandPool vkDestroyCommandPool
Definition: vulkan.hpp:52439
PFN_vkCmdEndDebugUtilsLabelEXT vkCmdEndDebugUtilsLabelEXT
Definition: vulkan.hpp:52323
PFN_vkCmdDrawIndirectCountAMD vkCmdDrawIndirectCountAMD
Definition: vulkan.hpp:52317
PFN_vkCreateDescriptorUpdateTemplateKHR vkCreateDescriptorUpdateTemplateKHR
Definition: vulkan.hpp:52382
PFN_vkCreateRenderPass vkCreateRenderPass
Definition: vulkan.hpp:52408
PFN_vkCmdBeginTransformFeedbackEXT vkCmdBeginTransformFeedbackEXT
Definition: vulkan.hpp:52285
PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR
Definition: vulkan.hpp:52608
PFN_vkCmdPushConstants vkCmdPushConstants
Definition: vulkan.hpp:52336
PFN_vkUpdateDescriptorSetWithTemplateKHR vkUpdateDescriptorSetWithTemplateKHR
Definition: vulkan.hpp:52649
PFN_vkCreateShaderModule vkCreateShaderModule
Definition: vulkan.hpp:52414
PFN_vkGetAccelerationStructureHandleNV vkGetAccelerationStructureHandleNV
Definition: vulkan.hpp:52483
PFN_vkDestroyValidationCacheEXT vkDestroyValidationCacheEXT
Definition: vulkan.hpp:52467
PFN_vkCmdBeginQueryIndexedEXT vkCmdBeginQueryIndexedEXT
Definition: vulkan.hpp:52282
PFN_vkGetPhysicalDevicePresentRectanglesKHR vkGetPhysicalDevicePresentRectanglesKHR
Definition: vulkan.hpp:52564
PFN_vkCreateDisplayPlaneSurfaceKHR vkCreateDisplayPlaneSurfaceKHR
Definition: vulkan.hpp:52385
PFN_vkCreateRayTracingPipelinesNV vkCreateRayTracingPipelinesNV
Definition: vulkan.hpp:52407
PFN_vkCmdReserveSpaceForCommandsNVX vkCmdReserveSpaceForCommandsNVX
Definition: vulkan.hpp:52339
PFN_vkReleaseDisplayEXT vkReleaseDisplayEXT
Definition: vulkan.hpp:52633
PFN_vkQueueEndDebugUtilsLabelEXT vkQueueEndDebugUtilsLabelEXT
Definition: vulkan.hpp:52625
PFN_vkCmdSetViewportShadingRatePaletteNV vkCmdSetViewportShadingRatePaletteNV
Definition: vulkan.hpp:52360
PFN_vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties
Definition: vulkan.hpp:52553
PFN_vkGetDeviceGroupPeerMemoryFeatures vkGetDeviceGroupPeerMemoryFeatures
Definition: vulkan.hpp:52494
PFN_vkCmdDrawMeshTasksIndirectNV vkCmdDrawMeshTasksIndirectNV
Definition: vulkan.hpp:52320
PFN_vkGetDisplayModePropertiesKHR vkGetDisplayModePropertiesKHR
Definition: vulkan.hpp:52503
PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets
Definition: vulkan.hpp:52286
PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR vkGetPhysicalDeviceExternalBufferPropertiesKHR
Definition: vulkan.hpp:52544
PFN_vkDestroySemaphore vkDestroySemaphore
Definition: vulkan.hpp:52463
PFN_vkCmdSetViewportWScalingNV vkCmdSetViewportWScalingNV
Definition: vulkan.hpp:52361
PFN_vkCmdDrawMeshTasksNV vkCmdDrawMeshTasksNV
Definition: vulkan.hpp:52321
PFN_vkGetPhysicalDeviceProperties2KHR vkGetPhysicalDeviceProperties2KHR
Definition: vulkan.hpp:52567
PFN_vkDestroyDebugReportCallbackEXT vkDestroyDebugReportCallbackEXT
Definition: vulkan.hpp:52440
PFN_vkCmdClearColorImage vkCmdClearColorImage
Definition: vulkan.hpp:52295
PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR vkGetPhysicalDeviceDisplayPlaneProperties2KHR
Definition: vulkan.hpp:52539
PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges
Definition: vulkan.hpp:52479
PFN_vkCmdExecuteCommands vkCmdExecuteCommands
Definition: vulkan.hpp:52329
PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR vkGetPhysicalDeviceDisplayPlanePropertiesKHR
Definition: vulkan.hpp:52540
PFN_vkCmdDispatchIndirect vkCmdDispatchIndirect
Definition: vulkan.hpp:52309
PFN_vkMergeValidationCachesEXT vkMergeValidationCachesEXT
Definition: vulkan.hpp:52622
PFN_vkGetDeviceGroupPresentCapabilitiesKHR vkGetDeviceGroupPresentCapabilitiesKHR
Definition: vulkan.hpp:52496
PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass
Definition: vulkan.hpp:52283
PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties
Definition: vulkan.hpp:52568
PFN_vkGetImageDrmFormatModifierPropertiesEXT vkGetImageDrmFormatModifierPropertiesEXT
Definition: vulkan.hpp:52513
PFN_vkCmdDebugMarkerEndEXT vkCmdDebugMarkerEndEXT
Definition: vulkan.hpp:52304
PFN_vkGetPhysicalDeviceSurfaceFormatsKHR vkGetPhysicalDeviceSurfaceFormatsKHR
Definition: vulkan.hpp:52578
PFN_vkRegisterDisplayEventEXT vkRegisterDisplayEventEXT
Definition: vulkan.hpp:52631
PFN_vkGetDeviceMemoryCommitment vkGetDeviceMemoryCommitment
Definition: vulkan.hpp:52498
PFN_vkGetQueryPoolResults vkGetQueryPoolResults
Definition: vulkan.hpp:52594
PFN_vkCreateSharedSwapchainsKHR vkCreateSharedSwapchainsKHR
Definition: vulkan.hpp:52415
PFN_vkDebugReportMessageEXT vkDebugReportMessageEXT
Definition: vulkan.hpp:52435
PFN_vkGetImageSparseMemoryRequirements2 vkGetImageSparseMemoryRequirements2
Definition: vulkan.hpp:52518
PFN_vkGetPhysicalDeviceSurfaceFormats2KHR vkGetPhysicalDeviceSurfaceFormats2KHR
Definition: vulkan.hpp:52577
PFN_vkCmdSetDepthBounds vkCmdSetDepthBounds
Definition: vulkan.hpp:52347
PFN_vkEndCommandBuffer vkEndCommandBuffer
Definition: vulkan.hpp:52470
PFN_vkCreateSamplerYcbcrConversion vkCreateSamplerYcbcrConversion
Definition: vulkan.hpp:52411
PFN_vkEnumeratePhysicalDeviceGroupsKHR vkEnumeratePhysicalDeviceGroupsKHR
Definition: vulkan.hpp:52477
PFN_vkGetMemoryHostPointerPropertiesEXT vkGetMemoryHostPointerPropertiesEXT
Definition: vulkan.hpp:52527
PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR vkGetDeviceGroupPeerMemoryFeaturesKHR
Definition: vulkan.hpp:52495
PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout
Definition: vulkan.hpp:52443
PFN_vkDestroyAccelerationStructureNV vkDestroyAccelerationStructureNV
Definition: vulkan.hpp:52436
PFN_vkGetDescriptorSetLayoutSupportKHR vkGetDescriptorSetLayoutSupportKHR
Definition: vulkan.hpp:52493
PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 vkGetPhysicalDeviceSparseImageFormatProperties2
Definition: vulkan.hpp:52572
PFN_vkGetImageMemoryRequirements2 vkGetImageMemoryRequirements2
Definition: vulkan.hpp:52515
PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr
Definition: vulkan.hpp:52499
PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR vkGetPhysicalDeviceSurfaceCapabilities2KHR
Definition: vulkan.hpp:52575
PFN_vkCmdNextSubpass2KHR vkCmdNextSubpass2KHR
Definition: vulkan.hpp:52333
PFN_vkGetSwapchainStatusKHR vkGetSwapchainStatusKHR
Definition: vulkan.hpp:52609
PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties
Definition: vulkan.hpp:52565
PFN_vkGetRefreshCycleDurationGOOGLE vkGetRefreshCycleDurationGOOGLE
Definition: vulkan.hpp:52600
PFN_vkCmdSetExclusiveScissorNV vkCmdSetExclusiveScissorNV
Definition: vulkan.hpp:52352
PFN_vkGetPhysicalDeviceSurfacePresentModesKHR vkGetPhysicalDeviceSurfacePresentModesKHR
Definition: vulkan.hpp:52579
PFN_vkGetQueueCheckpointDataNV vkGetQueueCheckpointDataNV
Definition: vulkan.hpp:52595
PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR vkGetPhysicalDeviceExternalFencePropertiesKHR
Definition: vulkan.hpp:52546
PFN_vkDestroySamplerYcbcrConversion vkDestroySamplerYcbcrConversion
Definition: vulkan.hpp:52461
PFN_vkDestroyBufferView vkDestroyBufferView
Definition: vulkan.hpp:52438
PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices
Definition: vulkan.hpp:52478
PFN_vkDestroyPipelineLayout vkDestroyPipelineLayout
Definition: vulkan.hpp:52457
PFN_vkCmdSetStencilWriteMask vkCmdSetStencilWriteMask
Definition: vulkan.hpp:52358
PFN_vkDestroyQueryPool vkDestroyQueryPool
Definition: vulkan.hpp:52458
PFN_vkCmdEndConditionalRenderingEXT vkCmdEndConditionalRenderingEXT
Definition: vulkan.hpp:52322
PFN_vkCreateDebugUtilsMessengerEXT vkCreateDebugUtilsMessengerEXT
Definition: vulkan.hpp:52378
PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines
Definition: vulkan.hpp:52389
PFN_vkGetPhysicalDeviceDisplayPropertiesKHR vkGetPhysicalDeviceDisplayPropertiesKHR
Definition: vulkan.hpp:52542
PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties
Definition: vulkan.hpp:52560
PFN_vkCmdWriteBufferMarkerAMD vkCmdWriteBufferMarkerAMD
Definition: vulkan.hpp:52366
PFN_vkBindBufferMemory vkBindBufferMemory
Definition: vulkan.hpp:52273
PFN_vkResetCommandPool vkResetCommandPool
Definition: vulkan.hpp:52635
PFN_vkGetValidationCacheDataEXT vkGetValidationCacheDataEXT
Definition: vulkan.hpp:52610
PFN_vkCmdWriteTimestamp vkCmdWriteTimestamp
Definition: vulkan.hpp:52367
PFN_vkGetPhysicalDeviceFormatProperties2 vkGetPhysicalDeviceFormatProperties2
Definition: vulkan.hpp:52554
PFN_vkEnumerateDeviceLayerProperties vkEnumerateDeviceLayerProperties
Definition: vulkan.hpp:52472
PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR
Definition: vulkan.hpp:52490
PFN_vkQueueInsertDebugUtilsLabelEXT vkQueueInsertDebugUtilsLabelEXT
Definition: vulkan.hpp:52626
PFN_vkDestroyImageView vkDestroyImageView
Definition: vulkan.hpp:52451
PFN_vkCmdSetSampleLocationsEXT vkCmdSetSampleLocationsEXT
Definition: vulkan.hpp:52354
PFN_vkCmdCopyAccelerationStructureNV vkCmdCopyAccelerationStructureNV
Definition: vulkan.hpp:52297
PFN_vkGetDisplayPlaneCapabilities2KHR vkGetDisplayPlaneCapabilities2KHR
Definition: vulkan.hpp:52504
PFN_vkCmdBindTransformFeedbackBuffersEXT vkCmdBindTransformFeedbackBuffersEXT
Definition: vulkan.hpp:52290
PFN_vkTrimCommandPoolKHR vkTrimCommandPoolKHR
Definition: vulkan.hpp:52645
PFN_vkUpdateDescriptorSetWithTemplate vkUpdateDescriptorSetWithTemplate
Definition: vulkan.hpp:52648
PFN_vkCmdBindIndexBuffer vkCmdBindIndexBuffer
Definition: vulkan.hpp:52287
PFN_vkCreateComputePipelines vkCreateComputePipelines
Definition: vulkan.hpp:52376
PFN_vkGetPhysicalDeviceImageFormatProperties2KHR vkGetPhysicalDeviceImageFormatProperties2KHR
Definition: vulkan.hpp:52559
PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets
Definition: vulkan.hpp:52269
PFN_vkGetPhysicalDeviceDisplayProperties2KHR vkGetPhysicalDeviceDisplayProperties2KHR
Definition: vulkan.hpp:52541
PFN_vkQueueBeginDebugUtilsLabelEXT vkQueueBeginDebugUtilsLabelEXT
Definition: vulkan.hpp:52623
PFN_vkCmdSetBlendConstants vkCmdSetBlendConstants
Definition: vulkan.hpp:52343
PFN_vkCreateIndirectCommandsLayoutNVX vkCreateIndirectCommandsLayoutNVX
Definition: vulkan.hpp:52398
PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT
Definition: vulkan.hpp:52441
PFN_vkCmdEndTransformFeedbackEXT vkCmdEndTransformFeedbackEXT
Definition: vulkan.hpp:52328
PFN_vkGetPhysicalDeviceProperties2 vkGetPhysicalDeviceProperties2
Definition: vulkan.hpp:52566
PFN_vkDisplayPowerControlEXT vkDisplayPowerControlEXT
Definition: vulkan.hpp:52469
PFN_vkCmdSetStencilReference vkCmdSetStencilReference
Definition: vulkan.hpp:52357
PFN_vkSetHdrMetadataEXT vkSetHdrMetadataEXT
Definition: vulkan.hpp:52642
PFN_vkImportFenceFdKHR vkImportFenceFdKHR
Definition: vulkan.hpp:52611
PFN_vkCmdBeginDebugUtilsLabelEXT vkCmdBeginDebugUtilsLabelEXT
Definition: vulkan.hpp:52280
PFN_vkSetDebugUtilsObjectNameEXT vkSetDebugUtilsObjectNameEXT
Definition: vulkan.hpp:52639
PFN_vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures
Definition: vulkan.hpp:52550
PFN_vkCmdDrawMeshTasksIndirectCountNV vkCmdDrawMeshTasksIndirectCountNV
Definition: vulkan.hpp:52319
PFN_vkGetPhysicalDeviceMemoryProperties2 vkGetPhysicalDeviceMemoryProperties2
Definition: vulkan.hpp:52561
PFN_vkCmdPushDescriptorSetKHR vkCmdPushDescriptorSetKHR
Definition: vulkan.hpp:52337
PFN_vkGetDescriptorSetLayoutSupport vkGetDescriptorSetLayoutSupport
Definition: vulkan.hpp:52492
PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR vkGetPhysicalDeviceQueueFamilyProperties2KHR
Definition: vulkan.hpp:52570
PFN_vkGetDisplayModeProperties2KHR vkGetDisplayModeProperties2KHR
Definition: vulkan.hpp:52502
PFN_vkGetMemoryFdPropertiesKHR vkGetMemoryFdPropertiesKHR
Definition: vulkan.hpp:52526
PFN_vkEnumeratePhysicalDeviceGroups vkEnumeratePhysicalDeviceGroups
Definition: vulkan.hpp:52476
PFN_vkResetCommandBuffer vkResetCommandBuffer
Definition: vulkan.hpp:52634
PFN_vkGetImageSparseMemoryRequirements vkGetImageSparseMemoryRequirements
Definition: vulkan.hpp:52517
PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT vkGetPhysicalDeviceMultisamplePropertiesEXT
Definition: vulkan.hpp:52563
PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements
Definition: vulkan.hpp:52488
PFN_vkDestroyDescriptorUpdateTemplateKHR vkDestroyDescriptorUpdateTemplateKHR
Definition: vulkan.hpp:52445
PFN_vkBindImageMemory2 vkBindImageMemory2
Definition: vulkan.hpp:52277
PFN_vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2
Definition: vulkan.hpp:52489
PFN_vkCmdCopyImageToBuffer vkCmdCopyImageToBuffer
Definition: vulkan.hpp:52301
void vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange *pRanges) const
Definition: vulkan.hpp:1223
void vkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin) const
Definition: vulkan.hpp:1155
VkResult vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences) const
Definition: vulkan.hpp:2453
VkResult vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion) const
Definition: vulkan.hpp:1659
void vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy *pRegions) const
Definition: vulkan.hpp:1239
VkResult vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass) const
Definition: vulkan.hpp:1647
VkResult vkCreateDescriptorUpdateTemplateKHR(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate) const
Definition: vulkan.hpp:1561
void vkCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) const
Definition: vulkan.hpp:1319
VkResult vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkLayerProperties *pProperties) const
Definition: vulkan.hpp:1873
void vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource *pSubresource, VkSubresourceLayout *pLayout) const
Definition: vulkan.hpp:2053
VkResult vkCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2KHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass) const
Definition: vulkan.hpp:1651
void vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) const
Definition: vulkan.hpp:2481
VkResult vkAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR *pAcquireInfo, uint32_t *pImageIndex) const
Definition: vulkan.hpp:1097
void vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator) const
Definition: vulkan.hpp:1845
VkResult vkCreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchains) const
Definition: vulkan.hpp:1675
VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV *pExternalImageFormatProperties) const
Definition: vulkan.hpp:2137
void vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) const
Definition: vulkan.hpp:1443
VkResult vkCreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugUtilsMessengerEXT *pMessenger) const
Definition: vulkan.hpp:1545
void vkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo) const
Definition: vulkan.hpp:1159
void vkCmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV *pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) const
Definition: vulkan.hpp:1499
VkResult vkDisplayPowerControlEXT(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT *pDisplayPowerInfo) const
Definition: vulkan.hpp:1861
void vkDestroyDescriptorUpdateTemplateKHR(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator) const
Definition: vulkan.hpp:1765
VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities) const
Definition: vulkan.hpp:2253
VkResult vkGetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR *pCapabilities) const
Definition: vulkan.hpp:1999
void vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties *pMemoryProperties) const
Definition: vulkan.hpp:2189
void vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy *pRegions) const
Definition: vulkan.hpp:1231
void vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks *pAllocator) const
Definition: vulkan.hpp:1913
VkResult vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties) const
Definition: vulkan.hpp:2181
void vkCmdReserveSpaceForCommandsNVX(VkCommandBuffer commandBuffer, const VkCmdReserveSpaceForCommandsInfoNVX *pReserveSpaceInfo) const
Definition: vulkan.hpp:1395
VkResult vkDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT *pTagInfo) const
Definition: vulkan.hpp:1721
VkResult vkGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t *pPropertyCount, VkDisplayModePropertiesKHR *pProperties) const
Definition: vulkan.hpp:1991
void vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator) const
Definition: vulkan.hpp:1741
VkResult vkGetAccelerationStructureHandleNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void *pData) const
Definition: vulkan.hpp:1917
VkResult vkRegisterObjectsNVX(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectTableEntryNVX *const *ppObjectTableEntries, const uint32_t *pObjectIndices) const
Definition: vulkan.hpp:2429
void vkCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) const
Definition: vulkan.hpp:1311
void vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) const
Definition: vulkan.hpp:1451
VkResult vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR *pModes) const
Definition: vulkan.hpp:1967
void vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers) const
Definition: vulkan.hpp:1905
VkResult vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex) const
Definition: vulkan.hpp:1101
VkResult vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages) const
Definition: vulkan.hpp:2345
VkResult vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate) const
Definition: vulkan.hpp:1557
VkResult vkCreateSamplerYcbcrConversionKHR(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion) const
Definition: vulkan.hpp:1663
VkResult vkGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT *pTimestampInfos, uint64_t *pTimestamps, uint64_t *pMaxDeviation) const
Definition: vulkan.hpp:1943
VkResult vkSetEvent(VkDevice device, VkEvent event) const
Definition: vulkan.hpp:2465
void vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks *pAllocator) const
Definition: vulkan.hpp:1757
void vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks *pAllocator) const
Definition: vulkan.hpp:1841
VkResult vkCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence) const
Definition: vulkan.hpp:1581
void vkGetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures) const
Definition: vulkan.hpp:1959
void vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks *pAllocator) const
Definition: vulkan.hpp:1781
VkResult vkGetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain) const
Definition: vulkan.hpp:2349
VkResult vkCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader) const
Definition: vulkan.hpp:1511
void vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) const
Definition: vulkan.hpp:1359
void vkGetAccelerationStructureMemoryRequirementsNV(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2KHR *pMemoryRequirements) const
Definition: vulkan.hpp:1921
VkResult vkReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display) const
Definition: vulkan.hpp:2433
void vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) const
Definition: vulkan.hpp:1279
void vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks *pAllocator) const
Definition: vulkan.hpp:1813
void vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t *pDynamicOffsets) const
Definition: vulkan.hpp:1183
void vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator) const
Definition: vulkan.hpp:1829
VkResult vkSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT *pNameInfo) const
Definition: vulkan.hpp:2457
VkResult vkGetDisplayPlaneCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR *pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR *pCapabilities) const
Definition: vulkan.hpp:1995
VkResult vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges) const
Definition: vulkan.hpp:2377
void vkGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties) const
Definition: vulkan.hpp:2197
void vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions) const
Definition: vulkan.hpp:1243
void vkQueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo) const
Definition: vulkan.hpp:2393
void vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator) const
Definition: vulkan.hpp:1821
void vkCmdEndRenderPass(VkCommandBuffer commandBuffer) const
Definition: vulkan.hpp:1343
void vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) const
Definition: vulkan.hpp:1423
VkResult vkGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPropertiesKHR *pProperties) const
Definition: vulkan.hpp:2117
void vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties) const
Definition: vulkan.hpp:2237
void vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties) const
Definition: vulkan.hpp:2193
void vkCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask) const
Definition: vulkan.hpp:1435
VkResult vkDeviceWaitIdle(VkDevice device) const
Definition: vulkan.hpp:1857
void vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) const
Definition: vulkan.hpp:1263
void vkCmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void *pCheckpointMarker) const
Definition: vulkan.hpp:1415
void vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks *pAllocator) const
Definition: vulkan.hpp:1753
VkResult vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence) const
Definition: vulkan.hpp:2413
void vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator) const
Definition: vulkan.hpp:1789
void vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport *pViewports) const
Definition: vulkan.hpp:1475
VkResult vkGetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT *pProperties) const
Definition: vulkan.hpp:2025
void vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t *pPropertyCount, VkSparseImageFormatProperties *pProperties) const
Definition: vulkan.hpp:2233
void vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties) const
Definition: vulkan.hpp:2209
void vkGetImageSparseMemoryRequirements2KHR(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements) const
Definition: vulkan.hpp:2049
void vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index) const
Definition: vulkan.hpp:1339
void vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) const
Definition: vulkan.hpp:1275
VkResult vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo *pBindInfo, VkFence fence) const
Definition: vulkan.hpp:2397
VkResult vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore) const
Definition: vulkan.hpp:1667
VkResult vkResetEvent(VkDevice device, VkEvent event) const
Definition: vulkan.hpp:2449
VkResult vkCreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSampler *pSampler) const
Definition: vulkan.hpp:1655
void vkGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties) const
Definition: vulkan.hpp:2133
void vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) const
Definition: vulkan.hpp:1467
void vkCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV *pCustomSampleOrders) const
Definition: vulkan.hpp:1419
void vkCmdTraceRaysNV(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth) const
Definition: vulkan.hpp:1487
VkResult vkGetMemoryFdPropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR *pMemoryFdProperties) const
Definition: vulkan.hpp:2071
VkResult vkGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, size_t *pDataSize, void *pData) const
Definition: vulkan.hpp:2353
VkResult vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout) const
Definition: vulkan.hpp:1635
void vkDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks *pAllocator) const
Definition: vulkan.hpp:1749
void vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator) const
Definition: vulkan.hpp:1733
void vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties *pFormatProperties) const
Definition: vulkan.hpp:2161
void vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) const
Definition: vulkan.hpp:1427
void vkSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData) const
Definition: vulkan.hpp:2473
VkResult vkGetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR *pGetFdInfo, int *pFd) const
Definition: vulkan.hpp:2327
void vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks *pAllocator) const
Definition: vulkan.hpp:1737
VkResult vkGetRefreshCycleDurationGOOGLE(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE *pDisplayTimingProperties) const
Definition: vulkan.hpp:2319
void vkCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) const
Definition: vulkan.hpp:1503
void vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets) const
Definition: vulkan.hpp:1351
void vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets) const
Definition: vulkan.hpp:1203
void vkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData) const
Definition: vulkan.hpp:2493
void vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, VkSubpassContents contents) const
Definition: vulkan.hpp:1171
void vkGetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties) const
Definition: vulkan.hpp:2241
VkResult vkGetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR *pGetFdInfo, int *pFd) const
Definition: vulkan.hpp:2011
void vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers) const
Definition: vulkan.hpp:1495
void vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties) const
Definition: vulkan.hpp:2169
VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPlaneProperties2KHR *pProperties) const
Definition: vulkan.hpp:2105
void vkGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements) const
Definition: vulkan.hpp:1935
VkResult vkEnumeratePhysicalDeviceGroupsKHR(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties) const
Definition: vulkan.hpp:1893
VkResult vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pRectCount, VkRect2D *pRects) const
Definition: vulkan.hpp:2205
void vkCmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) const
Definition: vulkan.hpp:1271
VkResult vkCreateObjectTableNVX(VkDevice device, const VkObjectTableCreateInfoNVX *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkObjectTableNVX *pObjectTable) const
Definition: vulkan.hpp:1627
void vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) const
Definition: vulkan.hpp:1367
void vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks *pAllocator) const
Definition: vulkan.hpp:1805
void vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties) const
Definition: vulkan.hpp:2121
void vkQueueEndDebugUtilsLabelEXT(VkQueue queue) const
Definition: vulkan.hpp:2401
void vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue) const
Definition: vulkan.hpp:1983
void vkCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) const
Definition: vulkan.hpp:1291
VkResult vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer) const
Definition: vulkan.hpp:1585
VkResult vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo) const
Definition: vulkan.hpp:2409
VkResult vkEndCommandBuffer(VkCommandBuffer commandBuffer) const
Definition: vulkan.hpp:1865
void vkGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT *pMultisampleProperties) const
Definition: vulkan.hpp:2201
VkResult vkCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pCallback) const
Definition: vulkan.hpp:1541
void vkCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void *pData) const
Definition: vulkan.hpp:1391
void vkGetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements) const
Definition: vulkan.hpp:1939
void vkCmdProcessCommandsNVX(VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX *pProcessCommandsInfo) const
Definition: vulkan.hpp:1379
VkResult vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineCache *pPipelineCache) const
Definition: vulkan.hpp:1631
void vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) const
Definition: vulkan.hpp:1299
void vkGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties) const
Definition: vulkan.hpp:2125
void vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes) const
Definition: vulkan.hpp:1199
VkResult vkGetMemoryFdKHR(VkDevice device, const VkMemoryGetFdInfoKHR *pGetFdInfo, int *pFd) const
Definition: vulkan.hpp:2067
void vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements *pSparseMemoryRequirements) const
Definition: vulkan.hpp:2041
void vkCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV *pShadingRatePalettes) const
Definition: vulkan.hpp:1479
void vkSetHdrMetadataEXT(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR *pSwapchains, const VkHdrMetadataEXT *pMetadata) const
Definition: vulkan.hpp:2469
void vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements) const
Definition: vulkan.hpp:2033
void vkCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask) const
Definition: vulkan.hpp:1323
VkResult vkSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT *pTagInfo) const
Definition: vulkan.hpp:2461
VkResult vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorSetLayout *pSetLayout) const
Definition: vulkan.hpp:1553
VkResult vkGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t *pDisplayCount, VkDisplayKHR *pDisplays) const
Definition: vulkan.hpp:2003
VkResult vkCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer) const
Definition: vulkan.hpp:1525
VkResult vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool) const
Definition: vulkan.hpp:1639
void vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) const
Definition: vulkan.hpp:1283
void vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) const
Definition: vulkan.hpp:1267
VkResult vkImportSemaphoreFdKHR(VkDevice device, const VkImportSemaphoreFdInfoKHR *pImportSemaphoreFdInfo) const
Definition: vulkan.hpp:2367
void vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer) const
Definition: vulkan.hpp:1327
void vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) const
Definition: vulkan.hpp:1411
void vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator) const
Definition: vulkan.hpp:1777
void vkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo) const
Definition: vulkan.hpp:1363
void vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks *pAllocator) const
Definition: vulkan.hpp:1825
void vkDestroySamplerYcbcrConversionKHR(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator) const
Definition: vulkan.hpp:1833
void vkCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) const
Definition: vulkan.hpp:1315
VkResult vkQueueWaitIdle(VkQueue queue) const
Definition: vulkan.hpp:2417
void vkGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport) const
Definition: vulkan.hpp:1947
VkResult vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain) const
Definition: vulkan.hpp:1679
VkResult vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCommandPool *pCommandPool) const
Definition: vulkan.hpp:1533
void vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties *pQueueFamilyProperties) const
Definition: vulkan.hpp:2221
void vkCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo) const
Definition: vulkan.hpp:1251
VkResult vkCreateAccelerationStructureNV(VkDevice device, const VkAccelerationStructureCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureNV *pAccelerationStructure) const
Definition: vulkan.hpp:1515
VkResult vkCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImageView *pView) const
Definition: vulkan.hpp:1609
void vkDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks *pAllocator) const
Definition: vulkan.hpp:1745
void vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties) const
Definition: vulkan.hpp:2217
VkResult vkGetFenceStatus(VkDevice device, VkFence fence) const
Definition: vulkan.hpp:2015
void vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites) const
Definition: vulkan.hpp:1387
VkResult vkRegisterDeviceEventEXT(VkDevice device, const VkDeviceEventInfoEXT *pDeviceEventInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence) const
Definition: vulkan.hpp:2421
VkResult vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkInstance *pInstance) const
Definition: vulkan.hpp:1617
void vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void *pValues) const
Definition: vulkan.hpp:1383
void vkQueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo) const
Definition: vulkan.hpp:2405
void vkDestroyIndirectCommandsLayoutNVX(VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout, const VkAllocationCallbacks *pAllocator) const
Definition: vulkan.hpp:1793
VkResult vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) const
Definition: vulkan.hpp:2445
void vkCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV *pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset) const
Definition: vulkan.hpp:1211
void vkUpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData) const
Definition: vulkan.hpp:2497
void vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers) const
Definition: vulkan.hpp:1375
void vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) const
Definition: vulkan.hpp:1769
void vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask) const
Definition: vulkan.hpp:1431
void vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D *pScissors) const
Definition: vulkan.hpp:1459
void vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator) const
Definition: vulkan.hpp:1761
VkResult vkMergeValidationCachesEXT(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT *pSrcCaches) const
Definition: vulkan.hpp:2389
void vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char *pLayerPrefix, const char *pMessage) const
Definition: vulkan.hpp:1725
void vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve *pRegions) const
Definition: vulkan.hpp:1407
void vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) const
Definition: vulkan.hpp:1335
void vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment *pAttachments, uint32_t rectCount, const VkClearRect *pRects) const
Definition: vulkan.hpp:1215
void vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements *pMemoryRequirements) const
Definition: vulkan.hpp:1931
VkResult vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos) const
Definition: vulkan.hpp:1139
PFN_vkVoidFunction vkGetDeviceProcAddr(VkDevice device, const char *pName) const
Definition: vulkan.hpp:1975
void vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator) const
Definition: vulkan.hpp:1837
VkResult vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache *pSrcCaches) const
Definition: vulkan.hpp:2385
void vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures) const
Definition: vulkan.hpp:2157
VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainEXT *pTimeDomains) const
Definition: vulkan.hpp:2101
void vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties) const
Definition: vulkan.hpp:2165
VkResult vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) const
Definition: vulkan.hpp:1131
VkResult vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos) const
Definition: vulkan.hpp:1135
VkResult vkGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void *pHostPointer, VkMemoryHostPointerPropertiesEXT *pMemoryHostPointerProperties) const
Definition: vulkan.hpp:2075
void vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator) const
Definition: vulkan.hpp:1785
VkResult vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) const
Definition: vulkan.hpp:1589
void vkDestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks *pAllocator) const
Definition: vulkan.hpp:1853
void vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet *pDescriptorCopies) const
Definition: vulkan.hpp:2501
VkResult vkBindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV *pBindInfos) const
Definition: vulkan.hpp:1127
void vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks *pAllocator) const
Definition: vulkan.hpp:1817
void vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) const
Definition: vulkan.hpp:1247
void vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT *pSampleLocationsInfo) const
Definition: vulkan.hpp:1455
VkResult vkGetDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t *pPropertyCount, VkDisplayModeProperties2KHR *pProperties) const
Definition: vulkan.hpp:1987
void vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties) const
Definition: vulkan.hpp:2213
void vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) const
Definition: vulkan.hpp:1471
void vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) const
Definition: vulkan.hpp:1287
void vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize *pCommittedMemoryInBytes) const
Definition: vulkan.hpp:1971
void vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator) const
Definition: vulkan.hpp:1773
void vkDestroyAccelerationStructureNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks *pAllocator) const
Definition: vulkan.hpp:1729
VkResult vkEnumerateInstanceVersion(uint32_t *pApiVersion) const
Definition: vulkan.hpp:1885
VkResult vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) const
Definition: vulkan.hpp:2437
void vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) const
Definition: vulkan.hpp:1463
void vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue *pColor, uint32_t rangeCount, const VkImageSubresourceRange *pRanges) const
Definition: vulkan.hpp:1219
VkResult vkCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkEvent *pEvent) const
Definition: vulkan.hpp:1577
VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT *pSurfaceCapabilities) const
Definition: vulkan.hpp:2245
void vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets) const
Definition: vulkan.hpp:1179
VkResult vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t *pDataSize, void *pData) const
Definition: vulkan.hpp:2297
VkResult vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos) const
Definition: vulkan.hpp:1151
void vkCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer) const
Definition: vulkan.hpp:1255
void vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties) const
Definition: vulkan.hpp:2129
VkResult vkEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties) const
Definition: vulkan.hpp:1889
VkResult vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges) const
Definition: vulkan.hpp:1901
VkResult vkCreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDisplayModeKHR *pMode) const
Definition: vulkan.hpp:1569
VkResult vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo, VkCommandBuffer *pCommandBuffers) const
Definition: vulkan.hpp:1111
VkResult vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void *pData, VkDeviceSize stride, VkQueryResultFlags flags) const
Definition: vulkan.hpp:2301
VkResult vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties *pImageFormatProperties) const
Definition: vulkan.hpp:2177
void vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) const
Definition: vulkan.hpp:1507
VkResult vkCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) const
Definition: vulkan.hpp:1643
void vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers) const
Definition: vulkan.hpp:1355
VkResult vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties) const
Definition: vulkan.hpp:2185
PFN_vkVoidFunction vkGetInstanceProcAddr(VkInstance instance, const char *pName) const
Definition: vulkan.hpp:2057
void vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) const
Definition: vulkan.hpp:1163
void vkCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) const
Definition: vulkan.hpp:1195
void vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy *pRegions) const
Definition: vulkan.hpp:1235
VkResult vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) const
Definition: vulkan.hpp:1537
VkResult vkDebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT *pNameInfo) const
Definition: vulkan.hpp:1717
VkResult vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties) const
Definition: vulkan.hpp:1869
void vkDestroyObjectTableNVX(VkDevice device, VkObjectTableNVX objectTable, const VkAllocationCallbacks *pAllocator) const
Definition: vulkan.hpp:1801
VkResult vkGetSwapchainCounterEXT(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t *pCounterValue) const
Definition: vulkan.hpp:2341
void vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks *pAllocator) const
Definition: vulkan.hpp:1809
void vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer) const
Definition: vulkan.hpp:1331
VkResult vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, VkPhysicalDevice *pPhysicalDevices) const
Definition: vulkan.hpp:1897
void vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D *pDiscardRectangles) const
Definition: vulkan.hpp:1439
void vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void *pData) const
Definition: vulkan.hpp:1491
void vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue) const
Definition: vulkan.hpp:1979
VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats) const
Definition: vulkan.hpp:2261
void vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties) const
Definition: vulkan.hpp:2141
void vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures) const
Definition: vulkan.hpp:2149
void vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(VkPhysicalDevice physicalDevice, VkDeviceGeneratedCommandsFeaturesNVX *pFeatures, VkDeviceGeneratedCommandsLimitsNVX *pLimits) const
Definition: vulkan.hpp:2173
VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, VkSurfaceCapabilities2KHR *pSurfaceCapabilities) const
Definition: vulkan.hpp:2249
void vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) const
Definition: vulkan.hpp:1187
VkResult vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) const
Definition: vulkan.hpp:1565
VkResult vkUnregisterObjectsNVX(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectEntryTypeNVX *pObjectEntryTypes, const uint32_t *pObjectIndices) const
Definition: vulkan.hpp:2489
void vkGetDescriptorSetLayoutSupportKHR(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport) const
Definition: vulkan.hpp:1951
VkResult vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets) const
Definition: vulkan.hpp:1909
VkResult vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBufferView *pView) const
Definition: vulkan.hpp:1529
VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pPresentModeCount, VkPresentModeKHR *pPresentModes) const
Definition: vulkan.hpp:2265
void vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit *pRegions, VkFilter filter) const
Definition: vulkan.hpp:1207
void vkCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) const
Definition: vulkan.hpp:1307
VkResult vkRegisterDisplayEventEXT(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT *pDisplayEventInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence) const
Definition: vulkan.hpp:2425
void vkCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV *pViewportWScalings) const
Definition: vulkan.hpp:1483
VkResult vkGetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayProperties2KHR *pProperties) const
Definition: vulkan.hpp:2113
VkResult vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void **ppData) const
Definition: vulkan.hpp:2381
void vkCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeNV mode) const
Definition: vulkan.hpp:1227
void vkCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) const
Definition: vulkan.hpp:1295
VkResult vkGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR *pDeviceGroupPresentCapabilities) const
Definition: vulkan.hpp:1963
VkResult vkImportFenceFdKHR(VkDevice device, const VkImportFenceFdInfoKHR *pImportFenceFdInfo) const
Definition: vulkan.hpp:2357
void vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties) const
Definition: vulkan.hpp:2225
void vkCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D *pExclusiveScissors) const
Definition: vulkan.hpp:1447
void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties) const
Definition: vulkan.hpp:2145
void vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfoKHR *pSubpassEndInfo) const
Definition: vulkan.hpp:1347
void vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, const VkSubpassBeginInfoKHR *pSubpassBeginInfo) const
Definition: vulkan.hpp:1175
void vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfoKHR *pSubpassBeginInfo, const VkSubpassEndInfoKHR *pSubpassEndInfo) const
Definition: vulkan.hpp:1371
void vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures) const
Definition: vulkan.hpp:2153
void vkGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties) const
Definition: vulkan.hpp:2229
VkResult vkGetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t *pInfoSize, void *pInfo) const
Definition: vulkan.hpp:2337
VkResult vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo, const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory) const
Definition: vulkan.hpp:1119
VkResult vkCreateIndirectCommandsLayoutNVX(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkIndirectCommandsLayoutNVX *pIndirectCommandsLayout) const
Definition: vulkan.hpp:1613
VkResult vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkShaderModule *pShaderModule) const
Definition: vulkan.hpp:1671
VkResult vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32 *pSupported) const
Definition: vulkan.hpp:2269
void vkUnmapMemory(VkDevice device, VkDeviceMemory memory) const
Definition: vulkan.hpp:2485
void vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures) const
Definition: vulkan.hpp:1955
void vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator) const
Definition: vulkan.hpp:1849
void vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements) const
Definition: vulkan.hpp:2029
VkResult vkGetEventStatus(VkDevice device, VkEvent event) const
Definition: vulkan.hpp:2007
void vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) const
Definition: vulkan.hpp:1191
void vkGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements) const
Definition: vulkan.hpp:2045
void vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) const
Definition: vulkan.hpp:2477
void vkGetQueueCheckpointDataNV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointDataNV *pCheckpointData) const
Definition: vulkan.hpp:2305
VkResult vkEnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties) const
Definition: vulkan.hpp:1877
void vkCmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo) const
Definition: vulkan.hpp:1259
void vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) const
Definition: vulkan.hpp:1403
VkResult vkEnumerateInstanceLayerProperties(uint32_t *pPropertyCount, VkLayerProperties *pProperties) const
Definition: vulkan.hpp:1881
VkResult vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos) const
Definition: vulkan.hpp:1147
VkResult vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo, VkDescriptorSet *pDescriptorSets) const
Definition: vulkan.hpp:1115
VkResult vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) const
Definition: vulkan.hpp:1143
void vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D *pGranularity) const
Definition: vulkan.hpp:2323
void vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) const
Definition: vulkan.hpp:1399
VkResult vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) const
Definition: vulkan.hpp:2441
VkResult vkGetPastPresentationTimingGOOGLE(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pPresentationTimingCount, VkPastPresentationTimingGOOGLE *pPresentationTimings) const
Definition: vulkan.hpp:2097
VkResult vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, uint64_t timeout) const
Definition: vulkan.hpp:2505
void vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index) const
Definition: vulkan.hpp:1167
VkResult vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorPool *pDescriptorPool) const
Definition: vulkan.hpp:1549
VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPlanePropertiesKHR *pProperties) const
Definition: vulkan.hpp:2109
VkResult vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo) const
Definition: vulkan.hpp:1123
VkResult vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImage *pImage) const
Definition: vulkan.hpp:1599
VkResult vkCreateDisplayPlaneSurfaceKHR(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) const
Definition: vulkan.hpp:1573
VkResult vkGetRayTracingShaderGroupHandlesNV(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData) const
Definition: vulkan.hpp:2315
void vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator) const
Definition: vulkan.hpp:1797
VkResult vkGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, uint32_t *pSurfaceFormatCount, VkSurfaceFormat2KHR *pSurfaceFormats) const
Definition: vulkan.hpp:2257
void vkGetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements) const
Definition: vulkan.hpp:2037
void vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride) const
Definition: vulkan.hpp:1303
VkResult vkCreateValidationCacheEXT(VkDevice device, const VkValidationCacheCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkValidationCacheEXT *pValidationCache) const
Definition: vulkan.hpp:1683
bool operator!=(DisplayKHR const &rhs) const
Definition: vulkan.hpp:4724
VULKAN_HPP_CONSTEXPR DisplayKHR(std::nullptr_t)
Definition: vulkan.hpp:4697
VULKAN_HPP_TYPESAFE_EXPLICIT DisplayKHR(VkDisplayKHR displayKHR)
Definition: vulkan.hpp:4701
bool operator==(DisplayKHR const &rhs) const
Definition: vulkan.hpp:4719
VULKAN_HPP_CONSTEXPR DisplayKHR()
Definition: vulkan.hpp:4693
DisplayKHR & operator=(std::nullptr_t)
Definition: vulkan.hpp:4713
bool operator<(DisplayKHR const &rhs) const
Definition: vulkan.hpp:4729
VULKAN_HPP_CONSTEXPR DisplayModeKHR(std::nullptr_t)
Definition: vulkan.hpp:4764
bool operator!=(DisplayModeKHR const &rhs) const
Definition: vulkan.hpp:4791
VULKAN_HPP_TYPESAFE_EXPLICIT DisplayModeKHR(VkDisplayModeKHR displayModeKHR)
Definition: vulkan.hpp:4768
VULKAN_HPP_CONSTEXPR DisplayModeKHR()
Definition: vulkan.hpp:4760
bool operator==(DisplayModeKHR const &rhs) const
Definition: vulkan.hpp:4786
DisplayModeKHR & operator=(std::nullptr_t)
Definition: vulkan.hpp:4780
bool operator<(DisplayModeKHR const &rhs) const
Definition: vulkan.hpp:4796
virtual std::string message(int ev) const override
Definition: vulkan.hpp:684
virtual const char * name() const noexcept override
Definition: vulkan.hpp:683
virtual ~Error()=default
virtual const char * what() const noexcept=0
Event & operator=(std::nullptr_t)
Definition: vulkan.hpp:3972
VULKAN_HPP_TYPESAFE_EXPLICIT Event(VkEvent event)
Definition: vulkan.hpp:3960
bool operator!=(Event const &rhs) const
Definition: vulkan.hpp:3983
VULKAN_HPP_CONSTEXPR Event()
Definition: vulkan.hpp:3952
bool operator<(Event const &rhs) const
Definition: vulkan.hpp:3988
VULKAN_HPP_CONSTEXPR Event(std::nullptr_t)
Definition: vulkan.hpp:3956
bool operator==(Event const &rhs) const
Definition: vulkan.hpp:3978
ExtensionNotPresentError(std::string const &message)
Definition: vulkan.hpp:806
FeatureNotPresentError(char const *message)
Definition: vulkan.hpp:816
FeatureNotPresentError(std::string const &message)
Definition: vulkan.hpp:814
VULKAN_HPP_CONSTEXPR Fence(std::nullptr_t)
Definition: vulkan.hpp:3822
bool operator<(Fence const &rhs) const
Definition: vulkan.hpp:3854
Fence & operator=(std::nullptr_t)
Definition: vulkan.hpp:3838
bool operator!=(Fence const &rhs) const
Definition: vulkan.hpp:3849
VULKAN_HPP_CONSTEXPR Fence()
Definition: vulkan.hpp:3818
bool operator==(Fence const &rhs) const
Definition: vulkan.hpp:3844
VULKAN_HPP_TYPESAFE_EXPLICIT Fence(VkFence fence)
Definition: vulkan.hpp:3826
bool operator!=(Flags< BitType > const &rhs) const
Definition: vulkan.hpp:231
Flags< BitType > operator|(Flags< BitType > const &rhs) const
Definition: vulkan.hpp:193
Flags< BitType > & operator&=(Flags< BitType > const &rhs)
Definition: vulkan.hpp:181
bool operator==(Flags< BitType > const &rhs) const
Definition: vulkan.hpp:226
Flags< BitType > & operator=(Flags< BitType > const &rhs)
Definition: vulkan.hpp:169
Flags(MaskType flags)
Definition: vulkan.hpp:164
Flags< BitType > operator^(Flags< BitType > const &rhs) const
Definition: vulkan.hpp:207
Flags< BitType > operator&(Flags< BitType > const &rhs) const
Definition: vulkan.hpp:200
VULKAN_HPP_CONSTEXPR Flags()
Definition: vulkan.hpp:149
Flags< BitType > & operator^=(Flags< BitType > const &rhs)
Definition: vulkan.hpp:187
Flags< BitType > operator~() const
Definition: vulkan.hpp:219
Flags(Flags< BitType > const &rhs)
Definition: vulkan.hpp:159
Flags< BitType > & operator|=(Flags< BitType > const &rhs)
Definition: vulkan.hpp:175
FormatNotSupportedError(std::string const &message)
Definition: vulkan.hpp:838
FormatNotSupportedError(char const *message)
Definition: vulkan.hpp:840
FragmentationEXTError(char const *message)
Definition: vulkan.hpp:928
FragmentationEXTError(std::string const &message)
Definition: vulkan.hpp:926
FragmentedPoolError(std::string const &message)
Definition: vulkan.hpp:846
FragmentedPoolError(char const *message)
Definition: vulkan.hpp:848
Framebuffer & operator=(std::nullptr_t)
Definition: vulkan.hpp:4106
bool operator<(Framebuffer const &rhs) const
Definition: vulkan.hpp:4122
bool operator!=(Framebuffer const &rhs) const
Definition: vulkan.hpp:4117
bool operator==(Framebuffer const &rhs) const
Definition: vulkan.hpp:4112
VULKAN_HPP_TYPESAFE_EXPLICIT Framebuffer(VkFramebuffer framebuffer)
Definition: vulkan.hpp:4094
VULKAN_HPP_CONSTEXPR Framebuffer()
Definition: vulkan.hpp:4086
VULKAN_HPP_CONSTEXPR Framebuffer(std::nullptr_t)
Definition: vulkan.hpp:4090
VULKAN_HPP_CONSTEXPR Image()
Definition: vulkan.hpp:3215
bool operator==(Image const &rhs) const
Definition: vulkan.hpp:3241
bool operator!=(Image const &rhs) const
Definition: vulkan.hpp:3246
VULKAN_HPP_CONSTEXPR Image(std::nullptr_t)
Definition: vulkan.hpp:3219
Image & operator=(std::nullptr_t)
Definition: vulkan.hpp:3235
VULKAN_HPP_TYPESAFE_EXPLICIT Image(VkImage image)
Definition: vulkan.hpp:3223
bool operator<(Image const &rhs) const
Definition: vulkan.hpp:3251
bool operator==(ImageView const &rhs) const
Definition: vulkan.hpp:3308
bool operator!=(ImageView const &rhs) const
Definition: vulkan.hpp:3313
VULKAN_HPP_CONSTEXPR ImageView()
Definition: vulkan.hpp:3282
ImageView & operator=(std::nullptr_t)
Definition: vulkan.hpp:3302
VULKAN_HPP_CONSTEXPR ImageView(std::nullptr_t)
Definition: vulkan.hpp:3286
bool operator<(ImageView const &rhs) const
Definition: vulkan.hpp:3318
VULKAN_HPP_TYPESAFE_EXPLICIT ImageView(VkImageView imageView)
Definition: vulkan.hpp:3290
IncompatibleDisplayKHRError(std::string const &message)
Definition: vulkan.hpp:894
IncompatibleDriverError(char const *message)
Definition: vulkan.hpp:824
IncompatibleDriverError(std::string const &message)
Definition: vulkan.hpp:822
bool operator<(IndirectCommandsLayoutNVX const &rhs) const
Definition: vulkan.hpp:4390
bool operator==(IndirectCommandsLayoutNVX const &rhs) const
Definition: vulkan.hpp:4380
bool operator!=(IndirectCommandsLayoutNVX const &rhs) const
Definition: vulkan.hpp:4385
VkIndirectCommandsLayoutNVX m_indirectCommandsLayoutNVX
Definition: vulkan.hpp:4413
VULKAN_HPP_TYPESAFE_EXPLICIT IndirectCommandsLayoutNVX(VkIndirectCommandsLayoutNVX indirectCommandsLayoutNVX)
Definition: vulkan.hpp:4362
VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNVX()
Definition: vulkan.hpp:4354
IndirectCommandsLayoutNVX & operator=(std::nullptr_t)
Definition: vulkan.hpp:4374
VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNVX(std::nullptr_t)
Definition: vulkan.hpp:4358
InitializationFailedError(std::string const &message)
Definition: vulkan.hpp:774
void destroySurfaceKHR(SurfaceKHR surface, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
PFN_vkVoidFunction getProcAddr(const char *pName, Dispatch const &d=Dispatch()) const
void destroyDebugReportCallbackEXT(DebugReportCallbackEXT callback, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
void destroy(const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
ResultValueType< UniqueHandle< SurfaceKHR, Dispatch > >::type createDisplayPlaneSurfaceKHRUnique(const DisplaySurfaceCreateInfoKHR &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
void destroy(DebugReportCallbackEXT callback, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
void submitDebugUtilsMessageEXT(DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, DebugUtilsMessageTypeFlagsEXT messageTypes, const DebugUtilsMessengerCallbackDataEXT &callbackData, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< PhysicalDeviceGroupProperties, Allocator > >::type enumeratePhysicalDeviceGroupsKHR(Dispatch const &d=Dispatch()) const
Result enumeratePhysicalDeviceGroupsKHR(uint32_t *pPhysicalDeviceGroupCount, PhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties, Dispatch const &d=Dispatch()) const
void destroy(SurfaceKHR surface, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
VULKAN_HPP_CONSTEXPR Instance()
Definition: vulkan.hpp:47305
Result enumeratePhysicalDeviceGroups(uint32_t *pPhysicalDeviceGroupCount, PhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties, Dispatch const &d=Dispatch()) const
void destroy(DebugReportCallbackEXT callback, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
ResultValueType< DebugUtilsMessengerEXT >::type createDebugUtilsMessengerEXT(const DebugUtilsMessengerCreateInfoEXT &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
Result createDebugReportCallbackEXT(const DebugReportCallbackCreateInfoEXT *pCreateInfo, const AllocationCallbacks *pAllocator, DebugReportCallbackEXT *pCallback, Dispatch const &d=Dispatch()) const
void destroyDebugReportCallbackEXT(DebugReportCallbackEXT callback, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
Result enumeratePhysicalDevices(uint32_t *pPhysicalDeviceCount, PhysicalDevice *pPhysicalDevices, Dispatch const &d=Dispatch()) const
void debugReportMessageEXT(DebugReportFlagsEXT flags, DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const std::string &layerPrefix, const std::string &message, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< PhysicalDeviceGroupProperties, Allocator > >::type enumeratePhysicalDeviceGroups(Dispatch const &d=Dispatch()) const
void destroy(Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< PhysicalDeviceGroupProperties, Allocator > >::type enumeratePhysicalDeviceGroups(Allocator const &vectorAllocator, Dispatch const &d) const
ResultValueType< UniqueHandle< DebugReportCallbackEXT, Dispatch > >::type createDebugReportCallbackEXTUnique(const DebugReportCallbackCreateInfoEXT &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
PFN_vkVoidFunction getProcAddr(const std::string &name, Dispatch const &d=Dispatch()) const
VULKAN_HPP_CONSTEXPR Instance(std::nullptr_t)
Definition: vulkan.hpp:47309
void destroyDebugUtilsMessengerEXT(DebugUtilsMessengerEXT messenger, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< PhysicalDevice, Allocator > >::type enumeratePhysicalDevices(Dispatch const &d=Dispatch()) const
Result createDebugUtilsMessengerEXT(const DebugUtilsMessengerCreateInfoEXT *pCreateInfo, const AllocationCallbacks *pAllocator, DebugUtilsMessengerEXT *pMessenger, Dispatch const &d=Dispatch()) const
void submitDebugUtilsMessageEXT(DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, DebugUtilsMessageTypeFlagsEXT messageTypes, const DebugUtilsMessengerCallbackDataEXT *pCallbackData, Dispatch const &d=Dispatch()) const
void destroySurfaceKHR(SurfaceKHR surface, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< UniqueHandle< DebugUtilsMessengerEXT, Dispatch > >::type createDebugUtilsMessengerEXTUnique(const DebugUtilsMessengerCreateInfoEXT &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
VULKAN_HPP_TYPESAFE_EXPLICIT Instance(VkInstance instance)
Definition: vulkan.hpp:47313
ResultValueType< std::vector< PhysicalDevice, Allocator > >::type enumeratePhysicalDevices(Allocator const &vectorAllocator, Dispatch const &d) const
ResultValueType< DebugReportCallbackEXT >::type createDebugReportCallbackEXT(const DebugReportCallbackCreateInfoEXT &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
void debugReportMessageEXT(DebugReportFlagsEXT flags, DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char *pLayerPrefix, const char *pMessage, Dispatch const &d=Dispatch()) const
void destroy(DebugUtilsMessengerEXT messenger, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< SurfaceKHR >::type createDisplayPlaneSurfaceKHR(const DisplaySurfaceCreateInfoKHR &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
bool operator!=(Instance const &rhs) const
Definition: vulkan.hpp:47336
void destroy(DebugUtilsMessengerEXT messenger, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< PhysicalDeviceGroupProperties, Allocator > >::type enumeratePhysicalDeviceGroupsKHR(Allocator const &vectorAllocator, Dispatch const &d) const
void destroyDebugUtilsMessengerEXT(DebugUtilsMessengerEXT messenger, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
bool operator==(Instance const &rhs) const
Definition: vulkan.hpp:47331
Result createDisplayPlaneSurfaceKHR(const DisplaySurfaceCreateInfoKHR *pCreateInfo, const AllocationCallbacks *pAllocator, SurfaceKHR *pSurface, Dispatch const &d=Dispatch()) const
Instance & operator=(std::nullptr_t)
Definition: vulkan.hpp:47325
bool operator<(Instance const &rhs) const
Definition: vulkan.hpp:47341
void destroy(SurfaceKHR surface, const AllocationCallbacks *pAllocator, Dispatch const &d=Dispatch()) const
InvalidDrmFormatModifierPlaneLayoutEXTError(std::string const &message)
Definition: vulkan.hpp:918
InvalidExternalHandleError(std::string const &message)
Definition: vulkan.hpp:862
InvalidShaderNVError(char const *message)
Definition: vulkan.hpp:912
InvalidShaderNVError(std::string const &message)
Definition: vulkan.hpp:910
LayerNotPresentError(std::string const &message)
Definition: vulkan.hpp:798
LayerNotPresentError(char const *message)
Definition: vulkan.hpp:800
virtual const char * what() const noexcept
Definition: vulkan.hpp:728
LogicError(const std::string &what)
Definition: vulkan.hpp:722
LogicError(char const *what)
Definition: vulkan.hpp:724
MemoryMapFailedError(char const *message)
Definition: vulkan.hpp:792
MemoryMapFailedError(std::string const &message)
Definition: vulkan.hpp:790
NativeWindowInUseKHRError(std::string const &message)
Definition: vulkan.hpp:878
NotPermittedEXTError(char const *message)
Definition: vulkan.hpp:936
NotPermittedEXTError(std::string const &message)
Definition: vulkan.hpp:934
Optional< const AllocationCallbacks > getAllocator() const
Definition: vulkan.hpp:2550
ObjectDestroy(Optional< const AllocationCallbacks > allocationCallbacks=nullptr, Dispatch const &dispatch=Dispatch())
Definition: vulkan.hpp:2545
Optional< const AllocationCallbacks > m_allocationCallbacks
Definition: vulkan.hpp:2560
Optional< const AllocationCallbacks > getAllocator() const
Definition: vulkan.hpp:2524
Optional< const AllocationCallbacks > m_allocationCallbacks
Definition: vulkan.hpp:2535
ObjectDestroy(OwnerType owner=OwnerType(), Optional< const AllocationCallbacks > allocationCallbacks=nullptr, Dispatch const &dispatch=Dispatch())
Definition: vulkan.hpp:2517
OwnerType getOwner() const
Definition: vulkan.hpp:2574
Optional< const AllocationCallbacks > getAllocator() const
Definition: vulkan.hpp:2575
ObjectFree(OwnerType owner=OwnerType(), Optional< const AllocationCallbacks > allocationCallbacks=nullptr, Dispatch const &dispatch=Dispatch())
Definition: vulkan.hpp:2568
Optional< const AllocationCallbacks > m_allocationCallbacks
Definition: vulkan.hpp:2586
bool operator!=(ObjectTableNVX const &rhs) const
Definition: vulkan.hpp:4318
ObjectTableNVX & operator=(std::nullptr_t)
Definition: vulkan.hpp:4307
bool operator<(ObjectTableNVX const &rhs) const
Definition: vulkan.hpp:4323
bool operator==(ObjectTableNVX const &rhs) const
Definition: vulkan.hpp:4313
VULKAN_HPP_CONSTEXPR ObjectTableNVX()
Definition: vulkan.hpp:4287
VULKAN_HPP_TYPESAFE_EXPLICIT ObjectTableNVX(VkObjectTableNVX objectTableNVX)
Definition: vulkan.hpp:4295
VULKAN_HPP_CONSTEXPR ObjectTableNVX(std::nullptr_t)
Definition: vulkan.hpp:4291
Optional(std::nullptr_t)
Definition: vulkan.hpp:275
RefType const * operator->() const
Definition: vulkan.hpp:278
Optional(RefType &reference)
Definition: vulkan.hpp:273
OutOfDateKHRError(std::string const &message)
Definition: vulkan.hpp:886
OutOfDateKHRError(char const *message)
Definition: vulkan.hpp:888
OutOfDeviceMemoryError(char const *message)
Definition: vulkan.hpp:768
OutOfDeviceMemoryError(std::string const &message)
Definition: vulkan.hpp:766
OutOfHostMemoryError(std::string const &message)
Definition: vulkan.hpp:758
OutOfHostMemoryError(char const *message)
Definition: vulkan.hpp:760
OutOfPoolMemoryError(char const *message)
Definition: vulkan.hpp:856
OutOfPoolMemoryError(std::string const &message)
Definition: vulkan.hpp:854
void getExternalBufferPropertiesKHR(const PhysicalDeviceExternalBufferInfo *pExternalBufferInfo, ExternalBufferProperties *pExternalBufferProperties, Dispatch const &d=Dispatch()) const
ExternalFenceProperties getExternalFencePropertiesKHR(const PhysicalDeviceExternalFenceInfo &externalFenceInfo, Dispatch const &d=Dispatch()) const
Result getSurfaceCapabilities2KHR(const PhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, SurfaceCapabilities2KHR *pSurfaceCapabilities, Dispatch const &d=Dispatch()) const
PhysicalDeviceMemoryProperties getMemoryProperties(Dispatch const &d=Dispatch()) const
void getFeatures2KHR(PhysicalDeviceFeatures2 *pFeatures, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< DisplayKHR, Allocator > >::type getDisplayPlaneSupportedDisplaysKHR(uint32_t planeIndex, Dispatch const &d=Dispatch()) const
Result getDisplayPropertiesKHR(uint32_t *pPropertyCount, DisplayPropertiesKHR *pProperties, Dispatch const &d=Dispatch()) const
PhysicalDevice & operator=(std::nullptr_t)
Definition: vulkan.hpp:45079
ResultValueType< std::vector< DisplayPlaneProperties2KHR, Allocator > >::type getDisplayPlaneProperties2KHR(Dispatch const &d=Dispatch()) const
Result getCalibrateableTimeDomainsEXT(uint32_t *pTimeDomainCount, TimeDomainEXT *pTimeDomains, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< DisplayModeProperties2KHR, Allocator > >::type getDisplayModeProperties2KHR(DisplayKHR display, Dispatch const &d=Dispatch()) const
PhysicalDeviceFeatures getFeatures(Dispatch const &d=Dispatch()) const
DeviceGeneratedCommandsLimitsNVX getGeneratedCommandsPropertiesNVX(DeviceGeneratedCommandsFeaturesNVX &features, Dispatch const &d=Dispatch()) const
void getFeatures(PhysicalDeviceFeatures *pFeatures, Dispatch const &d=Dispatch()) const
Result getDisplayModePropertiesKHR(DisplayKHR display, uint32_t *pPropertyCount, DisplayModePropertiesKHR *pProperties, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< SurfaceFormatKHR, Allocator > >::type getSurfaceFormatsKHR(SurfaceKHR surface, Allocator const &vectorAllocator, Dispatch const &d) const
Result createDisplayModeKHR(DisplayKHR display, const DisplayModeCreateInfoKHR *pCreateInfo, const AllocationCallbacks *pAllocator, DisplayModeKHR *pMode, Dispatch const &d=Dispatch()) const
std::vector< SparseImageFormatProperties, Allocator > getSparseImageFormatProperties(Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, Dispatch const &d=Dispatch()) const
Result getSurfaceFormatsKHR(SurfaceKHR surface, uint32_t *pSurfaceFormatCount, SurfaceFormatKHR *pSurfaceFormats, Dispatch const &d=Dispatch()) const
ResultValueType< DisplayPlaneCapabilities2KHR >::type getDisplayPlaneCapabilities2KHR(const DisplayPlaneInfo2KHR &displayPlaneInfo, Dispatch const &d=Dispatch()) const
ResultValueType< Device >::type createDevice(const DeviceCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< LayerProperties, Allocator > >::type enumerateDeviceLayerProperties(Dispatch const &d=Dispatch()) const
Result getExternalImageFormatPropertiesNV(Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ExternalMemoryHandleTypeFlagsNV externalHandleType, ExternalImageFormatPropertiesNV *pExternalImageFormatProperties, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< PresentModeKHR, Allocator > >::type getSurfacePresentModesKHR(SurfaceKHR surface, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< PresentModeKHR, Allocator > >::type getSurfacePresentModesKHR(SurfaceKHR surface, Allocator const &vectorAllocator, Dispatch const &d) const
ResultValueType< std::vector< SurfaceFormat2KHR, Allocator > >::type getSurfaceFormats2KHR(const PhysicalDeviceSurfaceInfo2KHR &surfaceInfo, Allocator const &vectorAllocator, Dispatch const &d) const
void getQueueFamilyProperties(uint32_t *pQueueFamilyPropertyCount, QueueFamilyProperties *pQueueFamilyProperties, Dispatch const &d=Dispatch()) const
void getQueueFamilyProperties2KHR(uint32_t *pQueueFamilyPropertyCount, QueueFamilyProperties2 *pQueueFamilyProperties, Dispatch const &d=Dispatch()) const
Result getDisplayPlaneCapabilitiesKHR(DisplayModeKHR mode, uint32_t planeIndex, DisplayPlaneCapabilitiesKHR *pCapabilities, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< DisplayProperties2KHR, Allocator > >::type getDisplayProperties2KHR(Dispatch const &d=Dispatch()) const
Result getDisplayPlaneCapabilities2KHR(const DisplayPlaneInfo2KHR *pDisplayPlaneInfo, DisplayPlaneCapabilities2KHR *pCapabilities, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< TimeDomainEXT, Allocator > >::type getCalibrateableTimeDomainsEXT(Allocator const &vectorAllocator, Dispatch const &d) const
Result getSurfaceSupportKHR(uint32_t queueFamilyIndex, SurfaceKHR surface, Bool32 *pSupported, Dispatch const &d=Dispatch()) const
Result getImageFormatProperties2KHR(const PhysicalDeviceImageFormatInfo2 *pImageFormatInfo, ImageFormatProperties2 *pImageFormatProperties, Dispatch const &d=Dispatch()) const
void getFeatures2(PhysicalDeviceFeatures2 *pFeatures, Dispatch const &d=Dispatch()) const
std::vector< QueueFamilyProperties2, Allocator > getQueueFamilyProperties2(Dispatch const &d=Dispatch()) const
ResultValueType< void >::type releaseDisplayEXT(DisplayKHR display, Dispatch const &d=Dispatch()) const
PhysicalDeviceMemoryProperties2 getMemoryProperties2(Dispatch const &d=Dispatch()) const
std::vector< QueueFamilyProperties2, Allocator > getQueueFamilyProperties2KHR(Allocator const &vectorAllocator, Dispatch const &d) const
void getQueueFamilyProperties2(uint32_t *pQueueFamilyPropertyCount, QueueFamilyProperties2 *pQueueFamilyProperties, Dispatch const &d=Dispatch()) const
std::vector< QueueFamilyProperties, Allocator > getQueueFamilyProperties(Allocator const &vectorAllocator, Dispatch const &d) const
ExternalBufferProperties getExternalBufferPropertiesKHR(const PhysicalDeviceExternalBufferInfo &externalBufferInfo, Dispatch const &d=Dispatch()) const
void getExternalFencePropertiesKHR(const PhysicalDeviceExternalFenceInfo *pExternalFenceInfo, ExternalFenceProperties *pExternalFenceProperties, Dispatch const &d=Dispatch()) const
ExternalBufferProperties getExternalBufferProperties(const PhysicalDeviceExternalBufferInfo &externalBufferInfo, Dispatch const &d=Dispatch()) const
Result createDevice(const DeviceCreateInfo *pCreateInfo, const AllocationCallbacks *pAllocator, Device *pDevice, Dispatch const &d=Dispatch()) const
ResultValueType< DisplayModeKHR >::type createDisplayModeKHR(DisplayKHR display, const DisplayModeCreateInfoKHR &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ResultValueType< StructureChain< X, Y, Z... > >::type getSurfaceCapabilities2KHR(const PhysicalDeviceSurfaceInfo2KHR &surfaceInfo, Dispatch const &d=Dispatch()) const
ResultValueType< ExternalImageFormatPropertiesNV >::type getExternalImageFormatPropertiesNV(Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ExternalMemoryHandleTypeFlagsNV externalHandleType, Dispatch const &d=Dispatch()) const
std::vector< QueueFamilyProperties2, Allocator > getQueueFamilyProperties2(Allocator const &vectorAllocator, Dispatch const &d) const
std::vector< QueueFamilyProperties, Allocator > getQueueFamilyProperties(Dispatch const &d=Dispatch()) const
std::vector< SparseImageFormatProperties2, Allocator > getSparseImageFormatProperties2KHR(const PhysicalDeviceSparseImageFormatInfo2 &formatInfo, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< Rect2D, Allocator > >::type getPresentRectanglesKHR(SurfaceKHR surface, Allocator const &vectorAllocator, Dispatch const &d) const
Result getDisplayPlaneProperties2KHR(uint32_t *pPropertyCount, DisplayPlaneProperties2KHR *pProperties, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< TimeDomainEXT, Allocator > >::type getCalibrateableTimeDomainsEXT(Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< DisplayPlanePropertiesKHR, Allocator > >::type getDisplayPlanePropertiesKHR(Allocator const &vectorAllocator, Dispatch const &d) const
void getProperties2(PhysicalDeviceProperties2 *pProperties, Dispatch const &d=Dispatch()) const
std::vector< SparseImageFormatProperties2, Allocator > getSparseImageFormatProperties2(const PhysicalDeviceSparseImageFormatInfo2 &formatInfo, Allocator const &vectorAllocator, Dispatch const &d) const
std::vector< QueueFamilyProperties2, Allocator > getQueueFamilyProperties2KHR(Dispatch const &d=Dispatch()) const
ResultValueType< UniqueHandle< Device, Dispatch > >::type createDeviceUnique(const DeviceCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch()) const
ExternalSemaphoreProperties getExternalSemaphoreProperties(const PhysicalDeviceExternalSemaphoreInfo &externalSemaphoreInfo, Dispatch const &d=Dispatch()) const
StructureChain< X, Y, Z... > getProperties(Dispatch const &d=Dispatch()) const
void getSparseImageFormatProperties(Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, uint32_t *pPropertyCount, SparseImageFormatProperties *pProperties, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< Rect2D, Allocator > >::type getPresentRectanglesKHR(SurfaceKHR surface, Dispatch const &d=Dispatch()) const
Result getDisplayPlaneSupportedDisplaysKHR(uint32_t planeIndex, uint32_t *pDisplayCount, DisplayKHR *pDisplays, Dispatch const &d=Dispatch()) const
MultisamplePropertiesEXT getMultisamplePropertiesEXT(SampleCountFlagBits samples, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< DisplayKHR, Allocator > >::type getDisplayPlaneSupportedDisplaysKHR(uint32_t planeIndex, Allocator const &vectorAllocator, Dispatch const &d) const
Result getImageFormatProperties(Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ImageFormatProperties *pImageFormatProperties, Dispatch const &d=Dispatch()) const
ResultValueType< SurfaceCapabilities2KHR >::type getSurfaceCapabilities2KHR(const PhysicalDeviceSurfaceInfo2KHR &surfaceInfo, Dispatch const &d=Dispatch()) const
void getFormatProperties2(Format format, FormatProperties2 *pFormatProperties, Dispatch const &d=Dispatch()) const
VULKAN_HPP_CONSTEXPR PhysicalDevice(std::nullptr_t)
Definition: vulkan.hpp:45063
Result getDisplayProperties2KHR(uint32_t *pPropertyCount, DisplayProperties2KHR *pProperties, Dispatch const &d=Dispatch()) const
VULKAN_HPP_TYPESAFE_EXPLICIT PhysicalDevice(VkPhysicalDevice physicalDevice)
Definition: vulkan.hpp:45067
ResultValueType< SurfaceCapabilitiesKHR >::type getSurfaceCapabilitiesKHR(SurfaceKHR surface, Dispatch const &d=Dispatch()) const
void getGeneratedCommandsPropertiesNVX(DeviceGeneratedCommandsFeaturesNVX *pFeatures, DeviceGeneratedCommandsLimitsNVX *pLimits, Dispatch const &d=Dispatch()) const
void getSparseImageFormatProperties2(const PhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, SparseImageFormatProperties2 *pProperties, Dispatch const &d=Dispatch()) const
std::vector< SparseImageFormatProperties2, Allocator > getSparseImageFormatProperties2(const PhysicalDeviceSparseImageFormatInfo2 &formatInfo, Dispatch const &d=Dispatch()) const
ResultValueType< SurfaceCapabilities2EXT >::type getSurfaceCapabilities2EXT(SurfaceKHR surface, Dispatch const &d=Dispatch()) const
void getFormatProperties(Format format, FormatProperties *pFormatProperties, Dispatch const &d=Dispatch()) const
bool operator==(PhysicalDevice const &rhs) const
Definition: vulkan.hpp:45085
PhysicalDeviceFeatures2 getFeatures2KHR(Dispatch const &d=Dispatch()) const
void getProperties2KHR(PhysicalDeviceProperties2 *pProperties, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< ExtensionProperties, Allocator > >::type enumerateDeviceExtensionProperties(Optional< const std::string > layerName, Allocator const &vectorAllocator, Dispatch const &d) const
Result getSurfaceCapabilities2EXT(SurfaceKHR surface, SurfaceCapabilities2EXT *pSurfaceCapabilities, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< DisplayModePropertiesKHR, Allocator > >::type getDisplayModePropertiesKHR(DisplayKHR display, Allocator const &vectorAllocator, Dispatch const &d) const
void getProperties(PhysicalDeviceProperties *pProperties, Dispatch const &d=Dispatch()) const
std::vector< SparseImageFormatProperties, Allocator > getSparseImageFormatProperties(Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, Allocator const &vectorAllocator, Dispatch const &d) const
ResultValueType< std::vector< ExtensionProperties, Allocator > >::type enumerateDeviceExtensionProperties(Optional< const std::string > layerName=nullptr, Dispatch const &d=Dispatch()) const
void getSparseImageFormatProperties2KHR(const PhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, SparseImageFormatProperties2 *pProperties, Dispatch const &d=Dispatch()) const
void getMultisamplePropertiesEXT(SampleCountFlagBits samples, MultisamplePropertiesEXT *pMultisampleProperties, Dispatch const &d=Dispatch()) const
PhysicalDeviceMemoryProperties2 getMemoryProperties2KHR(Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< DisplayPropertiesKHR, Allocator > >::type getDisplayPropertiesKHR(Allocator const &vectorAllocator, Dispatch const &d) const
ResultValueType< ImageFormatProperties2 >::type getImageFormatProperties2KHR(const PhysicalDeviceImageFormatInfo2 &imageFormatInfo, Dispatch const &d=Dispatch()) const
ResultValueType< DisplayPlaneCapabilitiesKHR >::type getDisplayPlaneCapabilitiesKHR(DisplayModeKHR mode, uint32_t planeIndex, Dispatch const &d=Dispatch()) const
void getMemoryProperties(PhysicalDeviceMemoryProperties *pMemoryProperties, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< SurfaceFormat2KHR, Allocator > >::type getSurfaceFormats2KHR(const PhysicalDeviceSurfaceInfo2KHR &surfaceInfo, Dispatch const &d=Dispatch()) const
void getExternalSemaphoreProperties(const PhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, ExternalSemaphoreProperties *pExternalSemaphoreProperties, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< DisplayPlanePropertiesKHR, Allocator > >::type getDisplayPlanePropertiesKHR(Dispatch const &d=Dispatch()) const
Result getSurfacePresentModesKHR(SurfaceKHR surface, uint32_t *pPresentModeCount, PresentModeKHR *pPresentModes, Dispatch const &d=Dispatch()) const
Result enumerateDeviceLayerProperties(uint32_t *pPropertyCount, LayerProperties *pProperties, Dispatch const &d=Dispatch()) const
void getMemoryProperties2KHR(PhysicalDeviceMemoryProperties2 *pMemoryProperties, Dispatch const &d=Dispatch()) const
ResultValueType< ImageFormatProperties2 >::type getImageFormatProperties2(const PhysicalDeviceImageFormatInfo2 &imageFormatInfo, Dispatch const &d=Dispatch()) const
Result getSurfaceFormats2KHR(const PhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, uint32_t *pSurfaceFormatCount, SurfaceFormat2KHR *pSurfaceFormats, Dispatch const &d=Dispatch()) const
StructureChain< X, Y, Z... > getFormatProperties2(Format format, Dispatch const &d=Dispatch()) const
Result enumerateDeviceExtensionProperties(const char *pLayerName, uint32_t *pPropertyCount, ExtensionProperties *pProperties, Dispatch const &d=Dispatch()) const
Result getDisplayModeProperties2KHR(DisplayKHR display, uint32_t *pPropertyCount, DisplayModeProperties2KHR *pProperties, Dispatch const &d=Dispatch()) const
PhysicalDeviceProperties2 getProperties2(Dispatch const &d=Dispatch()) const
VULKAN_HPP_CONSTEXPR PhysicalDevice()
Definition: vulkan.hpp:45059
ResultValueType< std::vector< LayerProperties, Allocator > >::type enumerateDeviceLayerProperties(Allocator const &vectorAllocator, Dispatch const &d) const
StructureChain< X, Y, Z... > getProperties2KHR(Dispatch const &d=Dispatch()) const
PhysicalDeviceProperties getProperties(Dispatch const &d=Dispatch()) const
bool operator!=(PhysicalDevice const &rhs) const
Definition: vulkan.hpp:45090
ResultValueType< ImageFormatProperties >::type getImageFormatProperties(Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, Dispatch const &d=Dispatch()) const
Result getPresentRectanglesKHR(SurfaceKHR surface, uint32_t *pRectCount, Rect2D *pRects, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< DisplayModePropertiesKHR, Allocator > >::type getDisplayModePropertiesKHR(DisplayKHR display, Dispatch const &d=Dispatch()) const
ResultValueType< Bool32 >::type getSurfaceSupportKHR(uint32_t queueFamilyIndex, SurfaceKHR surface, Dispatch const &d=Dispatch()) const
PhysicalDeviceProperties2 getProperties2KHR(Dispatch const &d=Dispatch()) const
ResultValueType< StructureChain< X, Y, Z... > >::type getImageFormatProperties2KHR(const PhysicalDeviceImageFormatInfo2 &imageFormatInfo, Dispatch const &d=Dispatch()) const
FormatProperties getFormatProperties(Format format, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< DisplayProperties2KHR, Allocator > >::type getDisplayProperties2KHR(Allocator const &vectorAllocator, Dispatch const &d) const
ExternalSemaphoreProperties getExternalSemaphorePropertiesKHR(const PhysicalDeviceExternalSemaphoreInfo &externalSemaphoreInfo, Dispatch const &d=Dispatch()) const
StructureChain< X, Y, Z... > getFeatures2(Dispatch const &d=Dispatch()) const
void getExternalSemaphorePropertiesKHR(const PhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, ExternalSemaphoreProperties *pExternalSemaphoreProperties, Dispatch const &d=Dispatch()) const
Result getImageFormatProperties2(const PhysicalDeviceImageFormatInfo2 *pImageFormatInfo, ImageFormatProperties2 *pImageFormatProperties, Dispatch const &d=Dispatch()) const
void getExternalBufferProperties(const PhysicalDeviceExternalBufferInfo *pExternalBufferInfo, ExternalBufferProperties *pExternalBufferProperties, Dispatch const &d=Dispatch()) const
void getFormatProperties2KHR(Format format, FormatProperties2 *pFormatProperties, Dispatch const &d=Dispatch()) const
FormatProperties2 getFormatProperties2(Format format, Dispatch const &d=Dispatch()) const
Result getDisplayPlanePropertiesKHR(uint32_t *pPropertyCount, DisplayPlanePropertiesKHR *pProperties, Dispatch const &d=Dispatch()) const
void getMemoryProperties2(PhysicalDeviceMemoryProperties2 *pMemoryProperties, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< SurfaceFormatKHR, Allocator > >::type getSurfaceFormatsKHR(SurfaceKHR surface, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< DisplayPlaneProperties2KHR, Allocator > >::type getDisplayPlaneProperties2KHR(Allocator const &vectorAllocator, Dispatch const &d) const
FormatProperties2 getFormatProperties2KHR(Format format, Dispatch const &d=Dispatch()) const
std::vector< SparseImageFormatProperties2, Allocator > getSparseImageFormatProperties2KHR(const PhysicalDeviceSparseImageFormatInfo2 &formatInfo, Allocator const &vectorAllocator, Dispatch const &d) const
bool operator<(PhysicalDevice const &rhs) const
Definition: vulkan.hpp:45095
Result getSurfaceCapabilitiesKHR(SurfaceKHR surface, SurfaceCapabilitiesKHR *pSurfaceCapabilities, Dispatch const &d=Dispatch()) const
StructureChain< X, Y, Z... > getProperties2(Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< DisplayPropertiesKHR, Allocator > >::type getDisplayPropertiesKHR(Dispatch const &d=Dispatch()) const
StructureChain< X, Y, Z... > getFeatures2KHR(Dispatch const &d=Dispatch()) const
ExternalFenceProperties getExternalFenceProperties(const PhysicalDeviceExternalFenceInfo &externalFenceInfo, Dispatch const &d=Dispatch()) const
ResultValueType< std::vector< DisplayModeProperties2KHR, Allocator > >::type getDisplayModeProperties2KHR(DisplayKHR display, Allocator const &vectorAllocator, Dispatch const &d) const
StructureChain< X, Y, Z... > getFormatProperties2KHR(Format format, Dispatch const &d=Dispatch()) const
ResultValueType< StructureChain< X, Y, Z... > >::type getImageFormatProperties2(const PhysicalDeviceImageFormatInfo2 &imageFormatInfo, Dispatch const &d=Dispatch()) const
PhysicalDeviceFeatures2 getFeatures2(Dispatch const &d=Dispatch()) const
void getExternalFenceProperties(const PhysicalDeviceExternalFenceInfo *pExternalFenceInfo, ExternalFenceProperties *pExternalFenceProperties, Dispatch const &d=Dispatch()) const
bool operator!=(PipelineCache const &rhs) const
Definition: vulkan.hpp:4251
VULKAN_HPP_CONSTEXPR PipelineCache()
Definition: vulkan.hpp:4220
PipelineCache & operator=(std::nullptr_t)
Definition: vulkan.hpp:4240
VULKAN_HPP_CONSTEXPR PipelineCache(std::nullptr_t)
Definition: vulkan.hpp:4224
bool operator==(PipelineCache const &rhs) const
Definition: vulkan.hpp:4246
bool operator<(PipelineCache const &rhs) const
Definition: vulkan.hpp:4256
VULKAN_HPP_TYPESAFE_EXPLICIT PipelineCache(VkPipelineCache pipelineCache)
Definition: vulkan.hpp:4228
VULKAN_HPP_TYPESAFE_EXPLICIT Pipeline(VkPipeline pipeline)
Definition: vulkan.hpp:3424
VULKAN_HPP_CONSTEXPR Pipeline()
Definition: vulkan.hpp:3416
bool operator==(Pipeline const &rhs) const
Definition: vulkan.hpp:3442
VULKAN_HPP_CONSTEXPR Pipeline(std::nullptr_t)
Definition: vulkan.hpp:3420
Pipeline & operator=(std::nullptr_t)
Definition: vulkan.hpp:3436
bool operator!=(Pipeline const &rhs) const
Definition: vulkan.hpp:3447
bool operator<(Pipeline const &rhs) const
Definition: vulkan.hpp:3452
bool operator<(PipelineLayout const &rhs) const
Definition: vulkan.hpp:3519
bool operator==(PipelineLayout const &rhs) const
Definition: vulkan.hpp:3509
PipelineLayout & operator=(std::nullptr_t)
Definition: vulkan.hpp:3503
bool operator!=(PipelineLayout const &rhs) const
Definition: vulkan.hpp:3514
VULKAN_HPP_CONSTEXPR PipelineLayout()
Definition: vulkan.hpp:3483
VULKAN_HPP_TYPESAFE_EXPLICIT PipelineLayout(VkPipelineLayout pipelineLayout)
Definition: vulkan.hpp:3491
VULKAN_HPP_CONSTEXPR PipelineLayout(std::nullptr_t)
Definition: vulkan.hpp:3487
PoolType getPool() const
Definition: vulkan.hpp:2601
PoolFree(OwnerType owner=OwnerType(), PoolType pool=PoolType(), Dispatch const &dispatch=Dispatch())
Definition: vulkan.hpp:2594
Dispatch const * m_dispatch
Definition: vulkan.hpp:2613
OwnerType getOwner() const
Definition: vulkan.hpp:2600
QueryPool & operator=(std::nullptr_t)
Definition: vulkan.hpp:4039
bool operator!=(QueryPool const &rhs) const
Definition: vulkan.hpp:4050
VULKAN_HPP_CONSTEXPR QueryPool()
Definition: vulkan.hpp:4019
bool operator<(QueryPool const &rhs) const
Definition: vulkan.hpp:4055
bool operator==(QueryPool const &rhs) const
Definition: vulkan.hpp:4045
VULKAN_HPP_CONSTEXPR QueryPool(std::nullptr_t)
Definition: vulkan.hpp:4023
VULKAN_HPP_TYPESAFE_EXPLICIT QueryPool(VkQueryPool queryPool)
Definition: vulkan.hpp:4027
Result presentKHR(const PresentInfoKHR *pPresentInfo, Dispatch const &d=Dispatch()) const
void endDebugUtilsLabelEXT(Dispatch const &d=Dispatch()) const
bool operator==(Queue const &rhs) const
Definition: vulkan.hpp:39678
void insertDebugUtilsLabelEXT(const DebugUtilsLabelEXT *pLabelInfo, Dispatch const &d=Dispatch()) const
ResultValueType< void >::type bindSparse(ArrayProxy< const BindSparseInfo > bindInfo, Fence fence, Dispatch const &d=Dispatch()) const
ResultValueType< void >::type waitIdle(Dispatch const &d=Dispatch()) const
VULKAN_HPP_TYPESAFE_EXPLICIT Queue(VkQueue queue)
Definition: vulkan.hpp:39660
std::vector< CheckpointDataNV, Allocator > getCheckpointDataNV(Allocator const &vectorAllocator, Dispatch const &d) const
void getCheckpointDataNV(uint32_t *pCheckpointDataCount, CheckpointDataNV *pCheckpointData, Dispatch const &d=Dispatch()) const
bool operator<(Queue const &rhs) const
Definition: vulkan.hpp:39688
bool operator!=(Queue const &rhs) const
Definition: vulkan.hpp:39683
Result submit(uint32_t submitCount, const SubmitInfo *pSubmits, Fence fence, Dispatch const &d=Dispatch()) const
VULKAN_HPP_CONSTEXPR Queue()
Definition: vulkan.hpp:39652
ResultValueType< void >::type submit(ArrayProxy< const SubmitInfo > submits, Fence fence, Dispatch const &d=Dispatch()) const
Result presentKHR(const PresentInfoKHR &presentInfo, Dispatch const &d=Dispatch()) const
void beginDebugUtilsLabelEXT(const DebugUtilsLabelEXT *pLabelInfo, Dispatch const &d=Dispatch()) const
Result bindSparse(uint32_t bindInfoCount, const BindSparseInfo *pBindInfo, Fence fence, Dispatch const &d=Dispatch()) const
std::vector< CheckpointDataNV, Allocator > getCheckpointDataNV(Dispatch const &d=Dispatch()) const
void beginDebugUtilsLabelEXT(const DebugUtilsLabelEXT &labelInfo, Dispatch const &d=Dispatch()) const
VULKAN_HPP_CONSTEXPR Queue(std::nullptr_t)
Definition: vulkan.hpp:39656
void insertDebugUtilsLabelEXT(const DebugUtilsLabelEXT &labelInfo, Dispatch const &d=Dispatch()) const
Queue & operator=(std::nullptr_t)
Definition: vulkan.hpp:39672
RenderPass & operator=(std::nullptr_t)
Definition: vulkan.hpp:4173
bool operator!=(RenderPass const &rhs) const
Definition: vulkan.hpp:4184
VULKAN_HPP_CONSTEXPR RenderPass()
Definition: vulkan.hpp:4153
bool operator<(RenderPass const &rhs) const
Definition: vulkan.hpp:4189
VULKAN_HPP_CONSTEXPR RenderPass(std::nullptr_t)
Definition: vulkan.hpp:4157
VULKAN_HPP_TYPESAFE_EXPLICIT RenderPass(VkRenderPass renderPass)
Definition: vulkan.hpp:4161
bool operator==(RenderPass const &rhs) const
Definition: vulkan.hpp:4179
VULKAN_HPP_TYPESAFE_EXPLICIT Sampler(VkSampler sampler)
Definition: vulkan.hpp:3558
bool operator==(Sampler const &rhs) const
Definition: vulkan.hpp:3576
Sampler & operator=(std::nullptr_t)
Definition: vulkan.hpp:3570
bool operator<(Sampler const &rhs) const
Definition: vulkan.hpp:3586
VULKAN_HPP_CONSTEXPR Sampler(std::nullptr_t)
Definition: vulkan.hpp:3554
bool operator!=(Sampler const &rhs) const
Definition: vulkan.hpp:3581
VULKAN_HPP_CONSTEXPR Sampler()
Definition: vulkan.hpp:3550
SamplerYcbcrConversion & operator=(std::nullptr_t)
Definition: vulkan.hpp:4510
VkSamplerYcbcrConversion m_samplerYcbcrConversion
Definition: vulkan.hpp:4549
VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion(std::nullptr_t)
Definition: vulkan.hpp:4494
bool operator<(SamplerYcbcrConversion const &rhs) const
Definition: vulkan.hpp:4526
VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion()
Definition: vulkan.hpp:4490
VULKAN_HPP_TYPESAFE_EXPLICIT SamplerYcbcrConversion(VkSamplerYcbcrConversion samplerYcbcrConversion)
Definition: vulkan.hpp:4498
bool operator!=(SamplerYcbcrConversion const &rhs) const
Definition: vulkan.hpp:4521
bool operator==(SamplerYcbcrConversion const &rhs) const
Definition: vulkan.hpp:4516
Semaphore & operator=(std::nullptr_t)
Definition: vulkan.hpp:3905
bool operator==(Semaphore const &rhs) const
Definition: vulkan.hpp:3911
VULKAN_HPP_CONSTEXPR Semaphore(std::nullptr_t)
Definition: vulkan.hpp:3889
bool operator<(Semaphore const &rhs) const
Definition: vulkan.hpp:3921
VULKAN_HPP_TYPESAFE_EXPLICIT Semaphore(VkSemaphore semaphore)
Definition: vulkan.hpp:3893
VULKAN_HPP_CONSTEXPR Semaphore()
Definition: vulkan.hpp:3885
bool operator!=(Semaphore const &rhs) const
Definition: vulkan.hpp:3916
bool operator!=(ShaderModule const &rhs) const
Definition: vulkan.hpp:3380
VULKAN_HPP_CONSTEXPR ShaderModule(std::nullptr_t)
Definition: vulkan.hpp:3353
bool operator<(ShaderModule const &rhs) const
Definition: vulkan.hpp:3385
ShaderModule & operator=(std::nullptr_t)
Definition: vulkan.hpp:3369
VULKAN_HPP_CONSTEXPR ShaderModule()
Definition: vulkan.hpp:3349
bool operator==(ShaderModule const &rhs) const
Definition: vulkan.hpp:3375
VULKAN_HPP_TYPESAFE_EXPLICIT ShaderModule(VkShaderModule shaderModule)
Definition: vulkan.hpp:3357
StructureChain & operator=(StructureChain const &rhs)
Definition: vulkan.hpp:539
StructureChain(StructureElements const &... elems)
Definition: vulkan.hpp:534
void linkAndCopy(StructureChain const &rhs)
Definition: vulkan.hpp:572
void linkAndCopyElements(X const &xelem, Y const &yelem, Z const &... zelem)
Definition: vulkan.hpp:590
void linkAndCopyElements(X const &xelem)
Definition: vulkan.hpp:583
StructureChain(StructureChain const &rhs)
Definition: vulkan.hpp:529
void linkAndCopy(StructureChain const &rhs)
Definition: vulkan.hpp:565
VULKAN_HPP_CONSTEXPR SurfaceKHR(std::nullptr_t)
Definition: vulkan.hpp:4831
bool operator<(SurfaceKHR const &rhs) const
Definition: vulkan.hpp:4863
VULKAN_HPP_TYPESAFE_EXPLICIT SurfaceKHR(VkSurfaceKHR surfaceKHR)
Definition: vulkan.hpp:4835
SurfaceKHR & operator=(std::nullptr_t)
Definition: vulkan.hpp:4847
bool operator==(SurfaceKHR const &rhs) const
Definition: vulkan.hpp:4853
bool operator!=(SurfaceKHR const &rhs) const
Definition: vulkan.hpp:4858
VULKAN_HPP_CONSTEXPR SurfaceKHR()
Definition: vulkan.hpp:4827
SurfaceLostKHRError(char const *message)
Definition: vulkan.hpp:872
SurfaceLostKHRError(std::string const &message)
Definition: vulkan.hpp:870
bool operator!=(SwapchainKHR const &rhs) const
Definition: vulkan.hpp:4925
SwapchainKHR & operator=(std::nullptr_t)
Definition: vulkan.hpp:4914
VULKAN_HPP_TYPESAFE_EXPLICIT SwapchainKHR(VkSwapchainKHR swapchainKHR)
Definition: vulkan.hpp:4902
VULKAN_HPP_CONSTEXPR SwapchainKHR(std::nullptr_t)
Definition: vulkan.hpp:4898
bool operator==(SwapchainKHR const &rhs) const
Definition: vulkan.hpp:4920
VULKAN_HPP_CONSTEXPR SwapchainKHR()
Definition: vulkan.hpp:4894
bool operator<(SwapchainKHR const &rhs) const
Definition: vulkan.hpp:4930
SystemError(int ev, std::error_category const &ecat)
Definition: vulkan.hpp:740
SystemError(int ev, std::error_category const &ecat, char const *what)
Definition: vulkan.hpp:744
SystemError(std::error_code ec, char const *what)
Definition: vulkan.hpp:738
SystemError(std::error_code ec)
Definition: vulkan.hpp:734
SystemError(int ev, std::error_category const &ecat, std::string const &what)
Definition: vulkan.hpp:742
SystemError(std::error_code ec, std::string const &what)
Definition: vulkan.hpp:736
virtual const char * what() const noexcept
Definition: vulkan.hpp:748
TooManyObjectsError(char const *message)
Definition: vulkan.hpp:832
TooManyObjectsError(std::string const &message)
Definition: vulkan.hpp:830
UniqueHandle(UniqueHandle const &)=delete
UniqueHandle(Type const &value=Type(), Deleter const &deleter=Deleter())
Definition: vulkan.hpp:387
void swap(UniqueHandle< Type, Dispatch > &rhs)
Definition: vulkan.hpp:464
Type const * operator->() const
Definition: vulkan.hpp:418
UniqueHandle & operator=(UniqueHandle const &)=delete
Type const & operator*() const
Definition: vulkan.hpp:428
typename UniqueHandleTraits< Type, Dispatch >::deleter Deleter
Definition: vulkan.hpp:385
void reset(Type const &value=Type())
Definition: vulkan.hpp:448
const Type & get() const
Definition: vulkan.hpp:438
UniqueHandle & operator=(UniqueHandle &&other)
Definition: vulkan.hpp:406
UniqueHandle(UniqueHandle &&other)
Definition: vulkan.hpp:394
bool operator==(ValidationCacheEXT const &rhs) const
Definition: vulkan.hpp:4585
VkValidationCacheEXT m_validationCacheEXT
Definition: vulkan.hpp:4618
ValidationCacheEXT & operator=(std::nullptr_t)
Definition: vulkan.hpp:4579
bool operator<(ValidationCacheEXT const &rhs) const
Definition: vulkan.hpp:4595
VULKAN_HPP_TYPESAFE_EXPLICIT ValidationCacheEXT(VkValidationCacheEXT validationCacheEXT)
Definition: vulkan.hpp:4567
VULKAN_HPP_CONSTEXPR ValidationCacheEXT(std::nullptr_t)
Definition: vulkan.hpp:4563
bool operator!=(ValidationCacheEXT const &rhs) const
Definition: vulkan.hpp:4590
VULKAN_HPP_CONSTEXPR ValidationCacheEXT()
Definition: vulkan.hpp:4559
ValidationFailedEXTError(std::string const &message)
Definition: vulkan.hpp:902
EGLSurface surface
Definition: eglext.h:248
EGLImageKHR EGLint EGLint * handle
Definition: eglext.h:937
EGLSurface EGLNativeWindowType * window
Definition: eglext.h:1025
EGLSurface EGLint * rects
Definition: eglext.h:282
EGLenum objectType
Definition: eglext.h:128
EGLSetBlobFuncANDROID set
Definition: eglext.h:470
EGLSetBlobFuncANDROID EGLGetBlobFuncANDROID get
Definition: eglext.h:470
GLsizei GLenum GLsizei GLsizei GLuint memory
Definition: gl2ext.h:1474
GLuint64 GLenum GLint fd
Definition: gl2ext.h:1508
GLuint64 GLenum handleType
Definition: gl2ext.h:1508
static const double T[]
Definition: k_tan.c:53
static SDL_AudioDeviceID device
Definition: loopwave.c:37
Flags< CommandBufferResetFlagBits, VkCommandBufferResetFlags > CommandBufferResetFlags
Definition: vulkan.hpp:26928
Flags< PipelineRasterizationStateStreamCreateFlagBitsEXT, VkPipelineRasterizationStateStreamCreateFlagsEXT > PipelineRasterizationStateStreamCreateFlagsEXT
Definition: vulkan.hpp:2942
UniqueHandle< CommandBuffer, DispatchLoaderStatic > UniqueCommandBuffer
Definition: vulkan.hpp:39906
Result createInstance(const InstanceCreateInfo *pCreateInfo, const AllocationCallbacks *pAllocator, Instance *pInstance, Dispatch const &d=Dispatch())
Definition: vulkan.hpp:48312
Flags< FramebufferCreateFlagBits, VkFramebufferCreateFlags > FramebufferCreateFlags
Definition: vulkan.hpp:2626
Flags< PipelineMultisampleStateCreateFlagBits, VkPipelineMultisampleStateCreateFlags > PipelineMultisampleStateCreateFlags
Definition: vulkan.hpp:2680
PipelineVertexInputStateCreateFlagBits
Definition: vulkan.hpp:2707
PipelineCoverageToColorStateCreateFlagBitsNV
Definition: vulkan.hpp:2903
Flags< ExternalFenceFeatureFlagBits, VkExternalFenceFeatureFlags > ExternalFenceFeatureFlags
Definition: vulkan.hpp:33306
Flags< ValidationCacheCreateFlagBitsEXT, VkValidationCacheCreateFlagsEXT > ValidationCacheCreateFlagsEXT
Definition: vulkan.hpp:2918
PipelineRasterizationStateCreateFlagBits
Definition: vulkan.hpp:2683
Flags< SemaphoreCreateFlagBits, VkSemaphoreCreateFlags > SemaphoreCreateFlags
Definition: vulkan.hpp:2746
Flags< SparseImageFormatFlagBits, VkSparseImageFormatFlags > SparseImageFormatFlags
Definition: vulkan.hpp:25970
Flags< PipelineDiscardRectangleStateCreateFlagBitsEXT, VkPipelineDiscardRectangleStateCreateFlagsEXT > PipelineDiscardRectangleStateCreateFlagsEXT
Definition: vulkan.hpp:2900
Flags< SamplerCreateFlagBits, VkSamplerCreateFlags > SamplerCreateFlags
Definition: vulkan.hpp:2644
Flags< BitType > operator^(BitType bit, Flags< BitType > const &flags)
Definition: vulkan.hpp:263
Flags< MemoryAllocateFlagBits, VkMemoryAllocateFlags > MemoryAllocateFlags
Definition: vulkan.hpp:33962
Flags< DependencyFlagBits, VkDependencyFlags > DependencyFlags
Definition: vulkan.hpp:28832
Flags< FenceCreateFlagBits, VkFenceCreateFlags > FenceCreateFlags
Definition: vulkan.hpp:24019
Flags< QueryResultFlagBits, VkQueryResultFlags > QueryResultFlags
Definition: vulkan.hpp:24354
Flags< PipelineCacheCreateFlagBits, VkPipelineCacheCreateFlags > PipelineCacheCreateFlags
Definition: vulkan.hpp:2656
Flags< MemoryMapFlagBits, VkMemoryMapFlags > MemoryMapFlags
Definition: vulkan.hpp:2764
Flags< PipelineRasterizationStateCreateFlagBits, VkPipelineRasterizationStateCreateFlags > PipelineRasterizationStateCreateFlags
Definition: vulkan.hpp:2686
Flags< PipelineRasterizationConservativeStateCreateFlagBitsEXT, VkPipelineRasterizationConservativeStateCreateFlagsEXT > PipelineRasterizationConservativeStateCreateFlagsEXT
Definition: vulkan.hpp:2936
Flags< ImageCreateFlagBits, VkImageCreateFlags > ImageCreateFlags
Definition: vulkan.hpp:23505
UniqueHandle< Pipeline, DispatchLoaderStatic > UniquePipeline
Definition: vulkan.hpp:39934
Flags< CommandPoolTrimFlagBits, VkCommandPoolTrimFlags > CommandPoolTrimFlags
Definition: vulkan.hpp:2886
Flags< ShaderStageFlagBits, VkShaderStageFlags > ShaderStageFlags
Definition: vulkan.hpp:22941
Flags< QueueFlagBits, VkQueueFlags > QueueFlags
Definition: vulkan.hpp:21913
Flags< GeometryInstanceFlagBitsNV, VkGeometryInstanceFlagsNV > GeometryInstanceFlagsNV
Definition: vulkan.hpp:36839
VULKAN_HPP_INLINE const std::error_category & errorCategory()
Definition: vulkan.hpp:691
PipelineDiscardRectangleStateCreateFlagBitsEXT
Definition: vulkan.hpp:2897
Flags< ImageUsageFlagBits, VkImageUsageFlags > ImageUsageFlags
Definition: vulkan.hpp:23366
Flags< DisplayModeCreateFlagBitsKHR, VkDisplayModeCreateFlagsKHR > DisplayModeCreateFlagsKHR
Definition: vulkan.hpp:2784
Flags< DisplayPlaneAlphaFlagBitsKHR, VkDisplayPlaneAlphaFlagsKHR > DisplayPlaneAlphaFlagsKHR
Definition: vulkan.hpp:29188
Flags< GeometryFlagBitsNV, VkGeometryFlagsNV > GeometryFlagsNV
Definition: vulkan.hpp:36865
Flags< ConditionalRenderingFlagBitsEXT, VkConditionalRenderingFlagsEXT > ConditionalRenderingFlagsEXT
Definition: vulkan.hpp:36413
Flags< BufferCreateFlagBits, VkBufferCreateFlags > BufferCreateFlags
Definition: vulkan.hpp:22791
Flags< ExternalMemoryFeatureFlagBits, VkExternalMemoryFeatureFlags > ExternalMemoryFeatureFlags
Definition: vulkan.hpp:32283
Result enumerateInstanceVersion(uint32_t *pApiVersion, Dispatch const &d=Dispatch())
Definition: vulkan.hpp:37581
Flags< IndirectCommandsLayoutUsageFlagBitsNVX, VkIndirectCommandsLayoutUsageFlagsNVX > IndirectCommandsLayoutUsageFlagsNVX
Definition: vulkan.hpp:30525
Flags< ColorComponentFlagBits, VkColorComponentFlags > ColorComponentFlags
Definition: vulkan.hpp:23767
Flags< SurfaceCounterFlagBitsEXT, VkSurfaceCounterFlagsEXT > SurfaceCounterFlagsEXT
Definition: vulkan.hpp:33592
DescriptorUpdateTemplateCreateFlagBits
Definition: vulkan.hpp:2773
Flags< ExternalMemoryHandleTypeFlagBits, VkExternalMemoryHandleTypeFlags > ExternalMemoryHandleTypeFlags
Definition: vulkan.hpp:31557
Result enumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pPropertyCount, ExtensionProperties *pProperties, Dispatch const &d=Dispatch())
Definition: vulkan.hpp:37662
Flags< DeviceGroupPresentModeFlagBitsKHR, VkDeviceGroupPresentModeFlagsKHR > DeviceGroupPresentModeFlagsKHR
Definition: vulkan.hpp:34064
Flags< AttachmentDescriptionFlagBits, VkAttachmentDescriptionFlags > AttachmentDescriptionFlags
Definition: vulkan.hpp:28393
VULKAN_HPP_INLINE CullModeFlags operator~(CullModeFlagBits bits)
Definition: vulkan.hpp:8465
PipelineMultisampleStateCreateFlagBits
Definition: vulkan.hpp:2677
Flags< PeerMemoryFeatureFlagBits, VkPeerMemoryFeatureFlags > PeerMemoryFeatureFlags
Definition: vulkan.hpp:33934
Flags< QueryPoolCreateFlagBits, VkQueryPoolCreateFlags > QueryPoolCreateFlags
Definition: vulkan.hpp:2632
Flags< DeviceCreateFlagBits, VkDeviceCreateFlags > DeviceCreateFlags
Definition: vulkan.hpp:2734
Flags< AccessFlagBits, VkAccessFlags > AccessFlags
Definition: vulkan.hpp:22536
Flags< BufferViewCreateFlagBits, VkBufferViewCreateFlags > BufferViewCreateFlags
Definition: vulkan.hpp:2722
VULKAN_HPP_INLINE std::string to_string(Result value)
Definition: vulkan.hpp:637
Flags< PipelineCoverageModulationStateCreateFlagBitsNV, VkPipelineCoverageModulationStateCreateFlagsNV > PipelineCoverageModulationStateCreateFlagsNV
Definition: vulkan.hpp:2912
Result enumerateInstanceLayerProperties(uint32_t *pPropertyCount, LayerProperties *pProperties, Dispatch const &d=Dispatch())
Definition: vulkan.hpp:37606
Flags< BitType > operator|(BitType bit, Flags< BitType > const &flags)
Definition: vulkan.hpp:251
Flags< MemoryPropertyFlagBits, VkMemoryPropertyFlags > MemoryPropertyFlags
Definition: vulkan.hpp:22335
Flags< ExternalMemoryHandleTypeFlagBitsNV, VkExternalMemoryHandleTypeFlagsNV > ExternalMemoryHandleTypeFlagsNV
Definition: vulkan.hpp:30098
Flags< DeviceQueueCreateFlagBits, VkDeviceQueueCreateFlags > DeviceQueueCreateFlags
Definition: vulkan.hpp:22005
Flags< SwapchainCreateFlagBitsKHR, VkSwapchainCreateFlagsKHR > SwapchainCreateFlagsKHR
Definition: vulkan.hpp:34265
Flags< EventCreateFlagBits, VkEventCreateFlags > EventCreateFlags
Definition: vulkan.hpp:2758
Flags< PipelineStageFlagBits, VkPipelineStageFlags > PipelineStageFlags
Definition: vulkan.hpp:26713
PipelineInputAssemblyStateCreateFlagBits
Definition: vulkan.hpp:2701
PipelineViewportSwizzleStateCreateFlagBitsNV
Definition: vulkan.hpp:2891
Flags< ExternalMemoryFeatureFlagBitsNV, VkExternalMemoryFeatureFlagsNV > ExternalMemoryFeatureFlagsNV
Definition: vulkan.hpp:30317
Flags< PipelineVertexInputStateCreateFlagBits, VkPipelineVertexInputStateCreateFlags > PipelineVertexInputStateCreateFlags
Definition: vulkan.hpp:2710
Flags< DebugReportFlagBitsEXT, VkDebugReportFlagsEXT > DebugReportFlagsEXT
Definition: vulkan.hpp:29699
UniqueHandle< DescriptorSet, DispatchLoaderStatic > UniqueDescriptorSet
Definition: vulkan.hpp:39912
Flags< ObjectEntryUsageFlagBitsNVX, VkObjectEntryUsageFlagsNVX > ObjectEntryUsageFlagsNVX
Definition: vulkan.hpp:30551
Flags< SubgroupFeatureFlagBits, VkSubgroupFeatureFlags > SubgroupFeatureFlags
Definition: vulkan.hpp:30458
Flags< CompositeAlphaFlagBitsKHR, VkCompositeAlphaFlagsKHR > CompositeAlphaFlagsKHR
Definition: vulkan.hpp:29291
Flags< MemoryHeapFlagBits, VkMemoryHeapFlags > MemoryHeapFlags
Definition: vulkan.hpp:22390
Flags< ExternalFenceHandleTypeFlagBits, VkExternalFenceHandleTypeFlags > ExternalFenceHandleTypeFlags
Definition: vulkan.hpp:33010
Flags< BufferUsageFlagBits, VkBufferUsageFlags > BufferUsageFlags
Definition: vulkan.hpp:22763
Flags< ImageViewCreateFlagBits, VkImageViewCreateFlags > ImageViewCreateFlags
Definition: vulkan.hpp:2740
PipelineDepthStencilStateCreateFlagBits
Definition: vulkan.hpp:2659
Flags< DescriptorBindingFlagBitsEXT, VkDescriptorBindingFlagsEXT > DescriptorBindingFlagsEXT
Definition: vulkan.hpp:36259
Flags< FormatFeatureFlagBits, VkFormatFeatureFlags > FormatFeatureFlags
Definition: vulkan.hpp:24136
Flags< SampleCountFlagBits, VkSampleCountFlags > SampleCountFlags
Definition: vulkan.hpp:26959
AccelerationStructureMemoryRequirementsTypeNV
Definition: vulkan.hpp:37183
Flags< SemaphoreImportFlagBits, VkSemaphoreImportFlags > SemaphoreImportFlags
Definition: vulkan.hpp:32784
Flags< SubpassDescriptionFlagBits, VkSubpassDescriptionFlags > SubpassDescriptionFlags
Definition: vulkan.hpp:34766
VULKAN_HPP_INLINE void swap(UniqueHandle< Type, Dispatch > &lhs, UniqueHandle< Type, Dispatch > &rhs)
Definition: vulkan.hpp:475
Flags< ExternalSemaphoreFeatureFlagBits, VkExternalSemaphoreFeatureFlags > ExternalSemaphoreFeatureFlags
Definition: vulkan.hpp:32717
Flags< PipelineCreateFlagBits, VkPipelineCreateFlags > PipelineCreateFlags
Definition: vulkan.hpp:23639
Flags< SparseMemoryBindFlagBits, VkSparseMemoryBindFlags > SparseMemoryBindFlags
Definition: vulkan.hpp:26129
Flags< PipelineColorBlendStateCreateFlagBits, VkPipelineColorBlendStateCreateFlags > PipelineColorBlendStateCreateFlags
Definition: vulkan.hpp:2674
Flags< ExternalSemaphoreHandleTypeFlagBits, VkExternalSemaphoreHandleTypeFlags > ExternalSemaphoreHandleTypeFlags
Definition: vulkan.hpp:32421
VULKAN_HPP_INLINE void throwResultException(Result result, char const *message)
Definition: vulkan.hpp:940
Flags< BitType > operator&(BitType bit, Flags< BitType > const &flags)
Definition: vulkan.hpp:257
Flags< StencilFaceFlagBits, VkStencilFaceFlags > StencilFaceFlags
Definition: vulkan.hpp:28687
Flags< PipelineDepthStencilStateCreateFlagBits, VkPipelineDepthStencilStateCreateFlags > PipelineDepthStencilStateCreateFlags
Definition: vulkan.hpp:2662
Flags< FenceImportFlagBits, VkFenceImportFlags > FenceImportFlags
Definition: vulkan.hpp:33373
ResultValueType< UniqueHandle< Instance, Dispatch > >::type createInstanceUnique(const InstanceCreateInfo &createInfo, Optional< const AllocationCallbacks > allocator=nullptr, Dispatch const &d=Dispatch())
Definition: vulkan.hpp:48326
Flags< DebugUtilsMessageSeverityFlagBitsEXT, VkDebugUtilsMessageSeverityFlagsEXT > DebugUtilsMessageSeverityFlagsEXT
Definition: vulkan.hpp:36017
Flags< SurfaceTransformFlagBitsKHR, VkSurfaceTransformFlagsKHR > SurfaceTransformFlagsKHR
Definition: vulkan.hpp:29324
Flags< ShaderModuleCreateFlagBits, VkShaderModuleCreateFlags > ShaderModuleCreateFlags
Definition: vulkan.hpp:2752
Flags< RenderPassCreateFlagBits, VkRenderPassCreateFlags > RenderPassCreateFlags
Definition: vulkan.hpp:2638
Flags< DebugUtilsMessengerCreateFlagBitsEXT, VkDebugUtilsMessengerCreateFlagsEXT > DebugUtilsMessengerCreateFlagsEXT
Definition: vulkan.hpp:2924
PipelineRasterizationStateStreamCreateFlagBitsEXT
Definition: vulkan.hpp:2939
Flags< PipelineLayoutCreateFlagBits, VkPipelineLayoutCreateFlags > PipelineLayoutCreateFlags
Definition: vulkan.hpp:2650
Flags< PipelineShaderStageCreateFlagBits, VkPipelineShaderStageCreateFlags > PipelineShaderStageCreateFlags
Definition: vulkan.hpp:2716
Flags< QueryPipelineStatisticFlagBits, VkQueryPipelineStatisticFlags > QueryPipelineStatisticFlags
Definition: vulkan.hpp:24416
PipelineRasterizationConservativeStateCreateFlagBitsEXT
Definition: vulkan.hpp:2933
Flags< PipelineViewportStateCreateFlagBits, VkPipelineViewportStateCreateFlags > PipelineViewportStateCreateFlags
Definition: vulkan.hpp:2692
Flags< DisplaySurfaceCreateFlagBitsKHR, VkDisplaySurfaceCreateFlagsKHR > DisplaySurfaceCreateFlagsKHR
Definition: vulkan.hpp:2790
Flags< DescriptorUpdateTemplateCreateFlagBits, VkDescriptorUpdateTemplateCreateFlags > DescriptorUpdateTemplateCreateFlags
Definition: vulkan.hpp:2776
Flags< CullModeFlagBits, VkCullModeFlags > CullModeFlags
Definition: vulkan.hpp:8458
Flags< DebugUtilsMessengerCallbackDataFlagBitsEXT, VkDebugUtilsMessengerCallbackDataFlagsEXT > DebugUtilsMessengerCallbackDataFlagsEXT
Definition: vulkan.hpp:2930
VULKAN_HPP_INLINE ResultValueType< void >::type createResultValue(Result result, char const *message)
Definition: vulkan.hpp:1022
PipelineCoverageModulationStateCreateFlagBitsNV
Definition: vulkan.hpp:2909
Flags< DebugUtilsMessageTypeFlagBitsEXT, VkDebugUtilsMessageTypeFlagsEXT > DebugUtilsMessageTypeFlagsEXT
Definition: vulkan.hpp:36044
PipelineTessellationStateCreateFlagBits
Definition: vulkan.hpp:2695
Flags< CommandPoolCreateFlagBits, VkCommandPoolCreateFlags > CommandPoolCreateFlags
Definition: vulkan.hpp:26808
Flags< DescriptorPoolResetFlagBits, VkDescriptorPoolResetFlags > DescriptorPoolResetFlags
Definition: vulkan.hpp:2770
DebugUtilsMessengerCallbackDataFlagBitsEXT
Definition: vulkan.hpp:2927
Flags< InstanceCreateFlagBits, VkInstanceCreateFlags > InstanceCreateFlags
Definition: vulkan.hpp:2728
Flags< QueryControlFlagBits, VkQueryControlFlags > QueryControlFlags
Definition: vulkan.hpp:24326
Flags< PipelineCoverageToColorStateCreateFlagBitsNV, VkPipelineCoverageToColorStateCreateFlagsNV > PipelineCoverageToColorStateCreateFlagsNV
Definition: vulkan.hpp:2906
Flags< CommandPoolResetFlagBits, VkCommandPoolResetFlags > CommandPoolResetFlags
Definition: vulkan.hpp:26903
Flags< ImageAspectFlagBits, VkImageAspectFlags > ImageAspectFlags
Definition: vulkan.hpp:24724
Flags< DescriptorPoolCreateFlagBits, VkDescriptorPoolCreateFlags > DescriptorPoolCreateFlags
Definition: vulkan.hpp:28713
Flags< DescriptorSetLayoutCreateFlagBits, VkDescriptorSetLayoutCreateFlags > DescriptorSetLayoutCreateFlags
Definition: vulkan.hpp:31435
Flags< CommandBufferUsageFlagBits, VkCommandBufferUsageFlags > CommandBufferUsageFlags
Definition: vulkan.hpp:24381
Flags< PipelineDynamicStateCreateFlagBits, VkPipelineDynamicStateCreateFlags > PipelineDynamicStateCreateFlags
Definition: vulkan.hpp:2668
VULKAN_HPP_INLINE std::error_code make_error_code(Result e)
Definition: vulkan.hpp:697
Flags< BuildAccelerationStructureFlagBitsNV, VkBuildAccelerationStructureFlagsNV > BuildAccelerationStructureFlagsNV
Definition: vulkan.hpp:36894
Flags< PipelineTessellationStateCreateFlagBits, VkPipelineTessellationStateCreateFlags > PipelineTessellationStateCreateFlags
Definition: vulkan.hpp:2698
Flags< PipelineInputAssemblyStateCreateFlagBits, VkPipelineInputAssemblyStateCreateFlags > PipelineInputAssemblyStateCreateFlags
Definition: vulkan.hpp:2704
VULKAN_HPP_INLINE std::error_condition make_error_condition(Result e)
Definition: vulkan.hpp:702
Flags< PipelineViewportSwizzleStateCreateFlagBitsNV, VkPipelineViewportSwizzleStateCreateFlagsNV > PipelineViewportSwizzleStateCreateFlagsNV
Definition: vulkan.hpp:2894
UniqueHandle< SwapchainKHR, DispatchLoaderStatic > UniqueSwapchainKHR
Definition: vulkan.hpp:39952
STL namespace.
AccelerationStructureCreateInfoNV(DeviceSize compactedSize_=0, AccelerationStructureInfoNV info_=AccelerationStructureInfoNV())
Definition: vulkan.hpp:37114
bool operator!=(AccelerationStructureCreateInfoNV const &rhs) const
Definition: vulkan.hpp:37167
AccelerationStructureCreateInfoNV & setInfo(AccelerationStructureInfoNV info_)
Definition: vulkan.hpp:37143
AccelerationStructureCreateInfoNV(VkAccelerationStructureCreateInfoNV const &rhs)
Definition: vulkan.hpp:37121
AccelerationStructureCreateInfoNV & setPNext(const void *pNext_)
Definition: vulkan.hpp:37131
AccelerationStructureCreateInfoNV & operator=(VkAccelerationStructureCreateInfoNV const &rhs)
Definition: vulkan.hpp:37126
AccelerationStructureCreateInfoNV & setCompactedSize(DeviceSize compactedSize_)
Definition: vulkan.hpp:37137
bool operator==(AccelerationStructureCreateInfoNV const &rhs) const
Definition: vulkan.hpp:37159
AccelerationStructureInfoNV & setPGeometries(const GeometryNV *pGeometries_)
Definition: vulkan.hpp:37067
AccelerationStructureInfoNV & setGeometryCount(uint32_t geometryCount_)
Definition: vulkan.hpp:37061
AccelerationStructureInfoNV & setType(AccelerationStructureTypeNV type_)
Definition: vulkan.hpp:37043
AccelerationStructureInfoNV & setPNext(const void *pNext_)
Definition: vulkan.hpp:37037
AccelerationStructureInfoNV & setFlags(BuildAccelerationStructureFlagsNV flags_)
Definition: vulkan.hpp:37049
bool operator==(AccelerationStructureInfoNV const &rhs) const
Definition: vulkan.hpp:37083
AccelerationStructureInfoNV(AccelerationStructureTypeNV type_=AccelerationStructureTypeNV::eTopLevel, BuildAccelerationStructureFlagsNV flags_=BuildAccelerationStructureFlagsNV(), uint32_t instanceCount_=0, uint32_t geometryCount_=0, const GeometryNV *pGeometries_=nullptr)
Definition: vulkan.hpp:37014
BuildAccelerationStructureFlagsNV flags
Definition: vulkan.hpp:37105
AccelerationStructureInfoNV & operator=(VkAccelerationStructureInfoNV const &rhs)
Definition: vulkan.hpp:37032
AccelerationStructureInfoNV(VkAccelerationStructureInfoNV const &rhs)
Definition: vulkan.hpp:37027
AccelerationStructureInfoNV & setInstanceCount(uint32_t instanceCount_)
Definition: vulkan.hpp:37055
bool operator!=(AccelerationStructureInfoNV const &rhs) const
Definition: vulkan.hpp:37094
AccelerationStructureMemoryRequirementsTypeNV type
Definition: vulkan.hpp:37254
bool operator==(AccelerationStructureMemoryRequirementsInfoNV const &rhs) const
Definition: vulkan.hpp:37236
AccelerationStructureMemoryRequirementsInfoNV & operator=(VkAccelerationStructureMemoryRequirementsInfoNV const &rhs)
Definition: vulkan.hpp:37203
AccelerationStructureMemoryRequirementsInfoNV(VkAccelerationStructureMemoryRequirementsInfoNV const &rhs)
Definition: vulkan.hpp:37198
AccelerationStructureMemoryRequirementsInfoNV & setPNext(const void *pNext_)
Definition: vulkan.hpp:37208
bool operator!=(AccelerationStructureMemoryRequirementsInfoNV const &rhs) const
Definition: vulkan.hpp:37244
AccelerationStructureMemoryRequirementsInfoNV & setType(AccelerationStructureMemoryRequirementsTypeNV type_)
Definition: vulkan.hpp:37214
AccelerationStructureMemoryRequirementsInfoNV & setAccelerationStructure(AccelerationStructureNV accelerationStructure_)
Definition: vulkan.hpp:37220
AccelerationStructureMemoryRequirementsInfoNV(AccelerationStructureMemoryRequirementsTypeNV type_=AccelerationStructureMemoryRequirementsTypeNV::eObject, AccelerationStructureNV accelerationStructure_=AccelerationStructureNV())
Definition: vulkan.hpp:37191
AcquireNextImageInfoKHR & setTimeout(uint64_t timeout_)
Definition: vulkan.hpp:15017
AcquireNextImageInfoKHR & operator=(VkAcquireNextImageInfoKHR const &rhs)
Definition: vulkan.hpp:15000
AcquireNextImageInfoKHR & setPNext(const void *pNext_)
Definition: vulkan.hpp:15005
bool operator==(AcquireNextImageInfoKHR const &rhs) const
Definition: vulkan.hpp:15051
AcquireNextImageInfoKHR(SwapchainKHR swapchain_=SwapchainKHR(), uint64_t timeout_=0, Semaphore semaphore_=Semaphore(), Fence fence_=Fence(), uint32_t deviceMask_=0)
Definition: vulkan.hpp:14982
bool operator!=(AcquireNextImageInfoKHR const &rhs) const
Definition: vulkan.hpp:15062
AcquireNextImageInfoKHR & setDeviceMask(uint32_t deviceMask_)
Definition: vulkan.hpp:15035
AcquireNextImageInfoKHR & setFence(Fence fence_)
Definition: vulkan.hpp:15029
AcquireNextImageInfoKHR(VkAcquireNextImageInfoKHR const &rhs)
Definition: vulkan.hpp:14995
AcquireNextImageInfoKHR & setSemaphore(Semaphore semaphore_)
Definition: vulkan.hpp:15023
AcquireNextImageInfoKHR & setSwapchain(SwapchainKHR swapchain_)
Definition: vulkan.hpp:15011
AllocationCallbacks & setPfnReallocation(PFN_vkReallocationFunction pfnReallocation_)
Definition: vulkan.hpp:5674
AllocationCallbacks & setPfnFree(PFN_vkFreeFunction pfnFree_)
Definition: vulkan.hpp:5680
PFN_vkReallocationFunction pfnReallocation
Definition: vulkan.hpp:5725
AllocationCallbacks & setPUserData(void *pUserData_)
Definition: vulkan.hpp:5662
PFN_vkInternalFreeNotification pfnInternalFree
Definition: vulkan.hpp:5728
PFN_vkInternalAllocationNotification pfnInternalAllocation
Definition: vulkan.hpp:5727
AllocationCallbacks & setPfnInternalFree(PFN_vkInternalFreeNotification pfnInternalFree_)
Definition: vulkan.hpp:5692
AllocationCallbacks(void *pUserData_=nullptr, PFN_vkAllocationFunction pfnAllocation_=nullptr, PFN_vkReallocationFunction pfnReallocation_=nullptr, PFN_vkFreeFunction pfnFree_=nullptr, PFN_vkInternalAllocationNotification pfnInternalAllocation_=nullptr, PFN_vkInternalFreeNotification pfnInternalFree_=nullptr)
Definition: vulkan.hpp:5637
AllocationCallbacks & setPfnAllocation(PFN_vkAllocationFunction pfnAllocation_)
Definition: vulkan.hpp:5668
bool operator==(AllocationCallbacks const &rhs) const
Definition: vulkan.hpp:5708
AllocationCallbacks & operator=(VkAllocationCallbacks const &rhs)
Definition: vulkan.hpp:5657
AllocationCallbacks(VkAllocationCallbacks const &rhs)
Definition: vulkan.hpp:5652
bool operator!=(AllocationCallbacks const &rhs) const
Definition: vulkan.hpp:5718
AllocationCallbacks & setPfnInternalAllocation(PFN_vkInternalAllocationNotification pfnInternalAllocation_)
Definition: vulkan.hpp:5686
PFN_vkAllocationFunction pfnAllocation
Definition: vulkan.hpp:5724
ApplicationInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:9525
ApplicationInfo & operator=(VkApplicationInfo const &rhs)
Definition: vulkan.hpp:9520
ApplicationInfo & setPApplicationName(const char *pApplicationName_)
Definition: vulkan.hpp:9531
ApplicationInfo(const char *pApplicationName_=nullptr, uint32_t applicationVersion_=0, const char *pEngineName_=nullptr, uint32_t engineVersion_=0, uint32_t apiVersion_=0)
Definition: vulkan.hpp:9502
ApplicationInfo & setApplicationVersion(uint32_t applicationVersion_)
Definition: vulkan.hpp:9537
bool operator==(ApplicationInfo const &rhs) const
Definition: vulkan.hpp:9571
ApplicationInfo & setApiVersion(uint32_t apiVersion_)
Definition: vulkan.hpp:9555
ApplicationInfo & setPEngineName(const char *pEngineName_)
Definition: vulkan.hpp:9543
ApplicationInfo & setEngineVersion(uint32_t engineVersion_)
Definition: vulkan.hpp:9549
bool operator!=(ApplicationInfo const &rhs) const
Definition: vulkan.hpp:9582
ApplicationInfo(VkApplicationInfo const &rhs)
Definition: vulkan.hpp:9515
AttachmentDescription2KHR(VkAttachmentDescription2KHR const &rhs)
Definition: vulkan.hpp:28563
bool operator!=(AttachmentDescription2KHR const &rhs) const
Definition: vulkan.hpp:28658
AttachmentDescription2KHR & setSamples(SampleCountFlagBits samples_)
Definition: vulkan.hpp:28591
AttachmentDescription2KHR & setLoadOp(AttachmentLoadOp loadOp_)
Definition: vulkan.hpp:28597
AttachmentDescription2KHR & setFlags(AttachmentDescriptionFlags flags_)
Definition: vulkan.hpp:28579
AttachmentDescription2KHR & setStencilStoreOp(AttachmentStoreOp stencilStoreOp_)
Definition: vulkan.hpp:28615
AttachmentDescription2KHR & setInitialLayout(ImageLayout initialLayout_)
Definition: vulkan.hpp:28621
AttachmentDescription2KHR & setFormat(Format format_)
Definition: vulkan.hpp:28585
AttachmentDescription2KHR & setStoreOp(AttachmentStoreOp storeOp_)
Definition: vulkan.hpp:28603
bool operator==(AttachmentDescription2KHR const &rhs) const
Definition: vulkan.hpp:28643
AttachmentDescription2KHR & setStencilLoadOp(AttachmentLoadOp stencilLoadOp_)
Definition: vulkan.hpp:28609
AttachmentDescription2KHR & setPNext(const void *pNext_)
Definition: vulkan.hpp:28573
AttachmentDescription2KHR & setFinalLayout(ImageLayout finalLayout_)
Definition: vulkan.hpp:28627
AttachmentDescription2KHR & operator=(VkAttachmentDescription2KHR const &rhs)
Definition: vulkan.hpp:28568
AttachmentDescription2KHR(AttachmentDescriptionFlags flags_=AttachmentDescriptionFlags(), Format format_=Format::eUndefined, SampleCountFlagBits samples_=SampleCountFlagBits::e1, AttachmentLoadOp loadOp_=AttachmentLoadOp::eLoad, AttachmentStoreOp storeOp_=AttachmentStoreOp::eStore, AttachmentLoadOp stencilLoadOp_=AttachmentLoadOp::eLoad, AttachmentStoreOp stencilStoreOp_=AttachmentStoreOp::eStore, ImageLayout initialLayout_=ImageLayout::eUndefined, ImageLayout finalLayout_=ImageLayout::eUndefined)
Definition: vulkan.hpp:28542
AttachmentDescription & setStencilLoadOp(AttachmentLoadOp stencilLoadOp_)
Definition: vulkan.hpp:28476
AttachmentDescription & setLoadOp(AttachmentLoadOp loadOp_)
Definition: vulkan.hpp:28464
AttachmentDescription & setFormat(Format format_)
Definition: vulkan.hpp:28452
AttachmentDescription & setStoreOp(AttachmentStoreOp storeOp_)
Definition: vulkan.hpp:28470
AttachmentDescription & setStencilStoreOp(AttachmentStoreOp stencilStoreOp_)
Definition: vulkan.hpp:28482
AttachmentDescription & operator=(VkAttachmentDescription const &rhs)
Definition: vulkan.hpp:28441
AttachmentDescription & setSamples(SampleCountFlagBits samples_)
Definition: vulkan.hpp:28458
AttachmentDescription & setFinalLayout(ImageLayout finalLayout_)
Definition: vulkan.hpp:28494
AttachmentDescription & setInitialLayout(ImageLayout initialLayout_)
Definition: vulkan.hpp:28488
AttachmentDescription & setFlags(AttachmentDescriptionFlags flags_)
Definition: vulkan.hpp:28446
AttachmentDescription(AttachmentDescriptionFlags flags_=AttachmentDescriptionFlags(), Format format_=Format::eUndefined, SampleCountFlagBits samples_=SampleCountFlagBits::e1, AttachmentLoadOp loadOp_=AttachmentLoadOp::eLoad, AttachmentStoreOp storeOp_=AttachmentStoreOp::eStore, AttachmentLoadOp stencilLoadOp_=AttachmentLoadOp::eLoad, AttachmentStoreOp stencilStoreOp_=AttachmentStoreOp::eStore, ImageLayout initialLayout_=ImageLayout::eUndefined, ImageLayout finalLayout_=ImageLayout::eUndefined)
Definition: vulkan.hpp:28415
AttachmentDescriptionFlags flags
Definition: vulkan.hpp:28528
bool operator!=(AttachmentDescription const &rhs) const
Definition: vulkan.hpp:28523
AttachmentDescription(VkAttachmentDescription const &rhs)
Definition: vulkan.hpp:28436
bool operator==(AttachmentDescription const &rhs) const
Definition: vulkan.hpp:28510
AttachmentReference2KHR & setPNext(const void *pNext_)
Definition: vulkan.hpp:25904
AttachmentReference2KHR & setAspectMask(ImageAspectFlags aspectMask_)
Definition: vulkan.hpp:25922
AttachmentReference2KHR & setLayout(ImageLayout layout_)
Definition: vulkan.hpp:25916
bool operator!=(AttachmentReference2KHR const &rhs) const
Definition: vulkan.hpp:25947
AttachmentReference2KHR(uint32_t attachment_=0, ImageLayout layout_=ImageLayout::eUndefined, ImageAspectFlags aspectMask_=ImageAspectFlags())
Definition: vulkan.hpp:25885
bool operator==(AttachmentReference2KHR const &rhs) const
Definition: vulkan.hpp:25938
AttachmentReference2KHR & setAttachment(uint32_t attachment_)
Definition: vulkan.hpp:25910
AttachmentReference2KHR(VkAttachmentReference2KHR const &rhs)
Definition: vulkan.hpp:25894
AttachmentReference2KHR & operator=(VkAttachmentReference2KHR const &rhs)
Definition: vulkan.hpp:25899
AttachmentReference & setLayout(ImageLayout layout_)
Definition: vulkan.hpp:8012
AttachmentReference(uint32_t attachment_=0, ImageLayout layout_=ImageLayout::eUndefined)
Definition: vulkan.hpp:7989
AttachmentReference & setAttachment(uint32_t attachment_)
Definition: vulkan.hpp:8006
AttachmentReference(VkAttachmentReference const &rhs)
Definition: vulkan.hpp:7996
bool operator==(AttachmentReference const &rhs) const
Definition: vulkan.hpp:8028
AttachmentReference & operator=(VkAttachmentReference const &rhs)
Definition: vulkan.hpp:8001
bool operator!=(AttachmentReference const &rhs) const
Definition: vulkan.hpp:8034
AttachmentSampleLocationsEXT(uint32_t attachmentIndex_=0, SampleLocationsInfoEXT sampleLocationsInfo_=SampleLocationsInfoEXT())
Definition: vulkan.hpp:28075
AttachmentSampleLocationsEXT & operator=(VkAttachmentSampleLocationsEXT const &rhs)
Definition: vulkan.hpp:28087
AttachmentSampleLocationsEXT & setSampleLocationsInfo(SampleLocationsInfoEXT sampleLocationsInfo_)
Definition: vulkan.hpp:28098
bool operator==(AttachmentSampleLocationsEXT const &rhs) const
Definition: vulkan.hpp:28114
bool operator!=(AttachmentSampleLocationsEXT const &rhs) const
Definition: vulkan.hpp:28120
AttachmentSampleLocationsEXT & setAttachmentIndex(uint32_t attachmentIndex_)
Definition: vulkan.hpp:28092
AttachmentSampleLocationsEXT(VkAttachmentSampleLocationsEXT const &rhs)
Definition: vulkan.hpp:28082
BaseInStructure & operator=(VkBaseInStructure const &rhs)
Definition: vulkan.hpp:48397
bool operator==(BaseInStructure const &rhs) const
Definition: vulkan.hpp:48418
const struct BaseInStructure * pNext
Definition: vulkan.hpp:48430
BaseInStructure(VkBaseInStructure const &rhs)
Definition: vulkan.hpp:48392
bool operator!=(BaseInStructure const &rhs) const
Definition: vulkan.hpp:48424
BaseInStructure & setPNext(const struct BaseInStructure *pNext_)
Definition: vulkan.hpp:48402
BaseOutStructure & setPNext(struct BaseOutStructure *pNext_)
Definition: vulkan.hpp:48354
bool operator==(BaseOutStructure const &rhs) const
Definition: vulkan.hpp:48370
struct BaseOutStructure * pNext
Definition: vulkan.hpp:48382
BaseOutStructure(VkBaseOutStructure const &rhs)
Definition: vulkan.hpp:48344
bool operator!=(BaseOutStructure const &rhs) const
Definition: vulkan.hpp:48376
BaseOutStructure & operator=(VkBaseOutStructure const &rhs)
Definition: vulkan.hpp:48349
BindAccelerationStructureMemoryInfoNV & setDeviceIndexCount(uint32_t deviceIndexCount_)
Definition: vulkan.hpp:20592
BindAccelerationStructureMemoryInfoNV & setPNext(const void *pNext_)
Definition: vulkan.hpp:20568
BindAccelerationStructureMemoryInfoNV(AccelerationStructureNV accelerationStructure_=AccelerationStructureNV(), DeviceMemory memory_=DeviceMemory(), DeviceSize memoryOffset_=0, uint32_t deviceIndexCount_=0, const uint32_t *pDeviceIndices_=nullptr)
Definition: vulkan.hpp:20545
BindAccelerationStructureMemoryInfoNV(VkBindAccelerationStructureMemoryInfoNV const &rhs)
Definition: vulkan.hpp:20558
BindAccelerationStructureMemoryInfoNV & setMemory(DeviceMemory memory_)
Definition: vulkan.hpp:20580
bool operator==(BindAccelerationStructureMemoryInfoNV const &rhs) const
Definition: vulkan.hpp:20614
BindAccelerationStructureMemoryInfoNV & setAccelerationStructure(AccelerationStructureNV accelerationStructure_)
Definition: vulkan.hpp:20574
BindAccelerationStructureMemoryInfoNV & setPDeviceIndices(const uint32_t *pDeviceIndices_)
Definition: vulkan.hpp:20598
BindAccelerationStructureMemoryInfoNV & setMemoryOffset(DeviceSize memoryOffset_)
Definition: vulkan.hpp:20586
bool operator!=(BindAccelerationStructureMemoryInfoNV const &rhs) const
Definition: vulkan.hpp:20625
BindAccelerationStructureMemoryInfoNV & operator=(VkBindAccelerationStructureMemoryInfoNV const &rhs)
Definition: vulkan.hpp:20563
BindBufferMemoryDeviceGroupInfo & setDeviceIndexCount(uint32_t deviceIndexCount_)
Definition: vulkan.hpp:14301
bool operator!=(BindBufferMemoryDeviceGroupInfo const &rhs) const
Definition: vulkan.hpp:14331
BindBufferMemoryDeviceGroupInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:14295
BindBufferMemoryDeviceGroupInfo(VkBindBufferMemoryDeviceGroupInfo const &rhs)
Definition: vulkan.hpp:14285
BindBufferMemoryDeviceGroupInfo & setPDeviceIndices(const uint32_t *pDeviceIndices_)
Definition: vulkan.hpp:14307
BindBufferMemoryDeviceGroupInfo & operator=(VkBindBufferMemoryDeviceGroupInfo const &rhs)
Definition: vulkan.hpp:14290
BindBufferMemoryDeviceGroupInfo(uint32_t deviceIndexCount_=0, const uint32_t *pDeviceIndices_=nullptr)
Definition: vulkan.hpp:14278
bool operator==(BindBufferMemoryDeviceGroupInfo const &rhs) const
Definition: vulkan.hpp:14323
BindBufferMemoryInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:14215
BindBufferMemoryInfo & setBuffer(Buffer buffer_)
Definition: vulkan.hpp:14221
BindBufferMemoryInfo(VkBindBufferMemoryInfo const &rhs)
Definition: vulkan.hpp:14205
bool operator!=(BindBufferMemoryInfo const &rhs) const
Definition: vulkan.hpp:14258
bool operator==(BindBufferMemoryInfo const &rhs) const
Definition: vulkan.hpp:14249
BindBufferMemoryInfo & operator=(VkBindBufferMemoryInfo const &rhs)
Definition: vulkan.hpp:14210
BindBufferMemoryInfo & setMemory(DeviceMemory memory_)
Definition: vulkan.hpp:14227
BindBufferMemoryInfo(Buffer buffer_=Buffer(), DeviceMemory memory_=DeviceMemory(), DeviceSize memoryOffset_=0)
Definition: vulkan.hpp:14196
BindBufferMemoryInfo & setMemoryOffset(DeviceSize memoryOffset_)
Definition: vulkan.hpp:14233
BindImageMemoryDeviceGroupInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:14453
BindImageMemoryDeviceGroupInfo & setDeviceIndexCount(uint32_t deviceIndexCount_)
Definition: vulkan.hpp:14459
BindImageMemoryDeviceGroupInfo & setSplitInstanceBindRegionCount(uint32_t splitInstanceBindRegionCount_)
Definition: vulkan.hpp:14471
BindImageMemoryDeviceGroupInfo(uint32_t deviceIndexCount_=0, const uint32_t *pDeviceIndices_=nullptr, uint32_t splitInstanceBindRegionCount_=0, const Rect2D *pSplitInstanceBindRegions_=nullptr)
Definition: vulkan.hpp:14432
BindImageMemoryDeviceGroupInfo & operator=(VkBindImageMemoryDeviceGroupInfo const &rhs)
Definition: vulkan.hpp:14448
bool operator!=(BindImageMemoryDeviceGroupInfo const &rhs) const
Definition: vulkan.hpp:14503
BindImageMemoryDeviceGroupInfo & setPDeviceIndices(const uint32_t *pDeviceIndices_)
Definition: vulkan.hpp:14465
BindImageMemoryDeviceGroupInfo & setPSplitInstanceBindRegions(const Rect2D *pSplitInstanceBindRegions_)
Definition: vulkan.hpp:14477
BindImageMemoryDeviceGroupInfo(VkBindImageMemoryDeviceGroupInfo const &rhs)
Definition: vulkan.hpp:14443
bool operator==(BindImageMemoryDeviceGroupInfo const &rhs) const
Definition: vulkan.hpp:14493
BindImageMemoryInfo(Image image_=Image(), DeviceMemory memory_=DeviceMemory(), DeviceSize memoryOffset_=0)
Definition: vulkan.hpp:14350
BindImageMemoryInfo & operator=(VkBindImageMemoryInfo const &rhs)
Definition: vulkan.hpp:14364
BindImageMemoryInfo & setMemoryOffset(DeviceSize memoryOffset_)
Definition: vulkan.hpp:14387
bool operator==(BindImageMemoryInfo const &rhs) const
Definition: vulkan.hpp:14403
BindImageMemoryInfo(VkBindImageMemoryInfo const &rhs)
Definition: vulkan.hpp:14359
bool operator!=(BindImageMemoryInfo const &rhs) const
Definition: vulkan.hpp:14412
BindImageMemoryInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:14369
BindImageMemoryInfo & setImage(Image image_)
Definition: vulkan.hpp:14375
BindImageMemoryInfo & setMemory(DeviceMemory memory_)
Definition: vulkan.hpp:14381
BindImageMemorySwapchainInfoKHR(VkBindImageMemorySwapchainInfoKHR const &rhs)
Definition: vulkan.hpp:14919
bool operator!=(BindImageMemorySwapchainInfoKHR const &rhs) const
Definition: vulkan.hpp:14965
BindImageMemorySwapchainInfoKHR & setImageIndex(uint32_t imageIndex_)
Definition: vulkan.hpp:14941
bool operator==(BindImageMemorySwapchainInfoKHR const &rhs) const
Definition: vulkan.hpp:14957
BindImageMemorySwapchainInfoKHR & setPNext(const void *pNext_)
Definition: vulkan.hpp:14929
BindImageMemorySwapchainInfoKHR & setSwapchain(SwapchainKHR swapchain_)
Definition: vulkan.hpp:14935
BindImageMemorySwapchainInfoKHR(SwapchainKHR swapchain_=SwapchainKHR(), uint32_t imageIndex_=0)
Definition: vulkan.hpp:14912
BindImageMemorySwapchainInfoKHR & operator=(VkBindImageMemorySwapchainInfoKHR const &rhs)
Definition: vulkan.hpp:14924
bool operator==(BindImagePlaneMemoryInfo const &rhs) const
Definition: vulkan.hpp:25798
BindImagePlaneMemoryInfo & operator=(VkBindImagePlaneMemoryInfo const &rhs)
Definition: vulkan.hpp:25771
BindImagePlaneMemoryInfo(ImageAspectFlagBits planeAspect_=ImageAspectFlagBits::eColor)
Definition: vulkan.hpp:25761
bool operator!=(BindImagePlaneMemoryInfo const &rhs) const
Definition: vulkan.hpp:25805
BindImagePlaneMemoryInfo & setPlaneAspect(ImageAspectFlagBits planeAspect_)
Definition: vulkan.hpp:25782
BindImagePlaneMemoryInfo(VkBindImagePlaneMemoryInfo const &rhs)
Definition: vulkan.hpp:25766
BindImagePlaneMemoryInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:25776
BindSparseInfo & setPImageBinds(const SparseImageMemoryBindInfo *pImageBinds_)
Definition: vulkan.hpp:26617
BindSparseInfo & setSignalSemaphoreCount(uint32_t signalSemaphoreCount_)
Definition: vulkan.hpp:26623
const SparseImageOpaqueMemoryBindInfo * pImageOpaqueBinds
Definition: vulkan.hpp:26676
BindSparseInfo & setImageOpaqueBindCount(uint32_t imageOpaqueBindCount_)
Definition: vulkan.hpp:26599
bool operator!=(BindSparseInfo const &rhs) const
Definition: vulkan.hpp:26661
BindSparseInfo & setImageBindCount(uint32_t imageBindCount_)
Definition: vulkan.hpp:26611
BindSparseInfo & setBufferBindCount(uint32_t bufferBindCount_)
Definition: vulkan.hpp:26587
BindSparseInfo & setPImageOpaqueBinds(const SparseImageOpaqueMemoryBindInfo *pImageOpaqueBinds_)
Definition: vulkan.hpp:26605
BindSparseInfo & setWaitSemaphoreCount(uint32_t waitSemaphoreCount_)
Definition: vulkan.hpp:26575
BindSparseInfo & setPSignalSemaphores(const Semaphore *pSignalSemaphores_)
Definition: vulkan.hpp:26629
BindSparseInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:26569
BindSparseInfo & operator=(VkBindSparseInfo const &rhs)
Definition: vulkan.hpp:26564
const SparseBufferMemoryBindInfo * pBufferBinds
Definition: vulkan.hpp:26674
BindSparseInfo(VkBindSparseInfo const &rhs)
Definition: vulkan.hpp:26559
BindSparseInfo(uint32_t waitSemaphoreCount_=0, const Semaphore *pWaitSemaphores_=nullptr, uint32_t bufferBindCount_=0, const SparseBufferMemoryBindInfo *pBufferBinds_=nullptr, uint32_t imageOpaqueBindCount_=0, const SparseImageOpaqueMemoryBindInfo *pImageOpaqueBinds_=nullptr, uint32_t imageBindCount_=0, const SparseImageMemoryBindInfo *pImageBinds_=nullptr, uint32_t signalSemaphoreCount_=0, const Semaphore *pSignalSemaphores_=nullptr)
Definition: vulkan.hpp:26536
bool operator==(BindSparseInfo const &rhs) const
Definition: vulkan.hpp:26645
const SparseImageMemoryBindInfo * pImageBinds
Definition: vulkan.hpp:26678
BindSparseInfo & setPBufferBinds(const SparseBufferMemoryBindInfo *pBufferBinds_)
Definition: vulkan.hpp:26593
BindSparseInfo & setPWaitSemaphores(const Semaphore *pWaitSemaphores_)
Definition: vulkan.hpp:26581
BufferCopy & setSize(DeviceSize size_)
Definition: vulkan.hpp:5896
BufferCopy(DeviceSize srcOffset_=0, DeviceSize dstOffset_=0, DeviceSize size_=0)
Definition: vulkan.hpp:5865
BufferCopy & operator=(VkBufferCopy const &rhs)
Definition: vulkan.hpp:5879
BufferCopy(VkBufferCopy const &rhs)
Definition: vulkan.hpp:5874
BufferCopy & setSrcOffset(DeviceSize srcOffset_)
Definition: vulkan.hpp:5884
bool operator!=(BufferCopy const &rhs) const
Definition: vulkan.hpp:5919
BufferCopy & setDstOffset(DeviceSize dstOffset_)
Definition: vulkan.hpp:5890
bool operator==(BufferCopy const &rhs) const
Definition: vulkan.hpp:5912
BufferCreateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:22838
BufferCreateInfo(BufferCreateFlags flags_=BufferCreateFlags(), DeviceSize size_=0, BufferUsageFlags usage_=BufferUsageFlags(), SharingMode sharingMode_=SharingMode::eExclusive, uint32_t queueFamilyIndexCount_=0, const uint32_t *pQueueFamilyIndices_=nullptr)
Definition: vulkan.hpp:22813
bool operator!=(BufferCreateInfo const &rhs) const
Definition: vulkan.hpp:22902
BufferCreateInfo & setFlags(BufferCreateFlags flags_)
Definition: vulkan.hpp:22844
BufferCreateInfo(VkBufferCreateInfo const &rhs)
Definition: vulkan.hpp:22828
BufferCreateInfo & setPQueueFamilyIndices(const uint32_t *pQueueFamilyIndices_)
Definition: vulkan.hpp:22874
BufferCreateInfo & setQueueFamilyIndexCount(uint32_t queueFamilyIndexCount_)
Definition: vulkan.hpp:22868
bool operator==(BufferCreateInfo const &rhs) const
Definition: vulkan.hpp:22890
BufferCreateInfo & operator=(VkBufferCreateInfo const &rhs)
Definition: vulkan.hpp:22833
BufferCreateInfo & setUsage(BufferUsageFlags usage_)
Definition: vulkan.hpp:22856
BufferCreateInfo & setSharingMode(SharingMode sharingMode_)
Definition: vulkan.hpp:22862
BufferCreateInfo & setSize(DeviceSize size_)
Definition: vulkan.hpp:22850
BufferImageCopy & setBufferImageHeight(uint32_t bufferImageHeight_)
Definition: vulkan.hpp:25418
BufferImageCopy & operator=(VkBufferImageCopy const &rhs)
Definition: vulkan.hpp:25401
BufferImageCopy & setImageExtent(Extent3D imageExtent_)
Definition: vulkan.hpp:25436
ImageSubresourceLayers imageSubresource
Definition: vulkan.hpp:25470
BufferImageCopy & setImageOffset(Offset3D imageOffset_)
Definition: vulkan.hpp:25430
BufferImageCopy(DeviceSize bufferOffset_=0, uint32_t bufferRowLength_=0, uint32_t bufferImageHeight_=0, ImageSubresourceLayers imageSubresource_=ImageSubresourceLayers(), Offset3D imageOffset_=Offset3D(), Extent3D imageExtent_=Extent3D())
Definition: vulkan.hpp:25381
BufferImageCopy & setBufferOffset(DeviceSize bufferOffset_)
Definition: vulkan.hpp:25406
BufferImageCopy & setImageSubresource(ImageSubresourceLayers imageSubresource_)
Definition: vulkan.hpp:25424
BufferImageCopy(VkBufferImageCopy const &rhs)
Definition: vulkan.hpp:25396
bool operator!=(BufferImageCopy const &rhs) const
Definition: vulkan.hpp:25462
BufferImageCopy & setBufferRowLength(uint32_t bufferRowLength_)
Definition: vulkan.hpp:25412
bool operator==(BufferImageCopy const &rhs) const
Definition: vulkan.hpp:25452
BufferMemoryBarrier & setSrcAccessMask(AccessFlags srcAccessMask_)
Definition: vulkan.hpp:22661
BufferMemoryBarrier(VkBufferMemoryBarrier const &rhs)
Definition: vulkan.hpp:22645
BufferMemoryBarrier & operator=(VkBufferMemoryBarrier const &rhs)
Definition: vulkan.hpp:22650
BufferMemoryBarrier & setPNext(const void *pNext_)
Definition: vulkan.hpp:22655
BufferMemoryBarrier & setSrcQueueFamilyIndex(uint32_t srcQueueFamilyIndex_)
Definition: vulkan.hpp:22673
bool operator==(BufferMemoryBarrier const &rhs) const
Definition: vulkan.hpp:22713
BufferMemoryBarrier & setBuffer(Buffer buffer_)
Definition: vulkan.hpp:22685
bool operator!=(BufferMemoryBarrier const &rhs) const
Definition: vulkan.hpp:22726
BufferMemoryBarrier(AccessFlags srcAccessMask_=AccessFlags(), AccessFlags dstAccessMask_=AccessFlags(), uint32_t srcQueueFamilyIndex_=0, uint32_t dstQueueFamilyIndex_=0, Buffer buffer_=Buffer(), DeviceSize offset_=0, DeviceSize size_=0)
Definition: vulkan.hpp:22628
BufferMemoryBarrier & setSize(DeviceSize size_)
Definition: vulkan.hpp:22697
BufferMemoryBarrier & setDstQueueFamilyIndex(uint32_t dstQueueFamilyIndex_)
Definition: vulkan.hpp:22679
BufferMemoryBarrier & setDstAccessMask(AccessFlags dstAccessMask_)
Definition: vulkan.hpp:22667
BufferMemoryBarrier & setOffset(DeviceSize offset_)
Definition: vulkan.hpp:22691
bool operator!=(BufferMemoryRequirementsInfo2 const &rhs) const
Definition: vulkan.hpp:15931
BufferMemoryRequirementsInfo2 & operator=(VkBufferMemoryRequirementsInfo2 const &rhs)
Definition: vulkan.hpp:15897
BufferMemoryRequirementsInfo2(VkBufferMemoryRequirementsInfo2 const &rhs)
Definition: vulkan.hpp:15892
BufferMemoryRequirementsInfo2 & setBuffer(Buffer buffer_)
Definition: vulkan.hpp:15908
bool operator==(BufferMemoryRequirementsInfo2 const &rhs) const
Definition: vulkan.hpp:15924
BufferMemoryRequirementsInfo2 & setPNext(const void *pNext_)
Definition: vulkan.hpp:15902
BufferMemoryRequirementsInfo2(Buffer buffer_=Buffer())
Definition: vulkan.hpp:15887
BufferViewCreateInfo(BufferViewCreateFlags flags_=BufferViewCreateFlags(), Buffer buffer_=Buffer(), Format format_=Format::eUndefined, DeviceSize offset_=0, DeviceSize range_=0)
Definition: vulkan.hpp:10112
BufferViewCreateInfo(VkBufferViewCreateInfo const &rhs)
Definition: vulkan.hpp:10125
BufferViewCreateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:10135
bool operator==(BufferViewCreateInfo const &rhs) const
Definition: vulkan.hpp:10181
bool operator!=(BufferViewCreateInfo const &rhs) const
Definition: vulkan.hpp:10192
BufferViewCreateInfo & setOffset(DeviceSize offset_)
Definition: vulkan.hpp:10159
BufferViewCreateInfo & operator=(VkBufferViewCreateInfo const &rhs)
Definition: vulkan.hpp:10130
BufferViewCreateInfo & setFormat(Format format_)
Definition: vulkan.hpp:10153
BufferViewCreateInfo & setFlags(BufferViewCreateFlags flags_)
Definition: vulkan.hpp:10141
BufferViewCreateInfo & setRange(DeviceSize range_)
Definition: vulkan.hpp:10165
BufferViewCreateInfo & setBuffer(Buffer buffer_)
Definition: vulkan.hpp:10147
CalibratedTimestampInfoEXT & setTimeDomain(TimeDomainEXT timeDomain_)
Definition: vulkan.hpp:29653
bool operator!=(CalibratedTimestampInfoEXT const &rhs) const
Definition: vulkan.hpp:29676
bool operator==(CalibratedTimestampInfoEXT const &rhs) const
Definition: vulkan.hpp:29669
CalibratedTimestampInfoEXT & setPNext(const void *pNext_)
Definition: vulkan.hpp:29647
CalibratedTimestampInfoEXT(VkCalibratedTimestampInfoEXT const &rhs)
Definition: vulkan.hpp:29637
CalibratedTimestampInfoEXT & operator=(VkCalibratedTimestampInfoEXT const &rhs)
Definition: vulkan.hpp:29642
CalibratedTimestampInfoEXT(TimeDomainEXT timeDomain_=TimeDomainEXT::eDevice)
Definition: vulkan.hpp:29632
bool operator!=(CheckpointDataNV const &rhs) const
Definition: vulkan.hpp:26786
bool operator==(CheckpointDataNV const &rhs) const
Definition: vulkan.hpp:26778
ClearAttachment & operator=(VkClearAttachment const &rhs)
Definition: vulkan.hpp:25579
ClearAttachment(ImageAspectFlags aspectMask_=ImageAspectFlags(), uint32_t colorAttachment_=0, ClearValue clearValue_=ClearValue())
Definition: vulkan.hpp:25565
ClearAttachment & setClearValue(ClearValue clearValue_)
Definition: vulkan.hpp:25596
ClearAttachment(VkClearAttachment const &rhs)
Definition: vulkan.hpp:25574
ClearAttachment & setAspectMask(ImageAspectFlags aspectMask_)
Definition: vulkan.hpp:25584
ClearAttachment & setColorAttachment(uint32_t colorAttachment_)
Definition: vulkan.hpp:25590
ClearDepthStencilValue(VkClearDepthStencilValue const &rhs)
Definition: vulkan.hpp:6133
ClearDepthStencilValue(float depth_=0, uint32_t stencil_=0)
Definition: vulkan.hpp:6126
ClearDepthStencilValue & setDepth(float depth_)
Definition: vulkan.hpp:6143
bool operator!=(ClearDepthStencilValue const &rhs) const
Definition: vulkan.hpp:6171
ClearDepthStencilValue & setStencil(uint32_t stencil_)
Definition: vulkan.hpp:6149
bool operator==(ClearDepthStencilValue const &rhs) const
Definition: vulkan.hpp:6165
ClearDepthStencilValue & operator=(VkClearDepthStencilValue const &rhs)
Definition: vulkan.hpp:6138
ClearRect & operator=(VkClearRect const &rhs)
Definition: vulkan.hpp:5524
ClearRect & setBaseArrayLayer(uint32_t baseArrayLayer_)
Definition: vulkan.hpp:5535
ClearRect & setRect(Rect2D rect_)
Definition: vulkan.hpp:5529
ClearRect & setLayerCount(uint32_t layerCount_)
Definition: vulkan.hpp:5541
bool operator==(ClearRect const &rhs) const
Definition: vulkan.hpp:5557
ClearRect(VkClearRect const &rhs)
Definition: vulkan.hpp:5519
ClearRect(Rect2D rect_=Rect2D(), uint32_t baseArrayLayer_=0, uint32_t layerCount_=0)
Definition: vulkan.hpp:5510
bool operator!=(ClearRect const &rhs) const
Definition: vulkan.hpp:5564
CmdProcessCommandsInfoNVX & setSequencesIndexBuffer(Buffer sequencesIndexBuffer_)
Definition: vulkan.hpp:47191
CmdProcessCommandsInfoNVX & setSequencesCountOffset(DeviceSize sequencesCountOffset_)
Definition: vulkan.hpp:47185
CmdProcessCommandsInfoNVX(ObjectTableNVX objectTable_=ObjectTableNVX(), IndirectCommandsLayoutNVX indirectCommandsLayout_=IndirectCommandsLayoutNVX(), uint32_t indirectCommandsTokenCount_=0, const IndirectCommandsTokenNVX *pIndirectCommandsTokens_=nullptr, uint32_t maxSequencesCount_=0, CommandBuffer targetCommandBuffer_=CommandBuffer(), Buffer sequencesCountBuffer_=Buffer(), DeviceSize sequencesCountOffset_=0, Buffer sequencesIndexBuffer_=Buffer(), DeviceSize sequencesIndexOffset_=0)
Definition: vulkan.hpp:47104
IndirectCommandsLayoutNVX indirectCommandsLayout
Definition: vulkan.hpp:47240
CmdProcessCommandsInfoNVX & operator=(VkCmdProcessCommandsInfoNVX const &rhs)
Definition: vulkan.hpp:47132
CmdProcessCommandsInfoNVX(VkCmdProcessCommandsInfoNVX const &rhs)
Definition: vulkan.hpp:47127
CmdProcessCommandsInfoNVX & setPNext(const void *pNext_)
Definition: vulkan.hpp:47137
const IndirectCommandsTokenNVX * pIndirectCommandsTokens
Definition: vulkan.hpp:47242
CmdProcessCommandsInfoNVX & setMaxSequencesCount(uint32_t maxSequencesCount_)
Definition: vulkan.hpp:47167
CmdProcessCommandsInfoNVX & setIndirectCommandsLayout(IndirectCommandsLayoutNVX indirectCommandsLayout_)
Definition: vulkan.hpp:47149
CmdProcessCommandsInfoNVX & setTargetCommandBuffer(CommandBuffer targetCommandBuffer_)
Definition: vulkan.hpp:47173
bool operator!=(CmdProcessCommandsInfoNVX const &rhs) const
Definition: vulkan.hpp:47229
CmdProcessCommandsInfoNVX & setSequencesIndexOffset(DeviceSize sequencesIndexOffset_)
Definition: vulkan.hpp:47197
CmdProcessCommandsInfoNVX & setPIndirectCommandsTokens(const IndirectCommandsTokenNVX *pIndirectCommandsTokens_)
Definition: vulkan.hpp:47161
CmdProcessCommandsInfoNVX & setObjectTable(ObjectTableNVX objectTable_)
Definition: vulkan.hpp:47143
CmdProcessCommandsInfoNVX & setSequencesCountBuffer(Buffer sequencesCountBuffer_)
Definition: vulkan.hpp:47179
bool operator==(CmdProcessCommandsInfoNVX const &rhs) const
Definition: vulkan.hpp:47213
CmdProcessCommandsInfoNVX & setIndirectCommandsTokenCount(uint32_t indirectCommandsTokenCount_)
Definition: vulkan.hpp:47155
CmdReserveSpaceForCommandsInfoNVX & operator=(VkCmdReserveSpaceForCommandsInfoNVX const &rhs)
Definition: vulkan.hpp:13064
bool operator!=(CmdReserveSpaceForCommandsInfoNVX const &rhs) const
Definition: vulkan.hpp:13112
CmdReserveSpaceForCommandsInfoNVX & setIndirectCommandsLayout(IndirectCommandsLayoutNVX indirectCommandsLayout_)
Definition: vulkan.hpp:13081
bool operator==(CmdReserveSpaceForCommandsInfoNVX const &rhs) const
Definition: vulkan.hpp:13103
CmdReserveSpaceForCommandsInfoNVX & setObjectTable(ObjectTableNVX objectTable_)
Definition: vulkan.hpp:13075
CmdReserveSpaceForCommandsInfoNVX(ObjectTableNVX objectTable_=ObjectTableNVX(), IndirectCommandsLayoutNVX indirectCommandsLayout_=IndirectCommandsLayoutNVX(), uint32_t maxSequencesCount_=0)
Definition: vulkan.hpp:13050
CmdReserveSpaceForCommandsInfoNVX(VkCmdReserveSpaceForCommandsInfoNVX const &rhs)
Definition: vulkan.hpp:13059
CmdReserveSpaceForCommandsInfoNVX & setMaxSequencesCount(uint32_t maxSequencesCount_)
Definition: vulkan.hpp:13087
CmdReserveSpaceForCommandsInfoNVX & setPNext(const void *pNext_)
Definition: vulkan.hpp:13069
bool operator==(CoarseSampleLocationNV const &rhs) const
Definition: vulkan.hpp:7825
CoarseSampleLocationNV & setSample(uint32_t sample_)
Definition: vulkan.hpp:7809
CoarseSampleLocationNV & setPixelY(uint32_t pixelY_)
Definition: vulkan.hpp:7803
CoarseSampleLocationNV & operator=(VkCoarseSampleLocationNV const &rhs)
Definition: vulkan.hpp:7792
CoarseSampleLocationNV(VkCoarseSampleLocationNV const &rhs)
Definition: vulkan.hpp:7787
CoarseSampleLocationNV & setPixelX(uint32_t pixelX_)
Definition: vulkan.hpp:7797
bool operator!=(CoarseSampleLocationNV const &rhs) const
Definition: vulkan.hpp:7832
CoarseSampleLocationNV(uint32_t pixelX_=0, uint32_t pixelY_=0, uint32_t sample_=0)
Definition: vulkan.hpp:7778
CoarseSampleOrderCustomNV & setShadingRate(ShadingRatePaletteEntryNV shadingRate_)
Definition: vulkan.hpp:36689
CoarseSampleOrderCustomNV(VkCoarseSampleOrderCustomNV const &rhs)
Definition: vulkan.hpp:36679
bool operator!=(CoarseSampleOrderCustomNV const &rhs) const
Definition: vulkan.hpp:36731
bool operator==(CoarseSampleOrderCustomNV const &rhs) const
Definition: vulkan.hpp:36723
CoarseSampleOrderCustomNV(ShadingRatePaletteEntryNV shadingRate_=ShadingRatePaletteEntryNV::eNoInvocations, uint32_t sampleCount_=0, uint32_t sampleLocationCount_=0, const CoarseSampleLocationNV *pSampleLocations_=nullptr)
Definition: vulkan.hpp:36668
CoarseSampleOrderCustomNV & setSampleLocationCount(uint32_t sampleLocationCount_)
Definition: vulkan.hpp:36701
CoarseSampleOrderCustomNV & operator=(VkCoarseSampleOrderCustomNV const &rhs)
Definition: vulkan.hpp:36684
CoarseSampleOrderCustomNV & setPSampleLocations(const CoarseSampleLocationNV *pSampleLocations_)
Definition: vulkan.hpp:36707
const CoarseSampleLocationNV * pSampleLocations
Definition: vulkan.hpp:36739
CoarseSampleOrderCustomNV & setSampleCount(uint32_t sampleCount_)
Definition: vulkan.hpp:36695
CommandBufferAllocateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:11341
CommandBufferAllocateInfo & setLevel(CommandBufferLevel level_)
Definition: vulkan.hpp:11353
CommandBufferAllocateInfo(VkCommandBufferAllocateInfo const &rhs)
Definition: vulkan.hpp:11331
bool operator==(CommandBufferAllocateInfo const &rhs) const
Definition: vulkan.hpp:11375
CommandBufferAllocateInfo & setCommandBufferCount(uint32_t commandBufferCount_)
Definition: vulkan.hpp:11359
CommandBufferAllocateInfo & operator=(VkCommandBufferAllocateInfo const &rhs)
Definition: vulkan.hpp:11336
CommandBufferAllocateInfo & setCommandPool(CommandPool commandPool_)
Definition: vulkan.hpp:11347
bool operator!=(CommandBufferAllocateInfo const &rhs) const
Definition: vulkan.hpp:11384
CommandBufferAllocateInfo(CommandPool commandPool_=CommandPool(), CommandBufferLevel level_=CommandBufferLevel::ePrimary, uint32_t commandBufferCount_=0)
Definition: vulkan.hpp:11322
CommandBufferBeginInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:24565
bool operator!=(CommandBufferBeginInfo const &rhs) const
Definition: vulkan.hpp:24601
CommandBufferBeginInfo(CommandBufferUsageFlags flags_=CommandBufferUsageFlags(), const CommandBufferInheritanceInfo *pInheritanceInfo_=nullptr)
Definition: vulkan.hpp:24548
CommandBufferBeginInfo & setPInheritanceInfo(const CommandBufferInheritanceInfo *pInheritanceInfo_)
Definition: vulkan.hpp:24577
CommandBufferBeginInfo & setFlags(CommandBufferUsageFlags flags_)
Definition: vulkan.hpp:24571
const CommandBufferInheritanceInfo * pInheritanceInfo
Definition: vulkan.hpp:24612
CommandBufferBeginInfo(VkCommandBufferBeginInfo const &rhs)
Definition: vulkan.hpp:24555
bool operator==(CommandBufferBeginInfo const &rhs) const
Definition: vulkan.hpp:24593
CommandBufferBeginInfo & operator=(VkCommandBufferBeginInfo const &rhs)
Definition: vulkan.hpp:24560
CommandBufferInheritanceConditionalRenderingInfoEXT(Bool32 conditionalRenderingEnable_=0)
Definition: vulkan.hpp:18623
bool operator==(CommandBufferInheritanceConditionalRenderingInfoEXT const &rhs) const
Definition: vulkan.hpp:18660
CommandBufferInheritanceConditionalRenderingInfoEXT & setPNext(const void *pNext_)
Definition: vulkan.hpp:18638
CommandBufferInheritanceConditionalRenderingInfoEXT(VkCommandBufferInheritanceConditionalRenderingInfoEXT const &rhs)
Definition: vulkan.hpp:18628
CommandBufferInheritanceConditionalRenderingInfoEXT & operator=(VkCommandBufferInheritanceConditionalRenderingInfoEXT const &rhs)
Definition: vulkan.hpp:18633
CommandBufferInheritanceConditionalRenderingInfoEXT & setConditionalRenderingEnable(Bool32 conditionalRenderingEnable_)
Definition: vulkan.hpp:18644
bool operator!=(CommandBufferInheritanceConditionalRenderingInfoEXT const &rhs) const
Definition: vulkan.hpp:18667
CommandBufferInheritanceInfo & setQueryFlags(QueryControlFlags queryFlags_)
Definition: vulkan.hpp:24493
CommandBufferInheritanceInfo(RenderPass renderPass_=RenderPass(), uint32_t subpass_=0, Framebuffer framebuffer_=Framebuffer(), Bool32 occlusionQueryEnable_=0, QueryControlFlags queryFlags_=QueryControlFlags(), QueryPipelineStatisticFlags pipelineStatistics_=QueryPipelineStatisticFlags())
Definition: vulkan.hpp:24438
CommandBufferInheritanceInfo & setRenderPass(RenderPass renderPass_)
Definition: vulkan.hpp:24469
CommandBufferInheritanceInfo(VkCommandBufferInheritanceInfo const &rhs)
Definition: vulkan.hpp:24453
CommandBufferInheritanceInfo & setSubpass(uint32_t subpass_)
Definition: vulkan.hpp:24475
bool operator!=(CommandBufferInheritanceInfo const &rhs) const
Definition: vulkan.hpp:24527
QueryPipelineStatisticFlags pipelineStatistics
Definition: vulkan.hpp:24542
CommandBufferInheritanceInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:24463
CommandBufferInheritanceInfo & setOcclusionQueryEnable(Bool32 occlusionQueryEnable_)
Definition: vulkan.hpp:24487
CommandBufferInheritanceInfo & setFramebuffer(Framebuffer framebuffer_)
Definition: vulkan.hpp:24481
bool operator==(CommandBufferInheritanceInfo const &rhs) const
Definition: vulkan.hpp:24515
CommandBufferInheritanceInfo & setPipelineStatistics(QueryPipelineStatisticFlags pipelineStatistics_)
Definition: vulkan.hpp:24499
CommandBufferInheritanceInfo & operator=(VkCommandBufferInheritanceInfo const &rhs)
Definition: vulkan.hpp:24458
bool operator!=(CommandPoolCreateInfo const &rhs) const
Definition: vulkan.hpp:26883
CommandPoolCreateInfo & operator=(VkCommandPoolCreateInfo const &rhs)
Definition: vulkan.hpp:26842
CommandPoolCreateInfo(CommandPoolCreateFlags flags_=CommandPoolCreateFlags(), uint32_t queueFamilyIndex_=0)
Definition: vulkan.hpp:26830
CommandPoolCreateInfo(VkCommandPoolCreateInfo const &rhs)
Definition: vulkan.hpp:26837
CommandPoolCreateInfo & setFlags(CommandPoolCreateFlags flags_)
Definition: vulkan.hpp:26853
CommandPoolCreateInfo & setQueueFamilyIndex(uint32_t queueFamilyIndex_)
Definition: vulkan.hpp:26859
bool operator==(CommandPoolCreateInfo const &rhs) const
Definition: vulkan.hpp:26875
CommandPoolCreateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:26847
ComponentMapping(VkComponentMapping const &rhs)
Definition: vulkan.hpp:8112
bool operator==(ComponentMapping const &rhs) const
Definition: vulkan.hpp:8156
ComponentMapping(ComponentSwizzle r_=ComponentSwizzle::eIdentity, ComponentSwizzle g_=ComponentSwizzle::eIdentity, ComponentSwizzle b_=ComponentSwizzle::eIdentity, ComponentSwizzle a_=ComponentSwizzle::eIdentity)
Definition: vulkan.hpp:8101
ComponentMapping & setB(ComponentSwizzle b_)
Definition: vulkan.hpp:8134
ComponentMapping & setG(ComponentSwizzle g_)
Definition: vulkan.hpp:8128
ComponentMapping & setR(ComponentSwizzle r_)
Definition: vulkan.hpp:8122
ComponentMapping & operator=(VkComponentMapping const &rhs)
Definition: vulkan.hpp:8117
ComponentMapping & setA(ComponentSwizzle a_)
Definition: vulkan.hpp:8140
bool operator!=(ComponentMapping const &rhs) const
Definition: vulkan.hpp:8164
bool operator!=(ComputePipelineCreateInfo const &rhs) const
Definition: vulkan.hpp:23741
bool operator==(ComputePipelineCreateInfo const &rhs) const
Definition: vulkan.hpp:23730
ComputePipelineCreateInfo & setLayout(PipelineLayout layout_)
Definition: vulkan.hpp:23702
PipelineShaderStageCreateInfo stage
Definition: vulkan.hpp:23752
ComputePipelineCreateInfo & operator=(VkComputePipelineCreateInfo const &rhs)
Definition: vulkan.hpp:23679
ComputePipelineCreateInfo(PipelineCreateFlags flags_=PipelineCreateFlags(), PipelineShaderStageCreateInfo stage_=PipelineShaderStageCreateInfo(), PipelineLayout layout_=PipelineLayout(), Pipeline basePipelineHandle_=Pipeline(), int32_t basePipelineIndex_=0)
Definition: vulkan.hpp:23661
ComputePipelineCreateInfo & setFlags(PipelineCreateFlags flags_)
Definition: vulkan.hpp:23690
ComputePipelineCreateInfo & setBasePipelineHandle(Pipeline basePipelineHandle_)
Definition: vulkan.hpp:23708
ComputePipelineCreateInfo & setStage(PipelineShaderStageCreateInfo stage_)
Definition: vulkan.hpp:23696
ComputePipelineCreateInfo & setBasePipelineIndex(int32_t basePipelineIndex_)
Definition: vulkan.hpp:23714
ComputePipelineCreateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:23684
ComputePipelineCreateInfo(VkComputePipelineCreateInfo const &rhs)
Definition: vulkan.hpp:23674
ConditionalRenderingBeginInfoEXT & setFlags(ConditionalRenderingFlagsEXT flags_)
Definition: vulkan.hpp:36472
ConditionalRenderingBeginInfoEXT & setOffset(DeviceSize offset_)
Definition: vulkan.hpp:36466
ConditionalRenderingBeginInfoEXT(VkConditionalRenderingBeginInfoEXT const &rhs)
Definition: vulkan.hpp:36444
ConditionalRenderingBeginInfoEXT & setPNext(const void *pNext_)
Definition: vulkan.hpp:36454
ConditionalRenderingBeginInfoEXT(Buffer buffer_=Buffer(), DeviceSize offset_=0, ConditionalRenderingFlagsEXT flags_=ConditionalRenderingFlagsEXT())
Definition: vulkan.hpp:36435
ConditionalRenderingBeginInfoEXT & operator=(VkConditionalRenderingBeginInfoEXT const &rhs)
Definition: vulkan.hpp:36449
bool operator==(ConditionalRenderingBeginInfoEXT const &rhs) const
Definition: vulkan.hpp:36488
ConditionalRenderingBeginInfoEXT & setBuffer(Buffer buffer_)
Definition: vulkan.hpp:36460
bool operator!=(ConditionalRenderingBeginInfoEXT const &rhs) const
Definition: vulkan.hpp:36497
bool operator==(ConformanceVersionKHR const &rhs) const
Definition: vulkan.hpp:7246
ConformanceVersionKHR & operator=(VkConformanceVersionKHR const &rhs)
Definition: vulkan.hpp:7207
bool operator!=(ConformanceVersionKHR const &rhs) const
Definition: vulkan.hpp:7254
ConformanceVersionKHR & setPatch(uint8_t patch_)
Definition: vulkan.hpp:7230
ConformanceVersionKHR & setMinor(uint8_t minor_)
Definition: vulkan.hpp:7218
ConformanceVersionKHR(uint8_t major_=0, uint8_t minor_=0, uint8_t subminor_=0, uint8_t patch_=0)
Definition: vulkan.hpp:7191
ConformanceVersionKHR & setSubminor(uint8_t subminor_)
Definition: vulkan.hpp:7224
ConformanceVersionKHR(VkConformanceVersionKHR const &rhs)
Definition: vulkan.hpp:7202
ConformanceVersionKHR & setMajor(uint8_t major_)
Definition: vulkan.hpp:7212
CopyDescriptorSet & setPNext(const void *pNext_)
Definition: vulkan.hpp:10019
CopyDescriptorSet & setDstBinding(uint32_t dstBinding_)
Definition: vulkan.hpp:10049
CopyDescriptorSet & setDstArrayElement(uint32_t dstArrayElement_)
Definition: vulkan.hpp:10055
CopyDescriptorSet(DescriptorSet srcSet_=DescriptorSet(), uint32_t srcBinding_=0, uint32_t srcArrayElement_=0, DescriptorSet dstSet_=DescriptorSet(), uint32_t dstBinding_=0, uint32_t dstArrayElement_=0, uint32_t descriptorCount_=0)
Definition: vulkan.hpp:9992
CopyDescriptorSet & setDescriptorCount(uint32_t descriptorCount_)
Definition: vulkan.hpp:10061
bool operator!=(CopyDescriptorSet const &rhs) const
Definition: vulkan.hpp:10090
CopyDescriptorSet & setSrcSet(DescriptorSet srcSet_)
Definition: vulkan.hpp:10025
CopyDescriptorSet & setDstSet(DescriptorSet dstSet_)
Definition: vulkan.hpp:10043
CopyDescriptorSet & operator=(VkCopyDescriptorSet const &rhs)
Definition: vulkan.hpp:10014
CopyDescriptorSet & setSrcArrayElement(uint32_t srcArrayElement_)
Definition: vulkan.hpp:10037
CopyDescriptorSet(VkCopyDescriptorSet const &rhs)
Definition: vulkan.hpp:10009
CopyDescriptorSet & setSrcBinding(uint32_t srcBinding_)
Definition: vulkan.hpp:10031
bool operator==(CopyDescriptorSet const &rhs) const
Definition: vulkan.hpp:10077
bool operator==(DebugMarkerMarkerInfoEXT const &rhs) const
Definition: vulkan.hpp:12481
DebugMarkerMarkerInfoEXT(VkDebugMarkerMarkerInfoEXT const &rhs)
Definition: vulkan.hpp:12443
DebugMarkerMarkerInfoEXT & setColor(std::array< float, 4 > color_)
Definition: vulkan.hpp:12465
bool operator!=(DebugMarkerMarkerInfoEXT const &rhs) const
Definition: vulkan.hpp:12489
DebugMarkerMarkerInfoEXT & setPMarkerName(const char *pMarkerName_)
Definition: vulkan.hpp:12459
DebugMarkerMarkerInfoEXT & setPNext(const void *pNext_)
Definition: vulkan.hpp:12453
DebugMarkerMarkerInfoEXT & operator=(VkDebugMarkerMarkerInfoEXT const &rhs)
Definition: vulkan.hpp:12448
DebugMarkerMarkerInfoEXT(const char *pMarkerName_=nullptr, std::array< float, 4 > const &color_={ { 0, 0, 0, 0 } })
Definition: vulkan.hpp:12436
DebugMarkerObjectNameInfoEXT(VkDebugMarkerObjectNameInfoEXT const &rhs)
Definition: vulkan.hpp:29855
DebugMarkerObjectNameInfoEXT & setObjectType(DebugReportObjectTypeEXT objectType_)
Definition: vulkan.hpp:29871
DebugMarkerObjectNameInfoEXT & operator=(VkDebugMarkerObjectNameInfoEXT const &rhs)
Definition: vulkan.hpp:29860
DebugMarkerObjectNameInfoEXT(DebugReportObjectTypeEXT objectType_=DebugReportObjectTypeEXT::eUnknown, uint64_t object_=0, const char *pObjectName_=nullptr)
Definition: vulkan.hpp:29846
DebugMarkerObjectNameInfoEXT & setPObjectName(const char *pObjectName_)
Definition: vulkan.hpp:29883
DebugMarkerObjectNameInfoEXT & setObject(uint64_t object_)
Definition: vulkan.hpp:29877
bool operator==(DebugMarkerObjectNameInfoEXT const &rhs) const
Definition: vulkan.hpp:29899
DebugMarkerObjectNameInfoEXT & setPNext(const void *pNext_)
Definition: vulkan.hpp:29865
bool operator!=(DebugMarkerObjectNameInfoEXT const &rhs) const
Definition: vulkan.hpp:29908
DebugMarkerObjectTagInfoEXT & setPNext(const void *pNext_)
Definition: vulkan.hpp:29949
bool operator!=(DebugMarkerObjectTagInfoEXT const &rhs) const
Definition: vulkan.hpp:30006
DebugMarkerObjectTagInfoEXT & setTagSize(size_t tagSize_)
Definition: vulkan.hpp:29973
DebugMarkerObjectTagInfoEXT & setObject(uint64_t object_)
Definition: vulkan.hpp:29961
DebugMarkerObjectTagInfoEXT & setPTag(const void *pTag_)
Definition: vulkan.hpp:29979
DebugMarkerObjectTagInfoEXT(VkDebugMarkerObjectTagInfoEXT const &rhs)
Definition: vulkan.hpp:29939
DebugMarkerObjectTagInfoEXT(DebugReportObjectTypeEXT objectType_=DebugReportObjectTypeEXT::eUnknown, uint64_t object_=0, uint64_t tagName_=0, size_t tagSize_=0, const void *pTag_=nullptr)
Definition: vulkan.hpp:29926
bool operator==(DebugMarkerObjectTagInfoEXT const &rhs) const
Definition: vulkan.hpp:29995
DebugMarkerObjectTagInfoEXT & setTagName(uint64_t tagName_)
Definition: vulkan.hpp:29967
DebugMarkerObjectTagInfoEXT & setObjectType(DebugReportObjectTypeEXT objectType_)
Definition: vulkan.hpp:29955
DebugMarkerObjectTagInfoEXT & operator=(VkDebugMarkerObjectTagInfoEXT const &rhs)
Definition: vulkan.hpp:29944
bool operator!=(DebugReportCallbackCreateInfoEXT const &rhs) const
Definition: vulkan.hpp:29783
DebugReportCallbackCreateInfoEXT & setPNext(const void *pNext_)
Definition: vulkan.hpp:29740
DebugReportCallbackCreateInfoEXT & operator=(VkDebugReportCallbackCreateInfoEXT const &rhs)
Definition: vulkan.hpp:29735
DebugReportCallbackCreateInfoEXT(VkDebugReportCallbackCreateInfoEXT const &rhs)
Definition: vulkan.hpp:29730
DebugReportCallbackCreateInfoEXT(DebugReportFlagsEXT flags_=DebugReportFlagsEXT(), PFN_vkDebugReportCallbackEXT pfnCallback_=nullptr, void *pUserData_=nullptr)
Definition: vulkan.hpp:29721
DebugReportCallbackCreateInfoEXT & setFlags(DebugReportFlagsEXT flags_)
Definition: vulkan.hpp:29746
DebugReportCallbackCreateInfoEXT & setPUserData(void *pUserData_)
Definition: vulkan.hpp:29758
DebugReportCallbackCreateInfoEXT & setPfnCallback(PFN_vkDebugReportCallbackEXT pfnCallback_)
Definition: vulkan.hpp:29752
bool operator==(DebugReportCallbackCreateInfoEXT const &rhs) const
Definition: vulkan.hpp:29774
DebugUtilsLabelEXT(VkDebugUtilsLabelEXT const &rhs)
Definition: vulkan.hpp:17395
bool operator!=(DebugUtilsLabelEXT const &rhs) const
Definition: vulkan.hpp:17441
DebugUtilsLabelEXT & setPLabelName(const char *pLabelName_)
Definition: vulkan.hpp:17411
DebugUtilsLabelEXT & setColor(std::array< float, 4 > color_)
Definition: vulkan.hpp:17417
DebugUtilsLabelEXT & operator=(VkDebugUtilsLabelEXT const &rhs)
Definition: vulkan.hpp:17400
DebugUtilsLabelEXT & setPNext(const void *pNext_)
Definition: vulkan.hpp:17405
DebugUtilsLabelEXT(const char *pLabelName_=nullptr, std::array< float, 4 > const &color_={ { 0, 0, 0, 0 } })
Definition: vulkan.hpp:17388
bool operator==(DebugUtilsLabelEXT const &rhs) const
Definition: vulkan.hpp:17433
DebugUtilsMessengerCallbackDataEXT & setPQueueLabels(DebugUtilsLabelEXT *pQueueLabels_)
Definition: vulkan.hpp:21825
DebugUtilsMessengerCallbackDataEXT & setPNext(const void *pNext_)
Definition: vulkan.hpp:21789
DebugUtilsMessengerCallbackDataEXT(DebugUtilsMessengerCallbackDataFlagsEXT flags_=DebugUtilsMessengerCallbackDataFlagsEXT(), const char *pMessageIdName_=nullptr, int32_t messageIdNumber_=0, const char *pMessage_=nullptr, uint32_t queueLabelCount_=0, DebugUtilsLabelEXT *pQueueLabels_=nullptr, uint32_t cmdBufLabelCount_=0, DebugUtilsLabelEXT *pCmdBufLabels_=nullptr, uint32_t objectCount_=0, DebugUtilsObjectNameInfoEXT *pObjects_=nullptr)
Definition: vulkan.hpp:21756
DebugUtilsMessengerCallbackDataEXT(VkDebugUtilsMessengerCallbackDataEXT const &rhs)
Definition: vulkan.hpp:21779
bool operator!=(DebugUtilsMessengerCallbackDataEXT const &rhs) const
Definition: vulkan.hpp:21881
DebugUtilsMessengerCallbackDataFlagsEXT flags
Definition: vulkan.hpp:21891
bool operator==(DebugUtilsMessengerCallbackDataEXT const &rhs) const
Definition: vulkan.hpp:21865
DebugUtilsMessengerCallbackDataEXT & setPObjects(DebugUtilsObjectNameInfoEXT *pObjects_)
Definition: vulkan.hpp:21849
DebugUtilsMessengerCallbackDataEXT & setPCmdBufLabels(DebugUtilsLabelEXT *pCmdBufLabels_)
Definition: vulkan.hpp:21837
DebugUtilsMessengerCallbackDataEXT & setPMessageIdName(const char *pMessageIdName_)
Definition: vulkan.hpp:21801
DebugUtilsMessengerCallbackDataEXT & setFlags(DebugUtilsMessengerCallbackDataFlagsEXT flags_)
Definition: vulkan.hpp:21795
DebugUtilsMessengerCallbackDataEXT & setCmdBufLabelCount(uint32_t cmdBufLabelCount_)
Definition: vulkan.hpp:21831
DebugUtilsMessengerCallbackDataEXT & setQueueLabelCount(uint32_t queueLabelCount_)
Definition: vulkan.hpp:21819
DebugUtilsMessengerCallbackDataEXT & setPMessage(const char *pMessage_)
Definition: vulkan.hpp:21813
DebugUtilsMessengerCallbackDataEXT & operator=(VkDebugUtilsMessengerCallbackDataEXT const &rhs)
Definition: vulkan.hpp:21784
DebugUtilsMessengerCallbackDataEXT & setObjectCount(uint32_t objectCount_)
Definition: vulkan.hpp:21843
DebugUtilsMessengerCallbackDataEXT & setMessageIdNumber(int32_t messageIdNumber_)
Definition: vulkan.hpp:21807
DebugUtilsMessengerCreateInfoEXT & setPfnUserCallback(PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback_)
Definition: vulkan.hpp:36113
bool operator!=(DebugUtilsMessengerCreateInfoEXT const &rhs) const
Definition: vulkan.hpp:36146
PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback
Definition: vulkan.hpp:36159
DebugUtilsMessengerCreateInfoEXT & setFlags(DebugUtilsMessengerCreateFlagsEXT flags_)
Definition: vulkan.hpp:36095
DebugUtilsMessengerCreateInfoEXT(DebugUtilsMessengerCreateFlagsEXT flags_=DebugUtilsMessengerCreateFlagsEXT(), DebugUtilsMessageSeverityFlagsEXT messageSeverity_=DebugUtilsMessageSeverityFlagsEXT(), DebugUtilsMessageTypeFlagsEXT messageType_=DebugUtilsMessageTypeFlagsEXT(), PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback_=nullptr, void *pUserData_=nullptr)
Definition: vulkan.hpp:36066
bool operator==(DebugUtilsMessengerCreateInfoEXT const &rhs) const
Definition: vulkan.hpp:36135
DebugUtilsMessengerCreateInfoEXT & setPNext(const void *pNext_)
Definition: vulkan.hpp:36089
DebugUtilsMessengerCreateInfoEXT(VkDebugUtilsMessengerCreateInfoEXT const &rhs)
Definition: vulkan.hpp:36079
DebugUtilsMessengerCreateInfoEXT & setMessageSeverity(DebugUtilsMessageSeverityFlagsEXT messageSeverity_)
Definition: vulkan.hpp:36101
DebugUtilsMessageSeverityFlagsEXT messageSeverity
Definition: vulkan.hpp:36157
DebugUtilsMessengerCreateInfoEXT & setMessageType(DebugUtilsMessageTypeFlagsEXT messageType_)
Definition: vulkan.hpp:36107
DebugUtilsMessengerCreateInfoEXT & setPUserData(void *pUserData_)
Definition: vulkan.hpp:36119
DebugUtilsMessengerCreateInfoEXT & operator=(VkDebugUtilsMessengerCreateInfoEXT const &rhs)
Definition: vulkan.hpp:36084
DebugUtilsObjectNameInfoEXT(VkDebugUtilsObjectNameInfoEXT const &rhs)
Definition: vulkan.hpp:21585
DebugUtilsObjectNameInfoEXT & setPNext(const void *pNext_)
Definition: vulkan.hpp:21595
bool operator!=(DebugUtilsObjectNameInfoEXT const &rhs) const
Definition: vulkan.hpp:21638
DebugUtilsObjectNameInfoEXT(ObjectType objectType_=ObjectType::eUnknown, uint64_t objectHandle_=0, const char *pObjectName_=nullptr)
Definition: vulkan.hpp:21576
bool operator==(DebugUtilsObjectNameInfoEXT const &rhs) const
Definition: vulkan.hpp:21629
DebugUtilsObjectNameInfoEXT & operator=(VkDebugUtilsObjectNameInfoEXT const &rhs)
Definition: vulkan.hpp:21590
DebugUtilsObjectNameInfoEXT & setPObjectName(const char *pObjectName_)
Definition: vulkan.hpp:21613
DebugUtilsObjectNameInfoEXT & setObjectHandle(uint64_t objectHandle_)
Definition: vulkan.hpp:21607
DebugUtilsObjectNameInfoEXT & setObjectType(ObjectType objectType_)
Definition: vulkan.hpp:21601
DebugUtilsObjectTagInfoEXT(ObjectType objectType_=ObjectType::eUnknown, uint64_t objectHandle_=0, uint64_t tagName_=0, size_t tagSize_=0, const void *pTag_=nullptr)
Definition: vulkan.hpp:21656
DebugUtilsObjectTagInfoEXT & setPNext(const void *pNext_)
Definition: vulkan.hpp:21679
bool operator==(DebugUtilsObjectTagInfoEXT const &rhs) const
Definition: vulkan.hpp:21725
DebugUtilsObjectTagInfoEXT & operator=(VkDebugUtilsObjectTagInfoEXT const &rhs)
Definition: vulkan.hpp:21674
DebugUtilsObjectTagInfoEXT & setObjectType(ObjectType objectType_)
Definition: vulkan.hpp:21685
bool operator!=(DebugUtilsObjectTagInfoEXT const &rhs) const
Definition: vulkan.hpp:21736
DebugUtilsObjectTagInfoEXT & setTagSize(size_t tagSize_)
Definition: vulkan.hpp:21703
DebugUtilsObjectTagInfoEXT(VkDebugUtilsObjectTagInfoEXT const &rhs)
Definition: vulkan.hpp:21669
DebugUtilsObjectTagInfoEXT & setObjectHandle(uint64_t objectHandle_)
Definition: vulkan.hpp:21691
DebugUtilsObjectTagInfoEXT & setPTag(const void *pTag_)
Definition: vulkan.hpp:21709
DebugUtilsObjectTagInfoEXT & setTagName(uint64_t tagName_)
Definition: vulkan.hpp:21697
DedicatedAllocationBufferCreateInfoNV & operator=(VkDedicatedAllocationBufferCreateInfoNV const &rhs)
Definition: vulkan.hpp:12576
bool operator==(DedicatedAllocationBufferCreateInfoNV const &rhs) const
Definition: vulkan.hpp:12603
bool operator!=(DedicatedAllocationBufferCreateInfoNV const &rhs) const
Definition: vulkan.hpp:12610
DedicatedAllocationBufferCreateInfoNV & setDedicatedAllocation(Bool32 dedicatedAllocation_)
Definition: vulkan.hpp:12587
DedicatedAllocationBufferCreateInfoNV(VkDedicatedAllocationBufferCreateInfoNV const &rhs)
Definition: vulkan.hpp:12571
DedicatedAllocationBufferCreateInfoNV & setPNext(const void *pNext_)
Definition: vulkan.hpp:12581
DedicatedAllocationBufferCreateInfoNV(Bool32 dedicatedAllocation_=0)
Definition: vulkan.hpp:12566
DedicatedAllocationImageCreateInfoNV(Bool32 dedicatedAllocation_=0)
Definition: vulkan.hpp:12506
DedicatedAllocationImageCreateInfoNV & operator=(VkDedicatedAllocationImageCreateInfoNV const &rhs)
Definition: vulkan.hpp:12516
bool operator!=(DedicatedAllocationImageCreateInfoNV const &rhs) const
Definition: vulkan.hpp:12550
bool operator==(DedicatedAllocationImageCreateInfoNV const &rhs) const
Definition: vulkan.hpp:12543
DedicatedAllocationImageCreateInfoNV(VkDedicatedAllocationImageCreateInfoNV const &rhs)
Definition: vulkan.hpp:12511
DedicatedAllocationImageCreateInfoNV & setDedicatedAllocation(Bool32 dedicatedAllocation_)
Definition: vulkan.hpp:12527
DedicatedAllocationImageCreateInfoNV & setPNext(const void *pNext_)
Definition: vulkan.hpp:12521
bool operator==(DedicatedAllocationMemoryAllocateInfoNV const &rhs) const
Definition: vulkan.hpp:12671
DedicatedAllocationMemoryAllocateInfoNV(VkDedicatedAllocationMemoryAllocateInfoNV const &rhs)
Definition: vulkan.hpp:12633
DedicatedAllocationMemoryAllocateInfoNV & setBuffer(Buffer buffer_)
Definition: vulkan.hpp:12655
DedicatedAllocationMemoryAllocateInfoNV & setImage(Image image_)
Definition: vulkan.hpp:12649
DedicatedAllocationMemoryAllocateInfoNV & setPNext(const void *pNext_)
Definition: vulkan.hpp:12643
DedicatedAllocationMemoryAllocateInfoNV & operator=(VkDedicatedAllocationMemoryAllocateInfoNV const &rhs)
Definition: vulkan.hpp:12638
bool operator!=(DedicatedAllocationMemoryAllocateInfoNV const &rhs) const
Definition: vulkan.hpp:12679
DedicatedAllocationMemoryAllocateInfoNV(Image image_=Image(), Buffer buffer_=Buffer())
Definition: vulkan.hpp:12626
bool operator!=(DescriptorBufferInfo const &rhs) const
Definition: vulkan.hpp:5818
DescriptorBufferInfo & setBuffer(Buffer buffer_)
Definition: vulkan.hpp:5783
bool operator==(DescriptorBufferInfo const &rhs) const
Definition: vulkan.hpp:5811
DescriptorBufferInfo & operator=(VkDescriptorBufferInfo const &rhs)
Definition: vulkan.hpp:5778
DescriptorBufferInfo & setOffset(DeviceSize offset_)
Definition: vulkan.hpp:5789
DescriptorBufferInfo(VkDescriptorBufferInfo const &rhs)
Definition: vulkan.hpp:5773
DescriptorBufferInfo(Buffer buffer_=Buffer(), DeviceSize offset_=0, DeviceSize range_=0)
Definition: vulkan.hpp:5764
DescriptorBufferInfo & setRange(DeviceSize range_)
Definition: vulkan.hpp:5795
DescriptorImageInfo & setImageView(ImageView imageView_)
Definition: vulkan.hpp:7947
bool operator==(DescriptorImageInfo const &rhs) const
Definition: vulkan.hpp:7969
DescriptorImageInfo(Sampler sampler_=Sampler(), ImageView imageView_=ImageView(), ImageLayout imageLayout_=ImageLayout::eUndefined)
Definition: vulkan.hpp:7922
bool operator!=(DescriptorImageInfo const &rhs) const
Definition: vulkan.hpp:7976
DescriptorImageInfo & setImageLayout(ImageLayout imageLayout_)
Definition: vulkan.hpp:7953
DescriptorImageInfo & setSampler(Sampler sampler_)
Definition: vulkan.hpp:7941
DescriptorImageInfo(VkDescriptorImageInfo const &rhs)
Definition: vulkan.hpp:7931
DescriptorImageInfo & operator=(VkDescriptorImageInfo const &rhs)
Definition: vulkan.hpp:7936
DescriptorPoolCreateInfo(VkDescriptorPoolCreateInfo const &rhs)
Definition: vulkan.hpp:28746
DescriptorPoolCreateInfo & setMaxSets(uint32_t maxSets_)
Definition: vulkan.hpp:28768
DescriptorPoolCreateInfo & setPoolSizeCount(uint32_t poolSizeCount_)
Definition: vulkan.hpp:28774
DescriptorPoolCreateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:28756
DescriptorPoolCreateInfo & setPPoolSizes(const DescriptorPoolSize *pPoolSizes_)
Definition: vulkan.hpp:28780
DescriptorPoolCreateInfo & operator=(VkDescriptorPoolCreateInfo const &rhs)
Definition: vulkan.hpp:28751
bool operator==(DescriptorPoolCreateInfo const &rhs) const
Definition: vulkan.hpp:28796
bool operator!=(DescriptorPoolCreateInfo const &rhs) const
Definition: vulkan.hpp:28806
DescriptorPoolCreateInfo & setFlags(DescriptorPoolCreateFlags flags_)
Definition: vulkan.hpp:28762
DescriptorPoolCreateInfo(DescriptorPoolCreateFlags flags_=DescriptorPoolCreateFlags(), uint32_t maxSets_=0, uint32_t poolSizeCount_=0, const DescriptorPoolSize *pPoolSizes_=nullptr)
Definition: vulkan.hpp:28735
DescriptorPoolInlineUniformBlockCreateInfoEXT & operator=(VkDescriptorPoolInlineUniformBlockCreateInfoEXT const &rhs)
Definition: vulkan.hpp:16996
DescriptorPoolInlineUniformBlockCreateInfoEXT & setMaxInlineUniformBlockBindings(uint32_t maxInlineUniformBlockBindings_)
Definition: vulkan.hpp:17007
DescriptorPoolInlineUniformBlockCreateInfoEXT(VkDescriptorPoolInlineUniformBlockCreateInfoEXT const &rhs)
Definition: vulkan.hpp:16991
bool operator!=(DescriptorPoolInlineUniformBlockCreateInfoEXT const &rhs) const
Definition: vulkan.hpp:17030
DescriptorPoolInlineUniformBlockCreateInfoEXT & setPNext(const void *pNext_)
Definition: vulkan.hpp:17001
bool operator==(DescriptorPoolInlineUniformBlockCreateInfoEXT const &rhs) const
Definition: vulkan.hpp:17023
DescriptorPoolInlineUniformBlockCreateInfoEXT(uint32_t maxInlineUniformBlockBindings_=0)
Definition: vulkan.hpp:16986
DescriptorPoolSize & setType(DescriptorType type_)
Definition: vulkan.hpp:8212
bool operator!=(DescriptorPoolSize const &rhs) const
Definition: vulkan.hpp:8240
DescriptorPoolSize & setDescriptorCount(uint32_t descriptorCount_)
Definition: vulkan.hpp:8218
DescriptorPoolSize(VkDescriptorPoolSize const &rhs)
Definition: vulkan.hpp:8202
DescriptorPoolSize(DescriptorType type_=DescriptorType::eSampler, uint32_t descriptorCount_=0)
Definition: vulkan.hpp:8195
DescriptorPoolSize & operator=(VkDescriptorPoolSize const &rhs)
Definition: vulkan.hpp:8207
bool operator==(DescriptorPoolSize const &rhs) const
Definition: vulkan.hpp:8234
bool operator==(DescriptorSetAllocateInfo const &rhs) const
Definition: vulkan.hpp:10345
bool operator!=(DescriptorSetAllocateInfo const &rhs) const
Definition: vulkan.hpp:10354
DescriptorSetAllocateInfo(DescriptorPool descriptorPool_=DescriptorPool(), uint32_t descriptorSetCount_=0, const DescriptorSetLayout *pSetLayouts_=nullptr)
Definition: vulkan.hpp:10292
DescriptorSetAllocateInfo & operator=(VkDescriptorSetAllocateInfo const &rhs)
Definition: vulkan.hpp:10306
DescriptorSetAllocateInfo & setPSetLayouts(const DescriptorSetLayout *pSetLayouts_)
Definition: vulkan.hpp:10329
DescriptorSetAllocateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:10311
DescriptorSetAllocateInfo & setDescriptorPool(DescriptorPool descriptorPool_)
Definition: vulkan.hpp:10317
DescriptorSetAllocateInfo(VkDescriptorSetAllocateInfo const &rhs)
Definition: vulkan.hpp:10301
const DescriptorSetLayout * pSetLayouts
Definition: vulkan.hpp:10366
DescriptorSetAllocateInfo & setDescriptorSetCount(uint32_t descriptorSetCount_)
Definition: vulkan.hpp:10323
DescriptorSetLayoutBindingFlagsCreateInfoEXT(uint32_t bindingCount_=0, const DescriptorBindingFlagsEXT *pBindingFlags_=nullptr)
Definition: vulkan.hpp:36281
bool operator!=(DescriptorSetLayoutBindingFlagsCreateInfoEXT const &rhs) const
Definition: vulkan.hpp:36334
DescriptorSetLayoutBindingFlagsCreateInfoEXT & setPNext(const void *pNext_)
Definition: vulkan.hpp:36298
bool operator==(DescriptorSetLayoutBindingFlagsCreateInfoEXT const &rhs) const
Definition: vulkan.hpp:36326
DescriptorSetLayoutBindingFlagsCreateInfoEXT & setBindingCount(uint32_t bindingCount_)
Definition: vulkan.hpp:36304
DescriptorSetLayoutBindingFlagsCreateInfoEXT & operator=(VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const &rhs)
Definition: vulkan.hpp:36293
DescriptorSetLayoutBindingFlagsCreateInfoEXT(VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const &rhs)
Definition: vulkan.hpp:36288
DescriptorSetLayoutBindingFlagsCreateInfoEXT & setPBindingFlags(const DescriptorBindingFlagsEXT *pBindingFlags_)
Definition: vulkan.hpp:36310
DescriptorSetLayoutBinding & setDescriptorType(DescriptorType descriptorType_)
Definition: vulkan.hpp:22992
bool operator!=(DescriptorSetLayoutBinding const &rhs) const
Definition: vulkan.hpp:23035
DescriptorSetLayoutBinding(VkDescriptorSetLayoutBinding const &rhs)
Definition: vulkan.hpp:22976
DescriptorSetLayoutBinding & setStageFlags(ShaderStageFlags stageFlags_)
Definition: vulkan.hpp:23004
DescriptorSetLayoutBinding(uint32_t binding_=0, DescriptorType descriptorType_=DescriptorType::eSampler, uint32_t descriptorCount_=0, ShaderStageFlags stageFlags_=ShaderStageFlags(), const Sampler *pImmutableSamplers_=nullptr)
Definition: vulkan.hpp:22963
DescriptorSetLayoutBinding & setPImmutableSamplers(const Sampler *pImmutableSamplers_)
Definition: vulkan.hpp:23010
DescriptorSetLayoutBinding & setDescriptorCount(uint32_t descriptorCount_)
Definition: vulkan.hpp:22998
DescriptorSetLayoutBinding & setBinding(uint32_t binding_)
Definition: vulkan.hpp:22986
bool operator==(DescriptorSetLayoutBinding const &rhs) const
Definition: vulkan.hpp:23026
DescriptorSetLayoutBinding & operator=(VkDescriptorSetLayoutBinding const &rhs)
Definition: vulkan.hpp:22981
DescriptorSetLayoutCreateInfo(DescriptorSetLayoutCreateFlags flags_=DescriptorSetLayoutCreateFlags(), uint32_t bindingCount_=0, const DescriptorSetLayoutBinding *pBindings_=nullptr)
Definition: vulkan.hpp:31457
DescriptorSetLayoutCreateInfo & operator=(VkDescriptorSetLayoutCreateInfo const &rhs)
Definition: vulkan.hpp:31471
DescriptorSetLayoutCreateInfo & setPBindings(const DescriptorSetLayoutBinding *pBindings_)
Definition: vulkan.hpp:31494
DescriptorSetLayoutCreateInfo(VkDescriptorSetLayoutCreateInfo const &rhs)
Definition: vulkan.hpp:31466
const DescriptorSetLayoutBinding * pBindings
Definition: vulkan.hpp:31531
DescriptorSetLayoutCreateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:31476
bool operator!=(DescriptorSetLayoutCreateInfo const &rhs) const
Definition: vulkan.hpp:31519
DescriptorSetLayoutCreateInfo & setFlags(DescriptorSetLayoutCreateFlags flags_)
Definition: vulkan.hpp:31482
bool operator==(DescriptorSetLayoutCreateInfo const &rhs) const
Definition: vulkan.hpp:31510
DescriptorSetLayoutCreateInfo & setBindingCount(uint32_t bindingCount_)
Definition: vulkan.hpp:31488
bool operator==(DescriptorSetLayoutSupport const &rhs) const
Definition: vulkan.hpp:17303
bool operator!=(DescriptorSetLayoutSupport const &rhs) const
Definition: vulkan.hpp:17310
DescriptorSetVariableDescriptorCountAllocateInfoEXT & setPDescriptorCounts(const uint32_t *pDescriptorCounts_)
Definition: vulkan.hpp:18133
bool operator==(DescriptorSetVariableDescriptorCountAllocateInfoEXT const &rhs) const
Definition: vulkan.hpp:18149
bool operator!=(DescriptorSetVariableDescriptorCountAllocateInfoEXT const &rhs) const
Definition: vulkan.hpp:18157
DescriptorSetVariableDescriptorCountAllocateInfoEXT & operator=(VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const &rhs)
Definition: vulkan.hpp:18116
DescriptorSetVariableDescriptorCountAllocateInfoEXT(VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const &rhs)
Definition: vulkan.hpp:18111
DescriptorSetVariableDescriptorCountAllocateInfoEXT & setDescriptorSetCount(uint32_t descriptorSetCount_)
Definition: vulkan.hpp:18127
DescriptorSetVariableDescriptorCountAllocateInfoEXT(uint32_t descriptorSetCount_=0, const uint32_t *pDescriptorCounts_=nullptr)
Definition: vulkan.hpp:18104
DescriptorSetVariableDescriptorCountAllocateInfoEXT & setPNext(const void *pNext_)
Definition: vulkan.hpp:18121
bool operator!=(DescriptorSetVariableDescriptorCountLayoutSupportEXT const &rhs) const
Definition: vulkan.hpp:18191
bool operator==(DescriptorSetVariableDescriptorCountLayoutSupportEXT const &rhs) const
Definition: vulkan.hpp:18184
DescriptorUpdateTemplateCreateInfo & setFlags(DescriptorUpdateTemplateCreateFlags flags_)
Definition: vulkan.hpp:21435
DescriptorUpdateTemplateCreateInfo & setTemplateType(DescriptorUpdateTemplateType templateType_)
Definition: vulkan.hpp:21453
DescriptorUpdateTemplateCreateInfo & setPDescriptorUpdateEntries(const DescriptorUpdateTemplateEntry *pDescriptorUpdateEntries_)
Definition: vulkan.hpp:21447
DescriptorUpdateTemplateCreateInfo & setPNext(void *pNext_)
Definition: vulkan.hpp:21429
DescriptorUpdateTemplateCreateFlags flags
Definition: vulkan.hpp:21517
DescriptorUpdateTemplateCreateInfo(VkDescriptorUpdateTemplateCreateInfo const &rhs)
Definition: vulkan.hpp:21419
DescriptorUpdateTemplateCreateInfo(DescriptorUpdateTemplateCreateFlags flags_=DescriptorUpdateTemplateCreateFlags(), uint32_t descriptorUpdateEntryCount_=0, const DescriptorUpdateTemplateEntry *pDescriptorUpdateEntries_=nullptr, DescriptorUpdateTemplateType templateType_=DescriptorUpdateTemplateType::eDescriptorSet, DescriptorSetLayout descriptorSetLayout_=DescriptorSetLayout(), PipelineBindPoint pipelineBindPoint_=PipelineBindPoint::eGraphics, PipelineLayout pipelineLayout_=PipelineLayout(), uint32_t set_=0)
Definition: vulkan.hpp:21400
const DescriptorUpdateTemplateEntry * pDescriptorUpdateEntries
Definition: vulkan.hpp:21519
DescriptorUpdateTemplateCreateInfo & setDescriptorUpdateEntryCount(uint32_t descriptorUpdateEntryCount_)
Definition: vulkan.hpp:21441
DescriptorUpdateTemplateCreateInfo & setDescriptorSetLayout(DescriptorSetLayout descriptorSetLayout_)
Definition: vulkan.hpp:21459
DescriptorUpdateTemplateCreateInfo & setPipelineLayout(PipelineLayout pipelineLayout_)
Definition: vulkan.hpp:21471
bool operator==(DescriptorUpdateTemplateCreateInfo const &rhs) const
Definition: vulkan.hpp:21493
bool operator!=(DescriptorUpdateTemplateCreateInfo const &rhs) const
Definition: vulkan.hpp:21507
DescriptorUpdateTemplateCreateInfo & operator=(VkDescriptorUpdateTemplateCreateInfo const &rhs)
Definition: vulkan.hpp:21424
DescriptorUpdateTemplateCreateInfo & setPipelineBindPoint(PipelineBindPoint pipelineBindPoint_)
Definition: vulkan.hpp:21465
DescriptorUpdateTemplateCreateInfo & setSet(uint32_t set_)
Definition: vulkan.hpp:21477
Definition: vulkan.hpp:8251
DescriptorUpdateTemplateEntry & operator=(VkDescriptorUpdateTemplateEntry const &rhs)
Definition: vulkan.hpp:8272
DescriptorUpdateTemplateEntry & setDstBinding(uint32_t dstBinding_)
Definition: vulkan.hpp:8277
DescriptorUpdateTemplateEntry(uint32_t dstBinding_=0, uint32_t dstArrayElement_=0, uint32_t descriptorCount_=0, DescriptorType descriptorType_=DescriptorType::eSampler, size_t offset_=0, size_t stride_=0)
Definition: vulkan.hpp:8252
DescriptorType descriptorType
Definition: vulkan.hpp:8341
DescriptorUpdateTemplateEntry(VkDescriptorUpdateTemplateEntry const &rhs)
Definition: vulkan.hpp:8267
DescriptorUpdateTemplateEntry & setDescriptorCount(uint32_t descriptorCount_)
Definition: vulkan.hpp:8289
uint32_t descriptorCount
Definition: vulkan.hpp:8340
size_t stride
Definition: vulkan.hpp:8343
uint32_t dstBinding
Definition: vulkan.hpp:8338
DescriptorUpdateTemplateEntry & setDescriptorType(DescriptorType descriptorType_)
Definition: vulkan.hpp:8295
bool operator==(DescriptorUpdateTemplateEntry const &rhs) const
Definition: vulkan.hpp:8323
DescriptorUpdateTemplateEntry & setDstArrayElement(uint32_t dstArrayElement_)
Definition: vulkan.hpp:8283
bool operator!=(DescriptorUpdateTemplateEntry const &rhs) const
Definition: vulkan.hpp:8333
DescriptorUpdateTemplateEntry & setStride(size_t stride_)
Definition: vulkan.hpp:8307
DescriptorUpdateTemplateEntry & setOffset(size_t offset_)
Definition: vulkan.hpp:8301
uint32_t dstArrayElement
Definition: vulkan.hpp:8339
size_t offset
Definition: vulkan.hpp:8342
const PhysicalDeviceFeatures * pEnabledFeatures
Definition: vulkan.hpp:22241
DeviceCreateInfo & setQueueCreateInfoCount(uint32_t queueCreateInfoCount_)
Definition: vulkan.hpp:22158
bool operator==(DeviceCreateInfo const &rhs) const
Definition: vulkan.hpp:22210
DeviceCreateInfo & setEnabledExtensionCount(uint32_t enabledExtensionCount_)
Definition: vulkan.hpp:22182
bool operator!=(DeviceCreateInfo const &rhs) const
Definition: vulkan.hpp:22224
DeviceCreateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:22146
DeviceCreateInfo(DeviceCreateFlags flags_=DeviceCreateFlags(), uint32_t queueCreateInfoCount_=0, const DeviceQueueCreateInfo *pQueueCreateInfos_=nullptr, uint32_t enabledLayerCount_=0, const char *const *ppEnabledLayerNames_=nullptr, uint32_t enabledExtensionCount_=0, const char *const *ppEnabledExtensionNames_=nullptr, const PhysicalDeviceFeatures *pEnabledFeatures_=nullptr)
Definition: vulkan.hpp:22117
const char *const * ppEnabledExtensionNames
Definition: vulkan.hpp:22240
DeviceCreateInfo & setPEnabledFeatures(const PhysicalDeviceFeatures *pEnabledFeatures_)
Definition: vulkan.hpp:22194
DeviceCreateInfo & setPpEnabledExtensionNames(const char *const *ppEnabledExtensionNames_)
Definition: vulkan.hpp:22188
DeviceCreateInfo & operator=(VkDeviceCreateInfo const &rhs)
Definition: vulkan.hpp:22141
DeviceCreateInfo & setEnabledLayerCount(uint32_t enabledLayerCount_)
Definition: vulkan.hpp:22170
DeviceCreateInfo & setFlags(DeviceCreateFlags flags_)
Definition: vulkan.hpp:22152
const DeviceQueueCreateInfo * pQueueCreateInfos
Definition: vulkan.hpp:22236
const char *const * ppEnabledLayerNames
Definition: vulkan.hpp:22238
DeviceCreateInfo & setPpEnabledLayerNames(const char *const *ppEnabledLayerNames_)
Definition: vulkan.hpp:22176
DeviceCreateInfo & setPQueueCreateInfos(const DeviceQueueCreateInfo *pQueueCreateInfos_)
Definition: vulkan.hpp:22164
DeviceCreateInfo(VkDeviceCreateInfo const &rhs)
Definition: vulkan.hpp:22136
bool operator==(DeviceEventInfoEXT const &rhs) const
Definition: vulkan.hpp:33836
DeviceEventInfoEXT(VkDeviceEventInfoEXT const &rhs)
Definition: vulkan.hpp:33804
bool operator!=(DeviceEventInfoEXT const &rhs) const
Definition: vulkan.hpp:33843
DeviceEventInfoEXT(DeviceEventTypeEXT deviceEvent_=DeviceEventTypeEXT::eDisplayHotplug)
Definition: vulkan.hpp:33799
DeviceEventInfoEXT & setPNext(const void *pNext_)
Definition: vulkan.hpp:33814
DeviceEventInfoEXT & setDeviceEvent(DeviceEventTypeEXT deviceEvent_)
Definition: vulkan.hpp:33820
DeviceEventInfoEXT & operator=(VkDeviceEventInfoEXT const &rhs)
Definition: vulkan.hpp:33809
bool operator!=(DeviceGeneratedCommandsFeaturesNVX const &rhs) const
Definition: vulkan.hpp:12934
bool operator==(DeviceGeneratedCommandsFeaturesNVX const &rhs) const
Definition: vulkan.hpp:12927
DeviceGeneratedCommandsFeaturesNVX & operator=(VkDeviceGeneratedCommandsFeaturesNVX const &rhs)
Definition: vulkan.hpp:12900
DeviceGeneratedCommandsFeaturesNVX & setComputeBindingPointSupport(Bool32 computeBindingPointSupport_)
Definition: vulkan.hpp:12911
DeviceGeneratedCommandsFeaturesNVX & setPNext(const void *pNext_)
Definition: vulkan.hpp:12905
DeviceGeneratedCommandsFeaturesNVX(Bool32 computeBindingPointSupport_=0)
Definition: vulkan.hpp:12890
DeviceGeneratedCommandsFeaturesNVX(VkDeviceGeneratedCommandsFeaturesNVX const &rhs)
Definition: vulkan.hpp:12895
DeviceGeneratedCommandsLimitsNVX & setMaxIndirectCommandsLayoutTokenCount(uint32_t maxIndirectCommandsLayoutTokenCount_)
Definition: vulkan.hpp:12979
DeviceGeneratedCommandsLimitsNVX & setPNext(const void *pNext_)
Definition: vulkan.hpp:12973
DeviceGeneratedCommandsLimitsNVX & setMinSequenceCountBufferOffsetAlignment(uint32_t minSequenceCountBufferOffsetAlignment_)
Definition: vulkan.hpp:12991
bool operator!=(DeviceGeneratedCommandsLimitsNVX const &rhs) const
Definition: vulkan.hpp:13030
DeviceGeneratedCommandsLimitsNVX & setMinCommandsTokenBufferOffsetAlignment(uint32_t minCommandsTokenBufferOffsetAlignment_)
Definition: vulkan.hpp:13003
DeviceGeneratedCommandsLimitsNVX & setMaxObjectEntryCounts(uint32_t maxObjectEntryCounts_)
Definition: vulkan.hpp:12985
DeviceGeneratedCommandsLimitsNVX & operator=(VkDeviceGeneratedCommandsLimitsNVX const &rhs)
Definition: vulkan.hpp:12968
bool operator==(DeviceGeneratedCommandsLimitsNVX const &rhs) const
Definition: vulkan.hpp:13019
DeviceGeneratedCommandsLimitsNVX & setMinSequenceIndexBufferOffsetAlignment(uint32_t minSequenceIndexBufferOffsetAlignment_)
Definition: vulkan.hpp:12997
DeviceGeneratedCommandsLimitsNVX(uint32_t maxIndirectCommandsLayoutTokenCount_=0, uint32_t maxObjectEntryCounts_=0, uint32_t minSequenceCountBufferOffsetAlignment_=0, uint32_t minSequenceIndexBufferOffsetAlignment_=0, uint32_t minCommandsTokenBufferOffsetAlignment_=0)
Definition: vulkan.hpp:12950
DeviceGeneratedCommandsLimitsNVX(VkDeviceGeneratedCommandsLimitsNVX const &rhs)
Definition: vulkan.hpp:12963
DeviceGroupBindSparseInfo & operator=(VkDeviceGroupBindSparseInfo const &rhs)
Definition: vulkan.hpp:14792
bool operator==(DeviceGroupBindSparseInfo const &rhs) const
Definition: vulkan.hpp:14825
DeviceGroupBindSparseInfo & setResourceDeviceIndex(uint32_t resourceDeviceIndex_)
Definition: vulkan.hpp:14803
DeviceGroupBindSparseInfo(VkDeviceGroupBindSparseInfo const &rhs)
Definition: vulkan.hpp:14787
bool operator!=(DeviceGroupBindSparseInfo const &rhs) const
Definition: vulkan.hpp:14833
DeviceGroupBindSparseInfo & setMemoryDeviceIndex(uint32_t memoryDeviceIndex_)
Definition: vulkan.hpp:14809
DeviceGroupBindSparseInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:14797
DeviceGroupBindSparseInfo(uint32_t resourceDeviceIndex_=0, uint32_t memoryDeviceIndex_=0)
Definition: vulkan.hpp:14780
DeviceGroupCommandBufferBeginInfo & setDeviceMask(uint32_t deviceMask_)
Definition: vulkan.hpp:14627
DeviceGroupCommandBufferBeginInfo(VkDeviceGroupCommandBufferBeginInfo const &rhs)
Definition: vulkan.hpp:14611
bool operator!=(DeviceGroupCommandBufferBeginInfo const &rhs) const
Definition: vulkan.hpp:14650
bool operator==(DeviceGroupCommandBufferBeginInfo const &rhs) const
Definition: vulkan.hpp:14643
DeviceGroupCommandBufferBeginInfo & operator=(VkDeviceGroupCommandBufferBeginInfo const &rhs)
Definition: vulkan.hpp:14616
DeviceGroupCommandBufferBeginInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:14621
DeviceGroupDeviceCreateInfo & operator=(VkDeviceGroupDeviceCreateInfo const &rhs)
Definition: vulkan.hpp:48236
DeviceGroupDeviceCreateInfo & setPPhysicalDevices(const PhysicalDevice *pPhysicalDevices_)
Definition: vulkan.hpp:48253
bool operator==(DeviceGroupDeviceCreateInfo const &rhs) const
Definition: vulkan.hpp:48269
bool operator!=(DeviceGroupDeviceCreateInfo const &rhs) const
Definition: vulkan.hpp:48277
DeviceGroupDeviceCreateInfo(uint32_t physicalDeviceCount_=0, const PhysicalDevice *pPhysicalDevices_=nullptr)
Definition: vulkan.hpp:48224
DeviceGroupDeviceCreateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:48241
DeviceGroupDeviceCreateInfo & setPhysicalDeviceCount(uint32_t physicalDeviceCount_)
Definition: vulkan.hpp:48247
DeviceGroupDeviceCreateInfo(VkDeviceGroupDeviceCreateInfo const &rhs)
Definition: vulkan.hpp:48231
bool operator==(DeviceGroupPresentCapabilitiesKHR const &rhs) const
Definition: vulkan.hpp:34096
bool operator!=(DeviceGroupPresentCapabilitiesKHR const &rhs) const
Definition: vulkan.hpp:34104
uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE]
Definition: vulkan.hpp:34114
bool operator!=(DeviceGroupPresentInfoKHR const &rhs) const
Definition: vulkan.hpp:34183
DeviceGroupPresentModeFlagBitsKHR mode
Definition: vulkan.hpp:34195
bool operator==(DeviceGroupPresentInfoKHR const &rhs) const
Definition: vulkan.hpp:34174
DeviceGroupPresentInfoKHR & setPDeviceMasks(const uint32_t *pDeviceMasks_)
Definition: vulkan.hpp:34152
DeviceGroupPresentInfoKHR & setPNext(const void *pNext_)
Definition: vulkan.hpp:34140
DeviceGroupPresentInfoKHR & setMode(DeviceGroupPresentModeFlagBitsKHR mode_)
Definition: vulkan.hpp:34158
DeviceGroupPresentInfoKHR(uint32_t swapchainCount_=0, const uint32_t *pDeviceMasks_=nullptr, DeviceGroupPresentModeFlagBitsKHR mode_=DeviceGroupPresentModeFlagBitsKHR::eLocal)
Definition: vulkan.hpp:34121
DeviceGroupPresentInfoKHR(VkDeviceGroupPresentInfoKHR const &rhs)
Definition: vulkan.hpp:34130
DeviceGroupPresentInfoKHR & setSwapchainCount(uint32_t swapchainCount_)
Definition: vulkan.hpp:34146
DeviceGroupPresentInfoKHR & operator=(VkDeviceGroupPresentInfoKHR const &rhs)
Definition: vulkan.hpp:34135
DeviceGroupRenderPassBeginInfo & operator=(VkDeviceGroupRenderPassBeginInfo const &rhs)
Definition: vulkan.hpp:14538
DeviceGroupRenderPassBeginInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:14543
DeviceGroupRenderPassBeginInfo(VkDeviceGroupRenderPassBeginInfo const &rhs)
Definition: vulkan.hpp:14533
DeviceGroupRenderPassBeginInfo & setDeviceMask(uint32_t deviceMask_)
Definition: vulkan.hpp:14549
DeviceGroupRenderPassBeginInfo(uint32_t deviceMask_=0, uint32_t deviceRenderAreaCount_=0, const Rect2D *pDeviceRenderAreas_=nullptr)
Definition: vulkan.hpp:14524
DeviceGroupRenderPassBeginInfo & setPDeviceRenderAreas(const Rect2D *pDeviceRenderAreas_)
Definition: vulkan.hpp:14561
bool operator==(DeviceGroupRenderPassBeginInfo const &rhs) const
Definition: vulkan.hpp:14577
bool operator!=(DeviceGroupRenderPassBeginInfo const &rhs) const
Definition: vulkan.hpp:14586
DeviceGroupRenderPassBeginInfo & setDeviceRenderAreaCount(uint32_t deviceRenderAreaCount_)
Definition: vulkan.hpp:14555
DeviceGroupSubmitInfo & setPCommandBufferDeviceMasks(const uint32_t *pCommandBufferDeviceMasks_)
Definition: vulkan.hpp:14717
bool operator==(DeviceGroupSubmitInfo const &rhs) const
Definition: vulkan.hpp:14745
DeviceGroupSubmitInfo & setPWaitSemaphoreDeviceIndices(const uint32_t *pWaitSemaphoreDeviceIndices_)
Definition: vulkan.hpp:14705
DeviceGroupSubmitInfo & operator=(VkDeviceGroupSubmitInfo const &rhs)
Definition: vulkan.hpp:14688
bool operator!=(DeviceGroupSubmitInfo const &rhs) const
Definition: vulkan.hpp:14757
DeviceGroupSubmitInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:14693
DeviceGroupSubmitInfo & setPSignalSemaphoreDeviceIndices(const uint32_t *pSignalSemaphoreDeviceIndices_)
Definition: vulkan.hpp:14729
DeviceGroupSubmitInfo(uint32_t waitSemaphoreCount_=0, const uint32_t *pWaitSemaphoreDeviceIndices_=nullptr, uint32_t commandBufferCount_=0, const uint32_t *pCommandBufferDeviceMasks_=nullptr, uint32_t signalSemaphoreCount_=0, const uint32_t *pSignalSemaphoreDeviceIndices_=nullptr)
Definition: vulkan.hpp:14668
DeviceGroupSubmitInfo & setWaitSemaphoreCount(uint32_t waitSemaphoreCount_)
Definition: vulkan.hpp:14699
DeviceGroupSubmitInfo(VkDeviceGroupSubmitInfo const &rhs)
Definition: vulkan.hpp:14683
DeviceGroupSubmitInfo & setCommandBufferCount(uint32_t commandBufferCount_)
Definition: vulkan.hpp:14711
DeviceGroupSubmitInfo & setSignalSemaphoreCount(uint32_t signalSemaphoreCount_)
Definition: vulkan.hpp:14723
DeviceGroupSwapchainCreateInfoKHR & operator=(VkDeviceGroupSwapchainCreateInfoKHR const &rhs)
Definition: vulkan.hpp:34211
bool operator==(DeviceGroupSwapchainCreateInfoKHR const &rhs) const
Definition: vulkan.hpp:34238
DeviceGroupSwapchainCreateInfoKHR(VkDeviceGroupSwapchainCreateInfoKHR const &rhs)
Definition: vulkan.hpp:34206
DeviceGroupSwapchainCreateInfoKHR & setModes(DeviceGroupPresentModeFlagsKHR modes_)
Definition: vulkan.hpp:34222
bool operator!=(DeviceGroupSwapchainCreateInfoKHR const &rhs) const
Definition: vulkan.hpp:34245
DeviceGroupSwapchainCreateInfoKHR & setPNext(const void *pNext_)
Definition: vulkan.hpp:34216
DeviceGroupSwapchainCreateInfoKHR(DeviceGroupPresentModeFlagsKHR modes_=DeviceGroupPresentModeFlagsKHR())
Definition: vulkan.hpp:34201
DeviceMemoryOverallocationCreateInfoAMD(VkDeviceMemoryOverallocationCreateInfoAMD const &rhs)
Definition: vulkan.hpp:37520
bool operator==(DeviceMemoryOverallocationCreateInfoAMD const &rhs) const
Definition: vulkan.hpp:37552
DeviceMemoryOverallocationCreateInfoAMD & operator=(VkDeviceMemoryOverallocationCreateInfoAMD const &rhs)
Definition: vulkan.hpp:37525
DeviceMemoryOverallocationCreateInfoAMD & setOverallocationBehavior(MemoryOverallocationBehaviorAMD overallocationBehavior_)
Definition: vulkan.hpp:37536
bool operator!=(DeviceMemoryOverallocationCreateInfoAMD const &rhs) const
Definition: vulkan.hpp:37559
DeviceMemoryOverallocationCreateInfoAMD & setPNext(const void *pNext_)
Definition: vulkan.hpp:37530
DeviceMemoryOverallocationCreateInfoAMD(MemoryOverallocationBehaviorAMD overallocationBehavior_=MemoryOverallocationBehaviorAMD::eDefault)
Definition: vulkan.hpp:37515
bool operator==(DeviceQueueCreateInfo const &rhs) const
Definition: vulkan.hpp:22088
bool operator!=(DeviceQueueCreateInfo const &rhs) const
Definition: vulkan.hpp:22098
DeviceQueueCreateInfo & setPQueuePriorities(const float *pQueuePriorities_)
Definition: vulkan.hpp:22072
DeviceQueueCreateInfo & setQueueFamilyIndex(uint32_t queueFamilyIndex_)
Definition: vulkan.hpp:22060
DeviceQueueCreateInfo(DeviceQueueCreateFlags flags_=DeviceQueueCreateFlags(), uint32_t queueFamilyIndex_=0, uint32_t queueCount_=0, const float *pQueuePriorities_=nullptr)
Definition: vulkan.hpp:22027
DeviceQueueCreateInfo & setFlags(DeviceQueueCreateFlags flags_)
Definition: vulkan.hpp:22054
DeviceQueueCreateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:22048
DeviceQueueCreateInfo & setQueueCount(uint32_t queueCount_)
Definition: vulkan.hpp:22066
DeviceQueueCreateInfo & operator=(VkDeviceQueueCreateInfo const &rhs)
Definition: vulkan.hpp:22043
DeviceQueueCreateInfo(VkDeviceQueueCreateInfo const &rhs)
Definition: vulkan.hpp:22038
bool operator!=(DeviceQueueGlobalPriorityCreateInfoEXT const &rhs) const
Definition: vulkan.hpp:35995
bool operator==(DeviceQueueGlobalPriorityCreateInfoEXT const &rhs) const
Definition: vulkan.hpp:35988
DeviceQueueGlobalPriorityCreateInfoEXT(QueueGlobalPriorityEXT globalPriority_=QueueGlobalPriorityEXT::eLow)
Definition: vulkan.hpp:35951
DeviceQueueGlobalPriorityCreateInfoEXT(VkDeviceQueueGlobalPriorityCreateInfoEXT const &rhs)
Definition: vulkan.hpp:35956
DeviceQueueGlobalPriorityCreateInfoEXT & setPNext(const void *pNext_)
Definition: vulkan.hpp:35966
DeviceQueueGlobalPriorityCreateInfoEXT & operator=(VkDeviceQueueGlobalPriorityCreateInfoEXT const &rhs)
Definition: vulkan.hpp:35961
DeviceQueueGlobalPriorityCreateInfoEXT & setGlobalPriority(QueueGlobalPriorityEXT globalPriority_)
Definition: vulkan.hpp:35972
bool operator==(DeviceQueueInfo2 const &rhs) const
Definition: vulkan.hpp:22300
DeviceQueueInfo2 & setFlags(DeviceQueueCreateFlags flags_)
Definition: vulkan.hpp:22272
DeviceQueueInfo2 & setPNext(const void *pNext_)
Definition: vulkan.hpp:22266
DeviceQueueInfo2(VkDeviceQueueInfo2 const &rhs)
Definition: vulkan.hpp:22256
bool operator!=(DeviceQueueInfo2 const &rhs) const
Definition: vulkan.hpp:22309
DeviceQueueInfo2(DeviceQueueCreateFlags flags_=DeviceQueueCreateFlags(), uint32_t queueFamilyIndex_=0, uint32_t queueIndex_=0)
Definition: vulkan.hpp:22247
DeviceQueueInfo2 & setQueueFamilyIndex(uint32_t queueFamilyIndex_)
Definition: vulkan.hpp:22278
DeviceQueueInfo2 & setQueueIndex(uint32_t queueIndex_)
Definition: vulkan.hpp:22284
DeviceQueueInfo2 & operator=(VkDeviceQueueInfo2 const &rhs)
Definition: vulkan.hpp:22261
bool operator!=(DispatchIndirectCommand const &rhs) const
Definition: vulkan.hpp:7065
DispatchIndirectCommand(VkDispatchIndirectCommand const &rhs)
Definition: vulkan.hpp:7020
DispatchIndirectCommand & setX(uint32_t x_)
Definition: vulkan.hpp:7030
DispatchIndirectCommand & operator=(VkDispatchIndirectCommand const &rhs)
Definition: vulkan.hpp:7025
DispatchIndirectCommand & setY(uint32_t y_)
Definition: vulkan.hpp:7036
bool operator==(DispatchIndirectCommand const &rhs) const
Definition: vulkan.hpp:7058
DispatchIndirectCommand(uint32_t x_=0, uint32_t y_=0, uint32_t z_=0)
Definition: vulkan.hpp:7011
DispatchIndirectCommand & setZ(uint32_t z_)
Definition: vulkan.hpp:7042
DisplayEventInfoEXT(VkDisplayEventInfoEXT const &rhs)
Definition: vulkan.hpp:33869
DisplayEventInfoEXT & setPNext(const void *pNext_)
Definition: vulkan.hpp:33879
DisplayEventInfoEXT & operator=(VkDisplayEventInfoEXT const &rhs)
Definition: vulkan.hpp:33874
DisplayEventInfoEXT(DisplayEventTypeEXT displayEvent_=DisplayEventTypeEXT::eFirstPixelOut)
Definition: vulkan.hpp:33864
DisplayEventInfoEXT & setDisplayEvent(DisplayEventTypeEXT displayEvent_)
Definition: vulkan.hpp:33885
bool operator==(DisplayEventInfoEXT const &rhs) const
Definition: vulkan.hpp:33901
bool operator!=(DisplayEventInfoEXT const &rhs) const
Definition: vulkan.hpp:33908
DisplayModeCreateInfoKHR(DisplayModeCreateFlagsKHR flags_=DisplayModeCreateFlagsKHR(), DisplayModeParametersKHR parameters_=DisplayModeParametersKHR())
Definition: vulkan.hpp:11742
DisplayModeCreateInfoKHR & setPNext(const void *pNext_)
Definition: vulkan.hpp:11759
bool operator!=(DisplayModeCreateInfoKHR const &rhs) const
Definition: vulkan.hpp:11795
bool operator==(DisplayModeCreateInfoKHR const &rhs) const
Definition: vulkan.hpp:11787
DisplayModeCreateInfoKHR & operator=(VkDisplayModeCreateInfoKHR const &rhs)
Definition: vulkan.hpp:11754
DisplayModeCreateInfoKHR & setFlags(DisplayModeCreateFlagsKHR flags_)
Definition: vulkan.hpp:11765
DisplayModeCreateInfoKHR(VkDisplayModeCreateInfoKHR const &rhs)
Definition: vulkan.hpp:11749
DisplayModeCreateInfoKHR & setParameters(DisplayModeParametersKHR parameters_)
Definition: vulkan.hpp:11771
DisplayModeParametersKHR & setVisibleRegion(Extent2D visibleRegion_)
Definition: vulkan.hpp:7123
DisplayModeParametersKHR(Extent2D visibleRegion_=Extent2D(), uint32_t refreshRate_=0)
Definition: vulkan.hpp:7106
bool operator==(DisplayModeParametersKHR const &rhs) const
Definition: vulkan.hpp:7145
DisplayModeParametersKHR & setRefreshRate(uint32_t refreshRate_)
Definition: vulkan.hpp:7129
bool operator!=(DisplayModeParametersKHR const &rhs) const
Definition: vulkan.hpp:7151
DisplayModeParametersKHR(VkDisplayModeParametersKHR const &rhs)
Definition: vulkan.hpp:7113
DisplayModeParametersKHR & operator=(VkDisplayModeParametersKHR const &rhs)
Definition: vulkan.hpp:7118
bool operator==(DisplayModeProperties2KHR const &rhs) const
Definition: vulkan.hpp:15702
bool operator!=(DisplayModeProperties2KHR const &rhs) const
Definition: vulkan.hpp:15709
DisplayModePropertiesKHR displayModeProperties
Definition: vulkan.hpp:15719
bool operator==(DisplayModePropertiesKHR const &rhs) const
Definition: vulkan.hpp:7173
bool operator!=(DisplayModePropertiesKHR const &rhs) const
Definition: vulkan.hpp:7179
bool operator==(DisplayPlaneCapabilities2KHR const &rhs) const
Definition: vulkan.hpp:29262
bool operator!=(DisplayPlaneCapabilities2KHR const &rhs) const
Definition: vulkan.hpp:29269
bool operator==(DisplayPlaneCapabilitiesKHR const &rhs) const
Definition: vulkan.hpp:29220
bool operator!=(DisplayPlaneCapabilitiesKHR const &rhs) const
Definition: vulkan.hpp:29233
bool operator!=(DisplayPlaneInfo2KHR const &rhs) const
Definition: vulkan.hpp:15778
DisplayPlaneInfo2KHR & setPNext(const void *pNext_)
Definition: vulkan.hpp:15742
DisplayPlaneInfo2KHR & setMode(DisplayModeKHR mode_)
Definition: vulkan.hpp:15748
DisplayPlaneInfo2KHR & operator=(VkDisplayPlaneInfo2KHR const &rhs)
Definition: vulkan.hpp:15737
DisplayPlaneInfo2KHR(DisplayModeKHR mode_=DisplayModeKHR(), uint32_t planeIndex_=0)
Definition: vulkan.hpp:15725
DisplayPlaneInfo2KHR(VkDisplayPlaneInfo2KHR const &rhs)
Definition: vulkan.hpp:15732
bool operator==(DisplayPlaneInfo2KHR const &rhs) const
Definition: vulkan.hpp:15770
DisplayPlaneInfo2KHR & setPlaneIndex(uint32_t planeIndex_)
Definition: vulkan.hpp:15754
bool operator!=(DisplayPlaneProperties2KHR const &rhs) const
Definition: vulkan.hpp:15676
bool operator==(DisplayPlaneProperties2KHR const &rhs) const
Definition: vulkan.hpp:15669
DisplayPlanePropertiesKHR displayPlaneProperties
Definition: vulkan.hpp:15686
bool operator!=(DisplayPlanePropertiesKHR const &rhs) const
Definition: vulkan.hpp:7094
bool operator==(DisplayPlanePropertiesKHR const &rhs) const
Definition: vulkan.hpp:7088
bool operator==(DisplayPowerInfoEXT const &rhs) const
Definition: vulkan.hpp:33771
DisplayPowerInfoEXT & operator=(VkDisplayPowerInfoEXT const &rhs)
Definition: vulkan.hpp:33744
DisplayPowerInfoEXT(DisplayPowerStateEXT powerState_=DisplayPowerStateEXT::eOff)
Definition: vulkan.hpp:33734
DisplayPowerInfoEXT & setPowerState(DisplayPowerStateEXT powerState_)
Definition: vulkan.hpp:33755
bool operator!=(DisplayPowerInfoEXT const &rhs) const
Definition: vulkan.hpp:33778
DisplayPowerInfoEXT(VkDisplayPowerInfoEXT const &rhs)
Definition: vulkan.hpp:33739
DisplayPowerInfoEXT & setPNext(const void *pNext_)
Definition: vulkan.hpp:33749
DisplayPresentInfoKHR(Rect2D srcRect_=Rect2D(), Rect2D dstRect_=Rect2D(), Bool32 persistent_=0)
Definition: vulkan.hpp:11812
DisplayPresentInfoKHR & setPersistent(Bool32 persistent_)
Definition: vulkan.hpp:11849
DisplayPresentInfoKHR & setDstRect(Rect2D dstRect_)
Definition: vulkan.hpp:11843
DisplayPresentInfoKHR(VkDisplayPresentInfoKHR const &rhs)
Definition: vulkan.hpp:11821
DisplayPresentInfoKHR & setPNext(const void *pNext_)
Definition: vulkan.hpp:11831
bool operator==(DisplayPresentInfoKHR const &rhs) const
Definition: vulkan.hpp:11865
DisplayPresentInfoKHR & operator=(VkDisplayPresentInfoKHR const &rhs)
Definition: vulkan.hpp:11826
DisplayPresentInfoKHR & setSrcRect(Rect2D srcRect_)
Definition: vulkan.hpp:11837
bool operator!=(DisplayPresentInfoKHR const &rhs) const
Definition: vulkan.hpp:11874
bool operator==(DisplayProperties2KHR const &rhs) const
Definition: vulkan.hpp:29601
bool operator!=(DisplayProperties2KHR const &rhs) const
Definition: vulkan.hpp:29608
SurfaceTransformFlagsKHR supportedTransforms
Definition: vulkan.hpp:29376
bool operator!=(DisplayPropertiesKHR const &rhs) const
Definition: vulkan.hpp:29367
bool operator==(DisplayPropertiesKHR const &rhs) const
Definition: vulkan.hpp:29356
DisplaySurfaceCreateInfoKHR & setTransform(SurfaceTransformFlagBitsKHR transform_)
Definition: vulkan.hpp:29443
DisplaySurfaceCreateInfoKHR & setGlobalAlpha(float globalAlpha_)
Definition: vulkan.hpp:29449
bool operator==(DisplaySurfaceCreateInfoKHR const &rhs) const
Definition: vulkan.hpp:29477
DisplaySurfaceCreateInfoKHR & setImageExtent(Extent2D imageExtent_)
Definition: vulkan.hpp:29461
DisplaySurfaceCreateInfoKHR & setPlaneStackIndex(uint32_t planeStackIndex_)
Definition: vulkan.hpp:29437
DisplaySurfaceCreateInfoKHR(DisplaySurfaceCreateFlagsKHR flags_=DisplaySurfaceCreateFlagsKHR(), DisplayModeKHR displayMode_=DisplayModeKHR(), uint32_t planeIndex_=0, uint32_t planeStackIndex_=0, SurfaceTransformFlagBitsKHR transform_=SurfaceTransformFlagBitsKHR::eIdentity, float globalAlpha_=0, DisplayPlaneAlphaFlagBitsKHR alphaMode_=DisplayPlaneAlphaFlagBitsKHR::eOpaque, Extent2D imageExtent_=Extent2D())
Definition: vulkan.hpp:29384
DisplaySurfaceCreateInfoKHR & setAlphaMode(DisplayPlaneAlphaFlagBitsKHR alphaMode_)
Definition: vulkan.hpp:29455
DisplaySurfaceCreateInfoKHR & setDisplayMode(DisplayModeKHR displayMode_)
Definition: vulkan.hpp:29425
DisplaySurfaceCreateInfoKHR & setPNext(const void *pNext_)
Definition: vulkan.hpp:29413
DisplaySurfaceCreateInfoKHR & operator=(VkDisplaySurfaceCreateInfoKHR const &rhs)
Definition: vulkan.hpp:29408
DisplaySurfaceCreateInfoKHR(VkDisplaySurfaceCreateInfoKHR const &rhs)
Definition: vulkan.hpp:29403
bool operator!=(DisplaySurfaceCreateInfoKHR const &rhs) const
Definition: vulkan.hpp:29491
DisplaySurfaceCreateInfoKHR & setFlags(DisplaySurfaceCreateFlagsKHR flags_)
Definition: vulkan.hpp:29419
DisplaySurfaceCreateInfoKHR & setPlaneIndex(uint32_t planeIndex_)
Definition: vulkan.hpp:29431
DrawIndexedIndirectCommand & setInstanceCount(uint32_t instanceCount_)
Definition: vulkan.hpp:6953
DrawIndexedIndirectCommand & operator=(VkDrawIndexedIndirectCommand const &rhs)
Definition: vulkan.hpp:6942
bool operator==(DrawIndexedIndirectCommand const &rhs) const
Definition: vulkan.hpp:6987
DrawIndexedIndirectCommand(VkDrawIndexedIndirectCommand const &rhs)
Definition: vulkan.hpp:6937
DrawIndexedIndirectCommand(uint32_t indexCount_=0, uint32_t instanceCount_=0, uint32_t firstIndex_=0, int32_t vertexOffset_=0, uint32_t firstInstance_=0)
Definition: vulkan.hpp:6924
DrawIndexedIndirectCommand & setFirstIndex(uint32_t firstIndex_)
Definition: vulkan.hpp:6959
DrawIndexedIndirectCommand & setIndexCount(uint32_t indexCount_)
Definition: vulkan.hpp:6947
bool operator!=(DrawIndexedIndirectCommand const &rhs) const
Definition: vulkan.hpp:6996
DrawIndexedIndirectCommand & setFirstInstance(uint32_t firstInstance_)
Definition: vulkan.hpp:6971
DrawIndexedIndirectCommand & setVertexOffset(int32_t vertexOffset_)
Definition: vulkan.hpp:6965
DrawIndirectCommand(uint32_t vertexCount_=0, uint32_t instanceCount_=0, uint32_t firstVertex_=0, uint32_t firstInstance_=0)
Definition: vulkan.hpp:6847
DrawIndirectCommand(VkDrawIndirectCommand const &rhs)
Definition: vulkan.hpp:6858
bool operator==(DrawIndirectCommand const &rhs) const
Definition: vulkan.hpp:6902
DrawIndirectCommand & setFirstInstance(uint32_t firstInstance_)
Definition: vulkan.hpp:6886
DrawIndirectCommand & setVertexCount(uint32_t vertexCount_)
Definition: vulkan.hpp:6868
bool operator!=(DrawIndirectCommand const &rhs) const
Definition: vulkan.hpp:6910
DrawIndirectCommand & setInstanceCount(uint32_t instanceCount_)
Definition: vulkan.hpp:6874
DrawIndirectCommand & operator=(VkDrawIndirectCommand const &rhs)
Definition: vulkan.hpp:6863
DrawIndirectCommand & setFirstVertex(uint32_t firstVertex_)
Definition: vulkan.hpp:6880
DrawMeshTasksIndirectCommandNV(VkDrawMeshTasksIndirectCommandNV const &rhs)
Definition: vulkan.hpp:7852
bool operator!=(DrawMeshTasksIndirectCommandNV const &rhs) const
Definition: vulkan.hpp:7890
DrawMeshTasksIndirectCommandNV(uint32_t taskCount_=0, uint32_t firstTask_=0)
Definition: vulkan.hpp:7845
DrawMeshTasksIndirectCommandNV & setTaskCount(uint32_t taskCount_)
Definition: vulkan.hpp:7862
DrawMeshTasksIndirectCommandNV & operator=(VkDrawMeshTasksIndirectCommandNV const &rhs)
Definition: vulkan.hpp:7857
bool operator==(DrawMeshTasksIndirectCommandNV const &rhs) const
Definition: vulkan.hpp:7884
DrawMeshTasksIndirectCommandNV & setFirstTask(uint32_t firstTask_)
Definition: vulkan.hpp:7868
bool operator==(DrmFormatModifierPropertiesEXT const &rhs) const
Definition: vulkan.hpp:24233
bool operator!=(DrmFormatModifierPropertiesEXT const &rhs) const
Definition: vulkan.hpp:24240
DrmFormatModifierPropertiesListEXT & operator=(VkDrmFormatModifierPropertiesListEXT const &rhs)
Definition: vulkan.hpp:24265
DrmFormatModifierPropertiesListEXT & setDrmFormatModifierCount(uint32_t drmFormatModifierCount_)
Definition: vulkan.hpp:24276
DrmFormatModifierPropertiesListEXT(VkDrmFormatModifierPropertiesListEXT const &rhs)
Definition: vulkan.hpp:24260
DrmFormatModifierPropertiesListEXT & setPNext(void *pNext_)
Definition: vulkan.hpp:24270
DrmFormatModifierPropertiesListEXT(uint32_t drmFormatModifierCount_=0, DrmFormatModifierPropertiesEXT *pDrmFormatModifierProperties_=nullptr)
Definition: vulkan.hpp:24253
DrmFormatModifierPropertiesEXT * pDrmFormatModifierProperties
Definition: vulkan.hpp:24317
bool operator==(DrmFormatModifierPropertiesListEXT const &rhs) const
Definition: vulkan.hpp:24298
DrmFormatModifierPropertiesListEXT & setPDrmFormatModifierProperties(DrmFormatModifierPropertiesEXT *pDrmFormatModifierProperties_)
Definition: vulkan.hpp:24282
bool operator!=(DrmFormatModifierPropertiesListEXT const &rhs) const
Definition: vulkan.hpp:24306
bool operator==(EventCreateInfo const &rhs) const
Definition: vulkan.hpp:11539
EventCreateInfo(EventCreateFlags flags_=EventCreateFlags())
Definition: vulkan.hpp:11502
EventCreateInfo & setFlags(EventCreateFlags flags_)
Definition: vulkan.hpp:11523
EventCreateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:11517
EventCreateInfo(VkEventCreateInfo const &rhs)
Definition: vulkan.hpp:11507
bool operator!=(EventCreateInfo const &rhs) const
Definition: vulkan.hpp:11546
EventCreateInfo & operator=(VkEventCreateInfo const &rhs)
Definition: vulkan.hpp:11512
ExportFenceCreateInfo & setHandleTypes(ExternalFenceHandleTypeFlags handleTypes_)
Definition: vulkan.hpp:33117
ExportFenceCreateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:33111
ExportFenceCreateInfo(VkExportFenceCreateInfo const &rhs)
Definition: vulkan.hpp:33101
ExportFenceCreateInfo(ExternalFenceHandleTypeFlags handleTypes_=ExternalFenceHandleTypeFlags())
Definition: vulkan.hpp:33096
bool operator!=(ExportFenceCreateInfo const &rhs) const
Definition: vulkan.hpp:33140
ExternalFenceHandleTypeFlags handleTypes
Definition: vulkan.hpp:33150
bool operator==(ExportFenceCreateInfo const &rhs) const
Definition: vulkan.hpp:33133
ExportFenceCreateInfo & operator=(VkExportFenceCreateInfo const &rhs)
Definition: vulkan.hpp:33106
ExportMemoryAllocateInfo(ExternalMemoryHandleTypeFlags handleTypes_=ExternalMemoryHandleTypeFlags())
Definition: vulkan.hpp:31849
ExportMemoryAllocateInfo(VkExportMemoryAllocateInfo const &rhs)
Definition: vulkan.hpp:31854
ExternalMemoryHandleTypeFlags handleTypes
Definition: vulkan.hpp:31903
bool operator!=(ExportMemoryAllocateInfo const &rhs) const
Definition: vulkan.hpp:31893
ExportMemoryAllocateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:31864
ExportMemoryAllocateInfo & setHandleTypes(ExternalMemoryHandleTypeFlags handleTypes_)
Definition: vulkan.hpp:31870
ExportMemoryAllocateInfo & operator=(VkExportMemoryAllocateInfo const &rhs)
Definition: vulkan.hpp:31859
bool operator==(ExportMemoryAllocateInfo const &rhs) const
Definition: vulkan.hpp:31886
ExportMemoryAllocateInfoNV(VkExportMemoryAllocateInfoNV const &rhs)
Definition: vulkan.hpp:30185
ExportMemoryAllocateInfoNV & setPNext(const void *pNext_)
Definition: vulkan.hpp:30195
ExternalMemoryHandleTypeFlagsNV handleTypes
Definition: vulkan.hpp:30234
bool operator!=(ExportMemoryAllocateInfoNV const &rhs) const
Definition: vulkan.hpp:30224
bool operator==(ExportMemoryAllocateInfoNV const &rhs) const
Definition: vulkan.hpp:30217
ExportMemoryAllocateInfoNV & setHandleTypes(ExternalMemoryHandleTypeFlagsNV handleTypes_)
Definition: vulkan.hpp:30201
ExportMemoryAllocateInfoNV(ExternalMemoryHandleTypeFlagsNV handleTypes_=ExternalMemoryHandleTypeFlagsNV())
Definition: vulkan.hpp:30180
ExportMemoryAllocateInfoNV & operator=(VkExportMemoryAllocateInfoNV const &rhs)
Definition: vulkan.hpp:30190
ExportSemaphoreCreateInfo(ExternalSemaphoreHandleTypeFlags handleTypes_=ExternalSemaphoreHandleTypeFlags())
Definition: vulkan.hpp:32507
bool operator!=(ExportSemaphoreCreateInfo const &rhs) const
Definition: vulkan.hpp:32551
ExportSemaphoreCreateInfo & operator=(VkExportSemaphoreCreateInfo const &rhs)
Definition: vulkan.hpp:32517
ExternalSemaphoreHandleTypeFlags handleTypes
Definition: vulkan.hpp:32561
ExportSemaphoreCreateInfo(VkExportSemaphoreCreateInfo const &rhs)
Definition: vulkan.hpp:32512
ExportSemaphoreCreateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:32522
ExportSemaphoreCreateInfo & setHandleTypes(ExternalSemaphoreHandleTypeFlags handleTypes_)
Definition: vulkan.hpp:32528
bool operator==(ExportSemaphoreCreateInfo const &rhs) const
Definition: vulkan.hpp:32544
bool operator==(ExtensionProperties const &rhs) const
Definition: vulkan.hpp:5587
char extensionName[VK_MAX_EXTENSION_NAME_SIZE]
Definition: vulkan.hpp:5598
bool operator!=(ExtensionProperties const &rhs) const
Definition: vulkan.hpp:5593
Extent2D(VkExtent2D const &rhs)
Definition: vulkan.hpp:5232
bool operator!=(Extent2D const &rhs) const
Definition: vulkan.hpp:5270
Extent2D(uint32_t width_=0, uint32_t height_=0)
Definition: vulkan.hpp:5225
Extent2D & operator=(VkExtent2D const &rhs)
Definition: vulkan.hpp:5237
bool operator==(Extent2D const &rhs) const
Definition: vulkan.hpp:5264
Extent2D & setHeight(uint32_t height_)
Definition: vulkan.hpp:5248
Extent2D & setWidth(uint32_t width_)
Definition: vulkan.hpp:5242
bool operator!=(Extent3D const &rhs) const
Definition: vulkan.hpp:5343
Extent3D(uint32_t width_=0, uint32_t height_=0, uint32_t depth_=0)
Definition: vulkan.hpp:5282
bool operator==(Extent3D const &rhs) const
Definition: vulkan.hpp:5336
Extent3D(Extent2D const &extent2D, uint32_t depth_=0)
Definition: vulkan.hpp:5291
Extent3D(VkExtent3D const &rhs)
Definition: vulkan.hpp:5298
Extent3D & setHeight(uint32_t height_)
Definition: vulkan.hpp:5314
Extent3D & setWidth(uint32_t width_)
Definition: vulkan.hpp:5308
Extent3D & operator=(VkExtent3D const &rhs)
Definition: vulkan.hpp:5303
Extent3D & setDepth(uint32_t depth_)
Definition: vulkan.hpp:5320
ExternalMemoryProperties externalMemoryProperties
Definition: vulkan.hpp:32401
bool operator!=(ExternalBufferProperties const &rhs) const
Definition: vulkan.hpp:32391
bool operator==(ExternalBufferProperties const &rhs) const
Definition: vulkan.hpp:32384
ExternalFenceFeatureFlags externalFenceFeatures
Definition: vulkan.hpp:33361
ExternalFenceHandleTypeFlags compatibleHandleTypes
Definition: vulkan.hpp:33360
bool operator!=(ExternalFenceProperties const &rhs) const
Definition: vulkan.hpp:33349
bool operator==(ExternalFenceProperties const &rhs) const
Definition: vulkan.hpp:33340
ExternalFenceHandleTypeFlags exportFromImportedHandleTypes
Definition: vulkan.hpp:33359
bool operator!=(ExternalImageFormatProperties const &rhs) const
Definition: vulkan.hpp:32356
bool operator==(ExternalImageFormatProperties const &rhs) const
Definition: vulkan.hpp:32349
bool operator==(ExternalImageFormatPropertiesNV const &rhs) const
Definition: vulkan.hpp:30349
ExternalMemoryFeatureFlagsNV externalMemoryFeatures
Definition: vulkan.hpp:30363
ExternalMemoryHandleTypeFlagsNV compatibleHandleTypes
Definition: vulkan.hpp:30365
ExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes
Definition: vulkan.hpp:30364
bool operator!=(ExternalImageFormatPropertiesNV const &rhs) const
Definition: vulkan.hpp:30357
ExternalMemoryBufferCreateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:31802
ExternalMemoryBufferCreateInfo & setHandleTypes(ExternalMemoryHandleTypeFlags handleTypes_)
Definition: vulkan.hpp:31808
bool operator==(ExternalMemoryBufferCreateInfo const &rhs) const
Definition: vulkan.hpp:31824
ExternalMemoryBufferCreateInfo(VkExternalMemoryBufferCreateInfo const &rhs)
Definition: vulkan.hpp:31792
ExternalMemoryBufferCreateInfo(ExternalMemoryHandleTypeFlags handleTypes_=ExternalMemoryHandleTypeFlags())
Definition: vulkan.hpp:31787
ExternalMemoryBufferCreateInfo & operator=(VkExternalMemoryBufferCreateInfo const &rhs)
Definition: vulkan.hpp:31797
bool operator!=(ExternalMemoryBufferCreateInfo const &rhs) const
Definition: vulkan.hpp:31831
bool operator!=(ExternalMemoryImageCreateInfo const &rhs) const
Definition: vulkan.hpp:31769
ExternalMemoryImageCreateInfo & operator=(VkExternalMemoryImageCreateInfo const &rhs)
Definition: vulkan.hpp:31735
ExternalMemoryImageCreateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:31740
ExternalMemoryImageCreateInfo(VkExternalMemoryImageCreateInfo const &rhs)
Definition: vulkan.hpp:31730
bool operator==(ExternalMemoryImageCreateInfo const &rhs) const
Definition: vulkan.hpp:31762
ExternalMemoryImageCreateInfo(ExternalMemoryHandleTypeFlags handleTypes_=ExternalMemoryHandleTypeFlags())
Definition: vulkan.hpp:31725
ExternalMemoryImageCreateInfo & setHandleTypes(ExternalMemoryHandleTypeFlags handleTypes_)
Definition: vulkan.hpp:31746
ExternalMemoryImageCreateInfoNV & setHandleTypes(ExternalMemoryHandleTypeFlagsNV handleTypes_)
Definition: vulkan.hpp:30141
ExternalMemoryImageCreateInfoNV & setPNext(const void *pNext_)
Definition: vulkan.hpp:30135
bool operator!=(ExternalMemoryImageCreateInfoNV const &rhs) const
Definition: vulkan.hpp:30164
ExternalMemoryImageCreateInfoNV(VkExternalMemoryImageCreateInfoNV const &rhs)
Definition: vulkan.hpp:30125
ExternalMemoryHandleTypeFlagsNV handleTypes
Definition: vulkan.hpp:30174
bool operator==(ExternalMemoryImageCreateInfoNV const &rhs) const
Definition: vulkan.hpp:30157
ExternalMemoryImageCreateInfoNV & operator=(VkExternalMemoryImageCreateInfoNV const &rhs)
Definition: vulkan.hpp:30130
ExternalMemoryImageCreateInfoNV(ExternalMemoryHandleTypeFlagsNV handleTypes_=ExternalMemoryHandleTypeFlagsNV())
Definition: vulkan.hpp:30120
ExternalMemoryHandleTypeFlags compatibleHandleTypes
Definition: vulkan.hpp:32331
bool operator!=(ExternalMemoryProperties const &rhs) const
Definition: vulkan.hpp:32324
bool operator==(ExternalMemoryProperties const &rhs) const
Definition: vulkan.hpp:32317
ExternalMemoryHandleTypeFlags exportFromImportedHandleTypes
Definition: vulkan.hpp:32330
ExternalMemoryFeatureFlags externalMemoryFeatures
Definition: vulkan.hpp:32329
bool operator!=(ExternalSemaphoreProperties const &rhs) const
Definition: vulkan.hpp:32760
bool operator==(ExternalSemaphoreProperties const &rhs) const
Definition: vulkan.hpp:32751
ExternalSemaphoreHandleTypeFlags compatibleHandleTypes
Definition: vulkan.hpp:32771
ExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes
Definition: vulkan.hpp:32770
ExternalSemaphoreFeatureFlags externalSemaphoreFeatures
Definition: vulkan.hpp:32772
FenceCreateInfo & setFlags(FenceCreateFlags flags_)
Definition: vulkan.hpp:24062
FenceCreateInfo(FenceCreateFlags flags_=FenceCreateFlags())
Definition: vulkan.hpp:24041
FenceCreateInfo(VkFenceCreateInfo const &rhs)
Definition: vulkan.hpp:24046
bool operator!=(FenceCreateInfo const &rhs) const
Definition: vulkan.hpp:24085
bool operator==(FenceCreateInfo const &rhs) const
Definition: vulkan.hpp:24078
FenceCreateInfo & operator=(VkFenceCreateInfo const &rhs)
Definition: vulkan.hpp:24051
FenceCreateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:24056
FenceGetFdInfoKHR & setFence(Fence fence_)
Definition: vulkan.hpp:33253
ExternalFenceHandleTypeFlagBits handleType
Definition: vulkan.hpp:33294
bool operator!=(FenceGetFdInfoKHR const &rhs) const
Definition: vulkan.hpp:33283
FenceGetFdInfoKHR & operator=(VkFenceGetFdInfoKHR const &rhs)
Definition: vulkan.hpp:33242
FenceGetFdInfoKHR & setHandleType(ExternalFenceHandleTypeFlagBits handleType_)
Definition: vulkan.hpp:33259
FenceGetFdInfoKHR & setPNext(const void *pNext_)
Definition: vulkan.hpp:33247
FenceGetFdInfoKHR(VkFenceGetFdInfoKHR const &rhs)
Definition: vulkan.hpp:33237
FenceGetFdInfoKHR(Fence fence_=Fence(), ExternalFenceHandleTypeFlagBits handleType_=ExternalFenceHandleTypeFlagBits::eOpaqueFd)
Definition: vulkan.hpp:33230
bool operator==(FenceGetFdInfoKHR const &rhs) const
Definition: vulkan.hpp:33275
bool operator==(FormatProperties2 const &rhs) const
Definition: vulkan.hpp:24198
bool operator!=(FormatProperties2 const &rhs) const
Definition: vulkan.hpp:24205
FormatFeatureFlags linearTilingFeatures
Definition: vulkan.hpp:24180
FormatFeatureFlags optimalTilingFeatures
Definition: vulkan.hpp:24181
bool operator==(FormatProperties const &rhs) const
Definition: vulkan.hpp:24168
bool operator!=(FormatProperties const &rhs) const
Definition: vulkan.hpp:24175
FramebufferCreateInfo & setHeight(uint32_t height_)
Definition: vulkan.hpp:11685
FramebufferCreateInfo & setRenderPass(RenderPass renderPass_)
Definition: vulkan.hpp:11661
FramebufferCreateInfo & setFlags(FramebufferCreateFlags flags_)
Definition: vulkan.hpp:11655
bool operator==(FramebufferCreateInfo const &rhs) const
Definition: vulkan.hpp:11707
FramebufferCreateInfo & setLayers(uint32_t layers_)
Definition: vulkan.hpp:11691
bool operator!=(FramebufferCreateInfo const &rhs) const
Definition: vulkan.hpp:11720
FramebufferCreateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:11649
FramebufferCreateInfo & operator=(VkFramebufferCreateInfo const &rhs)
Definition: vulkan.hpp:11644
FramebufferCreateInfo(FramebufferCreateFlags flags_=FramebufferCreateFlags(), RenderPass renderPass_=RenderPass(), uint32_t attachmentCount_=0, const ImageView *pAttachments_=nullptr, uint32_t width_=0, uint32_t height_=0, uint32_t layers_=0)
Definition: vulkan.hpp:11622
FramebufferCreateInfo & setWidth(uint32_t width_)
Definition: vulkan.hpp:11679
FramebufferCreateInfo & setPAttachments(const ImageView *pAttachments_)
Definition: vulkan.hpp:11673
FramebufferCreateInfo(VkFramebufferCreateInfo const &rhs)
Definition: vulkan.hpp:11639
FramebufferCreateInfo & setAttachmentCount(uint32_t attachmentCount_)
Definition: vulkan.hpp:11667
GeometryAABBNV & setOffset(DeviceSize offset_)
Definition: vulkan.hpp:20443
GeometryAABBNV & setNumAABBs(uint32_t numAABBs_)
Definition: vulkan.hpp:20431
bool operator==(GeometryAABBNV const &rhs) const
Definition: vulkan.hpp:20459
GeometryAABBNV & setPNext(const void *pNext_)
Definition: vulkan.hpp:20419
GeometryAABBNV & operator=(VkGeometryAABBNV const &rhs)
Definition: vulkan.hpp:20414
GeometryAABBNV(Buffer aabbData_=Buffer(), uint32_t numAABBs_=0, uint32_t stride_=0, DeviceSize offset_=0)
Definition: vulkan.hpp:20398
GeometryAABBNV & setStride(uint32_t stride_)
Definition: vulkan.hpp:20437
GeometryAABBNV & setAabbData(Buffer aabbData_)
Definition: vulkan.hpp:20425
bool operator!=(GeometryAABBNV const &rhs) const
Definition: vulkan.hpp:20469
GeometryAABBNV(VkGeometryAABBNV const &rhs)
Definition: vulkan.hpp:20409
GeometryDataNV & operator=(VkGeometryDataNV const &rhs)
Definition: vulkan.hpp:20500
GeometryDataNV & setAabbs(GeometryAABBNV aabbs_)
Definition: vulkan.hpp:20511
GeometryDataNV(VkGeometryDataNV const &rhs)
Definition: vulkan.hpp:20495
GeometryDataNV & setTriangles(GeometryTrianglesNV triangles_)
Definition: vulkan.hpp:20505
GeometryDataNV(GeometryTrianglesNV triangles_=GeometryTrianglesNV(), GeometryAABBNV aabbs_=GeometryAABBNV())
Definition: vulkan.hpp:20488
bool operator==(GeometryDataNV const &rhs) const
Definition: vulkan.hpp:20527
bool operator!=(GeometryDataNV const &rhs) const
Definition: vulkan.hpp:20533
GeometryNV & setPNext(const void *pNext_)
Definition: vulkan.hpp:36953
GeometryNV & setGeometry(GeometryDataNV geometry_)
Definition: vulkan.hpp:36965
GeometryNV(GeometryTypeNV geometryType_=GeometryTypeNV::eTriangles, GeometryDataNV geometry_=GeometryDataNV(), GeometryFlagsNV flags_=GeometryFlagsNV())
Definition: vulkan.hpp:36934
GeometryNV & setFlags(GeometryFlagsNV flags_)
Definition: vulkan.hpp:36971
GeometryNV & setGeometryType(GeometryTypeNV geometryType_)
Definition: vulkan.hpp:36959
GeometryNV & operator=(VkGeometryNV const &rhs)
Definition: vulkan.hpp:36948
bool operator!=(GeometryNV const &rhs) const
Definition: vulkan.hpp:36996
GeometryNV(VkGeometryNV const &rhs)
Definition: vulkan.hpp:36943
bool operator==(GeometryNV const &rhs) const
Definition: vulkan.hpp:36987
GeometryTrianglesNV & setVertexCount(uint32_t vertexCount_)
Definition: vulkan.hpp:20291
GeometryTrianglesNV(VkGeometryTrianglesNV const &rhs)
Definition: vulkan.hpp:20263
GeometryTrianglesNV & setIndexOffset(DeviceSize indexOffset_)
Definition: vulkan.hpp:20315
GeometryTrianglesNV & setVertexData(Buffer vertexData_)
Definition: vulkan.hpp:20279
GeometryTrianglesNV & operator=(VkGeometryTrianglesNV const &rhs)
Definition: vulkan.hpp:20268
GeometryTrianglesNV & setIndexCount(uint32_t indexCount_)
Definition: vulkan.hpp:20321
GeometryTrianglesNV & setVertexStride(DeviceSize vertexStride_)
Definition: vulkan.hpp:20297
GeometryTrianglesNV(Buffer vertexData_=Buffer(), DeviceSize vertexOffset_=0, uint32_t vertexCount_=0, DeviceSize vertexStride_=0, Format vertexFormat_=Format::eUndefined, Buffer indexData_=Buffer(), DeviceSize indexOffset_=0, uint32_t indexCount_=0, IndexType indexType_=IndexType::eUint16, Buffer transformData_=Buffer(), DeviceSize transformOffset_=0)
Definition: vulkan.hpp:20238
GeometryTrianglesNV & setIndexType(IndexType indexType_)
Definition: vulkan.hpp:20327
GeometryTrianglesNV & setVertexOffset(DeviceSize vertexOffset_)
Definition: vulkan.hpp:20285
bool operator==(GeometryTrianglesNV const &rhs) const
Definition: vulkan.hpp:20355
GeometryTrianglesNV & setPNext(const void *pNext_)
Definition: vulkan.hpp:20273
GeometryTrianglesNV & setIndexData(Buffer indexData_)
Definition: vulkan.hpp:20309
GeometryTrianglesNV & setTransformData(Buffer transformData_)
Definition: vulkan.hpp:20333
bool operator!=(GeometryTrianglesNV const &rhs) const
Definition: vulkan.hpp:20372
GeometryTrianglesNV & setVertexFormat(Format vertexFormat_)
Definition: vulkan.hpp:20303
GeometryTrianglesNV & setTransformOffset(DeviceSize transformOffset_)
Definition: vulkan.hpp:20339
GraphicsPipelineCreateInfo & setPInputAssemblyState(const PipelineInputAssemblyStateCreateInfo *pInputAssemblyState_)
Definition: vulkan.hpp:27392
GraphicsPipelineCreateInfo(PipelineCreateFlags flags_=PipelineCreateFlags(), uint32_t stageCount_=0, const PipelineShaderStageCreateInfo *pStages_=nullptr, const PipelineVertexInputStateCreateInfo *pVertexInputState_=nullptr, const PipelineInputAssemblyStateCreateInfo *pInputAssemblyState_=nullptr, const PipelineTessellationStateCreateInfo *pTessellationState_=nullptr, const PipelineViewportStateCreateInfo *pViewportState_=nullptr, const PipelineRasterizationStateCreateInfo *pRasterizationState_=nullptr, const PipelineMultisampleStateCreateInfo *pMultisampleState_=nullptr, const PipelineDepthStencilStateCreateInfo *pDepthStencilState_=nullptr, const PipelineColorBlendStateCreateInfo *pColorBlendState_=nullptr, const PipelineDynamicStateCreateInfo *pDynamicState_=nullptr, PipelineLayout layout_=PipelineLayout(), RenderPass renderPass_=RenderPass(), uint32_t subpass_=0, Pipeline basePipelineHandle_=Pipeline(), int32_t basePipelineIndex_=0)
Definition: vulkan.hpp:27315
const PipelineViewportStateCreateInfo * pViewportState
Definition: vulkan.hpp:27519
GraphicsPipelineCreateInfo & setLayout(PipelineLayout layout_)
Definition: vulkan.hpp:27440
const PipelineDynamicStateCreateInfo * pDynamicState
Definition: vulkan.hpp:27524
GraphicsPipelineCreateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:27362
GraphicsPipelineCreateInfo(VkGraphicsPipelineCreateInfo const &rhs)
Definition: vulkan.hpp:27352
GraphicsPipelineCreateInfo & setPDynamicState(const PipelineDynamicStateCreateInfo *pDynamicState_)
Definition: vulkan.hpp:27434
const PipelineMultisampleStateCreateInfo * pMultisampleState
Definition: vulkan.hpp:27521
bool operator!=(GraphicsPipelineCreateInfo const &rhs) const
Definition: vulkan.hpp:27503
const PipelineTessellationStateCreateInfo * pTessellationState
Definition: vulkan.hpp:27518
GraphicsPipelineCreateInfo & setPStages(const PipelineShaderStageCreateInfo *pStages_)
Definition: vulkan.hpp:27380
GraphicsPipelineCreateInfo & setFlags(PipelineCreateFlags flags_)
Definition: vulkan.hpp:27368
const PipelineVertexInputStateCreateInfo * pVertexInputState
Definition: vulkan.hpp:27516
const PipelineColorBlendStateCreateInfo * pColorBlendState
Definition: vulkan.hpp:27523
const PipelineShaderStageCreateInfo * pStages
Definition: vulkan.hpp:27515
const PipelineDepthStencilStateCreateInfo * pDepthStencilState
Definition: vulkan.hpp:27522
GraphicsPipelineCreateInfo & setBasePipelineIndex(int32_t basePipelineIndex_)
Definition: vulkan.hpp:27464
GraphicsPipelineCreateInfo & operator=(VkGraphicsPipelineCreateInfo const &rhs)
Definition: vulkan.hpp:27357
const PipelineRasterizationStateCreateInfo * pRasterizationState
Definition: vulkan.hpp:27520
GraphicsPipelineCreateInfo & setPColorBlendState(const PipelineColorBlendStateCreateInfo *pColorBlendState_)
Definition: vulkan.hpp:27428
GraphicsPipelineCreateInfo & setSubpass(uint32_t subpass_)
Definition: vulkan.hpp:27452
bool operator==(GraphicsPipelineCreateInfo const &rhs) const
Definition: vulkan.hpp:27480
GraphicsPipelineCreateInfo & setPMultisampleState(const PipelineMultisampleStateCreateInfo *pMultisampleState_)
Definition: vulkan.hpp:27416
const PipelineInputAssemblyStateCreateInfo * pInputAssemblyState
Definition: vulkan.hpp:27517
GraphicsPipelineCreateInfo & setStageCount(uint32_t stageCount_)
Definition: vulkan.hpp:27374
GraphicsPipelineCreateInfo & setPTessellationState(const PipelineTessellationStateCreateInfo *pTessellationState_)
Definition: vulkan.hpp:27398
GraphicsPipelineCreateInfo & setBasePipelineHandle(Pipeline basePipelineHandle_)
Definition: vulkan.hpp:27458
GraphicsPipelineCreateInfo & setPRasterizationState(const PipelineRasterizationStateCreateInfo *pRasterizationState_)
Definition: vulkan.hpp:27410
GraphicsPipelineCreateInfo & setPViewportState(const PipelineViewportStateCreateInfo *pViewportState_)
Definition: vulkan.hpp:27404
GraphicsPipelineCreateInfo & setPVertexInputState(const PipelineVertexInputStateCreateInfo *pVertexInputState_)
Definition: vulkan.hpp:27386
GraphicsPipelineCreateInfo & setRenderPass(RenderPass renderPass_)
Definition: vulkan.hpp:27446
GraphicsPipelineCreateInfo & setPDepthStencilState(const PipelineDepthStencilStateCreateInfo *pDepthStencilState_)
Definition: vulkan.hpp:27422
HdrMetadataEXT & operator=(VkHdrMetadataEXT const &rhs)
Definition: vulkan.hpp:15106
bool operator!=(HdrMetadataEXT const &rhs) const
Definition: vulkan.hpp:15189
HdrMetadataEXT & setDisplayPrimaryRed(XYColorEXT displayPrimaryRed_)
Definition: vulkan.hpp:15117
HdrMetadataEXT & setMaxLuminance(float maxLuminance_)
Definition: vulkan.hpp:15141
HdrMetadataEXT(XYColorEXT displayPrimaryRed_=XYColorEXT(), XYColorEXT displayPrimaryGreen_=XYColorEXT(), XYColorEXT displayPrimaryBlue_=XYColorEXT(), XYColorEXT whitePoint_=XYColorEXT(), float maxLuminance_=0, float minLuminance_=0, float maxContentLightLevel_=0, float maxFrameAverageLightLevel_=0)
Definition: vulkan.hpp:15082
HdrMetadataEXT & setDisplayPrimaryBlue(XYColorEXT displayPrimaryBlue_)
Definition: vulkan.hpp:15129
HdrMetadataEXT & setMaxContentLightLevel(float maxContentLightLevel_)
Definition: vulkan.hpp:15153
HdrMetadataEXT & setMinLuminance(float minLuminance_)
Definition: vulkan.hpp:15147
HdrMetadataEXT & setWhitePoint(XYColorEXT whitePoint_)
Definition: vulkan.hpp:15135
HdrMetadataEXT & setMaxFrameAverageLightLevel(float maxFrameAverageLightLevel_)
Definition: vulkan.hpp:15159
HdrMetadataEXT & setDisplayPrimaryGreen(XYColorEXT displayPrimaryGreen_)
Definition: vulkan.hpp:15123
HdrMetadataEXT & setPNext(const void *pNext_)
Definition: vulkan.hpp:15111
bool operator==(HdrMetadataEXT const &rhs) const
Definition: vulkan.hpp:15175
HdrMetadataEXT(VkHdrMetadataEXT const &rhs)
Definition: vulkan.hpp:15101
ImageBlit & setDstOffsets(std::array< Offset3D, 2 > dstOffsets_)
Definition: vulkan.hpp:25343
ImageBlit(VkImageBlit const &rhs)
Definition: vulkan.hpp:25315
bool operator==(ImageBlit const &rhs) const
Definition: vulkan.hpp:25359
ImageBlit & setSrcSubresource(ImageSubresourceLayers srcSubresource_)
Definition: vulkan.hpp:25325
ImageBlit(ImageSubresourceLayers srcSubresource_=ImageSubresourceLayers(), std::array< Offset3D, 2 > const &srcOffsets_={ { Offset3D(), Offset3D() } }, ImageSubresourceLayers dstSubresource_=ImageSubresourceLayers(), std::array< Offset3D, 2 > const &dstOffsets_={ { Offset3D(), Offset3D() } })
Definition: vulkan.hpp:25304
bool operator!=(ImageBlit const &rhs) const
Definition: vulkan.hpp:25367
ImageBlit & setDstSubresource(ImageSubresourceLayers dstSubresource_)
Definition: vulkan.hpp:25337
ImageBlit & operator=(VkImageBlit const &rhs)
Definition: vulkan.hpp:25320
ImageSubresourceLayers dstSubresource
Definition: vulkan.hpp:25374
ImageSubresourceLayers srcSubresource
Definition: vulkan.hpp:25372
ImageBlit & setSrcOffsets(std::array< Offset3D, 2 > srcOffsets_)
Definition: vulkan.hpp:25331
ImageCopy & setDstSubresource(ImageSubresourceLayers dstSubresource_)
Definition: vulkan.hpp:25252
ImageCopy & setExtent(Extent3D extent_)
Definition: vulkan.hpp:25264
ImageCopy & setSrcSubresource(ImageSubresourceLayers srcSubresource_)
Definition: vulkan.hpp:25240
ImageSubresourceLayers dstSubresource
Definition: vulkan.hpp:25296
bool operator!=(ImageCopy const &rhs) const
Definition: vulkan.hpp:25289
ImageCopy(ImageSubresourceLayers srcSubresource_=ImageSubresourceLayers(), Offset3D srcOffset_=Offset3D(), ImageSubresourceLayers dstSubresource_=ImageSubresourceLayers(), Offset3D dstOffset_=Offset3D(), Extent3D extent_=Extent3D())
Definition: vulkan.hpp:25217
ImageSubresourceLayers srcSubresource
Definition: vulkan.hpp:25294
ImageCopy & setSrcOffset(Offset3D srcOffset_)
Definition: vulkan.hpp:25246
ImageCopy & setDstOffset(Offset3D dstOffset_)
Definition: vulkan.hpp:25258
ImageCopy & operator=(VkImageCopy const &rhs)
Definition: vulkan.hpp:25235
bool operator==(ImageCopy const &rhs) const
Definition: vulkan.hpp:25280
ImageCopy(VkImageCopy const &rhs)
Definition: vulkan.hpp:25230
ImageCreateInfo & setPQueueFamilyIndices(const uint32_t *pQueueFamilyIndices_)
Definition: vulkan.hpp:27126
ImageCreateInfo & setSamples(SampleCountFlagBits samples_)
Definition: vulkan.hpp:27096
ImageCreateInfo & operator=(VkImageCreateInfo const &rhs)
Definition: vulkan.hpp:27049
ImageCreateInfo & setQueueFamilyIndexCount(uint32_t queueFamilyIndexCount_)
Definition: vulkan.hpp:27120
ImageCreateInfo & setExtent(Extent3D extent_)
Definition: vulkan.hpp:27078
ImageCreateInfo & setInitialLayout(ImageLayout initialLayout_)
Definition: vulkan.hpp:27132
ImageCreateInfo(ImageCreateFlags flags_=ImageCreateFlags(), ImageType imageType_=ImageType::e1D, Format format_=Format::eUndefined, Extent3D extent_=Extent3D(), uint32_t mipLevels_=0, uint32_t arrayLayers_=0, SampleCountFlagBits samples_=SampleCountFlagBits::e1, ImageTiling tiling_=ImageTiling::eOptimal, ImageUsageFlags usage_=ImageUsageFlags(), SharingMode sharingMode_=SharingMode::eExclusive, uint32_t queueFamilyIndexCount_=0, const uint32_t *pQueueFamilyIndices_=nullptr, ImageLayout initialLayout_=ImageLayout::eUndefined)
Definition: vulkan.hpp:27015
ImageCreateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:27054
ImageCreateInfo & setSharingMode(SharingMode sharingMode_)
Definition: vulkan.hpp:27114
bool operator!=(ImageCreateInfo const &rhs) const
Definition: vulkan.hpp:27167
ImageCreateInfo & setArrayLayers(uint32_t arrayLayers_)
Definition: vulkan.hpp:27090
ImageCreateInfo & setMipLevels(uint32_t mipLevels_)
Definition: vulkan.hpp:27084
ImageCreateInfo & setFormat(Format format_)
Definition: vulkan.hpp:27072
ImageCreateInfo & setUsage(ImageUsageFlags usage_)
Definition: vulkan.hpp:27108
ImageCreateInfo & setFlags(ImageCreateFlags flags_)
Definition: vulkan.hpp:27060
bool operator==(ImageCreateInfo const &rhs) const
Definition: vulkan.hpp:27148
ImageCreateInfo & setTiling(ImageTiling tiling_)
Definition: vulkan.hpp:27102
ImageCreateInfo & setImageType(ImageType imageType_)
Definition: vulkan.hpp:27066
ImageCreateInfo(VkImageCreateInfo const &rhs)
Definition: vulkan.hpp:27044
ImageDrmFormatModifierExplicitCreateInfoEXT & setPPlaneLayouts(const SubresourceLayout *pPlaneLayouts_)
Definition: vulkan.hpp:21042
ImageDrmFormatModifierExplicitCreateInfoEXT & setPNext(const void *pNext_)
Definition: vulkan.hpp:21024
ImageDrmFormatModifierExplicitCreateInfoEXT(uint64_t drmFormatModifier_=0, uint32_t drmFormatModifierPlaneCount_=0, const SubresourceLayout *pPlaneLayouts_=nullptr)
Definition: vulkan.hpp:21005
ImageDrmFormatModifierExplicitCreateInfoEXT & setDrmFormatModifierPlaneCount(uint32_t drmFormatModifierPlaneCount_)
Definition: vulkan.hpp:21036
ImageDrmFormatModifierExplicitCreateInfoEXT & operator=(VkImageDrmFormatModifierExplicitCreateInfoEXT const &rhs)
Definition: vulkan.hpp:21019
ImageDrmFormatModifierExplicitCreateInfoEXT & setDrmFormatModifier(uint64_t drmFormatModifier_)
Definition: vulkan.hpp:21030
bool operator==(ImageDrmFormatModifierExplicitCreateInfoEXT const &rhs) const
Definition: vulkan.hpp:21058
ImageDrmFormatModifierExplicitCreateInfoEXT(VkImageDrmFormatModifierExplicitCreateInfoEXT const &rhs)
Definition: vulkan.hpp:21014
bool operator!=(ImageDrmFormatModifierExplicitCreateInfoEXT const &rhs) const
Definition: vulkan.hpp:21067
bool operator==(ImageDrmFormatModifierListCreateInfoEXT const &rhs) const
Definition: vulkan.hpp:20980
ImageDrmFormatModifierListCreateInfoEXT(VkImageDrmFormatModifierListCreateInfoEXT const &rhs)
Definition: vulkan.hpp:20942
ImageDrmFormatModifierListCreateInfoEXT & setPNext(const void *pNext_)
Definition: vulkan.hpp:20952
bool operator!=(ImageDrmFormatModifierListCreateInfoEXT const &rhs) const
Definition: vulkan.hpp:20988
ImageDrmFormatModifierListCreateInfoEXT(uint32_t drmFormatModifierCount_=0, const uint64_t *pDrmFormatModifiers_=nullptr)
Definition: vulkan.hpp:20935
ImageDrmFormatModifierListCreateInfoEXT & setDrmFormatModifierCount(uint32_t drmFormatModifierCount_)
Definition: vulkan.hpp:20958
ImageDrmFormatModifierListCreateInfoEXT & setPDrmFormatModifiers(const uint64_t *pDrmFormatModifiers_)
Definition: vulkan.hpp:20964
ImageDrmFormatModifierListCreateInfoEXT & operator=(VkImageDrmFormatModifierListCreateInfoEXT const &rhs)
Definition: vulkan.hpp:20947
bool operator!=(ImageDrmFormatModifierPropertiesEXT const &rhs) const
Definition: vulkan.hpp:21102
bool operator==(ImageDrmFormatModifierPropertiesEXT const &rhs) const
Definition: vulkan.hpp:21095
ImageFormatListCreateInfoKHR & operator=(VkImageFormatListCreateInfoKHR const &rhs)
Definition: vulkan.hpp:17058
ImageFormatListCreateInfoKHR & setPViewFormats(const Format *pViewFormats_)
Definition: vulkan.hpp:17075
ImageFormatListCreateInfoKHR & setViewFormatCount(uint32_t viewFormatCount_)
Definition: vulkan.hpp:17069
ImageFormatListCreateInfoKHR(VkImageFormatListCreateInfoKHR const &rhs)
Definition: vulkan.hpp:17053
bool operator!=(ImageFormatListCreateInfoKHR const &rhs) const
Definition: vulkan.hpp:17099
ImageFormatListCreateInfoKHR(uint32_t viewFormatCount_=0, const Format *pViewFormats_=nullptr)
Definition: vulkan.hpp:17046
bool operator==(ImageFormatListCreateInfoKHR const &rhs) const
Definition: vulkan.hpp:17091
ImageFormatListCreateInfoKHR & setPNext(const void *pNext_)
Definition: vulkan.hpp:17063
bool operator!=(ImageFormatProperties2 const &rhs) const
Definition: vulkan.hpp:27865
bool operator==(ImageFormatProperties2 const &rhs) const
Definition: vulkan.hpp:27858
bool operator==(ImageFormatProperties const &rhs) const
Definition: vulkan.hpp:26991
bool operator!=(ImageFormatProperties const &rhs) const
Definition: vulkan.hpp:27000
ImageMemoryBarrier & setSrcQueueFamilyIndex(uint32_t srcQueueFamilyIndex_)
Definition: vulkan.hpp:25036
ImageMemoryBarrier & setNewLayout(ImageLayout newLayout_)
Definition: vulkan.hpp:25030
ImageMemoryBarrier & setDstQueueFamilyIndex(uint32_t dstQueueFamilyIndex_)
Definition: vulkan.hpp:25042
ImageMemoryBarrier & operator=(VkImageMemoryBarrier const &rhs)
Definition: vulkan.hpp:25001
ImageMemoryBarrier & setSubresourceRange(ImageSubresourceRange subresourceRange_)
Definition: vulkan.hpp:25054
bool operator!=(ImageMemoryBarrier const &rhs) const
Definition: vulkan.hpp:25084
ImageMemoryBarrier(AccessFlags srcAccessMask_=AccessFlags(), AccessFlags dstAccessMask_=AccessFlags(), ImageLayout oldLayout_=ImageLayout::eUndefined, ImageLayout newLayout_=ImageLayout::eUndefined, uint32_t srcQueueFamilyIndex_=0, uint32_t dstQueueFamilyIndex_=0, Image image_=Image(), ImageSubresourceRange subresourceRange_=ImageSubresourceRange())
Definition: vulkan.hpp:24977
ImageMemoryBarrier & setOldLayout(ImageLayout oldLayout_)
Definition: vulkan.hpp:25024
ImageMemoryBarrier & setSrcAccessMask(AccessFlags srcAccessMask_)
Definition: vulkan.hpp:25012
ImageMemoryBarrier & setPNext(const void *pNext_)
Definition: vulkan.hpp:25006
ImageMemoryBarrier & setDstAccessMask(AccessFlags dstAccessMask_)
Definition: vulkan.hpp:25018
ImageMemoryBarrier & setImage(Image image_)
Definition: vulkan.hpp:25048
ImageSubresourceRange subresourceRange
Definition: vulkan.hpp:25101
ImageMemoryBarrier(VkImageMemoryBarrier const &rhs)
Definition: vulkan.hpp:24996
bool operator==(ImageMemoryBarrier const &rhs) const
Definition: vulkan.hpp:25070
ImageMemoryRequirementsInfo2(VkImageMemoryRequirementsInfo2 const &rhs)
Definition: vulkan.hpp:15954
ImageMemoryRequirementsInfo2 & operator=(VkImageMemoryRequirementsInfo2 const &rhs)
Definition: vulkan.hpp:15959
ImageMemoryRequirementsInfo2 & setImage(Image image_)
Definition: vulkan.hpp:15970
bool operator!=(ImageMemoryRequirementsInfo2 const &rhs) const
Definition: vulkan.hpp:15993
bool operator==(ImageMemoryRequirementsInfo2 const &rhs) const
Definition: vulkan.hpp:15986
ImageMemoryRequirementsInfo2 & setPNext(const void *pNext_)
Definition: vulkan.hpp:15964
bool operator!=(ImagePlaneMemoryRequirementsInfo const &rhs) const
Definition: vulkan.hpp:25867
ImagePlaneMemoryRequirementsInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:25838
ImagePlaneMemoryRequirementsInfo & operator=(VkImagePlaneMemoryRequirementsInfo const &rhs)
Definition: vulkan.hpp:25833
bool operator==(ImagePlaneMemoryRequirementsInfo const &rhs) const
Definition: vulkan.hpp:25860
ImagePlaneMemoryRequirementsInfo & setPlaneAspect(ImageAspectFlagBits planeAspect_)
Definition: vulkan.hpp:25844
ImagePlaneMemoryRequirementsInfo(VkImagePlaneMemoryRequirementsInfo const &rhs)
Definition: vulkan.hpp:25828
ImagePlaneMemoryRequirementsInfo(ImageAspectFlagBits planeAspect_=ImageAspectFlagBits::eColor)
Definition: vulkan.hpp:25823
ImageResolve & setSrcOffset(Offset3D srcOffset_)
Definition: vulkan.hpp:25507
ImageResolve(ImageSubresourceLayers srcSubresource_=ImageSubresourceLayers(), Offset3D srcOffset_=Offset3D(), ImageSubresourceLayers dstSubresource_=ImageSubresourceLayers(), Offset3D dstOffset_=Offset3D(), Extent3D extent_=Extent3D())
Definition: vulkan.hpp:25478
ImageResolve & setDstSubresource(ImageSubresourceLayers dstSubresource_)
Definition: vulkan.hpp:25513
ImageResolve(VkImageResolve const &rhs)
Definition: vulkan.hpp:25491
bool operator==(ImageResolve const &rhs) const
Definition: vulkan.hpp:25541
bool operator!=(ImageResolve const &rhs) const
Definition: vulkan.hpp:25550
ImageResolve & setDstOffset(Offset3D dstOffset_)
Definition: vulkan.hpp:25519
ImageSubresourceLayers srcSubresource
Definition: vulkan.hpp:25555
ImageResolve & setSrcSubresource(ImageSubresourceLayers srcSubresource_)
Definition: vulkan.hpp:25501
ImageResolve & operator=(VkImageResolve const &rhs)
Definition: vulkan.hpp:25496
ImageSubresourceLayers dstSubresource
Definition: vulkan.hpp:25557
ImageResolve & setExtent(Extent3D extent_)
Definition: vulkan.hpp:25525
ImageSparseMemoryRequirementsInfo2(VkImageSparseMemoryRequirementsInfo2 const &rhs)
Definition: vulkan.hpp:16016
bool operator==(ImageSparseMemoryRequirementsInfo2 const &rhs) const
Definition: vulkan.hpp:16048
bool operator!=(ImageSparseMemoryRequirementsInfo2 const &rhs) const
Definition: vulkan.hpp:16055
ImageSparseMemoryRequirementsInfo2 & operator=(VkImageSparseMemoryRequirementsInfo2 const &rhs)
Definition: vulkan.hpp:16021
ImageSparseMemoryRequirementsInfo2 & setPNext(const void *pNext_)
Definition: vulkan.hpp:16026
ImageSparseMemoryRequirementsInfo2 & setImage(Image image_)
Definition: vulkan.hpp:16032
ImageSubresource & setMipLevel(uint32_t mipLevel_)
Definition: vulkan.hpp:24771
ImageSubresource(VkImageSubresource const &rhs)
Definition: vulkan.hpp:24755
bool operator!=(ImageSubresource const &rhs) const
Definition: vulkan.hpp:24800
ImageSubresource & operator=(VkImageSubresource const &rhs)
Definition: vulkan.hpp:24760
ImageSubresource & setArrayLayer(uint32_t arrayLayer_)
Definition: vulkan.hpp:24777
ImageSubresource(ImageAspectFlags aspectMask_=ImageAspectFlags(), uint32_t mipLevel_=0, uint32_t arrayLayer_=0)
Definition: vulkan.hpp:24746
ImageSubresource & setAspectMask(ImageAspectFlags aspectMask_)
Definition: vulkan.hpp:24765
bool operator==(ImageSubresource const &rhs) const
Definition: vulkan.hpp:24793
ImageSubresourceLayers & setAspectMask(ImageAspectFlags aspectMask_)
Definition: vulkan.hpp:24834
ImageSubresourceLayers(ImageAspectFlags aspectMask_=ImageAspectFlags(), uint32_t mipLevel_=0, uint32_t baseArrayLayer_=0, uint32_t layerCount_=0)
Definition: vulkan.hpp:24813
bool operator==(ImageSubresourceLayers const &rhs) const
Definition: vulkan.hpp:24868
ImageSubresourceLayers & setLayerCount(uint32_t layerCount_)
Definition: vulkan.hpp:24852
ImageSubresourceLayers & setBaseArrayLayer(uint32_t baseArrayLayer_)
Definition: vulkan.hpp:24846
ImageSubresourceLayers & operator=(VkImageSubresourceLayers const &rhs)
Definition: vulkan.hpp:24829
ImageSubresourceLayers(VkImageSubresourceLayers const &rhs)
Definition: vulkan.hpp:24824
ImageSubresourceLayers & setMipLevel(uint32_t mipLevel_)
Definition: vulkan.hpp:24840
bool operator!=(ImageSubresourceLayers const &rhs) const
Definition: vulkan.hpp:24876
ImageSubresourceRange & setBaseMipLevel(uint32_t baseMipLevel_)
Definition: vulkan.hpp:24919
ImageSubresourceRange(VkImageSubresourceRange const &rhs)
Definition: vulkan.hpp:24903
ImageSubresourceRange & setLayerCount(uint32_t layerCount_)
Definition: vulkan.hpp:24937
ImageSubresourceRange & setLevelCount(uint32_t levelCount_)
Definition: vulkan.hpp:24925
ImageSubresourceRange & setAspectMask(ImageAspectFlags aspectMask_)
Definition: vulkan.hpp:24913
ImageSubresourceRange & operator=(VkImageSubresourceRange const &rhs)
Definition: vulkan.hpp:24908
bool operator!=(ImageSubresourceRange const &rhs) const
Definition: vulkan.hpp:24962
bool operator==(ImageSubresourceRange const &rhs) const
Definition: vulkan.hpp:24953
ImageSubresourceRange(ImageAspectFlags aspectMask_=ImageAspectFlags(), uint32_t baseMipLevel_=0, uint32_t levelCount_=0, uint32_t baseArrayLayer_=0, uint32_t layerCount_=0)
Definition: vulkan.hpp:24890
ImageSubresourceRange & setBaseArrayLayer(uint32_t baseArrayLayer_)
Definition: vulkan.hpp:24931
bool operator==(ImageSwapchainCreateInfoKHR const &rhs) const
Definition: vulkan.hpp:14889
bool operator!=(ImageSwapchainCreateInfoKHR const &rhs) const
Definition: vulkan.hpp:14896
ImageSwapchainCreateInfoKHR(VkImageSwapchainCreateInfoKHR const &rhs)
Definition: vulkan.hpp:14857
ImageSwapchainCreateInfoKHR & operator=(VkImageSwapchainCreateInfoKHR const &rhs)
Definition: vulkan.hpp:14862
ImageSwapchainCreateInfoKHR & setPNext(const void *pNext_)
Definition: vulkan.hpp:14867
ImageSwapchainCreateInfoKHR & setSwapchain(SwapchainKHR swapchain_)
Definition: vulkan.hpp:14873
ImageSwapchainCreateInfoKHR(SwapchainKHR swapchain_=SwapchainKHR())
Definition: vulkan.hpp:14852
ImageViewASTCDecodeModeEXT & operator=(VkImageViewASTCDecodeModeEXT const &rhs)
Definition: vulkan.hpp:19080
ImageViewASTCDecodeModeEXT & setDecodeMode(Format decodeMode_)
Definition: vulkan.hpp:19091
ImageViewASTCDecodeModeEXT & setPNext(const void *pNext_)
Definition: vulkan.hpp:19085
ImageViewASTCDecodeModeEXT(Format decodeMode_=Format::eUndefined)
Definition: vulkan.hpp:19070
bool operator!=(ImageViewASTCDecodeModeEXT const &rhs) const
Definition: vulkan.hpp:19114
bool operator==(ImageViewASTCDecodeModeEXT const &rhs) const
Definition: vulkan.hpp:19107
ImageViewASTCDecodeModeEXT(VkImageViewASTCDecodeModeEXT const &rhs)
Definition: vulkan.hpp:19075
ImageViewCreateInfo & setComponents(ComponentMapping components_)
Definition: vulkan.hpp:25162
ImageViewCreateInfo & setFormat(Format format_)
Definition: vulkan.hpp:25156
ImageViewCreateInfo & setImage(Image image_)
Definition: vulkan.hpp:25144
ImageViewCreateInfo & setSubresourceRange(ImageSubresourceRange subresourceRange_)
Definition: vulkan.hpp:25168
ImageSubresourceRange subresourceRange
Definition: vulkan.hpp:25211
ImageViewCreateInfo(VkImageViewCreateInfo const &rhs)
Definition: vulkan.hpp:25122
ImageViewCreateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:25132
ImageViewCreateInfo & setViewType(ImageViewType viewType_)
Definition: vulkan.hpp:25150
bool operator==(ImageViewCreateInfo const &rhs) const
Definition: vulkan.hpp:25184
bool operator!=(ImageViewCreateInfo const &rhs) const
Definition: vulkan.hpp:25196
ImageViewCreateInfo & setFlags(ImageViewCreateFlags flags_)
Definition: vulkan.hpp:25138
ImageViewCreateInfo(ImageViewCreateFlags flags_=ImageViewCreateFlags(), Image image_=Image(), ImageViewType viewType_=ImageViewType::e1D, Format format_=Format::eUndefined, ComponentMapping components_=ComponentMapping(), ImageSubresourceRange subresourceRange_=ImageSubresourceRange())
Definition: vulkan.hpp:25107
ImageViewCreateInfo & operator=(VkImageViewCreateInfo const &rhs)
Definition: vulkan.hpp:25127
bool operator!=(ImageViewUsageCreateInfo const &rhs) const
Definition: vulkan.hpp:23465
ImageViewUsageCreateInfo & setUsage(ImageUsageFlags usage_)
Definition: vulkan.hpp:23442
ImageViewUsageCreateInfo(ImageUsageFlags usage_=ImageUsageFlags())
Definition: vulkan.hpp:23421
ImageViewUsageCreateInfo & operator=(VkImageViewUsageCreateInfo const &rhs)
Definition: vulkan.hpp:23431
ImageViewUsageCreateInfo(VkImageViewUsageCreateInfo const &rhs)
Definition: vulkan.hpp:23426
bool operator==(ImageViewUsageCreateInfo const &rhs) const
Definition: vulkan.hpp:23458
ImageViewUsageCreateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:23436
ImportFenceFdInfoKHR & setFence(Fence fence_)
Definition: vulkan.hpp:33526
ExternalFenceHandleTypeFlagBits handleType
Definition: vulkan.hpp:33582
ImportFenceFdInfoKHR(Fence fence_=Fence(), FenceImportFlags flags_=FenceImportFlags(), ExternalFenceHandleTypeFlagBits handleType_=ExternalFenceHandleTypeFlagBits::eOpaqueFd, int fd_=0)
Definition: vulkan.hpp:33499
ImportFenceFdInfoKHR & operator=(VkImportFenceFdInfoKHR const &rhs)
Definition: vulkan.hpp:33515
bool operator==(ImportFenceFdInfoKHR const &rhs) const
Definition: vulkan.hpp:33560
ImportFenceFdInfoKHR & setPNext(const void *pNext_)
Definition: vulkan.hpp:33520
bool operator!=(ImportFenceFdInfoKHR const &rhs) const
Definition: vulkan.hpp:33570
ImportFenceFdInfoKHR & setHandleType(ExternalFenceHandleTypeFlagBits handleType_)
Definition: vulkan.hpp:33538
ImportFenceFdInfoKHR(VkImportFenceFdInfoKHR const &rhs)
Definition: vulkan.hpp:33510
ImportFenceFdInfoKHR & setFd(int fd_)
Definition: vulkan.hpp:33544
ImportFenceFdInfoKHR & setFlags(FenceImportFlags flags_)
Definition: vulkan.hpp:33532
ImportMemoryFdInfoKHR(ExternalMemoryHandleTypeFlagBits handleType_=ExternalMemoryHandleTypeFlagBits::eOpaqueFd, int fd_=0)
Definition: vulkan.hpp:32065
ImportMemoryFdInfoKHR & setFd(int fd_)
Definition: vulkan.hpp:32094
ImportMemoryFdInfoKHR(VkImportMemoryFdInfoKHR const &rhs)
Definition: vulkan.hpp:32072
ImportMemoryFdInfoKHR & operator=(VkImportMemoryFdInfoKHR const &rhs)
Definition: vulkan.hpp:32077
ImportMemoryFdInfoKHR & setPNext(const void *pNext_)
Definition: vulkan.hpp:32082
bool operator!=(ImportMemoryFdInfoKHR const &rhs) const
Definition: vulkan.hpp:32118
bool operator==(ImportMemoryFdInfoKHR const &rhs) const
Definition: vulkan.hpp:32110
ExternalMemoryHandleTypeFlagBits handleType
Definition: vulkan.hpp:32128
ImportMemoryFdInfoKHR & setHandleType(ExternalMemoryHandleTypeFlagBits handleType_)
Definition: vulkan.hpp:32088
ImportMemoryHostPointerInfoEXT(ExternalMemoryHandleTypeFlagBits handleType_=ExternalMemoryHandleTypeFlagBits::eOpaqueFd, void *pHostPointer_=nullptr)
Definition: vulkan.hpp:32205
ImportMemoryHostPointerInfoEXT(VkImportMemoryHostPointerInfoEXT const &rhs)
Definition: vulkan.hpp:32212
bool operator==(ImportMemoryHostPointerInfoEXT const &rhs) const
Definition: vulkan.hpp:32250
ImportMemoryHostPointerInfoEXT & setPHostPointer(void *pHostPointer_)
Definition: vulkan.hpp:32234
ImportMemoryHostPointerInfoEXT & operator=(VkImportMemoryHostPointerInfoEXT const &rhs)
Definition: vulkan.hpp:32217
ExternalMemoryHandleTypeFlagBits handleType
Definition: vulkan.hpp:32268
ImportMemoryHostPointerInfoEXT & setPNext(const void *pNext_)
Definition: vulkan.hpp:32222
bool operator!=(ImportMemoryHostPointerInfoEXT const &rhs) const
Definition: vulkan.hpp:32258
ImportMemoryHostPointerInfoEXT & setHandleType(ExternalMemoryHandleTypeFlagBits handleType_)
Definition: vulkan.hpp:32228
bool operator==(ImportSemaphoreFdInfoKHR const &rhs) const
Definition: vulkan.hpp:32971
ImportSemaphoreFdInfoKHR(VkImportSemaphoreFdInfoKHR const &rhs)
Definition: vulkan.hpp:32921
bool operator!=(ImportSemaphoreFdInfoKHR const &rhs) const
Definition: vulkan.hpp:32981
ImportSemaphoreFdInfoKHR & setSemaphore(Semaphore semaphore_)
Definition: vulkan.hpp:32937
ImportSemaphoreFdInfoKHR & setPNext(const void *pNext_)
Definition: vulkan.hpp:32931
ImportSemaphoreFdInfoKHR(Semaphore semaphore_=Semaphore(), SemaphoreImportFlags flags_=SemaphoreImportFlags(), ExternalSemaphoreHandleTypeFlagBits handleType_=ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd, int fd_=0)
Definition: vulkan.hpp:32910
ImportSemaphoreFdInfoKHR & setHandleType(ExternalSemaphoreHandleTypeFlagBits handleType_)
Definition: vulkan.hpp:32949
ImportSemaphoreFdInfoKHR & setFlags(SemaphoreImportFlags flags_)
Definition: vulkan.hpp:32943
ExternalSemaphoreHandleTypeFlagBits handleType
Definition: vulkan.hpp:32993
ImportSemaphoreFdInfoKHR & setFd(int fd_)
Definition: vulkan.hpp:32955
ImportSemaphoreFdInfoKHR & operator=(VkImportSemaphoreFdInfoKHR const &rhs)
Definition: vulkan.hpp:32926
bool operator==(IndirectCommandsLayoutCreateInfoNVX const &rhs) const
Definition: vulkan.hpp:30790
IndirectCommandsLayoutCreateInfoNVX(PipelineBindPoint pipelineBindPoint_=PipelineBindPoint::eGraphics, IndirectCommandsLayoutUsageFlagsNVX flags_=IndirectCommandsLayoutUsageFlagsNVX(), uint32_t tokenCount_=0, const IndirectCommandsLayoutTokenNVX *pTokens_=nullptr)
Definition: vulkan.hpp:30729
IndirectCommandsLayoutCreateInfoNVX & setTokenCount(uint32_t tokenCount_)
Definition: vulkan.hpp:30768
IndirectCommandsLayoutCreateInfoNVX & setPipelineBindPoint(PipelineBindPoint pipelineBindPoint_)
Definition: vulkan.hpp:30756
IndirectCommandsLayoutCreateInfoNVX & operator=(VkIndirectCommandsLayoutCreateInfoNVX const &rhs)
Definition: vulkan.hpp:30745
IndirectCommandsLayoutCreateInfoNVX(VkIndirectCommandsLayoutCreateInfoNVX const &rhs)
Definition: vulkan.hpp:30740
IndirectCommandsLayoutCreateInfoNVX & setPNext(const void *pNext_)
Definition: vulkan.hpp:30750
bool operator!=(IndirectCommandsLayoutCreateInfoNVX const &rhs) const
Definition: vulkan.hpp:30800
IndirectCommandsLayoutCreateInfoNVX & setPTokens(const IndirectCommandsLayoutTokenNVX *pTokens_)
Definition: vulkan.hpp:30774
const IndirectCommandsLayoutTokenNVX * pTokens
Definition: vulkan.hpp:30813
IndirectCommandsLayoutCreateInfoNVX & setFlags(IndirectCommandsLayoutUsageFlagsNVX flags_)
Definition: vulkan.hpp:30762
IndirectCommandsLayoutTokenNVX & operator=(VkIndirectCommandsLayoutTokenNVX const &rhs)
Definition: vulkan.hpp:30668
IndirectCommandsLayoutTokenNVX & setDynamicCount(uint32_t dynamicCount_)
Definition: vulkan.hpp:30685
IndirectCommandsLayoutTokenNVX(VkIndirectCommandsLayoutTokenNVX const &rhs)
Definition: vulkan.hpp:30663
IndirectCommandsLayoutTokenNVX & setBindingUnit(uint32_t bindingUnit_)
Definition: vulkan.hpp:30679
bool operator!=(IndirectCommandsLayoutTokenNVX const &rhs) const
Definition: vulkan.hpp:30715
bool operator==(IndirectCommandsLayoutTokenNVX const &rhs) const
Definition: vulkan.hpp:30707
IndirectCommandsLayoutTokenNVX & setDivisor(uint32_t divisor_)
Definition: vulkan.hpp:30691
IndirectCommandsLayoutTokenNVX & setTokenType(IndirectCommandsTokenTypeNVX tokenType_)
Definition: vulkan.hpp:30673
IndirectCommandsLayoutTokenNVX(IndirectCommandsTokenTypeNVX tokenType_=IndirectCommandsTokenTypeNVX::ePipeline, uint32_t bindingUnit_=0, uint32_t dynamicCount_=0, uint32_t divisor_=0)
Definition: vulkan.hpp:30652
bool operator==(IndirectCommandsTokenNVX const &rhs) const
Definition: vulkan.hpp:30632
IndirectCommandsTokenNVX & setOffset(DeviceSize offset_)
Definition: vulkan.hpp:30616
IndirectCommandsTokenNVX(IndirectCommandsTokenTypeNVX tokenType_=IndirectCommandsTokenTypeNVX::ePipeline, Buffer buffer_=Buffer(), DeviceSize offset_=0)
Definition: vulkan.hpp:30585
IndirectCommandsTokenNVX & operator=(VkIndirectCommandsTokenNVX const &rhs)
Definition: vulkan.hpp:30599
IndirectCommandsTokenNVX(VkIndirectCommandsTokenNVX const &rhs)
Definition: vulkan.hpp:30594
bool operator!=(IndirectCommandsTokenNVX const &rhs) const
Definition: vulkan.hpp:30639
IndirectCommandsTokenNVX & setTokenType(IndirectCommandsTokenTypeNVX tokenType_)
Definition: vulkan.hpp:30604
IndirectCommandsTokenTypeNVX tokenType
Definition: vulkan.hpp:30644
IndirectCommandsTokenNVX & setBuffer(Buffer buffer_)
Definition: vulkan.hpp:30610
bool operator==(InputAttachmentAspectReference const &rhs) const
Definition: vulkan.hpp:25667
bool operator!=(InputAttachmentAspectReference const &rhs) const
Definition: vulkan.hpp:25674
InputAttachmentAspectReference & operator=(VkInputAttachmentAspectReference const &rhs)
Definition: vulkan.hpp:25634
InputAttachmentAspectReference(VkInputAttachmentAspectReference const &rhs)
Definition: vulkan.hpp:25629
InputAttachmentAspectReference & setInputAttachmentIndex(uint32_t inputAttachmentIndex_)
Definition: vulkan.hpp:25645
InputAttachmentAspectReference & setAspectMask(ImageAspectFlags aspectMask_)
Definition: vulkan.hpp:25651
InputAttachmentAspectReference & setSubpass(uint32_t subpass_)
Definition: vulkan.hpp:25639
InputAttachmentAspectReference(uint32_t subpass_=0, uint32_t inputAttachmentIndex_=0, ImageAspectFlags aspectMask_=ImageAspectFlags())
Definition: vulkan.hpp:25620
InstanceCreateInfo & setPpEnabledExtensionNames(const char *const *ppEnabledExtensionNames_)
Definition: vulkan.hpp:9663
InstanceCreateInfo & setPApplicationInfo(const ApplicationInfo *pApplicationInfo_)
Definition: vulkan.hpp:9639
bool operator==(InstanceCreateInfo const &rhs) const
Definition: vulkan.hpp:9679
InstanceCreateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:9627
const char *const * ppEnabledExtensionNames
Definition: vulkan.hpp:9706
InstanceCreateInfo(VkInstanceCreateInfo const &rhs)
Definition: vulkan.hpp:9617
InstanceCreateInfo & setEnabledExtensionCount(uint32_t enabledExtensionCount_)
Definition: vulkan.hpp:9657
InstanceCreateInfo & setFlags(InstanceCreateFlags flags_)
Definition: vulkan.hpp:9633
InstanceCreateInfo(InstanceCreateFlags flags_=InstanceCreateFlags(), const ApplicationInfo *pApplicationInfo_=nullptr, uint32_t enabledLayerCount_=0, const char *const *ppEnabledLayerNames_=nullptr, uint32_t enabledExtensionCount_=0, const char *const *ppEnabledExtensionNames_=nullptr)
Definition: vulkan.hpp:9602
InstanceCreateInfo & operator=(VkInstanceCreateInfo const &rhs)
Definition: vulkan.hpp:9622
const ApplicationInfo * pApplicationInfo
Definition: vulkan.hpp:9702
InstanceCreateInfo & setEnabledLayerCount(uint32_t enabledLayerCount_)
Definition: vulkan.hpp:9645
const char *const * ppEnabledLayerNames
Definition: vulkan.hpp:9704
InstanceCreateInfo & setPpEnabledLayerNames(const char *const *ppEnabledLayerNames_)
Definition: vulkan.hpp:9651
bool operator!=(InstanceCreateInfo const &rhs) const
Definition: vulkan.hpp:9691
bool operator!=(LayerProperties const &rhs) const
Definition: vulkan.hpp:5623
char layerName[VK_MAX_EXTENSION_NAME_SIZE]
Definition: vulkan.hpp:5628
char description[VK_MAX_DESCRIPTION_SIZE]
Definition: vulkan.hpp:5631
bool operator==(LayerProperties const &rhs) const
Definition: vulkan.hpp:5615
MappedMemoryRange & setMemory(DeviceMemory memory_)
Definition: vulkan.hpp:9807
bool operator!=(MappedMemoryRange const &rhs) const
Definition: vulkan.hpp:9844
MappedMemoryRange & setOffset(DeviceSize offset_)
Definition: vulkan.hpp:9813
MappedMemoryRange & setSize(DeviceSize size_)
Definition: vulkan.hpp:9819
bool operator==(MappedMemoryRange const &rhs) const
Definition: vulkan.hpp:9835
MappedMemoryRange & setPNext(const void *pNext_)
Definition: vulkan.hpp:9801
MappedMemoryRange & operator=(VkMappedMemoryRange const &rhs)
Definition: vulkan.hpp:9796
MappedMemoryRange(DeviceMemory memory_=DeviceMemory(), DeviceSize offset_=0, DeviceSize size_=0)
Definition: vulkan.hpp:9782
MappedMemoryRange(VkMappedMemoryRange const &rhs)
Definition: vulkan.hpp:9791
MemoryAllocateFlagsInfo & setFlags(MemoryAllocateFlags flags_)
Definition: vulkan.hpp:34009
MemoryAllocateFlagsInfo(MemoryAllocateFlags flags_=MemoryAllocateFlags(), uint32_t deviceMask_=0)
Definition: vulkan.hpp:33986
bool operator!=(MemoryAllocateFlagsInfo const &rhs) const
Definition: vulkan.hpp:34039
MemoryAllocateFlagsInfo & setDeviceMask(uint32_t deviceMask_)
Definition: vulkan.hpp:34015
MemoryAllocateFlagsInfo & operator=(VkMemoryAllocateFlagsInfo const &rhs)
Definition: vulkan.hpp:33998
bool operator==(MemoryAllocateFlagsInfo const &rhs) const
Definition: vulkan.hpp:34031
MemoryAllocateFlagsInfo(VkMemoryAllocateFlagsInfo const &rhs)
Definition: vulkan.hpp:33993
MemoryAllocateFlagsInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:34003
MemoryAllocateInfo & operator=(VkMemoryAllocateInfo const &rhs)
Definition: vulkan.hpp:9724
MemoryAllocateInfo(DeviceSize allocationSize_=0, uint32_t memoryTypeIndex_=0)
Definition: vulkan.hpp:9712
bool operator!=(MemoryAllocateInfo const &rhs) const
Definition: vulkan.hpp:9765
MemoryAllocateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:9729
MemoryAllocateInfo(VkMemoryAllocateInfo const &rhs)
Definition: vulkan.hpp:9719
bool operator==(MemoryAllocateInfo const &rhs) const
Definition: vulkan.hpp:9757
MemoryAllocateInfo & setMemoryTypeIndex(uint32_t memoryTypeIndex_)
Definition: vulkan.hpp:9741
MemoryAllocateInfo & setAllocationSize(DeviceSize allocationSize_)
Definition: vulkan.hpp:9735
bool operator==(MemoryBarrier const &rhs) const
Definition: vulkan.hpp:22603
MemoryBarrier(VkMemoryBarrier const &rhs)
Definition: vulkan.hpp:22565
MemoryBarrier & setPNext(const void *pNext_)
Definition: vulkan.hpp:22575
MemoryBarrier(AccessFlags srcAccessMask_=AccessFlags(), AccessFlags dstAccessMask_=AccessFlags())
Definition: vulkan.hpp:22558
bool operator!=(MemoryBarrier const &rhs) const
Definition: vulkan.hpp:22611
MemoryBarrier & setDstAccessMask(AccessFlags dstAccessMask_)
Definition: vulkan.hpp:22587
MemoryBarrier & operator=(VkMemoryBarrier const &rhs)
Definition: vulkan.hpp:22570
MemoryBarrier & setSrcAccessMask(AccessFlags srcAccessMask_)
Definition: vulkan.hpp:22581
MemoryDedicatedAllocateInfo & setBuffer(Buffer buffer_)
Definition: vulkan.hpp:16174
MemoryDedicatedAllocateInfo(VkMemoryDedicatedAllocateInfo const &rhs)
Definition: vulkan.hpp:16152
bool operator!=(MemoryDedicatedAllocateInfo const &rhs) const
Definition: vulkan.hpp:16198
MemoryDedicatedAllocateInfo(Image image_=Image(), Buffer buffer_=Buffer())
Definition: vulkan.hpp:16145
MemoryDedicatedAllocateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:16162
MemoryDedicatedAllocateInfo & operator=(VkMemoryDedicatedAllocateInfo const &rhs)
Definition: vulkan.hpp:16157
MemoryDedicatedAllocateInfo & setImage(Image image_)
Definition: vulkan.hpp:16168
bool operator==(MemoryDedicatedAllocateInfo const &rhs) const
Definition: vulkan.hpp:16190
bool operator==(MemoryDedicatedRequirements const &rhs) const
Definition: vulkan.hpp:16118
bool operator!=(MemoryDedicatedRequirements const &rhs) const
Definition: vulkan.hpp:16126
bool operator!=(MemoryFdPropertiesKHR const &rhs) const
Definition: vulkan.hpp:13571
bool operator==(MemoryFdPropertiesKHR const &rhs) const
Definition: vulkan.hpp:13564
MemoryGetFdInfoKHR(VkMemoryGetFdInfoKHR const &rhs)
Definition: vulkan.hpp:32142
MemoryGetFdInfoKHR & setPNext(const void *pNext_)
Definition: vulkan.hpp:32152
ExternalMemoryHandleTypeFlagBits handleType
Definition: vulkan.hpp:32199
MemoryGetFdInfoKHR & setMemory(DeviceMemory memory_)
Definition: vulkan.hpp:32158
MemoryGetFdInfoKHR(DeviceMemory memory_=DeviceMemory(), ExternalMemoryHandleTypeFlagBits handleType_=ExternalMemoryHandleTypeFlagBits::eOpaqueFd)
Definition: vulkan.hpp:32135
MemoryGetFdInfoKHR & setHandleType(ExternalMemoryHandleTypeFlagBits handleType_)
Definition: vulkan.hpp:32164
bool operator!=(MemoryGetFdInfoKHR const &rhs) const
Definition: vulkan.hpp:32188
MemoryGetFdInfoKHR & operator=(VkMemoryGetFdInfoKHR const &rhs)
Definition: vulkan.hpp:32147
bool operator==(MemoryGetFdInfoKHR const &rhs) const
Definition: vulkan.hpp:32180
bool operator!=(MemoryHeap const &rhs) const
Definition: vulkan.hpp:22428
bool operator==(MemoryHeap const &rhs) const
Definition: vulkan.hpp:22422
MemoryHostPointerPropertiesEXT & operator=(VkMemoryHostPointerPropertiesEXT const &rhs)
Definition: vulkan.hpp:17468
MemoryHostPointerPropertiesEXT(VkMemoryHostPointerPropertiesEXT const &rhs)
Definition: vulkan.hpp:17463
MemoryHostPointerPropertiesEXT(uint32_t memoryTypeBits_=0)
Definition: vulkan.hpp:17458
bool operator==(MemoryHostPointerPropertiesEXT const &rhs) const
Definition: vulkan.hpp:17495
MemoryHostPointerPropertiesEXT & setPNext(void *pNext_)
Definition: vulkan.hpp:17473
MemoryHostPointerPropertiesEXT & setMemoryTypeBits(uint32_t memoryTypeBits_)
Definition: vulkan.hpp:17479
bool operator!=(MemoryHostPointerPropertiesEXT const &rhs) const
Definition: vulkan.hpp:17502
bool operator!=(MemoryRequirements2 const &rhs) const
Definition: vulkan.hpp:16090
bool operator==(MemoryRequirements2 const &rhs) const
Definition: vulkan.hpp:16083
bool operator!=(MemoryRequirements const &rhs) const
Definition: vulkan.hpp:5751
bool operator==(MemoryRequirements const &rhs) const
Definition: vulkan.hpp:5744
bool operator==(MemoryType const &rhs) const
Definition: vulkan.hpp:22367
MemoryPropertyFlags propertyFlags
Definition: vulkan.hpp:22378
bool operator!=(MemoryType const &rhs) const
Definition: vulkan.hpp:22373
bool operator==(MultisamplePropertiesEXT const &rhs) const
Definition: vulkan.hpp:16714
bool operator!=(MultisamplePropertiesEXT const &rhs) const
Definition: vulkan.hpp:16721
bool operator!=(ObjectTableCreateInfoNVX const &rhs) const
Definition: vulkan.hpp:30944
ObjectTableCreateInfoNVX & setMaxStorageImagesPerDescriptor(uint32_t maxStorageImagesPerDescriptor_)
Definition: vulkan.hpp:30901
ObjectTableCreateInfoNVX & setPObjectEntryCounts(const uint32_t *pObjectEntryCounts_)
Definition: vulkan.hpp:30877
ObjectTableCreateInfoNVX & setPObjectEntryUsageFlags(const ObjectEntryUsageFlagsNVX *pObjectEntryUsageFlags_)
Definition: vulkan.hpp:30883
ObjectTableCreateInfoNVX & setObjectCount(uint32_t objectCount_)
Definition: vulkan.hpp:30865
bool operator==(ObjectTableCreateInfoNVX const &rhs) const
Definition: vulkan.hpp:30929
ObjectTableCreateInfoNVX & setPNext(const void *pNext_)
Definition: vulkan.hpp:30859
ObjectTableCreateInfoNVX(uint32_t objectCount_=0, const ObjectEntryTypeNVX *pObjectEntryTypes_=nullptr, const uint32_t *pObjectEntryCounts_=nullptr, const ObjectEntryUsageFlagsNVX *pObjectEntryUsageFlags_=nullptr, uint32_t maxUniformBuffersPerDescriptor_=0, uint32_t maxStorageBuffersPerDescriptor_=0, uint32_t maxStorageImagesPerDescriptor_=0, uint32_t maxSampledImagesPerDescriptor_=0, uint32_t maxPipelineLayouts_=0)
Definition: vulkan.hpp:30828
const ObjectEntryTypeNVX * pObjectEntryTypes
Definition: vulkan.hpp:30955
ObjectTableCreateInfoNVX & setMaxPipelineLayouts(uint32_t maxPipelineLayouts_)
Definition: vulkan.hpp:30913
ObjectTableCreateInfoNVX & setMaxStorageBuffersPerDescriptor(uint32_t maxStorageBuffersPerDescriptor_)
Definition: vulkan.hpp:30895
const ObjectEntryUsageFlagsNVX * pObjectEntryUsageFlags
Definition: vulkan.hpp:30957
ObjectTableCreateInfoNVX & operator=(VkObjectTableCreateInfoNVX const &rhs)
Definition: vulkan.hpp:30854
ObjectTableCreateInfoNVX(VkObjectTableCreateInfoNVX const &rhs)
Definition: vulkan.hpp:30849
ObjectTableCreateInfoNVX & setPObjectEntryTypes(const ObjectEntryTypeNVX *pObjectEntryTypes_)
Definition: vulkan.hpp:30871
ObjectTableCreateInfoNVX & setMaxUniformBuffersPerDescriptor(uint32_t maxUniformBuffersPerDescriptor_)
Definition: vulkan.hpp:30889
ObjectTableCreateInfoNVX & setMaxSampledImagesPerDescriptor(uint32_t maxSampledImagesPerDescriptor_)
Definition: vulkan.hpp:30907
Definition: vulkan.hpp:31098
ObjectEntryUsageFlagsNVX flags
Definition: vulkan.hpp:31177
bool operator!=(ObjectTableDescriptorSetEntryNVX const &rhs) const
Definition: vulkan.hpp:31171
bool operator==(ObjectTableDescriptorSetEntryNVX const &rhs) const
Definition: vulkan.hpp:31163
ObjectTableDescriptorSetEntryNVX & operator=(VkObjectTableDescriptorSetEntryNVX const &rhs)
Definition: vulkan.hpp:31124
ObjectEntryTypeNVX type
Definition: vulkan.hpp:31176
ObjectTableDescriptorSetEntryNVX(ObjectEntryTypeNVX type_=ObjectEntryTypeNVX::eDescriptorSet, ObjectEntryUsageFlagsNVX flags_=ObjectEntryUsageFlagsNVX(), PipelineLayout pipelineLayout_=PipelineLayout(), DescriptorSet descriptorSet_=DescriptorSet())
Definition: vulkan.hpp:31099
ObjectTableDescriptorSetEntryNVX & setDescriptorSet(DescriptorSet descriptorSet_)
Definition: vulkan.hpp:31147
ObjectTableDescriptorSetEntryNVX & setType(ObjectEntryTypeNVX type_)
Definition: vulkan.hpp:31129
ObjectTableDescriptorSetEntryNVX(ObjectTableEntryNVX const &objectTableEntryNVX, PipelineLayout pipelineLayout_=PipelineLayout(), DescriptorSet descriptorSet_=DescriptorSet())
Definition: vulkan.hpp:31110
ObjectTableDescriptorSetEntryNVX & setFlags(ObjectEntryUsageFlagsNVX flags_)
Definition: vulkan.hpp:31135
DescriptorSet descriptorSet
Definition: vulkan.hpp:31179
PipelineLayout pipelineLayout
Definition: vulkan.hpp:31178
ObjectTableDescriptorSetEntryNVX(VkObjectTableDescriptorSetEntryNVX const &rhs)
Definition: vulkan.hpp:31119
ObjectTableDescriptorSetEntryNVX & setPipelineLayout(PipelineLayout pipelineLayout_)
Definition: vulkan.hpp:31141
Definition: vulkan.hpp:30967
ObjectTableEntryNVX(ObjectEntryTypeNVX type_=ObjectEntryTypeNVX::eDescriptorSet, ObjectEntryUsageFlagsNVX flags_=ObjectEntryUsageFlagsNVX())
Definition: vulkan.hpp:30968
ObjectEntryTypeNVX type
Definition: vulkan.hpp:31018
ObjectEntryUsageFlagsNVX flags
Definition: vulkan.hpp:31019
ObjectTableEntryNVX & setFlags(ObjectEntryUsageFlagsNVX flags_)
Definition: vulkan.hpp:30991
ObjectTableEntryNVX(VkObjectTableEntryNVX const &rhs)
Definition: vulkan.hpp:30975
ObjectTableEntryNVX & operator=(VkObjectTableEntryNVX const &rhs)
Definition: vulkan.hpp:30980
ObjectTableEntryNVX & setType(ObjectEntryTypeNVX type_)
Definition: vulkan.hpp:30985
bool operator==(ObjectTableEntryNVX const &rhs) const
Definition: vulkan.hpp:31007
bool operator!=(ObjectTableEntryNVX const &rhs) const
Definition: vulkan.hpp:31013
Definition: vulkan.hpp:31258
ObjectTableIndexBufferEntryNVX & setFlags(ObjectEntryUsageFlagsNVX flags_)
Definition: vulkan.hpp:31295
IndexType indexType
Definition: vulkan.hpp:31339
ObjectEntryUsageFlagsNVX flags
Definition: vulkan.hpp:31337
ObjectTableIndexBufferEntryNVX & setBuffer(Buffer buffer_)
Definition: vulkan.hpp:31301
ObjectTableIndexBufferEntryNVX(ObjectTableEntryNVX const &objectTableEntryNVX, Buffer buffer_=Buffer(), IndexType indexType_=IndexType::eUint16)
Definition: vulkan.hpp:31270
ObjectTableIndexBufferEntryNVX & setType(ObjectEntryTypeNVX type_)
Definition: vulkan.hpp:31289
ObjectEntryTypeNVX type
Definition: vulkan.hpp:31336
ObjectTableIndexBufferEntryNVX(VkObjectTableIndexBufferEntryNVX const &rhs)
Definition: vulkan.hpp:31279
ObjectTableIndexBufferEntryNVX(ObjectEntryTypeNVX type_=ObjectEntryTypeNVX::eDescriptorSet, ObjectEntryUsageFlagsNVX flags_=ObjectEntryUsageFlagsNVX(), Buffer buffer_=Buffer(), IndexType indexType_=IndexType::eUint16)
Definition: vulkan.hpp:31259
bool operator!=(ObjectTableIndexBufferEntryNVX const &rhs) const
Definition: vulkan.hpp:31331
bool operator==(ObjectTableIndexBufferEntryNVX const &rhs) const
Definition: vulkan.hpp:31323
ObjectTableIndexBufferEntryNVX & setIndexType(IndexType indexType_)
Definition: vulkan.hpp:31307
ObjectTableIndexBufferEntryNVX & operator=(VkObjectTableIndexBufferEntryNVX const &rhs)
Definition: vulkan.hpp:31284
Buffer buffer
Definition: vulkan.hpp:31338
Definition: vulkan.hpp:31024
bool operator!=(ObjectTablePipelineEntryNVX const &rhs) const
Definition: vulkan.hpp:31086
Pipeline pipeline
Definition: vulkan.hpp:31093
ObjectTablePipelineEntryNVX & setType(ObjectEntryTypeNVX type_)
Definition: vulkan.hpp:31051
ObjectTablePipelineEntryNVX(ObjectEntryTypeNVX type_=ObjectEntryTypeNVX::eDescriptorSet, ObjectEntryUsageFlagsNVX flags_=ObjectEntryUsageFlagsNVX(), Pipeline pipeline_=Pipeline())
Definition: vulkan.hpp:31025
ObjectEntryTypeNVX type
Definition: vulkan.hpp:31091
ObjectTablePipelineEntryNVX(VkObjectTablePipelineEntryNVX const &rhs)
Definition: vulkan.hpp:31041
ObjectTablePipelineEntryNVX & operator=(VkObjectTablePipelineEntryNVX const &rhs)
Definition: vulkan.hpp:31046
ObjectTablePipelineEntryNVX & setFlags(ObjectEntryUsageFlagsNVX flags_)
Definition: vulkan.hpp:31057
ObjectEntryUsageFlagsNVX flags
Definition: vulkan.hpp:31092
ObjectTablePipelineEntryNVX(ObjectTableEntryNVX const &objectTableEntryNVX, Pipeline pipeline_=Pipeline())
Definition: vulkan.hpp:31034
ObjectTablePipelineEntryNVX & setPipeline(Pipeline pipeline_)
Definition: vulkan.hpp:31063
bool operator==(ObjectTablePipelineEntryNVX const &rhs) const
Definition: vulkan.hpp:31079
Definition: vulkan.hpp:31344
ObjectTablePushConstantEntryNVX & setPipelineLayout(PipelineLayout pipelineLayout_)
Definition: vulkan.hpp:31387
ShaderStageFlags stageFlags
Definition: vulkan.hpp:31425
ObjectTablePushConstantEntryNVX & setFlags(ObjectEntryUsageFlagsNVX flags_)
Definition: vulkan.hpp:31381
ObjectEntryUsageFlagsNVX flags
Definition: vulkan.hpp:31423
ObjectTablePushConstantEntryNVX(ObjectTableEntryNVX const &objectTableEntryNVX, PipelineLayout pipelineLayout_=PipelineLayout(), ShaderStageFlags stageFlags_=ShaderStageFlags())
Definition: vulkan.hpp:31356
ObjectTablePushConstantEntryNVX(ObjectEntryTypeNVX type_=ObjectEntryTypeNVX::eDescriptorSet, ObjectEntryUsageFlagsNVX flags_=ObjectEntryUsageFlagsNVX(), PipelineLayout pipelineLayout_=PipelineLayout(), ShaderStageFlags stageFlags_=ShaderStageFlags())
Definition: vulkan.hpp:31345
ObjectTablePushConstantEntryNVX & setType(ObjectEntryTypeNVX type_)
Definition: vulkan.hpp:31375
bool operator==(ObjectTablePushConstantEntryNVX const &rhs) const
Definition: vulkan.hpp:31409
ObjectTablePushConstantEntryNVX & operator=(VkObjectTablePushConstantEntryNVX const &rhs)
Definition: vulkan.hpp:31370
bool operator!=(ObjectTablePushConstantEntryNVX const &rhs) const
Definition: vulkan.hpp:31417
PipelineLayout pipelineLayout
Definition: vulkan.hpp:31424
ObjectEntryTypeNVX type
Definition: vulkan.hpp:31422
ObjectTablePushConstantEntryNVX(VkObjectTablePushConstantEntryNVX const &rhs)
Definition: vulkan.hpp:31365
ObjectTablePushConstantEntryNVX & setStageFlags(ShaderStageFlags stageFlags_)
Definition: vulkan.hpp:31393
Definition: vulkan.hpp:31184
ObjectTableVertexBufferEntryNVX & setFlags(ObjectEntryUsageFlagsNVX flags_)
Definition: vulkan.hpp:31217
Buffer buffer
Definition: vulkan.hpp:31253
ObjectTableVertexBufferEntryNVX & setBuffer(Buffer buffer_)
Definition: vulkan.hpp:31223
bool operator!=(ObjectTableVertexBufferEntryNVX const &rhs) const
Definition: vulkan.hpp:31246
ObjectEntryTypeNVX type
Definition: vulkan.hpp:31251
ObjectTableVertexBufferEntryNVX(VkObjectTableVertexBufferEntryNVX const &rhs)
Definition: vulkan.hpp:31201
ObjectTableVertexBufferEntryNVX(ObjectEntryTypeNVX type_=ObjectEntryTypeNVX::eDescriptorSet, ObjectEntryUsageFlagsNVX flags_=ObjectEntryUsageFlagsNVX(), Buffer buffer_=Buffer())
Definition: vulkan.hpp:31185
ObjectTableVertexBufferEntryNVX & setType(ObjectEntryTypeNVX type_)
Definition: vulkan.hpp:31211
ObjectEntryUsageFlagsNVX flags
Definition: vulkan.hpp:31252
ObjectTableVertexBufferEntryNVX & operator=(VkObjectTableVertexBufferEntryNVX const &rhs)
Definition: vulkan.hpp:31206
ObjectTableVertexBufferEntryNVX(ObjectTableEntryNVX const &objectTableEntryNVX, Buffer buffer_=Buffer())
Definition: vulkan.hpp:31194
bool operator==(ObjectTableVertexBufferEntryNVX const &rhs) const
Definition: vulkan.hpp:31239
bool operator!=(Offset2D const &rhs) const
Definition: vulkan.hpp:5139
Offset2D & operator=(VkOffset2D const &rhs)
Definition: vulkan.hpp:5106
bool operator==(Offset2D const &rhs) const
Definition: vulkan.hpp:5133
Offset2D & setY(int32_t y_)
Definition: vulkan.hpp:5117
Offset2D & setX(int32_t x_)
Definition: vulkan.hpp:5111
Offset2D(int32_t x_=0, int32_t y_=0)
Definition: vulkan.hpp:5094
Offset2D(VkOffset2D const &rhs)
Definition: vulkan.hpp:5101
Offset3D & setY(int32_t y_)
Definition: vulkan.hpp:5183
Offset3D(Offset2D const &offset2D, int32_t z_=0)
Definition: vulkan.hpp:5160
Offset3D & operator=(VkOffset3D const &rhs)
Definition: vulkan.hpp:5172
Offset3D & setX(int32_t x_)
Definition: vulkan.hpp:5177
bool operator!=(Offset3D const &rhs) const
Definition: vulkan.hpp:5212
Offset3D(int32_t x_=0, int32_t y_=0, int32_t z_=0)
Definition: vulkan.hpp:5151
bool operator==(Offset3D const &rhs) const
Definition: vulkan.hpp:5205
Offset3D & setZ(int32_t z_)
Definition: vulkan.hpp:5189
Offset3D(VkOffset3D const &rhs)
Definition: vulkan.hpp:5167
bool operator==(PastPresentationTimingGOOGLE const &rhs) const
Definition: vulkan.hpp:7492
bool operator!=(PastPresentationTimingGOOGLE const &rhs) const
Definition: vulkan.hpp:7501
PhysicalDevice16BitStorageFeatures & setUniformAndStorageBuffer16BitAccess(Bool32 uniformAndStorageBuffer16BitAccess_)
Definition: vulkan.hpp:15828
bool operator==(PhysicalDevice16BitStorageFeatures const &rhs) const
Definition: vulkan.hpp:15856
PhysicalDevice16BitStorageFeatures & setStorageInputOutput16(Bool32 storageInputOutput16_)
Definition: vulkan.hpp:15840
PhysicalDevice16BitStorageFeatures(VkPhysicalDevice16BitStorageFeatures const &rhs)
Definition: vulkan.hpp:15806
bool operator!=(PhysicalDevice16BitStorageFeatures const &rhs) const
Definition: vulkan.hpp:15866
PhysicalDevice16BitStorageFeatures & setPNext(void *pNext_)
Definition: vulkan.hpp:15816
PhysicalDevice16BitStorageFeatures & operator=(VkPhysicalDevice16BitStorageFeatures const &rhs)
Definition: vulkan.hpp:15811
PhysicalDevice16BitStorageFeatures & setStoragePushConstant16(Bool32 storagePushConstant16_)
Definition: vulkan.hpp:15834
PhysicalDevice16BitStorageFeatures(Bool32 storageBuffer16BitAccess_=0, Bool32 uniformAndStorageBuffer16BitAccess_=0, Bool32 storagePushConstant16_=0, Bool32 storageInputOutput16_=0)
Definition: vulkan.hpp:15795
PhysicalDevice16BitStorageFeatures & setStorageBuffer16BitAccess(Bool32 storageBuffer16BitAccess_)
Definition: vulkan.hpp:15822
PhysicalDevice8BitStorageFeaturesKHR & setStoragePushConstant8(Bool32 storagePushConstant8_)
Definition: vulkan.hpp:18782
PhysicalDevice8BitStorageFeaturesKHR(VkPhysicalDevice8BitStorageFeaturesKHR const &rhs)
Definition: vulkan.hpp:18754
PhysicalDevice8BitStorageFeaturesKHR & setPNext(void *pNext_)
Definition: vulkan.hpp:18764
bool operator==(PhysicalDevice8BitStorageFeaturesKHR const &rhs) const
Definition: vulkan.hpp:18798
PhysicalDevice8BitStorageFeaturesKHR & setUniformAndStorageBuffer8BitAccess(Bool32 uniformAndStorageBuffer8BitAccess_)
Definition: vulkan.hpp:18776
PhysicalDevice8BitStorageFeaturesKHR(Bool32 storageBuffer8BitAccess_=0, Bool32 uniformAndStorageBuffer8BitAccess_=0, Bool32 storagePushConstant8_=0)
Definition: vulkan.hpp:18745
bool operator!=(PhysicalDevice8BitStorageFeaturesKHR const &rhs) const
Definition: vulkan.hpp:18807
PhysicalDevice8BitStorageFeaturesKHR & setStorageBuffer8BitAccess(Bool32 storageBuffer8BitAccess_)
Definition: vulkan.hpp:18770
PhysicalDevice8BitStorageFeaturesKHR & operator=(VkPhysicalDevice8BitStorageFeaturesKHR const &rhs)
Definition: vulkan.hpp:18759
PhysicalDeviceASTCDecodeFeaturesEXT(VkPhysicalDeviceASTCDecodeFeaturesEXT const &rhs)
Definition: vulkan.hpp:19135
PhysicalDeviceASTCDecodeFeaturesEXT(Bool32 decodeModeSharedExponent_=0)
Definition: vulkan.hpp:19130
PhysicalDeviceASTCDecodeFeaturesEXT & operator=(VkPhysicalDeviceASTCDecodeFeaturesEXT const &rhs)
Definition: vulkan.hpp:19140
bool operator!=(PhysicalDeviceASTCDecodeFeaturesEXT const &rhs) const
Definition: vulkan.hpp:19174
bool operator==(PhysicalDeviceASTCDecodeFeaturesEXT const &rhs) const
Definition: vulkan.hpp:19167
PhysicalDeviceASTCDecodeFeaturesEXT & setPNext(void *pNext_)
Definition: vulkan.hpp:19145
PhysicalDeviceASTCDecodeFeaturesEXT & setDecodeModeSharedExponent(Bool32 decodeModeSharedExponent_)
Definition: vulkan.hpp:19151
PhysicalDeviceBlendOperationAdvancedFeaturesEXT(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const &rhs)
Definition: vulkan.hpp:16742
PhysicalDeviceBlendOperationAdvancedFeaturesEXT(Bool32 advancedBlendCoherentOperations_=0)
Definition: vulkan.hpp:16737
PhysicalDeviceBlendOperationAdvancedFeaturesEXT & operator=(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const &rhs)
Definition: vulkan.hpp:16747
PhysicalDeviceBlendOperationAdvancedFeaturesEXT & setAdvancedBlendCoherentOperations(Bool32 advancedBlendCoherentOperations_)
Definition: vulkan.hpp:16758
bool operator==(PhysicalDeviceBlendOperationAdvancedFeaturesEXT const &rhs) const
Definition: vulkan.hpp:16774
PhysicalDeviceBlendOperationAdvancedFeaturesEXT & setPNext(void *pNext_)
Definition: vulkan.hpp:16752
bool operator!=(PhysicalDeviceBlendOperationAdvancedFeaturesEXT const &rhs) const
Definition: vulkan.hpp:16781
bool operator!=(PhysicalDeviceBlendOperationAdvancedPropertiesEXT const &rhs) const
Definition: vulkan.hpp:16819
bool operator==(PhysicalDeviceBlendOperationAdvancedPropertiesEXT const &rhs) const
Definition: vulkan.hpp:16807
PhysicalDeviceComputeShaderDerivativesFeaturesNV & operator=(VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const &rhs)
Definition: vulkan.hpp:19703
bool operator!=(PhysicalDeviceComputeShaderDerivativesFeaturesNV const &rhs) const
Definition: vulkan.hpp:19744
bool operator==(PhysicalDeviceComputeShaderDerivativesFeaturesNV const &rhs) const
Definition: vulkan.hpp:19736
PhysicalDeviceComputeShaderDerivativesFeaturesNV(VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const &rhs)
Definition: vulkan.hpp:19698
PhysicalDeviceComputeShaderDerivativesFeaturesNV & setPNext(void *pNext_)
Definition: vulkan.hpp:19708
PhysicalDeviceComputeShaderDerivativesFeaturesNV & setComputeDerivativeGroupQuads(Bool32 computeDerivativeGroupQuads_)
Definition: vulkan.hpp:19714
PhysicalDeviceComputeShaderDerivativesFeaturesNV(Bool32 computeDerivativeGroupQuads_=0, Bool32 computeDerivativeGroupLinear_=0)
Definition: vulkan.hpp:19691
PhysicalDeviceComputeShaderDerivativesFeaturesNV & setComputeDerivativeGroupLinear(Bool32 computeDerivativeGroupLinear_)
Definition: vulkan.hpp:19720
bool operator==(PhysicalDeviceConditionalRenderingFeaturesEXT const &rhs) const
Definition: vulkan.hpp:18870
PhysicalDeviceConditionalRenderingFeaturesEXT & setConditionalRendering(Bool32 conditionalRendering_)
Definition: vulkan.hpp:18848
PhysicalDeviceConditionalRenderingFeaturesEXT & setInheritedConditionalRendering(Bool32 inheritedConditionalRendering_)
Definition: vulkan.hpp:18854
bool operator!=(PhysicalDeviceConditionalRenderingFeaturesEXT const &rhs) const
Definition: vulkan.hpp:18878
PhysicalDeviceConditionalRenderingFeaturesEXT & operator=(VkPhysicalDeviceConditionalRenderingFeaturesEXT const &rhs)
Definition: vulkan.hpp:18837
PhysicalDeviceConditionalRenderingFeaturesEXT(VkPhysicalDeviceConditionalRenderingFeaturesEXT const &rhs)
Definition: vulkan.hpp:18832
PhysicalDeviceConditionalRenderingFeaturesEXT(Bool32 conditionalRendering_=0, Bool32 inheritedConditionalRendering_=0)
Definition: vulkan.hpp:18825
PhysicalDeviceConditionalRenderingFeaturesEXT & setPNext(void *pNext_)
Definition: vulkan.hpp:18842
PhysicalDeviceConservativeRasterizationPropertiesEXT & setPNext(void *pNext_)
Definition: vulkan.hpp:17609
PhysicalDeviceConservativeRasterizationPropertiesEXT & setDegenerateTrianglesRasterized(Bool32 degenerateTrianglesRasterized_)
Definition: vulkan.hpp:17645
PhysicalDeviceConservativeRasterizationPropertiesEXT & setPrimitiveUnderestimation(Bool32 primitiveUnderestimation_)
Definition: vulkan.hpp:17633
PhysicalDeviceConservativeRasterizationPropertiesEXT & setConservativeRasterizationPostDepthCoverage(Bool32 conservativeRasterizationPostDepthCoverage_)
Definition: vulkan.hpp:17663
PhysicalDeviceConservativeRasterizationPropertiesEXT & setMaxExtraPrimitiveOverestimationSize(float maxExtraPrimitiveOverestimationSize_)
Definition: vulkan.hpp:17621
bool operator!=(PhysicalDeviceConservativeRasterizationPropertiesEXT const &rhs) const
Definition: vulkan.hpp:17694
PhysicalDeviceConservativeRasterizationPropertiesEXT & operator=(VkPhysicalDeviceConservativeRasterizationPropertiesEXT const &rhs)
Definition: vulkan.hpp:17604
PhysicalDeviceConservativeRasterizationPropertiesEXT & setFullyCoveredFragmentShaderInputVariable(Bool32 fullyCoveredFragmentShaderInputVariable_)
Definition: vulkan.hpp:17657
bool operator==(PhysicalDeviceConservativeRasterizationPropertiesEXT const &rhs) const
Definition: vulkan.hpp:17679
PhysicalDeviceConservativeRasterizationPropertiesEXT & setPrimitiveOverestimationSize(float primitiveOverestimationSize_)
Definition: vulkan.hpp:17615
PhysicalDeviceConservativeRasterizationPropertiesEXT & setExtraPrimitiveOverestimationSizeGranularity(float extraPrimitiveOverestimationSizeGranularity_)
Definition: vulkan.hpp:17627
PhysicalDeviceConservativeRasterizationPropertiesEXT & setConservativePointAndLineRasterization(Bool32 conservativePointAndLineRasterization_)
Definition: vulkan.hpp:17639
PhysicalDeviceConservativeRasterizationPropertiesEXT(float primitiveOverestimationSize_=0, float maxExtraPrimitiveOverestimationSize_=0, float extraPrimitiveOverestimationSizeGranularity_=0, Bool32 primitiveUnderestimation_=0, Bool32 conservativePointAndLineRasterization_=0, Bool32 degenerateTrianglesRasterized_=0, Bool32 degenerateLinesRasterized_=0, Bool32 fullyCoveredFragmentShaderInputVariable_=0, Bool32 conservativeRasterizationPostDepthCoverage_=0)
Definition: vulkan.hpp:17578
PhysicalDeviceConservativeRasterizationPropertiesEXT & setDegenerateLinesRasterized(Bool32 degenerateLinesRasterized_)
Definition: vulkan.hpp:17651
PhysicalDeviceConservativeRasterizationPropertiesEXT(VkPhysicalDeviceConservativeRasterizationPropertiesEXT const &rhs)
Definition: vulkan.hpp:17599
bool operator!=(PhysicalDeviceCornerSampledImageFeaturesNV const &rhs) const
Definition: vulkan.hpp:19675
PhysicalDeviceCornerSampledImageFeaturesNV(VkPhysicalDeviceCornerSampledImageFeaturesNV const &rhs)
Definition: vulkan.hpp:19636
PhysicalDeviceCornerSampledImageFeaturesNV(Bool32 cornerSampledImage_=0)
Definition: vulkan.hpp:19631
PhysicalDeviceCornerSampledImageFeaturesNV & setPNext(void *pNext_)
Definition: vulkan.hpp:19646
PhysicalDeviceCornerSampledImageFeaturesNV & operator=(VkPhysicalDeviceCornerSampledImageFeaturesNV const &rhs)
Definition: vulkan.hpp:19641
PhysicalDeviceCornerSampledImageFeaturesNV & setCornerSampledImage(Bool32 cornerSampledImage_)
Definition: vulkan.hpp:19652
bool operator==(PhysicalDeviceCornerSampledImageFeaturesNV const &rhs) const
Definition: vulkan.hpp:19668
PhysicalDeviceDescriptorIndexingFeaturesEXT & setPNext(void *pNext_)
Definition: vulkan.hpp:17830
PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderUniformTexelBufferArrayDynamicIndexing(Bool32 shaderUniformTexelBufferArrayDynamicIndexing_)
Definition: vulkan.hpp:17842
PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderStorageImageArrayNonUniformIndexing(Bool32 shaderStorageImageArrayNonUniformIndexing_)
Definition: vulkan.hpp:17872
PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderSampledImageArrayNonUniformIndexing(Bool32 shaderSampledImageArrayNonUniformIndexing_)
Definition: vulkan.hpp:17860
PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderUniformTexelBufferArrayNonUniformIndexing(Bool32 shaderUniformTexelBufferArrayNonUniformIndexing_)
Definition: vulkan.hpp:17884
PhysicalDeviceDescriptorIndexingFeaturesEXT & operator=(VkPhysicalDeviceDescriptorIndexingFeaturesEXT const &rhs)
Definition: vulkan.hpp:17825
PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingUpdateUnusedWhilePending(Bool32 descriptorBindingUpdateUnusedWhilePending_)
Definition: vulkan.hpp:17932
PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingUniformBufferUpdateAfterBind(Bool32 descriptorBindingUniformBufferUpdateAfterBind_)
Definition: vulkan.hpp:17896
PhysicalDeviceDescriptorIndexingFeaturesEXT(VkPhysicalDeviceDescriptorIndexingFeaturesEXT const &rhs)
Definition: vulkan.hpp:17820
PhysicalDeviceDescriptorIndexingFeaturesEXT & setRuntimeDescriptorArray(Bool32 runtimeDescriptorArray_)
Definition: vulkan.hpp:17950
PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingStorageBufferUpdateAfterBind(Bool32 descriptorBindingStorageBufferUpdateAfterBind_)
Definition: vulkan.hpp:17914
PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderInputAttachmentArrayDynamicIndexing(Bool32 shaderInputAttachmentArrayDynamicIndexing_)
Definition: vulkan.hpp:17836
bool operator==(PhysicalDeviceDescriptorIndexingFeaturesEXT const &rhs) const
Definition: vulkan.hpp:17966
PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderUniformBufferArrayNonUniformIndexing(Bool32 shaderUniformBufferArrayNonUniformIndexing_)
Definition: vulkan.hpp:17854
PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingStorageImageUpdateAfterBind(Bool32 descriptorBindingStorageImageUpdateAfterBind_)
Definition: vulkan.hpp:17908
PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingVariableDescriptorCount(Bool32 descriptorBindingVariableDescriptorCount_)
Definition: vulkan.hpp:17944
PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingPartiallyBound(Bool32 descriptorBindingPartiallyBound_)
Definition: vulkan.hpp:17938
PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingUniformTexelBufferUpdateAfterBind(Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind_)
Definition: vulkan.hpp:17920
PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderStorageTexelBufferArrayDynamicIndexing(Bool32 shaderStorageTexelBufferArrayDynamicIndexing_)
Definition: vulkan.hpp:17848
bool operator!=(PhysicalDeviceDescriptorIndexingFeaturesEXT const &rhs) const
Definition: vulkan.hpp:17992
PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingStorageTexelBufferUpdateAfterBind(Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind_)
Definition: vulkan.hpp:17926
PhysicalDeviceDescriptorIndexingFeaturesEXT & setDescriptorBindingSampledImageUpdateAfterBind(Bool32 descriptorBindingSampledImageUpdateAfterBind_)
Definition: vulkan.hpp:17902
PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderStorageBufferArrayNonUniformIndexing(Bool32 shaderStorageBufferArrayNonUniformIndexing_)
Definition: vulkan.hpp:17866
PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderStorageTexelBufferArrayNonUniformIndexing(Bool32 shaderStorageTexelBufferArrayNonUniformIndexing_)
Definition: vulkan.hpp:17890
PhysicalDeviceDescriptorIndexingFeaturesEXT & setShaderInputAttachmentArrayNonUniformIndexing(Bool32 shaderInputAttachmentArrayNonUniformIndexing_)
Definition: vulkan.hpp:17878
PhysicalDeviceDescriptorIndexingFeaturesEXT(Bool32 shaderInputAttachmentArrayDynamicIndexing_=0, Bool32 shaderUniformTexelBufferArrayDynamicIndexing_=0, Bool32 shaderStorageTexelBufferArrayDynamicIndexing_=0, Bool32 shaderUniformBufferArrayNonUniformIndexing_=0, Bool32 shaderSampledImageArrayNonUniformIndexing_=0, Bool32 shaderStorageBufferArrayNonUniformIndexing_=0, Bool32 shaderStorageImageArrayNonUniformIndexing_=0, Bool32 shaderInputAttachmentArrayNonUniformIndexing_=0, Bool32 shaderUniformTexelBufferArrayNonUniformIndexing_=0, Bool32 shaderStorageTexelBufferArrayNonUniformIndexing_=0, Bool32 descriptorBindingUniformBufferUpdateAfterBind_=0, Bool32 descriptorBindingSampledImageUpdateAfterBind_=0, Bool32 descriptorBindingStorageImageUpdateAfterBind_=0, Bool32 descriptorBindingStorageBufferUpdateAfterBind_=0, Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind_=0, Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind_=0, Bool32 descriptorBindingUpdateUnusedWhilePending_=0, Bool32 descriptorBindingPartiallyBound_=0, Bool32 descriptorBindingVariableDescriptorCount_=0, Bool32 runtimeDescriptorArray_=0)
Definition: vulkan.hpp:17777
bool operator!=(PhysicalDeviceDescriptorIndexingPropertiesEXT const &rhs) const
Definition: vulkan.hpp:18066
bool operator==(PhysicalDeviceDescriptorIndexingPropertiesEXT const &rhs) const
Definition: vulkan.hpp:18037
bool operator!=(PhysicalDeviceDiscardRectanglePropertiesEXT const &rhs) const
Definition: vulkan.hpp:15550
PhysicalDeviceDiscardRectanglePropertiesEXT & operator=(VkPhysicalDeviceDiscardRectanglePropertiesEXT const &rhs)
Definition: vulkan.hpp:15516
PhysicalDeviceDiscardRectanglePropertiesEXT(uint32_t maxDiscardRectangles_=0)
Definition: vulkan.hpp:15506
bool operator==(PhysicalDeviceDiscardRectanglePropertiesEXT const &rhs) const
Definition: vulkan.hpp:15543
PhysicalDeviceDiscardRectanglePropertiesEXT & setMaxDiscardRectangles(uint32_t maxDiscardRectangles_)
Definition: vulkan.hpp:15527
PhysicalDeviceDiscardRectanglePropertiesEXT & setPNext(void *pNext_)
Definition: vulkan.hpp:15521
PhysicalDeviceDiscardRectanglePropertiesEXT(VkPhysicalDeviceDiscardRectanglePropertiesEXT const &rhs)
Definition: vulkan.hpp:15511
char driverName[VK_MAX_DRIVER_NAME_SIZE_KHR]
Definition: vulkan.hpp:36402
bool operator==(PhysicalDeviceDriverPropertiesKHR const &rhs) const
Definition: vulkan.hpp:36381
bool operator!=(PhysicalDeviceDriverPropertiesKHR const &rhs) const
Definition: vulkan.hpp:36391
char driverInfo[VK_MAX_DRIVER_INFO_SIZE_KHR]
Definition: vulkan.hpp:36403
bool operator!=(PhysicalDeviceExclusiveScissorFeaturesNV const &rhs) const
Definition: vulkan.hpp:19545
bool operator==(PhysicalDeviceExclusiveScissorFeaturesNV const &rhs) const
Definition: vulkan.hpp:19538
PhysicalDeviceExclusiveScissorFeaturesNV & setPNext(void *pNext_)
Definition: vulkan.hpp:19516
PhysicalDeviceExclusiveScissorFeaturesNV & setExclusiveScissor(Bool32 exclusiveScissor_)
Definition: vulkan.hpp:19522
PhysicalDeviceExclusiveScissorFeaturesNV & operator=(VkPhysicalDeviceExclusiveScissorFeaturesNV const &rhs)
Definition: vulkan.hpp:19511
PhysicalDeviceExclusiveScissorFeaturesNV(VkPhysicalDeviceExclusiveScissorFeaturesNV const &rhs)
Definition: vulkan.hpp:19506
PhysicalDeviceExclusiveScissorFeaturesNV(Bool32 exclusiveScissor_=0)
Definition: vulkan.hpp:19501
ExternalMemoryHandleTypeFlagBits handleType
Definition: vulkan.hpp:31717
PhysicalDeviceExternalBufferInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:31662
PhysicalDeviceExternalBufferInfo(VkPhysicalDeviceExternalBufferInfo const &rhs)
Definition: vulkan.hpp:31652
PhysicalDeviceExternalBufferInfo & setHandleType(ExternalMemoryHandleTypeFlagBits handleType_)
Definition: vulkan.hpp:31680
PhysicalDeviceExternalBufferInfo & setUsage(BufferUsageFlags usage_)
Definition: vulkan.hpp:31674
PhysicalDeviceExternalBufferInfo & setFlags(BufferCreateFlags flags_)
Definition: vulkan.hpp:31668
bool operator!=(PhysicalDeviceExternalBufferInfo const &rhs) const
Definition: vulkan.hpp:31705
PhysicalDeviceExternalBufferInfo(BufferCreateFlags flags_=BufferCreateFlags(), BufferUsageFlags usage_=BufferUsageFlags(), ExternalMemoryHandleTypeFlagBits handleType_=ExternalMemoryHandleTypeFlagBits::eOpaqueFd)
Definition: vulkan.hpp:31643
bool operator==(PhysicalDeviceExternalBufferInfo const &rhs) const
Definition: vulkan.hpp:31696
PhysicalDeviceExternalBufferInfo & operator=(VkPhysicalDeviceExternalBufferInfo const &rhs)
Definition: vulkan.hpp:31657
bool operator==(PhysicalDeviceExternalFenceInfo const &rhs) const
Definition: vulkan.hpp:33071
PhysicalDeviceExternalFenceInfo(VkPhysicalDeviceExternalFenceInfo const &rhs)
Definition: vulkan.hpp:33039
PhysicalDeviceExternalFenceInfo & setHandleType(ExternalFenceHandleTypeFlagBits handleType_)
Definition: vulkan.hpp:33055
ExternalFenceHandleTypeFlagBits handleType
Definition: vulkan.hpp:33088
bool operator!=(PhysicalDeviceExternalFenceInfo const &rhs) const
Definition: vulkan.hpp:33078
PhysicalDeviceExternalFenceInfo(ExternalFenceHandleTypeFlagBits handleType_=ExternalFenceHandleTypeFlagBits::eOpaqueFd)
Definition: vulkan.hpp:33034
PhysicalDeviceExternalFenceInfo & operator=(VkPhysicalDeviceExternalFenceInfo const &rhs)
Definition: vulkan.hpp:33044
PhysicalDeviceExternalFenceInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:33049
bool operator==(PhysicalDeviceExternalImageFormatInfo const &rhs) const
Definition: vulkan.hpp:31618
bool operator!=(PhysicalDeviceExternalImageFormatInfo const &rhs) const
Definition: vulkan.hpp:31625
PhysicalDeviceExternalImageFormatInfo & setHandleType(ExternalMemoryHandleTypeFlagBits handleType_)
Definition: vulkan.hpp:31602
PhysicalDeviceExternalImageFormatInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:31596
PhysicalDeviceExternalImageFormatInfo(ExternalMemoryHandleTypeFlagBits handleType_=ExternalMemoryHandleTypeFlagBits::eOpaqueFd)
Definition: vulkan.hpp:31581
PhysicalDeviceExternalImageFormatInfo(VkPhysicalDeviceExternalImageFormatInfo const &rhs)
Definition: vulkan.hpp:31586
PhysicalDeviceExternalImageFormatInfo & operator=(VkPhysicalDeviceExternalImageFormatInfo const &rhs)
Definition: vulkan.hpp:31591
PhysicalDeviceExternalMemoryHostPropertiesEXT & operator=(VkPhysicalDeviceExternalMemoryHostPropertiesEXT const &rhs)
Definition: vulkan.hpp:17528
bool operator!=(PhysicalDeviceExternalMemoryHostPropertiesEXT const &rhs) const
Definition: vulkan.hpp:17562
PhysicalDeviceExternalMemoryHostPropertiesEXT & setPNext(void *pNext_)
Definition: vulkan.hpp:17533
bool operator==(PhysicalDeviceExternalMemoryHostPropertiesEXT const &rhs) const
Definition: vulkan.hpp:17555
PhysicalDeviceExternalMemoryHostPropertiesEXT & setMinImportedHostPointerAlignment(DeviceSize minImportedHostPointerAlignment_)
Definition: vulkan.hpp:17539
PhysicalDeviceExternalMemoryHostPropertiesEXT(VkPhysicalDeviceExternalMemoryHostPropertiesEXT const &rhs)
Definition: vulkan.hpp:17523
PhysicalDeviceExternalMemoryHostPropertiesEXT(DeviceSize minImportedHostPointerAlignment_=0)
Definition: vulkan.hpp:17518
PhysicalDeviceExternalSemaphoreInfo & operator=(VkPhysicalDeviceExternalSemaphoreInfo const &rhs)
Definition: vulkan.hpp:32455
PhysicalDeviceExternalSemaphoreInfo(VkPhysicalDeviceExternalSemaphoreInfo const &rhs)
Definition: vulkan.hpp:32450
bool operator==(PhysicalDeviceExternalSemaphoreInfo const &rhs) const
Definition: vulkan.hpp:32482
PhysicalDeviceExternalSemaphoreInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:32460
PhysicalDeviceExternalSemaphoreInfo & setHandleType(ExternalSemaphoreHandleTypeFlagBits handleType_)
Definition: vulkan.hpp:32466
PhysicalDeviceExternalSemaphoreInfo(ExternalSemaphoreHandleTypeFlagBits handleType_=ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd)
Definition: vulkan.hpp:32445
bool operator!=(PhysicalDeviceExternalSemaphoreInfo const &rhs) const
Definition: vulkan.hpp:32489
ExternalSemaphoreHandleTypeFlagBits handleType
Definition: vulkan.hpp:32499
PhysicalDeviceFeatures2 & operator=(VkPhysicalDeviceFeatures2 const &rhs)
Definition: vulkan.hpp:13140
PhysicalDeviceFeatures2(VkPhysicalDeviceFeatures2 const &rhs)
Definition: vulkan.hpp:13135
bool operator!=(PhysicalDeviceFeatures2 const &rhs) const
Definition: vulkan.hpp:13174
PhysicalDeviceFeatures2 & setPNext(void *pNext_)
Definition: vulkan.hpp:13145
bool operator==(PhysicalDeviceFeatures2 const &rhs) const
Definition: vulkan.hpp:13167
PhysicalDeviceFeatures2 & setFeatures(PhysicalDeviceFeatures features_)
Definition: vulkan.hpp:13151
PhysicalDeviceFeatures2(PhysicalDeviceFeatures features_=PhysicalDeviceFeatures())
Definition: vulkan.hpp:13130
PhysicalDeviceFeatures & setVertexPipelineStoresAndAtomics(Bool32 vertexPipelineStoresAndAtomics_)
Definition: vulkan.hpp:6499
PhysicalDeviceFeatures & setVariableMultisampleRate(Bool32 variableMultisampleRate_)
Definition: vulkan.hpp:6667
PhysicalDeviceFeatures & setMultiViewport(Bool32 multiViewport_)
Definition: vulkan.hpp:6457
PhysicalDeviceFeatures & setShaderClipDistance(Bool32 shaderClipDistance_)
Definition: vulkan.hpp:6571
PhysicalDeviceFeatures & setInheritedQueries(Bool32 inheritedQueries_)
Definition: vulkan.hpp:6673
PhysicalDeviceFeatures & operator=(VkPhysicalDeviceFeatures const &rhs)
Definition: vulkan.hpp:6344
PhysicalDeviceFeatures & setFragmentStoresAndAtomics(Bool32 fragmentStoresAndAtomics_)
Definition: vulkan.hpp:6505
PhysicalDeviceFeatures & setMultiDrawIndirect(Bool32 multiDrawIndirect_)
Definition: vulkan.hpp:6403
PhysicalDeviceFeatures & setShaderResourceMinLod(Bool32 shaderResourceMinLod_)
Definition: vulkan.hpp:6607
PhysicalDeviceFeatures & setSparseResidency4Samples(Bool32 sparseResidency4Samples_)
Definition: vulkan.hpp:6643
PhysicalDeviceFeatures & setWideLines(Bool32 wideLines_)
Definition: vulkan.hpp:6439
PhysicalDeviceFeatures & setSparseResidencyBuffer(Bool32 sparseResidencyBuffer_)
Definition: vulkan.hpp:6619
PhysicalDeviceFeatures & setShaderSampledImageArrayDynamicIndexing(Bool32 shaderSampledImageArrayDynamicIndexing_)
Definition: vulkan.hpp:6553
PhysicalDeviceFeatures & setLogicOp(Bool32 logicOp_)
Definition: vulkan.hpp:6397
PhysicalDeviceFeatures & setShaderStorageImageWriteWithoutFormat(Bool32 shaderStorageImageWriteWithoutFormat_)
Definition: vulkan.hpp:6541
PhysicalDeviceFeatures & setShaderTessellationAndGeometryPointSize(Bool32 shaderTessellationAndGeometryPointSize_)
Definition: vulkan.hpp:6511
PhysicalDeviceFeatures(Bool32 robustBufferAccess_=0, Bool32 fullDrawIndexUint32_=0, Bool32 imageCubeArray_=0, Bool32 independentBlend_=0, Bool32 geometryShader_=0, Bool32 tessellationShader_=0, Bool32 sampleRateShading_=0, Bool32 dualSrcBlend_=0, Bool32 logicOp_=0, Bool32 multiDrawIndirect_=0, Bool32 drawIndirectFirstInstance_=0, Bool32 depthClamp_=0, Bool32 depthBiasClamp_=0, Bool32 fillModeNonSolid_=0, Bool32 depthBounds_=0, Bool32 wideLines_=0, Bool32 largePoints_=0, Bool32 alphaToOne_=0, Bool32 multiViewport_=0, Bool32 samplerAnisotropy_=0, Bool32 textureCompressionETC2_=0, Bool32 textureCompressionASTC_LDR_=0, Bool32 textureCompressionBC_=0, Bool32 occlusionQueryPrecise_=0, Bool32 pipelineStatisticsQuery_=0, Bool32 vertexPipelineStoresAndAtomics_=0, Bool32 fragmentStoresAndAtomics_=0, Bool32 shaderTessellationAndGeometryPointSize_=0, Bool32 shaderImageGatherExtended_=0, Bool32 shaderStorageImageExtendedFormats_=0, Bool32 shaderStorageImageMultisample_=0, Bool32 shaderStorageImageReadWithoutFormat_=0, Bool32 shaderStorageImageWriteWithoutFormat_=0, Bool32 shaderUniformBufferArrayDynamicIndexing_=0, Bool32 shaderSampledImageArrayDynamicIndexing_=0, Bool32 shaderStorageBufferArrayDynamicIndexing_=0, Bool32 shaderStorageImageArrayDynamicIndexing_=0, Bool32 shaderClipDistance_=0, Bool32 shaderCullDistance_=0, Bool32 shaderFloat64_=0, Bool32 shaderInt64_=0, Bool32 shaderInt16_=0, Bool32 shaderResourceResidency_=0, Bool32 shaderResourceMinLod_=0, Bool32 sparseBinding_=0, Bool32 sparseResidencyBuffer_=0, Bool32 sparseResidencyImage2D_=0, Bool32 sparseResidencyImage3D_=0, Bool32 sparseResidency2Samples_=0, Bool32 sparseResidency4Samples_=0, Bool32 sparseResidency8Samples_=0, Bool32 sparseResidency16Samples_=0, Bool32 sparseResidencyAliased_=0, Bool32 variableMultisampleRate_=0, Bool32 inheritedQueries_=0)
Definition: vulkan.hpp:6226
PhysicalDeviceFeatures & setShaderUniformBufferArrayDynamicIndexing(Bool32 shaderUniformBufferArrayDynamicIndexing_)
Definition: vulkan.hpp:6547
PhysicalDeviceFeatures & setShaderStorageImageArrayDynamicIndexing(Bool32 shaderStorageImageArrayDynamicIndexing_)
Definition: vulkan.hpp:6565
PhysicalDeviceFeatures & setShaderImageGatherExtended(Bool32 shaderImageGatherExtended_)
Definition: vulkan.hpp:6517
PhysicalDeviceFeatures & setShaderInt64(Bool32 shaderInt64_)
Definition: vulkan.hpp:6589
PhysicalDeviceFeatures & setFillModeNonSolid(Bool32 fillModeNonSolid_)
Definition: vulkan.hpp:6427
PhysicalDeviceFeatures & setDepthBiasClamp(Bool32 depthBiasClamp_)
Definition: vulkan.hpp:6421
PhysicalDeviceFeatures & setImageCubeArray(Bool32 imageCubeArray_)
Definition: vulkan.hpp:6361
PhysicalDeviceFeatures & setDepthBounds(Bool32 depthBounds_)
Definition: vulkan.hpp:6433
PhysicalDeviceFeatures & setSampleRateShading(Bool32 sampleRateShading_)
Definition: vulkan.hpp:6385
PhysicalDeviceFeatures & setSparseResidencyImage2D(Bool32 sparseResidencyImage2D_)
Definition: vulkan.hpp:6625
PhysicalDeviceFeatures & setTessellationShader(Bool32 tessellationShader_)
Definition: vulkan.hpp:6379
PhysicalDeviceFeatures & setShaderInt16(Bool32 shaderInt16_)
Definition: vulkan.hpp:6595
PhysicalDeviceFeatures & setShaderResourceResidency(Bool32 shaderResourceResidency_)
Definition: vulkan.hpp:6601
PhysicalDeviceFeatures & setSparseResidency16Samples(Bool32 sparseResidency16Samples_)
Definition: vulkan.hpp:6655
PhysicalDeviceFeatures & setTextureCompressionETC2(Bool32 textureCompressionETC2_)
Definition: vulkan.hpp:6469
PhysicalDeviceFeatures & setTextureCompressionBC(Bool32 textureCompressionBC_)
Definition: vulkan.hpp:6481
PhysicalDeviceFeatures & setDepthClamp(Bool32 depthClamp_)
Definition: vulkan.hpp:6415
PhysicalDeviceFeatures & setIndependentBlend(Bool32 independentBlend_)
Definition: vulkan.hpp:6367
PhysicalDeviceFeatures & setShaderStorageImageExtendedFormats(Bool32 shaderStorageImageExtendedFormats_)
Definition: vulkan.hpp:6523
PhysicalDeviceFeatures & setShaderFloat64(Bool32 shaderFloat64_)
Definition: vulkan.hpp:6583
PhysicalDeviceFeatures & setShaderStorageBufferArrayDynamicIndexing(Bool32 shaderStorageBufferArrayDynamicIndexing_)
Definition: vulkan.hpp:6559
PhysicalDeviceFeatures & setShaderStorageImageReadWithoutFormat(Bool32 shaderStorageImageReadWithoutFormat_)
Definition: vulkan.hpp:6535
PhysicalDeviceFeatures & setAlphaToOne(Bool32 alphaToOne_)
Definition: vulkan.hpp:6451
PhysicalDeviceFeatures & setGeometryShader(Bool32 geometryShader_)
Definition: vulkan.hpp:6373
PhysicalDeviceFeatures & setShaderStorageImageMultisample(Bool32 shaderStorageImageMultisample_)
Definition: vulkan.hpp:6529
bool operator!=(PhysicalDeviceFeatures const &rhs) const
Definition: vulkan.hpp:6748
PhysicalDeviceFeatures & setSparseResidency2Samples(Bool32 sparseResidency2Samples_)
Definition: vulkan.hpp:6637
PhysicalDeviceFeatures & setDrawIndirectFirstInstance(Bool32 drawIndirectFirstInstance_)
Definition: vulkan.hpp:6409
PhysicalDeviceFeatures & setSparseResidencyAliased(Bool32 sparseResidencyAliased_)
Definition: vulkan.hpp:6661
PhysicalDeviceFeatures & setFullDrawIndexUint32(Bool32 fullDrawIndexUint32_)
Definition: vulkan.hpp:6355
PhysicalDeviceFeatures & setDualSrcBlend(Bool32 dualSrcBlend_)
Definition: vulkan.hpp:6391
PhysicalDeviceFeatures & setSparseResidency8Samples(Bool32 sparseResidency8Samples_)
Definition: vulkan.hpp:6649
PhysicalDeviceFeatures & setLargePoints(Bool32 largePoints_)
Definition: vulkan.hpp:6445
PhysicalDeviceFeatures(VkPhysicalDeviceFeatures const &rhs)
Definition: vulkan.hpp:6339
PhysicalDeviceFeatures & setShaderCullDistance(Bool32 shaderCullDistance_)
Definition: vulkan.hpp:6577
PhysicalDeviceFeatures & setSamplerAnisotropy(Bool32 samplerAnisotropy_)
Definition: vulkan.hpp:6463
PhysicalDeviceFeatures & setRobustBufferAccess(Bool32 robustBufferAccess_)
Definition: vulkan.hpp:6349
PhysicalDeviceFeatures & setOcclusionQueryPrecise(Bool32 occlusionQueryPrecise_)
Definition: vulkan.hpp:6487
PhysicalDeviceFeatures & setSparseBinding(Bool32 sparseBinding_)
Definition: vulkan.hpp:6613
bool operator==(PhysicalDeviceFeatures const &rhs) const
Definition: vulkan.hpp:6689
PhysicalDeviceFeatures & setTextureCompressionASTC_LDR(Bool32 textureCompressionASTC_LDR_)
Definition: vulkan.hpp:6475
PhysicalDeviceFeatures & setSparseResidencyImage3D(Bool32 sparseResidencyImage3D_)
Definition: vulkan.hpp:6631
PhysicalDeviceFeatures & setPipelineStatisticsQuery(Bool32 pipelineStatisticsQuery_)
Definition: vulkan.hpp:6493
PhysicalDeviceFragmentShaderBarycentricFeaturesNV(VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const &rhs)
Definition: vulkan.hpp:19766
PhysicalDeviceFragmentShaderBarycentricFeaturesNV & operator=(VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const &rhs)
Definition: vulkan.hpp:19771
PhysicalDeviceFragmentShaderBarycentricFeaturesNV & setPNext(void *pNext_)
Definition: vulkan.hpp:19776
PhysicalDeviceFragmentShaderBarycentricFeaturesNV(Bool32 fragmentShaderBarycentric_=0)
Definition: vulkan.hpp:19761
bool operator==(PhysicalDeviceFragmentShaderBarycentricFeaturesNV const &rhs) const
Definition: vulkan.hpp:19798
PhysicalDeviceFragmentShaderBarycentricFeaturesNV & setFragmentShaderBarycentric(Bool32 fragmentShaderBarycentric_)
Definition: vulkan.hpp:19782
bool operator!=(PhysicalDeviceFragmentShaderBarycentricFeaturesNV const &rhs) const
Definition: vulkan.hpp:19805
bool operator!=(PhysicalDeviceGroupProperties const &rhs) const
Definition: vulkan.hpp:47273
PhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE]
Definition: vulkan.hpp:47284
bool operator==(PhysicalDeviceGroupProperties const &rhs) const
Definition: vulkan.hpp:47264
bool operator!=(PhysicalDeviceIDProperties const &rhs) const
Definition: vulkan.hpp:13415
bool operator==(PhysicalDeviceIDProperties const &rhs) const
Definition: vulkan.hpp:13404
PhysicalDeviceImageDrmFormatModifierInfoEXT & operator=(VkPhysicalDeviceImageDrmFormatModifierInfoEXT const &rhs)
Definition: vulkan.hpp:20861
bool operator==(PhysicalDeviceImageDrmFormatModifierInfoEXT const &rhs) const
Definition: vulkan.hpp:20906
PhysicalDeviceImageDrmFormatModifierInfoEXT & setSharingMode(SharingMode sharingMode_)
Definition: vulkan.hpp:20878
PhysicalDeviceImageDrmFormatModifierInfoEXT & setPQueueFamilyIndices(const uint32_t *pQueueFamilyIndices_)
Definition: vulkan.hpp:20890
PhysicalDeviceImageDrmFormatModifierInfoEXT & setDrmFormatModifier(uint64_t drmFormatModifier_)
Definition: vulkan.hpp:20872
PhysicalDeviceImageDrmFormatModifierInfoEXT(VkPhysicalDeviceImageDrmFormatModifierInfoEXT const &rhs)
Definition: vulkan.hpp:20856
PhysicalDeviceImageDrmFormatModifierInfoEXT & setQueueFamilyIndexCount(uint32_t queueFamilyIndexCount_)
Definition: vulkan.hpp:20884
PhysicalDeviceImageDrmFormatModifierInfoEXT(uint64_t drmFormatModifier_=0, SharingMode sharingMode_=SharingMode::eExclusive, uint32_t queueFamilyIndexCount_=0, const uint32_t *pQueueFamilyIndices_=nullptr)
Definition: vulkan.hpp:20845
bool operator!=(PhysicalDeviceImageDrmFormatModifierInfoEXT const &rhs) const
Definition: vulkan.hpp:20916
PhysicalDeviceImageDrmFormatModifierInfoEXT & setPNext(const void *pNext_)
Definition: vulkan.hpp:20866
bool operator==(PhysicalDeviceImageFormatInfo2 const &rhs) const
Definition: vulkan.hpp:23596
PhysicalDeviceImageFormatInfo2 & setTiling(ImageTiling tiling_)
Definition: vulkan.hpp:23568
PhysicalDeviceImageFormatInfo2(Format format_=Format::eUndefined, ImageType type_=ImageType::e1D, ImageTiling tiling_=ImageTiling::eOptimal, ImageUsageFlags usage_=ImageUsageFlags(), ImageCreateFlags flags_=ImageCreateFlags())
Definition: vulkan.hpp:23527
PhysicalDeviceImageFormatInfo2 & setFlags(ImageCreateFlags flags_)
Definition: vulkan.hpp:23580
PhysicalDeviceImageFormatInfo2(VkPhysicalDeviceImageFormatInfo2 const &rhs)
Definition: vulkan.hpp:23540
bool operator!=(PhysicalDeviceImageFormatInfo2 const &rhs) const
Definition: vulkan.hpp:23607
PhysicalDeviceImageFormatInfo2 & operator=(VkPhysicalDeviceImageFormatInfo2 const &rhs)
Definition: vulkan.hpp:23545
PhysicalDeviceImageFormatInfo2 & setFormat(Format format_)
Definition: vulkan.hpp:23556
PhysicalDeviceImageFormatInfo2 & setType(ImageType type_)
Definition: vulkan.hpp:23562
PhysicalDeviceImageFormatInfo2 & setUsage(ImageUsageFlags usage_)
Definition: vulkan.hpp:23574
PhysicalDeviceImageFormatInfo2 & setPNext(const void *pNext_)
Definition: vulkan.hpp:23550
bool operator!=(PhysicalDeviceInlineUniformBlockFeaturesEXT const &rhs) const
Definition: vulkan.hpp:16858
bool operator==(PhysicalDeviceInlineUniformBlockFeaturesEXT const &rhs) const
Definition: vulkan.hpp:16850
bool operator==(PhysicalDeviceInlineUniformBlockPropertiesEXT const &rhs) const
Definition: vulkan.hpp:16885
bool operator!=(PhysicalDeviceInlineUniformBlockPropertiesEXT const &rhs) const
Definition: vulkan.hpp:16896
bool operator==(PhysicalDeviceLimits const &rhs) const
Definition: vulkan.hpp:27545
SampleCountFlags framebufferNoAttachmentsSampleCounts
Definition: vulkan.hpp:27743
bool operator!=(PhysicalDeviceLimits const &rhs) const
Definition: vulkan.hpp:27655
bool operator!=(PhysicalDeviceMaintenance3Properties const &rhs) const
Definition: vulkan.hpp:17274
bool operator==(PhysicalDeviceMaintenance3Properties const &rhs) const
Definition: vulkan.hpp:17266
bool operator!=(PhysicalDeviceMemoryProperties2 const &rhs) const
Definition: vulkan.hpp:22489
PhysicalDeviceMemoryProperties memoryProperties
Definition: vulkan.hpp:22499
bool operator==(PhysicalDeviceMemoryProperties2 const &rhs) const
Definition: vulkan.hpp:22482
bool operator!=(PhysicalDeviceMemoryProperties const &rhs) const
Definition: vulkan.hpp:22458
bool operator==(PhysicalDeviceMemoryProperties const &rhs) const
Definition: vulkan.hpp:22450
MemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS]
Definition: vulkan.hpp:22466
MemoryType memoryTypes[VK_MAX_MEMORY_TYPES]
Definition: vulkan.hpp:22464
PhysicalDeviceMeshShaderFeaturesNV(VkPhysicalDeviceMeshShaderFeaturesNV const &rhs)
Definition: vulkan.hpp:19995
PhysicalDeviceMeshShaderFeaturesNV & setTaskShader(Bool32 taskShader_)
Definition: vulkan.hpp:20011
bool operator==(PhysicalDeviceMeshShaderFeaturesNV const &rhs) const
Definition: vulkan.hpp:20033
PhysicalDeviceMeshShaderFeaturesNV & operator=(VkPhysicalDeviceMeshShaderFeaturesNV const &rhs)
Definition: vulkan.hpp:20000
PhysicalDeviceMeshShaderFeaturesNV(Bool32 taskShader_=0, Bool32 meshShader_=0)
Definition: vulkan.hpp:19988
bool operator!=(PhysicalDeviceMeshShaderFeaturesNV const &rhs) const
Definition: vulkan.hpp:20041
PhysicalDeviceMeshShaderFeaturesNV & setMeshShader(Bool32 meshShader_)
Definition: vulkan.hpp:20017
PhysicalDeviceMeshShaderFeaturesNV & setPNext(void *pNext_)
Definition: vulkan.hpp:20005
bool operator==(PhysicalDeviceMeshShaderPropertiesNV const &rhs) const
Definition: vulkan.hpp:20191
PhysicalDeviceMeshShaderPropertiesNV(uint32_t maxDrawMeshTasksCount_=0, uint32_t maxTaskWorkGroupInvocations_=0, std::array< uint32_t, 3 > const &maxTaskWorkGroupSize_={ { 0, 0, 0 } }, uint32_t maxTaskTotalMemorySize_=0, uint32_t maxTaskOutputCount_=0, uint32_t maxMeshWorkGroupInvocations_=0, std::array< uint32_t, 3 > const &maxMeshWorkGroupSize_={ { 0, 0, 0 } }, uint32_t maxMeshTotalMemorySize_=0, uint32_t maxMeshOutputVertices_=0, uint32_t maxMeshOutputPrimitives_=0, uint32_t maxMeshMultiviewViewCount_=0, uint32_t meshOutputPerVertexGranularity_=0, uint32_t meshOutputPerPrimitiveGranularity_=0)
Definition: vulkan.hpp:20058
PhysicalDeviceMeshShaderPropertiesNV(VkPhysicalDeviceMeshShaderPropertiesNV const &rhs)
Definition: vulkan.hpp:20087
PhysicalDeviceMeshShaderPropertiesNV & setPNext(void *pNext_)
Definition: vulkan.hpp:20097
PhysicalDeviceMeshShaderPropertiesNV & setMaxMeshMultiviewViewCount(uint32_t maxMeshMultiviewViewCount_)
Definition: vulkan.hpp:20163
PhysicalDeviceMeshShaderPropertiesNV & setMaxMeshWorkGroupSize(std::array< uint32_t, 3 > maxMeshWorkGroupSize_)
Definition: vulkan.hpp:20139
PhysicalDeviceMeshShaderPropertiesNV & setMeshOutputPerPrimitiveGranularity(uint32_t meshOutputPerPrimitiveGranularity_)
Definition: vulkan.hpp:20175
PhysicalDeviceMeshShaderPropertiesNV & setMaxMeshWorkGroupInvocations(uint32_t maxMeshWorkGroupInvocations_)
Definition: vulkan.hpp:20133
PhysicalDeviceMeshShaderPropertiesNV & setMeshOutputPerVertexGranularity(uint32_t meshOutputPerVertexGranularity_)
Definition: vulkan.hpp:20169
PhysicalDeviceMeshShaderPropertiesNV & setMaxMeshOutputPrimitives(uint32_t maxMeshOutputPrimitives_)
Definition: vulkan.hpp:20157
PhysicalDeviceMeshShaderPropertiesNV & operator=(VkPhysicalDeviceMeshShaderPropertiesNV const &rhs)
Definition: vulkan.hpp:20092
PhysicalDeviceMeshShaderPropertiesNV & setMaxMeshTotalMemorySize(uint32_t maxMeshTotalMemorySize_)
Definition: vulkan.hpp:20145
PhysicalDeviceMeshShaderPropertiesNV & setMaxTaskOutputCount(uint32_t maxTaskOutputCount_)
Definition: vulkan.hpp:20127
PhysicalDeviceMeshShaderPropertiesNV & setMaxMeshOutputVertices(uint32_t maxMeshOutputVertices_)
Definition: vulkan.hpp:20151
PhysicalDeviceMeshShaderPropertiesNV & setMaxDrawMeshTasksCount(uint32_t maxDrawMeshTasksCount_)
Definition: vulkan.hpp:20103
PhysicalDeviceMeshShaderPropertiesNV & setMaxTaskWorkGroupSize(std::array< uint32_t, 3 > maxTaskWorkGroupSize_)
Definition: vulkan.hpp:20115
PhysicalDeviceMeshShaderPropertiesNV & setMaxTaskWorkGroupInvocations(uint32_t maxTaskWorkGroupInvocations_)
Definition: vulkan.hpp:20109
bool operator!=(PhysicalDeviceMeshShaderPropertiesNV const &rhs) const
Definition: vulkan.hpp:20210
PhysicalDeviceMeshShaderPropertiesNV & setMaxTaskTotalMemorySize(uint32_t maxTaskTotalMemorySize_)
Definition: vulkan.hpp:20121
PhysicalDeviceMultiviewFeatures(Bool32 multiview_=0, Bool32 multiviewGeometryShader_=0, Bool32 multiviewTessellationShader_=0)
Definition: vulkan.hpp:13965
bool operator==(PhysicalDeviceMultiviewFeatures const &rhs) const
Definition: vulkan.hpp:14018
PhysicalDeviceMultiviewFeatures & setMultiviewGeometryShader(Bool32 multiviewGeometryShader_)
Definition: vulkan.hpp:13996
bool operator!=(PhysicalDeviceMultiviewFeatures const &rhs) const
Definition: vulkan.hpp:14027
PhysicalDeviceMultiviewFeatures(VkPhysicalDeviceMultiviewFeatures const &rhs)
Definition: vulkan.hpp:13974
PhysicalDeviceMultiviewFeatures & setPNext(void *pNext_)
Definition: vulkan.hpp:13984
PhysicalDeviceMultiviewFeatures & operator=(VkPhysicalDeviceMultiviewFeatures const &rhs)
Definition: vulkan.hpp:13979
PhysicalDeviceMultiviewFeatures & setMultiviewTessellationShader(Bool32 multiviewTessellationShader_)
Definition: vulkan.hpp:14002
PhysicalDeviceMultiviewFeatures & setMultiview(Bool32 multiview_)
Definition: vulkan.hpp:13990
bool operator!=(PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const &rhs) const
Definition: vulkan.hpp:15583
bool operator==(PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const &rhs) const
Definition: vulkan.hpp:15576
bool operator!=(PhysicalDeviceMultiviewProperties const &rhs) const
Definition: vulkan.hpp:14065
bool operator==(PhysicalDeviceMultiviewProperties const &rhs) const
Definition: vulkan.hpp:14057
bool operator==(PhysicalDevicePCIBusInfoPropertiesEXT const &rhs) const
Definition: vulkan.hpp:18398
bool operator!=(PhysicalDevicePCIBusInfoPropertiesEXT const &rhs) const
Definition: vulkan.hpp:18408
bool operator==(PhysicalDevicePointClippingProperties const &rhs) const
Definition: vulkan.hpp:35363
bool operator!=(PhysicalDevicePointClippingProperties const &rhs) const
Definition: vulkan.hpp:35370
bool operator!=(PhysicalDeviceProperties2 const &rhs) const
Definition: vulkan.hpp:27830
bool operator==(PhysicalDeviceProperties2 const &rhs) const
Definition: vulkan.hpp:27823
char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]
Definition: vulkan.hpp:27804
PhysicalDeviceSparseProperties sparseProperties
Definition: vulkan.hpp:27807
bool operator!=(PhysicalDeviceProperties const &rhs) const
Definition: vulkan.hpp:27794
bool operator==(PhysicalDeviceProperties const &rhs) const
Definition: vulkan.hpp:27781
PhysicalDeviceProtectedMemoryFeatures(VkPhysicalDeviceProtectedMemoryFeatures const &rhs)
Definition: vulkan.hpp:16474
PhysicalDeviceProtectedMemoryFeatures & setProtectedMemory(Bool32 protectedMemory_)
Definition: vulkan.hpp:16490
PhysicalDeviceProtectedMemoryFeatures & operator=(VkPhysicalDeviceProtectedMemoryFeatures const &rhs)
Definition: vulkan.hpp:16479
PhysicalDeviceProtectedMemoryFeatures(Bool32 protectedMemory_=0)
Definition: vulkan.hpp:16469
bool operator!=(PhysicalDeviceProtectedMemoryFeatures const &rhs) const
Definition: vulkan.hpp:16513
PhysicalDeviceProtectedMemoryFeatures & setPNext(void *pNext_)
Definition: vulkan.hpp:16484
bool operator==(PhysicalDeviceProtectedMemoryFeatures const &rhs) const
Definition: vulkan.hpp:16506
PhysicalDeviceProtectedMemoryProperties(Bool32 protectedNoFault_=0)
Definition: vulkan.hpp:16529
PhysicalDeviceProtectedMemoryProperties & setPNext(void *pNext_)
Definition: vulkan.hpp:16544
PhysicalDeviceProtectedMemoryProperties(VkPhysicalDeviceProtectedMemoryProperties const &rhs)
Definition: vulkan.hpp:16534
PhysicalDeviceProtectedMemoryProperties & operator=(VkPhysicalDeviceProtectedMemoryProperties const &rhs)
Definition: vulkan.hpp:16539
bool operator==(PhysicalDeviceProtectedMemoryProperties const &rhs) const
Definition: vulkan.hpp:16566
PhysicalDeviceProtectedMemoryProperties & setProtectedNoFault(Bool32 protectedNoFault_)
Definition: vulkan.hpp:16550
bool operator!=(PhysicalDeviceProtectedMemoryProperties const &rhs) const
Definition: vulkan.hpp:16573
PhysicalDevicePushDescriptorPropertiesKHR(VkPhysicalDevicePushDescriptorPropertiesKHR const &rhs)
Definition: vulkan.hpp:13197
bool operator!=(PhysicalDevicePushDescriptorPropertiesKHR const &rhs) const
Definition: vulkan.hpp:13236
PhysicalDevicePushDescriptorPropertiesKHR(uint32_t maxPushDescriptors_=0)
Definition: vulkan.hpp:13192
bool operator==(PhysicalDevicePushDescriptorPropertiesKHR const &rhs) const
Definition: vulkan.hpp:13229
PhysicalDevicePushDescriptorPropertiesKHR & setMaxPushDescriptors(uint32_t maxPushDescriptors_)
Definition: vulkan.hpp:13213
PhysicalDevicePushDescriptorPropertiesKHR & setPNext(void *pNext_)
Definition: vulkan.hpp:13207
PhysicalDevicePushDescriptorPropertiesKHR & operator=(VkPhysicalDevicePushDescriptorPropertiesKHR const &rhs)
Definition: vulkan.hpp:13202
bool operator==(PhysicalDeviceRayTracingPropertiesNV const &rhs) const
Definition: vulkan.hpp:20808
PhysicalDeviceRayTracingPropertiesNV & setPNext(void *pNext_)
Definition: vulkan.hpp:20744
PhysicalDeviceRayTracingPropertiesNV & setMaxInstanceCount(uint64_t maxInstanceCount_)
Definition: vulkan.hpp:20780
bool operator!=(PhysicalDeviceRayTracingPropertiesNV const &rhs) const
Definition: vulkan.hpp:20822
PhysicalDeviceRayTracingPropertiesNV & setMaxRecursionDepth(uint32_t maxRecursionDepth_)
Definition: vulkan.hpp:20756
PhysicalDeviceRayTracingPropertiesNV & setShaderGroupHandleSize(uint32_t shaderGroupHandleSize_)
Definition: vulkan.hpp:20750
PhysicalDeviceRayTracingPropertiesNV & operator=(VkPhysicalDeviceRayTracingPropertiesNV const &rhs)
Definition: vulkan.hpp:20739
PhysicalDeviceRayTracingPropertiesNV & setMaxShaderGroupStride(uint32_t maxShaderGroupStride_)
Definition: vulkan.hpp:20762
PhysicalDeviceRayTracingPropertiesNV & setMaxDescriptorSetAccelerationStructures(uint32_t maxDescriptorSetAccelerationStructures_)
Definition: vulkan.hpp:20792
PhysicalDeviceRayTracingPropertiesNV & setShaderGroupBaseAlignment(uint32_t shaderGroupBaseAlignment_)
Definition: vulkan.hpp:20768
PhysicalDeviceRayTracingPropertiesNV & setMaxGeometryCount(uint64_t maxGeometryCount_)
Definition: vulkan.hpp:20774
PhysicalDeviceRayTracingPropertiesNV & setMaxTriangleCount(uint64_t maxTriangleCount_)
Definition: vulkan.hpp:20786
PhysicalDeviceRayTracingPropertiesNV(uint32_t shaderGroupHandleSize_=0, uint32_t maxRecursionDepth_=0, uint32_t maxShaderGroupStride_=0, uint32_t shaderGroupBaseAlignment_=0, uint64_t maxGeometryCount_=0, uint64_t maxInstanceCount_=0, uint64_t maxTriangleCount_=0, uint32_t maxDescriptorSetAccelerationStructures_=0)
Definition: vulkan.hpp:20715
PhysicalDeviceRayTracingPropertiesNV(VkPhysicalDeviceRayTracingPropertiesNV const &rhs)
Definition: vulkan.hpp:20734
PhysicalDeviceRepresentativeFragmentTestFeaturesNV(VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const &rhs)
Definition: vulkan.hpp:19386
PhysicalDeviceRepresentativeFragmentTestFeaturesNV(Bool32 representativeFragmentTest_=0)
Definition: vulkan.hpp:19381
bool operator!=(PhysicalDeviceRepresentativeFragmentTestFeaturesNV const &rhs) const
Definition: vulkan.hpp:19425
PhysicalDeviceRepresentativeFragmentTestFeaturesNV & operator=(VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const &rhs)
Definition: vulkan.hpp:19391
bool operator==(PhysicalDeviceRepresentativeFragmentTestFeaturesNV const &rhs) const
Definition: vulkan.hpp:19418
PhysicalDeviceRepresentativeFragmentTestFeaturesNV & setPNext(void *pNext_)
Definition: vulkan.hpp:19396
PhysicalDeviceRepresentativeFragmentTestFeaturesNV & setRepresentativeFragmentTest(Bool32 representativeFragmentTest_)
Definition: vulkan.hpp:19402
bool operator!=(PhysicalDeviceSampleLocationsPropertiesEXT const &rhs) const
Definition: vulkan.hpp:28370
bool operator==(PhysicalDeviceSampleLocationsPropertiesEXT const &rhs) const
Definition: vulkan.hpp:28359
bool operator==(PhysicalDeviceSamplerFilterMinmaxPropertiesEXT const &rhs) const
Definition: vulkan.hpp:16679
bool operator!=(PhysicalDeviceSamplerFilterMinmaxPropertiesEXT const &rhs) const
Definition: vulkan.hpp:16687
PhysicalDeviceSamplerYcbcrConversionFeatures & setPNext(void *pNext_)
Definition: vulkan.hpp:16294
bool operator!=(PhysicalDeviceSamplerYcbcrConversionFeatures const &rhs) const
Definition: vulkan.hpp:16323
PhysicalDeviceSamplerYcbcrConversionFeatures & operator=(VkPhysicalDeviceSamplerYcbcrConversionFeatures const &rhs)
Definition: vulkan.hpp:16289
PhysicalDeviceSamplerYcbcrConversionFeatures(VkPhysicalDeviceSamplerYcbcrConversionFeatures const &rhs)
Definition: vulkan.hpp:16284
PhysicalDeviceSamplerYcbcrConversionFeatures & setSamplerYcbcrConversion(Bool32 samplerYcbcrConversion_)
Definition: vulkan.hpp:16300
PhysicalDeviceSamplerYcbcrConversionFeatures(Bool32 samplerYcbcrConversion_=0)
Definition: vulkan.hpp:16279
bool operator==(PhysicalDeviceSamplerYcbcrConversionFeatures const &rhs) const
Definition: vulkan.hpp:16316
PhysicalDeviceShaderAtomicInt64FeaturesKHR(Bool32 shaderBufferInt64Atomics_=0, Bool32 shaderSharedInt64Atomics_=0)
Definition: vulkan.hpp:18930
PhysicalDeviceShaderAtomicInt64FeaturesKHR & setShaderSharedInt64Atomics(Bool32 shaderSharedInt64Atomics_)
Definition: vulkan.hpp:18959
PhysicalDeviceShaderAtomicInt64FeaturesKHR & setPNext(void *pNext_)
Definition: vulkan.hpp:18947
bool operator==(PhysicalDeviceShaderAtomicInt64FeaturesKHR const &rhs) const
Definition: vulkan.hpp:18975
bool operator!=(PhysicalDeviceShaderAtomicInt64FeaturesKHR const &rhs) const
Definition: vulkan.hpp:18983
PhysicalDeviceShaderAtomicInt64FeaturesKHR & setShaderBufferInt64Atomics(Bool32 shaderBufferInt64Atomics_)
Definition: vulkan.hpp:18953
PhysicalDeviceShaderAtomicInt64FeaturesKHR(VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const &rhs)
Definition: vulkan.hpp:18937
PhysicalDeviceShaderAtomicInt64FeaturesKHR & operator=(VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const &rhs)
Definition: vulkan.hpp:18942
bool operator==(PhysicalDeviceShaderCorePropertiesAMD const &rhs) const
Definition: vulkan.hpp:17728
bool operator!=(PhysicalDeviceShaderCorePropertiesAMD const &rhs) const
Definition: vulkan.hpp:17748
bool operator==(PhysicalDeviceShaderDrawParameterFeatures const &rhs) const
Definition: vulkan.hpp:17365
PhysicalDeviceShaderDrawParameterFeatures & operator=(VkPhysicalDeviceShaderDrawParameterFeatures const &rhs)
Definition: vulkan.hpp:17338
PhysicalDeviceShaderDrawParameterFeatures & setShaderDrawParameters(Bool32 shaderDrawParameters_)
Definition: vulkan.hpp:17349
PhysicalDeviceShaderDrawParameterFeatures(Bool32 shaderDrawParameters_=0)
Definition: vulkan.hpp:17328
PhysicalDeviceShaderDrawParameterFeatures & setPNext(void *pNext_)
Definition: vulkan.hpp:17343
bool operator!=(PhysicalDeviceShaderDrawParameterFeatures const &rhs) const
Definition: vulkan.hpp:17372
PhysicalDeviceShaderDrawParameterFeatures(VkPhysicalDeviceShaderDrawParameterFeatures const &rhs)
Definition: vulkan.hpp:17333
bool operator==(PhysicalDeviceShaderImageFootprintFeaturesNV const &rhs) const
Definition: vulkan.hpp:19858
PhysicalDeviceShaderImageFootprintFeaturesNV & setPNext(void *pNext_)
Definition: vulkan.hpp:19836
PhysicalDeviceShaderImageFootprintFeaturesNV & operator=(VkPhysicalDeviceShaderImageFootprintFeaturesNV const &rhs)
Definition: vulkan.hpp:19831
bool operator!=(PhysicalDeviceShaderImageFootprintFeaturesNV const &rhs) const
Definition: vulkan.hpp:19865
PhysicalDeviceShaderImageFootprintFeaturesNV(VkPhysicalDeviceShaderImageFootprintFeaturesNV const &rhs)
Definition: vulkan.hpp:19826
PhysicalDeviceShaderImageFootprintFeaturesNV & setImageFootprint(Bool32 imageFootprint_)
Definition: vulkan.hpp:19842
PhysicalDeviceShadingRateImageFeaturesNV & setPNext(void *pNext_)
Definition: vulkan.hpp:19898
PhysicalDeviceShadingRateImageFeaturesNV(VkPhysicalDeviceShadingRateImageFeaturesNV const &rhs)
Definition: vulkan.hpp:19888
PhysicalDeviceShadingRateImageFeaturesNV & setShadingRateCoarseSampleOrder(Bool32 shadingRateCoarseSampleOrder_)
Definition: vulkan.hpp:19910
PhysicalDeviceShadingRateImageFeaturesNV & operator=(VkPhysicalDeviceShadingRateImageFeaturesNV const &rhs)
Definition: vulkan.hpp:19893
PhysicalDeviceShadingRateImageFeaturesNV & setShadingRateImage(Bool32 shadingRateImage_)
Definition: vulkan.hpp:19904
bool operator==(PhysicalDeviceShadingRateImageFeaturesNV const &rhs) const
Definition: vulkan.hpp:19926
PhysicalDeviceShadingRateImageFeaturesNV(Bool32 shadingRateImage_=0, Bool32 shadingRateCoarseSampleOrder_=0)
Definition: vulkan.hpp:19881
bool operator!=(PhysicalDeviceShadingRateImageFeaturesNV const &rhs) const
Definition: vulkan.hpp:19934
bool operator!=(PhysicalDeviceShadingRateImagePropertiesNV const &rhs) const
Definition: vulkan.hpp:19970
bool operator==(PhysicalDeviceShadingRateImagePropertiesNV const &rhs) const
Definition: vulkan.hpp:19961
bool operator!=(PhysicalDeviceSparseImageFormatInfo2 const &rhs) const
Definition: vulkan.hpp:27963
PhysicalDeviceSparseImageFormatInfo2 & setType(ImageType type_)
Definition: vulkan.hpp:27918
PhysicalDeviceSparseImageFormatInfo2(Format format_=Format::eUndefined, ImageType type_=ImageType::e1D, SampleCountFlagBits samples_=SampleCountFlagBits::e1, ImageUsageFlags usage_=ImageUsageFlags(), ImageTiling tiling_=ImageTiling::eOptimal)
Definition: vulkan.hpp:27883
PhysicalDeviceSparseImageFormatInfo2 & setUsage(ImageUsageFlags usage_)
Definition: vulkan.hpp:27930
PhysicalDeviceSparseImageFormatInfo2 & operator=(VkPhysicalDeviceSparseImageFormatInfo2 const &rhs)
Definition: vulkan.hpp:27901
bool operator==(PhysicalDeviceSparseImageFormatInfo2 const &rhs) const
Definition: vulkan.hpp:27952
PhysicalDeviceSparseImageFormatInfo2 & setTiling(ImageTiling tiling_)
Definition: vulkan.hpp:27936
PhysicalDeviceSparseImageFormatInfo2 & setFormat(Format format_)
Definition: vulkan.hpp:27912
PhysicalDeviceSparseImageFormatInfo2 & setSamples(SampleCountFlagBits samples_)
Definition: vulkan.hpp:27924
PhysicalDeviceSparseImageFormatInfo2 & setPNext(const void *pNext_)
Definition: vulkan.hpp:27906
PhysicalDeviceSparseImageFormatInfo2(VkPhysicalDeviceSparseImageFormatInfo2 const &rhs)
Definition: vulkan.hpp:27896
bool operator==(PhysicalDeviceSparseProperties const &rhs) const
Definition: vulkan.hpp:6823
bool operator!=(PhysicalDeviceSparseProperties const &rhs) const
Definition: vulkan.hpp:6832
bool operator==(PhysicalDeviceSubgroupProperties const &rhs) const
Definition: vulkan.hpp:30490
bool operator!=(PhysicalDeviceSubgroupProperties const &rhs) const
Definition: vulkan.hpp:30500
bool operator==(PhysicalDeviceSurfaceInfo2KHR const &rhs) const
Definition: vulkan.hpp:15636
PhysicalDeviceSurfaceInfo2KHR & setPNext(const void *pNext_)
Definition: vulkan.hpp:15614
PhysicalDeviceSurfaceInfo2KHR & operator=(VkPhysicalDeviceSurfaceInfo2KHR const &rhs)
Definition: vulkan.hpp:15609
PhysicalDeviceSurfaceInfo2KHR(VkPhysicalDeviceSurfaceInfo2KHR const &rhs)
Definition: vulkan.hpp:15604
PhysicalDeviceSurfaceInfo2KHR & setSurface(SurfaceKHR surface_)
Definition: vulkan.hpp:15620
bool operator!=(PhysicalDeviceSurfaceInfo2KHR const &rhs) const
Definition: vulkan.hpp:15643
PhysicalDeviceSurfaceInfo2KHR(SurfaceKHR surface_=SurfaceKHR())
Definition: vulkan.hpp:15599
bool operator!=(PhysicalDeviceTransformFeedbackFeaturesEXT const &rhs) const
Definition: vulkan.hpp:19243
bool operator==(PhysicalDeviceTransformFeedbackFeaturesEXT const &rhs) const
Definition: vulkan.hpp:19235
PhysicalDeviceTransformFeedbackFeaturesEXT & setGeometryStreams(Bool32 geometryStreams_)
Definition: vulkan.hpp:19219
PhysicalDeviceTransformFeedbackFeaturesEXT(VkPhysicalDeviceTransformFeedbackFeaturesEXT const &rhs)
Definition: vulkan.hpp:19197
PhysicalDeviceTransformFeedbackFeaturesEXT & setPNext(void *pNext_)
Definition: vulkan.hpp:19207
PhysicalDeviceTransformFeedbackFeaturesEXT(Bool32 transformFeedback_=0, Bool32 geometryStreams_=0)
Definition: vulkan.hpp:19190
PhysicalDeviceTransformFeedbackFeaturesEXT & setTransformFeedback(Bool32 transformFeedback_)
Definition: vulkan.hpp:19213
PhysicalDeviceTransformFeedbackFeaturesEXT & operator=(VkPhysicalDeviceTransformFeedbackFeaturesEXT const &rhs)
Definition: vulkan.hpp:19202
bool operator==(PhysicalDeviceTransformFeedbackPropertiesEXT const &rhs) const
Definition: vulkan.hpp:19270
bool operator!=(PhysicalDeviceTransformFeedbackPropertiesEXT const &rhs) const
Definition: vulkan.hpp:19286
bool operator==(PhysicalDeviceVariablePointerFeatures const &rhs) const
Definition: vulkan.hpp:13367
PhysicalDeviceVariablePointerFeatures & operator=(VkPhysicalDeviceVariablePointerFeatures const &rhs)
Definition: vulkan.hpp:13334
PhysicalDeviceVariablePointerFeatures(Bool32 variablePointersStorageBuffer_=0, Bool32 variablePointers_=0)
Definition: vulkan.hpp:13322
PhysicalDeviceVariablePointerFeatures & setVariablePointersStorageBuffer(Bool32 variablePointersStorageBuffer_)
Definition: vulkan.hpp:13345
PhysicalDeviceVariablePointerFeatures & setVariablePointers(Bool32 variablePointers_)
Definition: vulkan.hpp:13351
PhysicalDeviceVariablePointerFeatures & setPNext(void *pNext_)
Definition: vulkan.hpp:13339
PhysicalDeviceVariablePointerFeatures(VkPhysicalDeviceVariablePointerFeatures const &rhs)
Definition: vulkan.hpp:13329
bool operator!=(PhysicalDeviceVariablePointerFeatures const &rhs) const
Definition: vulkan.hpp:13375
bool operator!=(PhysicalDeviceVertexAttributeDivisorFeaturesEXT const &rhs) const
Definition: vulkan.hpp:19053
bool operator==(PhysicalDeviceVertexAttributeDivisorFeaturesEXT const &rhs) const
Definition: vulkan.hpp:19045
PhysicalDeviceVertexAttributeDivisorFeaturesEXT & operator=(VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const &rhs)
Definition: vulkan.hpp:19012
PhysicalDeviceVertexAttributeDivisorFeaturesEXT & setVertexAttributeInstanceRateZeroDivisor(Bool32 vertexAttributeInstanceRateZeroDivisor_)
Definition: vulkan.hpp:19029
PhysicalDeviceVertexAttributeDivisorFeaturesEXT(Bool32 vertexAttributeInstanceRateDivisor_=0, Bool32 vertexAttributeInstanceRateZeroDivisor_=0)
Definition: vulkan.hpp:19000
PhysicalDeviceVertexAttributeDivisorFeaturesEXT & setPNext(void *pNext_)
Definition: vulkan.hpp:19017
PhysicalDeviceVertexAttributeDivisorFeaturesEXT & setVertexAttributeInstanceRateDivisor(Bool32 vertexAttributeInstanceRateDivisor_)
Definition: vulkan.hpp:19023
PhysicalDeviceVertexAttributeDivisorFeaturesEXT(VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const &rhs)
Definition: vulkan.hpp:19007
PhysicalDeviceVertexAttributeDivisorPropertiesEXT & operator=(VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const &rhs)
Definition: vulkan.hpp:18338
PhysicalDeviceVertexAttributeDivisorPropertiesEXT(uint32_t maxVertexAttribDivisor_=0)
Definition: vulkan.hpp:18328
PhysicalDeviceVertexAttributeDivisorPropertiesEXT(VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const &rhs)
Definition: vulkan.hpp:18333
PhysicalDeviceVertexAttributeDivisorPropertiesEXT & setMaxVertexAttribDivisor(uint32_t maxVertexAttribDivisor_)
Definition: vulkan.hpp:18349
bool operator!=(PhysicalDeviceVertexAttributeDivisorPropertiesEXT const &rhs) const
Definition: vulkan.hpp:18372
PhysicalDeviceVertexAttributeDivisorPropertiesEXT & setPNext(void *pNext_)
Definition: vulkan.hpp:18343
bool operator==(PhysicalDeviceVertexAttributeDivisorPropertiesEXT const &rhs) const
Definition: vulkan.hpp:18365
bool operator!=(PhysicalDeviceVulkanMemoryModelFeaturesKHR const &rhs) const
Definition: vulkan.hpp:18913
bool operator==(PhysicalDeviceVulkanMemoryModelFeaturesKHR const &rhs) const
Definition: vulkan.hpp:18905
PipelineCacheCreateInfo(PipelineCacheCreateFlags flags_=PipelineCacheCreateFlags(), size_t initialDataSize_=0, const void *pInitialData_=nullptr)
Definition: vulkan.hpp:11032
PipelineCacheCreateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:11051
PipelineCacheCreateInfo & setFlags(PipelineCacheCreateFlags flags_)
Definition: vulkan.hpp:11057
PipelineCacheCreateInfo & operator=(VkPipelineCacheCreateInfo const &rhs)
Definition: vulkan.hpp:11046
bool operator==(PipelineCacheCreateInfo const &rhs) const
Definition: vulkan.hpp:11085
PipelineCacheCreateInfo & setPInitialData(const void *pInitialData_)
Definition: vulkan.hpp:11069
bool operator!=(PipelineCacheCreateInfo const &rhs) const
Definition: vulkan.hpp:11094
PipelineCacheCreateInfo(VkPipelineCacheCreateInfo const &rhs)
Definition: vulkan.hpp:11041
PipelineCacheCreateInfo & setInitialDataSize(size_t initialDataSize_)
Definition: vulkan.hpp:11063
PipelineColorBlendAdvancedStateCreateInfoEXT(Bool32 srcPremultiplied_=0, Bool32 dstPremultiplied_=0, BlendOverlapEXT blendOverlap_=BlendOverlapEXT::eUncorrelated)
Definition: vulkan.hpp:35743
PipelineColorBlendAdvancedStateCreateInfoEXT & setDstPremultiplied(Bool32 dstPremultiplied_)
Definition: vulkan.hpp:35774
bool operator!=(PipelineColorBlendAdvancedStateCreateInfoEXT const &rhs) const
Definition: vulkan.hpp:35805
PipelineColorBlendAdvancedStateCreateInfoEXT & setBlendOverlap(BlendOverlapEXT blendOverlap_)
Definition: vulkan.hpp:35780
PipelineColorBlendAdvancedStateCreateInfoEXT & operator=(VkPipelineColorBlendAdvancedStateCreateInfoEXT const &rhs)
Definition: vulkan.hpp:35757
PipelineColorBlendAdvancedStateCreateInfoEXT & setPNext(const void *pNext_)
Definition: vulkan.hpp:35762
bool operator==(PipelineColorBlendAdvancedStateCreateInfoEXT const &rhs) const
Definition: vulkan.hpp:35796
PipelineColorBlendAdvancedStateCreateInfoEXT(VkPipelineColorBlendAdvancedStateCreateInfoEXT const &rhs)
Definition: vulkan.hpp:35752
PipelineColorBlendAdvancedStateCreateInfoEXT & setSrcPremultiplied(Bool32 srcPremultiplied_)
Definition: vulkan.hpp:35768
PipelineColorBlendAttachmentState & setDstAlphaBlendFactor(BlendFactor dstAlphaBlendFactor_)
Definition: vulkan.hpp:23848
bool operator!=(PipelineColorBlendAttachmentState const &rhs) const
Definition: vulkan.hpp:23888
PipelineColorBlendAttachmentState & operator=(VkPipelineColorBlendAttachmentState const &rhs)
Definition: vulkan.hpp:23813
PipelineColorBlendAttachmentState & setColorWriteMask(ColorComponentFlags colorWriteMask_)
Definition: vulkan.hpp:23860
bool operator==(PipelineColorBlendAttachmentState const &rhs) const
Definition: vulkan.hpp:23876
PipelineColorBlendAttachmentState & setDstColorBlendFactor(BlendFactor dstColorBlendFactor_)
Definition: vulkan.hpp:23830
PipelineColorBlendAttachmentState & setSrcAlphaBlendFactor(BlendFactor srcAlphaBlendFactor_)
Definition: vulkan.hpp:23842
PipelineColorBlendAttachmentState(VkPipelineColorBlendAttachmentState const &rhs)
Definition: vulkan.hpp:23808
PipelineColorBlendAttachmentState & setColorBlendOp(BlendOp colorBlendOp_)
Definition: vulkan.hpp:23836
PipelineColorBlendAttachmentState(Bool32 blendEnable_=0, BlendFactor srcColorBlendFactor_=BlendFactor::eZero, BlendFactor dstColorBlendFactor_=BlendFactor::eZero, BlendOp colorBlendOp_=BlendOp::eAdd, BlendFactor srcAlphaBlendFactor_=BlendFactor::eZero, BlendFactor dstAlphaBlendFactor_=BlendFactor::eZero, BlendOp alphaBlendOp_=BlendOp::eAdd, ColorComponentFlags colorWriteMask_=ColorComponentFlags())
Definition: vulkan.hpp:23789
PipelineColorBlendAttachmentState & setBlendEnable(Bool32 blendEnable_)
Definition: vulkan.hpp:23818
PipelineColorBlendAttachmentState & setAlphaBlendOp(BlendOp alphaBlendOp_)
Definition: vulkan.hpp:23854
PipelineColorBlendAttachmentState & setSrcColorBlendFactor(BlendFactor srcColorBlendFactor_)
Definition: vulkan.hpp:23824
PipelineColorBlendStateCreateInfo & setBlendConstants(std::array< float, 4 > blendConstants_)
Definition: vulkan.hpp:23967
PipelineColorBlendStateCreateInfo & operator=(VkPipelineColorBlendStateCreateInfo const &rhs)
Definition: vulkan.hpp:23926
bool operator!=(PipelineColorBlendStateCreateInfo const &rhs) const
Definition: vulkan.hpp:23995
PipelineColorBlendStateCreateInfo & setFlags(PipelineColorBlendStateCreateFlags flags_)
Definition: vulkan.hpp:23937
bool operator==(PipelineColorBlendStateCreateInfo const &rhs) const
Definition: vulkan.hpp:23983
PipelineColorBlendStateCreateInfo & setLogicOp(LogicOp logicOp_)
Definition: vulkan.hpp:23949
const PipelineColorBlendAttachmentState * pAttachments
Definition: vulkan.hpp:24009
PipelineColorBlendStateCreateInfo(PipelineColorBlendStateCreateFlags flags_=PipelineColorBlendStateCreateFlags(), Bool32 logicOpEnable_=0, LogicOp logicOp_=LogicOp::eClear, uint32_t attachmentCount_=0, const PipelineColorBlendAttachmentState *pAttachments_=nullptr, std::array< float, 4 > const &blendConstants_={ { 0, 0, 0, 0 } })
Definition: vulkan.hpp:23906
PipelineColorBlendStateCreateInfo(VkPipelineColorBlendStateCreateInfo const &rhs)
Definition: vulkan.hpp:23921
PipelineColorBlendStateCreateInfo & setLogicOpEnable(Bool32 logicOpEnable_)
Definition: vulkan.hpp:23943
PipelineColorBlendStateCreateInfo & setAttachmentCount(uint32_t attachmentCount_)
Definition: vulkan.hpp:23955
PipelineColorBlendStateCreateInfo & setPAttachments(const PipelineColorBlendAttachmentState *pAttachments_)
Definition: vulkan.hpp:23961
PipelineColorBlendStateCreateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:23931
PipelineColorBlendStateCreateFlags flags
Definition: vulkan.hpp:24005
PipelineCoverageModulationStateCreateInfoNV & setPCoverageModulationTable(const float *pCoverageModulationTable_)
Definition: vulkan.hpp:35884
PipelineCoverageModulationStateCreateInfoNV & setCoverageModulationTableCount(uint32_t coverageModulationTableCount_)
Definition: vulkan.hpp:35878
PipelineCoverageModulationStateCreateInfoNV & setFlags(PipelineCoverageModulationStateCreateFlagsNV flags_)
Definition: vulkan.hpp:35860
bool operator==(PipelineCoverageModulationStateCreateInfoNV const &rhs) const
Definition: vulkan.hpp:35900
PipelineCoverageModulationStateCreateInfoNV(PipelineCoverageModulationStateCreateFlagsNV flags_=PipelineCoverageModulationStateCreateFlagsNV(), CoverageModulationModeNV coverageModulationMode_=CoverageModulationModeNV::eNone, Bool32 coverageModulationTableEnable_=0, uint32_t coverageModulationTableCount_=0, const float *pCoverageModulationTable_=nullptr)
Definition: vulkan.hpp:35831
PipelineCoverageModulationStateCreateInfoNV & operator=(VkPipelineCoverageModulationStateCreateInfoNV const &rhs)
Definition: vulkan.hpp:35849
PipelineCoverageModulationStateCreateInfoNV & setPNext(const void *pNext_)
Definition: vulkan.hpp:35854
PipelineCoverageModulationStateCreateFlagsNV flags
Definition: vulkan.hpp:35921
PipelineCoverageModulationStateCreateInfoNV & setCoverageModulationMode(CoverageModulationModeNV coverageModulationMode_)
Definition: vulkan.hpp:35866
PipelineCoverageModulationStateCreateInfoNV(VkPipelineCoverageModulationStateCreateInfoNV const &rhs)
Definition: vulkan.hpp:35844
PipelineCoverageModulationStateCreateInfoNV & setCoverageModulationTableEnable(Bool32 coverageModulationTableEnable_)
Definition: vulkan.hpp:35872
bool operator!=(PipelineCoverageModulationStateCreateInfoNV const &rhs) const
Definition: vulkan.hpp:35911
PipelineCoverageToColorStateCreateInfoNV & setCoverageToColorEnable(Bool32 coverageToColorEnable_)
Definition: vulkan.hpp:16620
bool operator==(PipelineCoverageToColorStateCreateInfoNV const &rhs) const
Definition: vulkan.hpp:16642
PipelineCoverageToColorStateCreateInfoNV & setPNext(const void *pNext_)
Definition: vulkan.hpp:16608
PipelineCoverageToColorStateCreateInfoNV & setFlags(PipelineCoverageToColorStateCreateFlagsNV flags_)
Definition: vulkan.hpp:16614
PipelineCoverageToColorStateCreateInfoNV & operator=(VkPipelineCoverageToColorStateCreateInfoNV const &rhs)
Definition: vulkan.hpp:16603
PipelineCoverageToColorStateCreateInfoNV & setCoverageToColorLocation(uint32_t coverageToColorLocation_)
Definition: vulkan.hpp:16626
PipelineCoverageToColorStateCreateInfoNV(VkPipelineCoverageToColorStateCreateInfoNV const &rhs)
Definition: vulkan.hpp:16598
PipelineCoverageToColorStateCreateFlagsNV flags
Definition: vulkan.hpp:16661
bool operator!=(PipelineCoverageToColorStateCreateInfoNV const &rhs) const
Definition: vulkan.hpp:16651
PipelineCoverageToColorStateCreateInfoNV(PipelineCoverageToColorStateCreateFlagsNV flags_=PipelineCoverageToColorStateCreateFlagsNV(), Bool32 coverageToColorEnable_=0, uint32_t coverageToColorLocation_=0)
Definition: vulkan.hpp:16589
PipelineDepthStencilStateCreateInfo & setBack(StencilOpState back_)
Definition: vulkan.hpp:10963
PipelineDepthStencilStateCreateInfo & operator=(VkPipelineDepthStencilStateCreateInfo const &rhs)
Definition: vulkan.hpp:10910
PipelineDepthStencilStateCreateInfo & setStencilTestEnable(Bool32 stencilTestEnable_)
Definition: vulkan.hpp:10951
PipelineDepthStencilStateCreateInfo & setDepthWriteEnable(Bool32 depthWriteEnable_)
Definition: vulkan.hpp:10933
PipelineDepthStencilStateCreateInfo & setMaxDepthBounds(float maxDepthBounds_)
Definition: vulkan.hpp:10975
PipelineDepthStencilStateCreateInfo & setMinDepthBounds(float minDepthBounds_)
Definition: vulkan.hpp:10969
PipelineDepthStencilStateCreateInfo & setDepthTestEnable(Bool32 depthTestEnable_)
Definition: vulkan.hpp:10927
PipelineDepthStencilStateCreateInfo(VkPipelineDepthStencilStateCreateInfo const &rhs)
Definition: vulkan.hpp:10905
PipelineDepthStencilStateCreateInfo & setFlags(PipelineDepthStencilStateCreateFlags flags_)
Definition: vulkan.hpp:10921
PipelineDepthStencilStateCreateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:10915
PipelineDepthStencilStateCreateInfo & setDepthBoundsTestEnable(Bool32 depthBoundsTestEnable_)
Definition: vulkan.hpp:10945
PipelineDepthStencilStateCreateFlags flags
Definition: vulkan.hpp:11017
bool operator==(PipelineDepthStencilStateCreateInfo const &rhs) const
Definition: vulkan.hpp:10991
PipelineDepthStencilStateCreateInfo(PipelineDepthStencilStateCreateFlags flags_=PipelineDepthStencilStateCreateFlags(), Bool32 depthTestEnable_=0, Bool32 depthWriteEnable_=0, CompareOp depthCompareOp_=CompareOp::eNever, Bool32 depthBoundsTestEnable_=0, Bool32 stencilTestEnable_=0, StencilOpState front_=StencilOpState(), StencilOpState back_=StencilOpState(), float minDepthBounds_=0, float maxDepthBounds_=0)
Definition: vulkan.hpp:10882
PipelineDepthStencilStateCreateInfo & setDepthCompareOp(CompareOp depthCompareOp_)
Definition: vulkan.hpp:10939
PipelineDepthStencilStateCreateInfo & setFront(StencilOpState front_)
Definition: vulkan.hpp:10957
bool operator!=(PipelineDepthStencilStateCreateInfo const &rhs) const
Definition: vulkan.hpp:11007
PipelineDiscardRectangleStateCreateInfoEXT(PipelineDiscardRectangleStateCreateFlagsEXT flags_=PipelineDiscardRectangleStateCreateFlagsEXT(), DiscardRectangleModeEXT discardRectangleMode_=DiscardRectangleModeEXT::eInclusive, uint32_t discardRectangleCount_=0, const Rect2D *pDiscardRectangles_=nullptr)
Definition: vulkan.hpp:34672
PipelineDiscardRectangleStateCreateInfoEXT & setPDiscardRectangles(const Rect2D *pDiscardRectangles_)
Definition: vulkan.hpp:34717
PipelineDiscardRectangleStateCreateFlagsEXT flags
Definition: vulkan.hpp:34753
PipelineDiscardRectangleStateCreateInfoEXT & setFlags(PipelineDiscardRectangleStateCreateFlagsEXT flags_)
Definition: vulkan.hpp:34699
PipelineDiscardRectangleStateCreateInfoEXT & setDiscardRectangleMode(DiscardRectangleModeEXT discardRectangleMode_)
Definition: vulkan.hpp:34705
PipelineDiscardRectangleStateCreateInfoEXT(VkPipelineDiscardRectangleStateCreateInfoEXT const &rhs)
Definition: vulkan.hpp:34683
PipelineDiscardRectangleStateCreateInfoEXT & setDiscardRectangleCount(uint32_t discardRectangleCount_)
Definition: vulkan.hpp:34711
bool operator!=(PipelineDiscardRectangleStateCreateInfoEXT const &rhs) const
Definition: vulkan.hpp:34743
PipelineDiscardRectangleStateCreateInfoEXT & setPNext(const void *pNext_)
Definition: vulkan.hpp:34693
PipelineDiscardRectangleStateCreateInfoEXT & operator=(VkPipelineDiscardRectangleStateCreateInfoEXT const &rhs)
Definition: vulkan.hpp:34688
bool operator==(PipelineDiscardRectangleStateCreateInfoEXT const &rhs) const
Definition: vulkan.hpp:34733
PipelineDynamicStateCreateInfo & operator=(VkPipelineDynamicStateCreateInfo const &rhs)
Definition: vulkan.hpp:21327
bool operator==(PipelineDynamicStateCreateInfo const &rhs) const
Definition: vulkan.hpp:21366
PipelineDynamicStateCreateInfo(PipelineDynamicStateCreateFlags flags_=PipelineDynamicStateCreateFlags(), uint32_t dynamicStateCount_=0, const DynamicState *pDynamicStates_=nullptr)
Definition: vulkan.hpp:21313
PipelineDynamicStateCreateInfo(VkPipelineDynamicStateCreateInfo const &rhs)
Definition: vulkan.hpp:21322
PipelineDynamicStateCreateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:21332
PipelineDynamicStateCreateInfo & setFlags(PipelineDynamicStateCreateFlags flags_)
Definition: vulkan.hpp:21338
bool operator!=(PipelineDynamicStateCreateInfo const &rhs) const
Definition: vulkan.hpp:21375
PipelineDynamicStateCreateInfo & setPDynamicStates(const DynamicState *pDynamicStates_)
Definition: vulkan.hpp:21350
PipelineDynamicStateCreateInfo & setDynamicStateCount(uint32_t dynamicStateCount_)
Definition: vulkan.hpp:21344
bool operator!=(PipelineInputAssemblyStateCreateInfo const &rhs) const
Definition: vulkan.hpp:10534
PipelineInputAssemblyStateCreateInfo & setTopology(PrimitiveTopology topology_)
Definition: vulkan.hpp:10503
PipelineInputAssemblyStateCreateInfo(VkPipelineInputAssemblyStateCreateInfo const &rhs)
Definition: vulkan.hpp:10481
PipelineInputAssemblyStateCreateInfo & setFlags(PipelineInputAssemblyStateCreateFlags flags_)
Definition: vulkan.hpp:10497
PipelineInputAssemblyStateCreateFlags flags
Definition: vulkan.hpp:10544
bool operator==(PipelineInputAssemblyStateCreateInfo const &rhs) const
Definition: vulkan.hpp:10525
PipelineInputAssemblyStateCreateInfo & setPrimitiveRestartEnable(Bool32 primitiveRestartEnable_)
Definition: vulkan.hpp:10509
PipelineInputAssemblyStateCreateInfo(PipelineInputAssemblyStateCreateFlags flags_=PipelineInputAssemblyStateCreateFlags(), PrimitiveTopology topology_=PrimitiveTopology::ePointList, Bool32 primitiveRestartEnable_=0)
Definition: vulkan.hpp:10472
PipelineInputAssemblyStateCreateInfo & operator=(VkPipelineInputAssemblyStateCreateInfo const &rhs)
Definition: vulkan.hpp:10486
PipelineInputAssemblyStateCreateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:10491
PipelineLayoutCreateInfo & setSetLayoutCount(uint32_t setLayoutCount_)
Definition: vulkan.hpp:23252
bool operator!=(PipelineLayoutCreateInfo const &rhs) const
Definition: vulkan.hpp:23297
PipelineLayoutCreateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:23240
PipelineLayoutCreateInfo & setFlags(PipelineLayoutCreateFlags flags_)
Definition: vulkan.hpp:23246
PipelineLayoutCreateInfo & setPSetLayouts(const DescriptorSetLayout *pSetLayouts_)
Definition: vulkan.hpp:23258
const PushConstantRange * pPushConstantRanges
Definition: vulkan.hpp:23311
const DescriptorSetLayout * pSetLayouts
Definition: vulkan.hpp:23309
PipelineLayoutCreateInfo & setPPushConstantRanges(const PushConstantRange *pPushConstantRanges_)
Definition: vulkan.hpp:23270
bool operator==(PipelineLayoutCreateInfo const &rhs) const
Definition: vulkan.hpp:23286
PipelineLayoutCreateInfo & operator=(VkPipelineLayoutCreateInfo const &rhs)
Definition: vulkan.hpp:23235
PipelineLayoutCreateInfo(VkPipelineLayoutCreateInfo const &rhs)
Definition: vulkan.hpp:23230
PipelineLayoutCreateInfo & setPushConstantRangeCount(uint32_t pushConstantRangeCount_)
Definition: vulkan.hpp:23264
PipelineLayoutCreateInfo(PipelineLayoutCreateFlags flags_=PipelineLayoutCreateFlags(), uint32_t setLayoutCount_=0, const DescriptorSetLayout *pSetLayouts_=nullptr, uint32_t pushConstantRangeCount_=0, const PushConstantRange *pPushConstantRanges_=nullptr)
Definition: vulkan.hpp:23217
PipelineMultisampleStateCreateInfo & setAlphaToOneEnable(Bool32 alphaToOneEnable_)
Definition: vulkan.hpp:27264
PipelineMultisampleStateCreateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:27222
PipelineMultisampleStateCreateInfo(PipelineMultisampleStateCreateFlags flags_=PipelineMultisampleStateCreateFlags(), SampleCountFlagBits rasterizationSamples_=SampleCountFlagBits::e1, Bool32 sampleShadingEnable_=0, float minSampleShading_=0, const SampleMask *pSampleMask_=nullptr, Bool32 alphaToCoverageEnable_=0, Bool32 alphaToOneEnable_=0)
Definition: vulkan.hpp:27195
PipelineMultisampleStateCreateInfo & setSampleShadingEnable(Bool32 sampleShadingEnable_)
Definition: vulkan.hpp:27240
PipelineMultisampleStateCreateFlags flags
Definition: vulkan.hpp:27303
PipelineMultisampleStateCreateInfo & setFlags(PipelineMultisampleStateCreateFlags flags_)
Definition: vulkan.hpp:27228
bool operator!=(PipelineMultisampleStateCreateInfo const &rhs) const
Definition: vulkan.hpp:27293
PipelineMultisampleStateCreateInfo & setAlphaToCoverageEnable(Bool32 alphaToCoverageEnable_)
Definition: vulkan.hpp:27258
PipelineMultisampleStateCreateInfo & setPSampleMask(const SampleMask *pSampleMask_)
Definition: vulkan.hpp:27252
PipelineMultisampleStateCreateInfo & setRasterizationSamples(SampleCountFlagBits rasterizationSamples_)
Definition: vulkan.hpp:27234
bool operator==(PipelineMultisampleStateCreateInfo const &rhs) const
Definition: vulkan.hpp:27280
PipelineMultisampleStateCreateInfo & operator=(VkPipelineMultisampleStateCreateInfo const &rhs)
Definition: vulkan.hpp:27217
PipelineMultisampleStateCreateInfo(VkPipelineMultisampleStateCreateInfo const &rhs)
Definition: vulkan.hpp:27212
PipelineMultisampleStateCreateInfo & setMinSampleShading(float minSampleShading_)
Definition: vulkan.hpp:27246
bool operator==(PipelineRasterizationConservativeStateCreateInfoEXT const &rhs) const
Definition: vulkan.hpp:36226
PipelineRasterizationConservativeStateCreateInfoEXT(VkPipelineRasterizationConservativeStateCreateInfoEXT const &rhs)
Definition: vulkan.hpp:36182
PipelineRasterizationConservativeStateCreateInfoEXT & setConservativeRasterizationMode(ConservativeRasterizationModeEXT conservativeRasterizationMode_)
Definition: vulkan.hpp:36204
PipelineRasterizationConservativeStateCreateInfoEXT & setPNext(const void *pNext_)
Definition: vulkan.hpp:36192
PipelineRasterizationConservativeStateCreateInfoEXT & setExtraPrimitiveOverestimationSize(float extraPrimitiveOverestimationSize_)
Definition: vulkan.hpp:36210
PipelineRasterizationConservativeStateCreateInfoEXT & operator=(VkPipelineRasterizationConservativeStateCreateInfoEXT const &rhs)
Definition: vulkan.hpp:36187
bool operator!=(PipelineRasterizationConservativeStateCreateInfoEXT const &rhs) const
Definition: vulkan.hpp:36235
PipelineRasterizationConservativeStateCreateInfoEXT & setFlags(PipelineRasterizationConservativeStateCreateFlagsEXT flags_)
Definition: vulkan.hpp:36198
PipelineRasterizationConservativeStateCreateInfoEXT(PipelineRasterizationConservativeStateCreateFlagsEXT flags_=PipelineRasterizationConservativeStateCreateFlagsEXT(), ConservativeRasterizationModeEXT conservativeRasterizationMode_=ConservativeRasterizationModeEXT::eDisabled, float extraPrimitiveOverestimationSize_=0)
Definition: vulkan.hpp:36173
PipelineRasterizationConservativeStateCreateFlagsEXT flags
Definition: vulkan.hpp:36245
bool operator!=(PipelineRasterizationStateCreateInfo const &rhs) const
Definition: vulkan.hpp:10856
PipelineRasterizationStateCreateInfo & setFlags(PipelineRasterizationStateCreateFlags flags_)
Definition: vulkan.hpp:10763
PipelineRasterizationStateCreateInfo & setPolygonMode(PolygonMode polygonMode_)
Definition: vulkan.hpp:10781
PipelineRasterizationStateCreateInfo & setDepthClampEnable(Bool32 depthClampEnable_)
Definition: vulkan.hpp:10769
PipelineRasterizationStateCreateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:10757
PipelineRasterizationStateCreateInfo(PipelineRasterizationStateCreateFlags flags_=PipelineRasterizationStateCreateFlags(), Bool32 depthClampEnable_=0, Bool32 rasterizerDiscardEnable_=0, PolygonMode polygonMode_=PolygonMode::eFill, CullModeFlags cullMode_=CullModeFlags(), FrontFace frontFace_=FrontFace::eCounterClockwise, Bool32 depthBiasEnable_=0, float depthBiasConstantFactor_=0, float depthBiasClamp_=0, float depthBiasSlopeFactor_=0, float lineWidth_=0)
Definition: vulkan.hpp:10722
PipelineRasterizationStateCreateInfo & setDepthBiasEnable(Bool32 depthBiasEnable_)
Definition: vulkan.hpp:10799
PipelineRasterizationStateCreateFlags flags
Definition: vulkan.hpp:10866
bool operator==(PipelineRasterizationStateCreateInfo const &rhs) const
Definition: vulkan.hpp:10839
PipelineRasterizationStateCreateInfo & setDepthBiasClamp(float depthBiasClamp_)
Definition: vulkan.hpp:10811
PipelineRasterizationStateCreateInfo & setCullMode(CullModeFlags cullMode_)
Definition: vulkan.hpp:10787
PipelineRasterizationStateCreateInfo & setRasterizerDiscardEnable(Bool32 rasterizerDiscardEnable_)
Definition: vulkan.hpp:10775
PipelineRasterizationStateCreateInfo & setDepthBiasSlopeFactor(float depthBiasSlopeFactor_)
Definition: vulkan.hpp:10817
PipelineRasterizationStateCreateInfo & setFrontFace(FrontFace frontFace_)
Definition: vulkan.hpp:10793
PipelineRasterizationStateCreateInfo & operator=(VkPipelineRasterizationStateCreateInfo const &rhs)
Definition: vulkan.hpp:10752
PipelineRasterizationStateCreateInfo & setDepthBiasConstantFactor(float depthBiasConstantFactor_)
Definition: vulkan.hpp:10805
PipelineRasterizationStateCreateInfo & setLineWidth(float lineWidth_)
Definition: vulkan.hpp:10823
PipelineRasterizationStateCreateInfo(VkPipelineRasterizationStateCreateInfo const &rhs)
Definition: vulkan.hpp:10747
PipelineRasterizationStateRasterizationOrderAMD(VkPipelineRasterizationStateRasterizationOrderAMD const &rhs)
Definition: vulkan.hpp:30037
bool operator!=(PipelineRasterizationStateRasterizationOrderAMD const &rhs) const
Definition: vulkan.hpp:30076
PipelineRasterizationStateRasterizationOrderAMD(RasterizationOrderAMD rasterizationOrder_=RasterizationOrderAMD::eStrict)
Definition: vulkan.hpp:30032
PipelineRasterizationStateRasterizationOrderAMD & setRasterizationOrder(RasterizationOrderAMD rasterizationOrder_)
Definition: vulkan.hpp:30053
PipelineRasterizationStateRasterizationOrderAMD & setPNext(const void *pNext_)
Definition: vulkan.hpp:30047
PipelineRasterizationStateRasterizationOrderAMD & operator=(VkPipelineRasterizationStateRasterizationOrderAMD const &rhs)
Definition: vulkan.hpp:30042
bool operator==(PipelineRasterizationStateRasterizationOrderAMD const &rhs) const
Definition: vulkan.hpp:30069
PipelineRasterizationStateStreamCreateInfoEXT(VkPipelineRasterizationStateStreamCreateInfoEXT const &rhs)
Definition: vulkan.hpp:19318
PipelineRasterizationStateStreamCreateFlagsEXT flags
Definition: vulkan.hpp:19374
bool operator==(PipelineRasterizationStateStreamCreateInfoEXT const &rhs) const
Definition: vulkan.hpp:19356
PipelineRasterizationStateStreamCreateInfoEXT & setPNext(const void *pNext_)
Definition: vulkan.hpp:19328
PipelineRasterizationStateStreamCreateInfoEXT & setFlags(PipelineRasterizationStateStreamCreateFlagsEXT flags_)
Definition: vulkan.hpp:19334
bool operator!=(PipelineRasterizationStateStreamCreateInfoEXT const &rhs) const
Definition: vulkan.hpp:19364
PipelineRasterizationStateStreamCreateInfoEXT & setRasterizationStream(uint32_t rasterizationStream_)
Definition: vulkan.hpp:19340
PipelineRasterizationStateStreamCreateInfoEXT & operator=(VkPipelineRasterizationStateStreamCreateInfoEXT const &rhs)
Definition: vulkan.hpp:19323
PipelineRasterizationStateStreamCreateInfoEXT(PipelineRasterizationStateStreamCreateFlagsEXT flags_=PipelineRasterizationStateStreamCreateFlagsEXT(), uint32_t rasterizationStream_=0)
Definition: vulkan.hpp:19311
PipelineRepresentativeFragmentTestStateCreateInfoNV(VkPipelineRepresentativeFragmentTestStateCreateInfoNV const &rhs)
Definition: vulkan.hpp:19446
PipelineRepresentativeFragmentTestStateCreateInfoNV & setRepresentativeFragmentTestEnable(Bool32 representativeFragmentTestEnable_)
Definition: vulkan.hpp:19462
PipelineRepresentativeFragmentTestStateCreateInfoNV & operator=(VkPipelineRepresentativeFragmentTestStateCreateInfoNV const &rhs)
Definition: vulkan.hpp:19451
PipelineRepresentativeFragmentTestStateCreateInfoNV(Bool32 representativeFragmentTestEnable_=0)
Definition: vulkan.hpp:19441
bool operator!=(PipelineRepresentativeFragmentTestStateCreateInfoNV const &rhs) const
Definition: vulkan.hpp:19485
PipelineRepresentativeFragmentTestStateCreateInfoNV & setPNext(const void *pNext_)
Definition: vulkan.hpp:19456
bool operator==(PipelineRepresentativeFragmentTestStateCreateInfoNV const &rhs) const
Definition: vulkan.hpp:19478
PipelineSampleLocationsStateCreateInfoEXT(Bool32 sampleLocationsEnable_=0, SampleLocationsInfoEXT sampleLocationsInfo_=SampleLocationsInfoEXT())
Definition: vulkan.hpp:28279
PipelineSampleLocationsStateCreateInfoEXT(VkPipelineSampleLocationsStateCreateInfoEXT const &rhs)
Definition: vulkan.hpp:28286
bool operator!=(PipelineSampleLocationsStateCreateInfoEXT const &rhs) const
Definition: vulkan.hpp:28332
PipelineSampleLocationsStateCreateInfoEXT & setSampleLocationsEnable(Bool32 sampleLocationsEnable_)
Definition: vulkan.hpp:28302
PipelineSampleLocationsStateCreateInfoEXT & setSampleLocationsInfo(SampleLocationsInfoEXT sampleLocationsInfo_)
Definition: vulkan.hpp:28308
PipelineSampleLocationsStateCreateInfoEXT & operator=(VkPipelineSampleLocationsStateCreateInfoEXT const &rhs)
Definition: vulkan.hpp:28291
bool operator==(PipelineSampleLocationsStateCreateInfoEXT const &rhs) const
Definition: vulkan.hpp:28324
PipelineSampleLocationsStateCreateInfoEXT & setPNext(const void *pNext_)
Definition: vulkan.hpp:28296
PipelineShaderStageCreateInfo & setFlags(PipelineShaderStageCreateFlags flags_)
Definition: vulkan.hpp:23079
PipelineShaderStageCreateInfo(VkPipelineShaderStageCreateInfo const &rhs)
Definition: vulkan.hpp:23063
PipelineShaderStageCreateInfo & operator=(VkPipelineShaderStageCreateInfo const &rhs)
Definition: vulkan.hpp:23068
PipelineShaderStageCreateInfo(PipelineShaderStageCreateFlags flags_=PipelineShaderStageCreateFlags(), ShaderStageFlagBits stage_=ShaderStageFlagBits::eVertex, ShaderModule module_=ShaderModule(), const char *pName_=nullptr, const SpecializationInfo *pSpecializationInfo_=nullptr)
Definition: vulkan.hpp:23050
PipelineShaderStageCreateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:23073
bool operator!=(PipelineShaderStageCreateInfo const &rhs) const
Definition: vulkan.hpp:23130
PipelineShaderStageCreateInfo & setStage(ShaderStageFlagBits stage_)
Definition: vulkan.hpp:23085
PipelineShaderStageCreateInfo & setPName(const char *pName_)
Definition: vulkan.hpp:23097
PipelineShaderStageCreateInfo & setPSpecializationInfo(const SpecializationInfo *pSpecializationInfo_)
Definition: vulkan.hpp:23103
bool operator==(PipelineShaderStageCreateInfo const &rhs) const
Definition: vulkan.hpp:23119
PipelineShaderStageCreateInfo & setModule(ShaderModule module_)
Definition: vulkan.hpp:23091
PipelineTessellationDomainOriginStateCreateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:35478
PipelineTessellationDomainOriginStateCreateInfo & setDomainOrigin(TessellationDomainOrigin domainOrigin_)
Definition: vulkan.hpp:35484
PipelineTessellationDomainOriginStateCreateInfo & operator=(VkPipelineTessellationDomainOriginStateCreateInfo const &rhs)
Definition: vulkan.hpp:35473
bool operator==(PipelineTessellationDomainOriginStateCreateInfo const &rhs) const
Definition: vulkan.hpp:35500
bool operator!=(PipelineTessellationDomainOriginStateCreateInfo const &rhs) const
Definition: vulkan.hpp:35507
PipelineTessellationDomainOriginStateCreateInfo(VkPipelineTessellationDomainOriginStateCreateInfo const &rhs)
Definition: vulkan.hpp:35468
PipelineTessellationDomainOriginStateCreateInfo(TessellationDomainOrigin domainOrigin_=TessellationDomainOrigin::eUpperLeft)
Definition: vulkan.hpp:35463
PipelineTessellationStateCreateInfo & setPatchControlPoints(uint32_t patchControlPoints_)
Definition: vulkan.hpp:10581
bool operator!=(PipelineTessellationStateCreateInfo const &rhs) const
Definition: vulkan.hpp:10605
PipelineTessellationStateCreateInfo & setFlags(PipelineTessellationStateCreateFlags flags_)
Definition: vulkan.hpp:10575
PipelineTessellationStateCreateInfo(PipelineTessellationStateCreateFlags flags_=PipelineTessellationStateCreateFlags(), uint32_t patchControlPoints_=0)
Definition: vulkan.hpp:10552
bool operator==(PipelineTessellationStateCreateInfo const &rhs) const
Definition: vulkan.hpp:10597
PipelineTessellationStateCreateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:10569
PipelineTessellationStateCreateInfo & operator=(VkPipelineTessellationStateCreateInfo const &rhs)
Definition: vulkan.hpp:10564
PipelineTessellationStateCreateInfo(VkPipelineTessellationStateCreateInfo const &rhs)
Definition: vulkan.hpp:10559
PipelineTessellationStateCreateFlags flags
Definition: vulkan.hpp:10615
PipelineVertexInputDivisorStateCreateInfoEXT & setPVertexBindingDivisors(const VertexInputBindingDivisorDescriptionEXT *pVertexBindingDivisors_)
Definition: vulkan.hpp:18287
PipelineVertexInputDivisorStateCreateInfoEXT & setPNext(const void *pNext_)
Definition: vulkan.hpp:18275
PipelineVertexInputDivisorStateCreateInfoEXT(VkPipelineVertexInputDivisorStateCreateInfoEXT const &rhs)
Definition: vulkan.hpp:18265
const VertexInputBindingDivisorDescriptionEXT * pVertexBindingDivisors
Definition: vulkan.hpp:18322
bool operator!=(PipelineVertexInputDivisorStateCreateInfoEXT const &rhs) const
Definition: vulkan.hpp:18311
PipelineVertexInputDivisorStateCreateInfoEXT(uint32_t vertexBindingDivisorCount_=0, const VertexInputBindingDivisorDescriptionEXT *pVertexBindingDivisors_=nullptr)
Definition: vulkan.hpp:18258
PipelineVertexInputDivisorStateCreateInfoEXT & setVertexBindingDivisorCount(uint32_t vertexBindingDivisorCount_)
Definition: vulkan.hpp:18281
bool operator==(PipelineVertexInputDivisorStateCreateInfoEXT const &rhs) const
Definition: vulkan.hpp:18303
PipelineVertexInputDivisorStateCreateInfoEXT & operator=(VkPipelineVertexInputDivisorStateCreateInfoEXT const &rhs)
Definition: vulkan.hpp:18270
PipelineVertexInputStateCreateInfo & setPVertexAttributeDescriptions(const VertexInputAttributeDescription *pVertexAttributeDescriptions_)
Definition: vulkan.hpp:10425
PipelineVertexInputStateCreateInfo(PipelineVertexInputStateCreateFlags flags_=PipelineVertexInputStateCreateFlags(), uint32_t vertexBindingDescriptionCount_=0, const VertexInputBindingDescription *pVertexBindingDescriptions_=nullptr, uint32_t vertexAttributeDescriptionCount_=0, const VertexInputAttributeDescription *pVertexAttributeDescriptions_=nullptr)
Definition: vulkan.hpp:10372
PipelineVertexInputStateCreateInfo & setPVertexBindingDescriptions(const VertexInputBindingDescription *pVertexBindingDescriptions_)
Definition: vulkan.hpp:10413
PipelineVertexInputStateCreateInfo & setVertexBindingDescriptionCount(uint32_t vertexBindingDescriptionCount_)
Definition: vulkan.hpp:10407
PipelineVertexInputStateCreateInfo & operator=(VkPipelineVertexInputStateCreateInfo const &rhs)
Definition: vulkan.hpp:10390
bool operator==(PipelineVertexInputStateCreateInfo const &rhs) const
Definition: vulkan.hpp:10441
PipelineVertexInputStateCreateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:10395
PipelineVertexInputStateCreateInfo & setVertexAttributeDescriptionCount(uint32_t vertexAttributeDescriptionCount_)
Definition: vulkan.hpp:10419
const VertexInputBindingDescription * pVertexBindingDescriptions
Definition: vulkan.hpp:10464
PipelineVertexInputStateCreateFlags flags
Definition: vulkan.hpp:10462
bool operator!=(PipelineVertexInputStateCreateInfo const &rhs) const
Definition: vulkan.hpp:10452
PipelineVertexInputStateCreateInfo(VkPipelineVertexInputStateCreateInfo const &rhs)
Definition: vulkan.hpp:10385
const VertexInputAttributeDescription * pVertexAttributeDescriptions
Definition: vulkan.hpp:10466
PipelineVertexInputStateCreateInfo & setFlags(PipelineVertexInputStateCreateFlags flags_)
Definition: vulkan.hpp:10401
PipelineViewportCoarseSampleOrderStateCreateInfoNV(VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const &rhs)
Definition: vulkan.hpp:36762
PipelineViewportCoarseSampleOrderStateCreateInfoNV(CoarseSampleOrderTypeNV sampleOrderType_=CoarseSampleOrderTypeNV::eDefault, uint32_t customSampleOrderCount_=0, const CoarseSampleOrderCustomNV *pCustomSampleOrders_=nullptr)
Definition: vulkan.hpp:36753
PipelineViewportCoarseSampleOrderStateCreateInfoNV & setSampleOrderType(CoarseSampleOrderTypeNV sampleOrderType_)
Definition: vulkan.hpp:36778
PipelineViewportCoarseSampleOrderStateCreateInfoNV & setPNext(const void *pNext_)
Definition: vulkan.hpp:36772
bool operator==(PipelineViewportCoarseSampleOrderStateCreateInfoNV const &rhs) const
Definition: vulkan.hpp:36806
PipelineViewportCoarseSampleOrderStateCreateInfoNV & setCustomSampleOrderCount(uint32_t customSampleOrderCount_)
Definition: vulkan.hpp:36784
PipelineViewportCoarseSampleOrderStateCreateInfoNV & operator=(VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const &rhs)
Definition: vulkan.hpp:36767
PipelineViewportCoarseSampleOrderStateCreateInfoNV & setPCustomSampleOrders(const CoarseSampleOrderCustomNV *pCustomSampleOrders_)
Definition: vulkan.hpp:36790
bool operator!=(PipelineViewportCoarseSampleOrderStateCreateInfoNV const &rhs) const
Definition: vulkan.hpp:36815
bool operator!=(PipelineViewportExclusiveScissorStateCreateInfoNV const &rhs) const
Definition: vulkan.hpp:19614
PipelineViewportExclusiveScissorStateCreateInfoNV(VkPipelineViewportExclusiveScissorStateCreateInfoNV const &rhs)
Definition: vulkan.hpp:19568
PipelineViewportExclusiveScissorStateCreateInfoNV(uint32_t exclusiveScissorCount_=0, const Rect2D *pExclusiveScissors_=nullptr)
Definition: vulkan.hpp:19561
PipelineViewportExclusiveScissorStateCreateInfoNV & setExclusiveScissorCount(uint32_t exclusiveScissorCount_)
Definition: vulkan.hpp:19584
PipelineViewportExclusiveScissorStateCreateInfoNV & setPNext(const void *pNext_)
Definition: vulkan.hpp:19578
bool operator==(PipelineViewportExclusiveScissorStateCreateInfoNV const &rhs) const
Definition: vulkan.hpp:19606
PipelineViewportExclusiveScissorStateCreateInfoNV & operator=(VkPipelineViewportExclusiveScissorStateCreateInfoNV const &rhs)
Definition: vulkan.hpp:19573
PipelineViewportExclusiveScissorStateCreateInfoNV & setPExclusiveScissors(const Rect2D *pExclusiveScissors_)
Definition: vulkan.hpp:19590
PipelineViewportShadingRateImageStateCreateInfoNV(VkPipelineViewportShadingRateImageStateCreateInfoNV const &rhs)
Definition: vulkan.hpp:36597
PipelineViewportShadingRateImageStateCreateInfoNV & operator=(VkPipelineViewportShadingRateImageStateCreateInfoNV const &rhs)
Definition: vulkan.hpp:36602
bool operator!=(PipelineViewportShadingRateImageStateCreateInfoNV const &rhs) const
Definition: vulkan.hpp:36650
PipelineViewportShadingRateImageStateCreateInfoNV & setShadingRateImageEnable(Bool32 shadingRateImageEnable_)
Definition: vulkan.hpp:36613
PipelineViewportShadingRateImageStateCreateInfoNV(Bool32 shadingRateImageEnable_=0, uint32_t viewportCount_=0, const ShadingRatePaletteNV *pShadingRatePalettes_=nullptr)
Definition: vulkan.hpp:36588
PipelineViewportShadingRateImageStateCreateInfoNV & setPNext(const void *pNext_)
Definition: vulkan.hpp:36607
bool operator==(PipelineViewportShadingRateImageStateCreateInfoNV const &rhs) const
Definition: vulkan.hpp:36641
PipelineViewportShadingRateImageStateCreateInfoNV & setPShadingRatePalettes(const ShadingRatePaletteNV *pShadingRatePalettes_)
Definition: vulkan.hpp:36625
PipelineViewportShadingRateImageStateCreateInfoNV & setViewportCount(uint32_t viewportCount_)
Definition: vulkan.hpp:36619
PipelineViewportStateCreateInfo(VkPipelineViewportStateCreateInfo const &rhs)
Definition: vulkan.hpp:10635
PipelineViewportStateCreateInfo(PipelineViewportStateCreateFlags flags_=PipelineViewportStateCreateFlags(), uint32_t viewportCount_=0, const Viewport *pViewports_=nullptr, uint32_t scissorCount_=0, const Rect2D *pScissors_=nullptr)
Definition: vulkan.hpp:10622
PipelineViewportStateCreateInfo & setScissorCount(uint32_t scissorCount_)
Definition: vulkan.hpp:10669
PipelineViewportStateCreateInfo & setFlags(PipelineViewportStateCreateFlags flags_)
Definition: vulkan.hpp:10651
PipelineViewportStateCreateInfo & setViewportCount(uint32_t viewportCount_)
Definition: vulkan.hpp:10657
bool operator!=(PipelineViewportStateCreateInfo const &rhs) const
Definition: vulkan.hpp:10702
PipelineViewportStateCreateInfo & operator=(VkPipelineViewportStateCreateInfo const &rhs)
Definition: vulkan.hpp:10640
PipelineViewportStateCreateInfo & setPViewports(const Viewport *pViewports_)
Definition: vulkan.hpp:10663
PipelineViewportStateCreateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:10645
bool operator==(PipelineViewportStateCreateInfo const &rhs) const
Definition: vulkan.hpp:10691
PipelineViewportStateCreateInfo & setPScissors(const Rect2D *pScissors_)
Definition: vulkan.hpp:10675
bool operator==(PipelineViewportSwizzleStateCreateInfoNV const &rhs) const
Definition: vulkan.hpp:34639
PipelineViewportSwizzleStateCreateInfoNV & setPViewportSwizzles(const ViewportSwizzleNV *pViewportSwizzles_)
Definition: vulkan.hpp:34623
PipelineViewportSwizzleStateCreateInfoNV(VkPipelineViewportSwizzleStateCreateInfoNV const &rhs)
Definition: vulkan.hpp:34595
PipelineViewportSwizzleStateCreateInfoNV & operator=(VkPipelineViewportSwizzleStateCreateInfoNV const &rhs)
Definition: vulkan.hpp:34600
PipelineViewportSwizzleStateCreateFlagsNV flags
Definition: vulkan.hpp:34658
PipelineViewportSwizzleStateCreateInfoNV & setPNext(const void *pNext_)
Definition: vulkan.hpp:34605
PipelineViewportSwizzleStateCreateInfoNV & setFlags(PipelineViewportSwizzleStateCreateFlagsNV flags_)
Definition: vulkan.hpp:34611
PipelineViewportSwizzleStateCreateInfoNV & setViewportCount(uint32_t viewportCount_)
Definition: vulkan.hpp:34617
bool operator!=(PipelineViewportSwizzleStateCreateInfoNV const &rhs) const
Definition: vulkan.hpp:34648
PipelineViewportSwizzleStateCreateInfoNV(PipelineViewportSwizzleStateCreateFlagsNV flags_=PipelineViewportSwizzleStateCreateFlagsNV(), uint32_t viewportCount_=0, const ViewportSwizzleNV *pViewportSwizzles_=nullptr)
Definition: vulkan.hpp:34586
PipelineViewportWScalingStateCreateInfoNV & operator=(VkPipelineViewportWScalingStateCreateInfoNV const &rhs)
Definition: vulkan.hpp:15440
bool operator==(PipelineViewportWScalingStateCreateInfoNV const &rhs) const
Definition: vulkan.hpp:15479
PipelineViewportWScalingStateCreateInfoNV & setPViewportWScalings(const ViewportWScalingNV *pViewportWScalings_)
Definition: vulkan.hpp:15463
PipelineViewportWScalingStateCreateInfoNV(Bool32 viewportWScalingEnable_=0, uint32_t viewportCount_=0, const ViewportWScalingNV *pViewportWScalings_=nullptr)
Definition: vulkan.hpp:15426
PipelineViewportWScalingStateCreateInfoNV & setViewportWScalingEnable(Bool32 viewportWScalingEnable_)
Definition: vulkan.hpp:15451
PipelineViewportWScalingStateCreateInfoNV(VkPipelineViewportWScalingStateCreateInfoNV const &rhs)
Definition: vulkan.hpp:15435
PipelineViewportWScalingStateCreateInfoNV & setPNext(const void *pNext_)
Definition: vulkan.hpp:15445
bool operator!=(PipelineViewportWScalingStateCreateInfoNV const &rhs) const
Definition: vulkan.hpp:15488
PipelineViewportWScalingStateCreateInfoNV & setViewportCount(uint32_t viewportCount_)
Definition: vulkan.hpp:15457
PresentInfoKHR & operator=(VkPresentInfoKHR const &rhs)
Definition: vulkan.hpp:21204
PresentInfoKHR(uint32_t waitSemaphoreCount_=0, const Semaphore *pWaitSemaphores_=nullptr, uint32_t swapchainCount_=0, const SwapchainKHR *pSwapchains_=nullptr, const uint32_t *pImageIndices_=nullptr, Result *pResults_=nullptr)
Definition: vulkan.hpp:21184
PresentInfoKHR & setPImageIndices(const uint32_t *pImageIndices_)
Definition: vulkan.hpp:21239
PresentInfoKHR & setPResults(Result *pResults_)
Definition: vulkan.hpp:21245
bool operator!=(PresentInfoKHR const &rhs) const
Definition: vulkan.hpp:21273
const SwapchainKHR * pSwapchains
Definition: vulkan.hpp:21286
PresentInfoKHR & setPSwapchains(const SwapchainKHR *pSwapchains_)
Definition: vulkan.hpp:21233
PresentInfoKHR & setSwapchainCount(uint32_t swapchainCount_)
Definition: vulkan.hpp:21227
PresentInfoKHR(VkPresentInfoKHR const &rhs)
Definition: vulkan.hpp:21199
PresentInfoKHR & setPNext(const void *pNext_)
Definition: vulkan.hpp:21209
PresentInfoKHR & setPWaitSemaphores(const Semaphore *pWaitSemaphores_)
Definition: vulkan.hpp:21221
PresentInfoKHR & setWaitSemaphoreCount(uint32_t waitSemaphoreCount_)
Definition: vulkan.hpp:21215
bool operator==(PresentInfoKHR const &rhs) const
Definition: vulkan.hpp:21261
const RectLayerKHR * pRectangles
Definition: vulkan.hpp:7393
bool operator==(PresentRegionKHR const &rhs) const
Definition: vulkan.hpp:7381
PresentRegionKHR & setRectangleCount(uint32_t rectangleCount_)
Definition: vulkan.hpp:7359
PresentRegionKHR(VkPresentRegionKHR const &rhs)
Definition: vulkan.hpp:7349
bool operator!=(PresentRegionKHR const &rhs) const
Definition: vulkan.hpp:7387
PresentRegionKHR & operator=(VkPresentRegionKHR const &rhs)
Definition: vulkan.hpp:7354
PresentRegionKHR(uint32_t rectangleCount_=0, const RectLayerKHR *pRectangles_=nullptr)
Definition: vulkan.hpp:7342
PresentRegionKHR & setPRectangles(const RectLayerKHR *pRectangles_)
Definition: vulkan.hpp:7365
bool operator!=(PresentRegionsKHR const &rhs) const
Definition: vulkan.hpp:13305
PresentRegionsKHR(uint32_t swapchainCount_=0, const PresentRegionKHR *pRegions_=nullptr)
Definition: vulkan.hpp:13252
bool operator==(PresentRegionsKHR const &rhs) const
Definition: vulkan.hpp:13297
PresentRegionsKHR & setPRegions(const PresentRegionKHR *pRegions_)
Definition: vulkan.hpp:13281
PresentRegionsKHR & setSwapchainCount(uint32_t swapchainCount_)
Definition: vulkan.hpp:13275
PresentRegionsKHR & operator=(VkPresentRegionsKHR const &rhs)
Definition: vulkan.hpp:13264
const PresentRegionKHR * pRegions
Definition: vulkan.hpp:13316
PresentRegionsKHR & setPNext(const void *pNext_)
Definition: vulkan.hpp:13269
PresentRegionsKHR(VkPresentRegionsKHR const &rhs)
Definition: vulkan.hpp:13259
bool operator!=(PresentTimeGOOGLE const &rhs) const
Definition: vulkan.hpp:7561
PresentTimeGOOGLE(uint32_t presentID_=0, uint64_t desiredPresentTime_=0)
Definition: vulkan.hpp:7516
PresentTimeGOOGLE & setPresentID(uint32_t presentID_)
Definition: vulkan.hpp:7533
PresentTimeGOOGLE(VkPresentTimeGOOGLE const &rhs)
Definition: vulkan.hpp:7523
bool operator==(PresentTimeGOOGLE const &rhs) const
Definition: vulkan.hpp:7555
PresentTimeGOOGLE & operator=(VkPresentTimeGOOGLE const &rhs)
Definition: vulkan.hpp:7528
PresentTimeGOOGLE & setDesiredPresentTime(uint64_t desiredPresentTime_)
Definition: vulkan.hpp:7539
PresentTimesInfoGOOGLE & setPNext(const void *pNext_)
Definition: vulkan.hpp:15229
PresentTimesInfoGOOGLE & operator=(VkPresentTimesInfoGOOGLE const &rhs)
Definition: vulkan.hpp:15224
PresentTimesInfoGOOGLE(VkPresentTimesInfoGOOGLE const &rhs)
Definition: vulkan.hpp:15219
bool operator!=(PresentTimesInfoGOOGLE const &rhs) const
Definition: vulkan.hpp:15265
PresentTimesInfoGOOGLE & setSwapchainCount(uint32_t swapchainCount_)
Definition: vulkan.hpp:15235
PresentTimesInfoGOOGLE & setPTimes(const PresentTimeGOOGLE *pTimes_)
Definition: vulkan.hpp:15241
PresentTimesInfoGOOGLE(uint32_t swapchainCount_=0, const PresentTimeGOOGLE *pTimes_=nullptr)
Definition: vulkan.hpp:15212
bool operator==(PresentTimesInfoGOOGLE const &rhs) const
Definition: vulkan.hpp:15257
ProtectedSubmitInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:16424
ProtectedSubmitInfo & setProtectedSubmit(Bool32 protectedSubmit_)
Definition: vulkan.hpp:16430
bool operator!=(ProtectedSubmitInfo const &rhs) const
Definition: vulkan.hpp:16453
bool operator==(ProtectedSubmitInfo const &rhs) const
Definition: vulkan.hpp:16446
ProtectedSubmitInfo(Bool32 protectedSubmit_=0)
Definition: vulkan.hpp:16409
ProtectedSubmitInfo & operator=(VkProtectedSubmitInfo const &rhs)
Definition: vulkan.hpp:16419
ProtectedSubmitInfo(VkProtectedSubmitInfo const &rhs)
Definition: vulkan.hpp:16414
PushConstantRange & setOffset(uint32_t offset_)
Definition: vulkan.hpp:23175
PushConstantRange & setSize(uint32_t size_)
Definition: vulkan.hpp:23181
bool operator!=(PushConstantRange const &rhs) const
Definition: vulkan.hpp:23204
PushConstantRange & setStageFlags(ShaderStageFlags stageFlags_)
Definition: vulkan.hpp:23169
PushConstantRange(ShaderStageFlags stageFlags_=ShaderStageFlags(), uint32_t offset_=0, uint32_t size_=0)
Definition: vulkan.hpp:23150
PushConstantRange(VkPushConstantRange const &rhs)
Definition: vulkan.hpp:23159
PushConstantRange & operator=(VkPushConstantRange const &rhs)
Definition: vulkan.hpp:23164
bool operator==(PushConstantRange const &rhs) const
Definition: vulkan.hpp:23197
QueryPipelineStatisticFlags pipelineStatistics
Definition: vulkan.hpp:24702
QueryPoolCreateInfo & setPipelineStatistics(QueryPipelineStatisticFlags pipelineStatistics_)
Definition: vulkan.hpp:24663
QueryPoolCreateInfo(QueryPoolCreateFlags flags_=QueryPoolCreateFlags(), QueryType queryType_=QueryType::eOcclusion, uint32_t queryCount_=0, QueryPipelineStatisticFlags pipelineStatistics_=QueryPipelineStatisticFlags())
Definition: vulkan.hpp:24618
QueryPoolCreateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:24639
QueryPoolCreateInfo & operator=(VkQueryPoolCreateInfo const &rhs)
Definition: vulkan.hpp:24634
bool operator!=(QueryPoolCreateInfo const &rhs) const
Definition: vulkan.hpp:24689
QueryPoolCreateInfo & setQueryCount(uint32_t queryCount_)
Definition: vulkan.hpp:24657
QueryPoolCreateInfo(VkQueryPoolCreateInfo const &rhs)
Definition: vulkan.hpp:24629
QueryPoolCreateInfo & setFlags(QueryPoolCreateFlags flags_)
Definition: vulkan.hpp:24645
bool operator==(QueryPoolCreateInfo const &rhs) const
Definition: vulkan.hpp:24679
QueryPoolCreateInfo & setQueryType(QueryType queryType_)
Definition: vulkan.hpp:24651
bool operator!=(QueueFamilyCheckpointPropertiesNV const &rhs) const
Definition: vulkan.hpp:26752
bool operator==(QueueFamilyCheckpointPropertiesNV const &rhs) const
Definition: vulkan.hpp:26745
bool operator==(QueueFamilyProperties2 const &rhs) const
Definition: vulkan.hpp:21977
bool operator!=(QueueFamilyProperties2 const &rhs) const
Definition: vulkan.hpp:21984
bool operator!=(QueueFamilyProperties const &rhs) const
Definition: vulkan.hpp:21953
bool operator==(QueueFamilyProperties const &rhs) const
Definition: vulkan.hpp:21945
RayTracingPipelineCreateInfoNV(PipelineCreateFlags flags_=PipelineCreateFlags(), uint32_t stageCount_=0, const PipelineShaderStageCreateInfo *pStages_=nullptr, uint32_t groupCount_=0, const RayTracingShaderGroupCreateInfoNV *pGroups_=nullptr, uint32_t maxRecursionDepth_=0, PipelineLayout layout_=PipelineLayout(), Pipeline basePipelineHandle_=Pipeline(), int32_t basePipelineIndex_=0)
Definition: vulkan.hpp:37368
RayTracingPipelineCreateInfoNV & setGroupCount(uint32_t groupCount_)
Definition: vulkan.hpp:37423
RayTracingPipelineCreateInfoNV & setMaxRecursionDepth(uint32_t maxRecursionDepth_)
Definition: vulkan.hpp:37435
RayTracingPipelineCreateInfoNV(VkRayTracingPipelineCreateInfoNV const &rhs)
Definition: vulkan.hpp:37389
RayTracingPipelineCreateInfoNV & setBasePipelineIndex(int32_t basePipelineIndex_)
Definition: vulkan.hpp:37453
const PipelineShaderStageCreateInfo * pStages
Definition: vulkan.hpp:37496
RayTracingPipelineCreateInfoNV & setPNext(const void *pNext_)
Definition: vulkan.hpp:37399
RayTracingPipelineCreateInfoNV & setBasePipelineHandle(Pipeline basePipelineHandle_)
Definition: vulkan.hpp:37447
bool operator!=(RayTracingPipelineCreateInfoNV const &rhs) const
Definition: vulkan.hpp:37484
RayTracingPipelineCreateInfoNV & setPStages(const PipelineShaderStageCreateInfo *pStages_)
Definition: vulkan.hpp:37417
const RayTracingShaderGroupCreateInfoNV * pGroups
Definition: vulkan.hpp:37498
RayTracingPipelineCreateInfoNV & setStageCount(uint32_t stageCount_)
Definition: vulkan.hpp:37411
RayTracingPipelineCreateInfoNV & operator=(VkRayTracingPipelineCreateInfoNV const &rhs)
Definition: vulkan.hpp:37394
RayTracingPipelineCreateInfoNV & setPGroups(const RayTracingShaderGroupCreateInfoNV *pGroups_)
Definition: vulkan.hpp:37429
bool operator==(RayTracingPipelineCreateInfoNV const &rhs) const
Definition: vulkan.hpp:37469
RayTracingPipelineCreateInfoNV & setLayout(PipelineLayout layout_)
Definition: vulkan.hpp:37441
RayTracingPipelineCreateInfoNV & setFlags(PipelineCreateFlags flags_)
Definition: vulkan.hpp:37405
RayTracingShaderGroupCreateInfoNV & setPNext(const void *pNext_)
Definition: vulkan.hpp:37291
RayTracingShaderGroupCreateInfoNV & setType(RayTracingShaderGroupTypeNV type_)
Definition: vulkan.hpp:37297
RayTracingShaderGroupCreateInfoNV & setGeneralShader(uint32_t generalShader_)
Definition: vulkan.hpp:37303
RayTracingShaderGroupCreateInfoNV & setAnyHitShader(uint32_t anyHitShader_)
Definition: vulkan.hpp:37315
RayTracingShaderGroupCreateInfoNV(VkRayTracingShaderGroupCreateInfoNV const &rhs)
Definition: vulkan.hpp:37281
bool operator==(RayTracingShaderGroupCreateInfoNV const &rhs) const
Definition: vulkan.hpp:37337
RayTracingShaderGroupCreateInfoNV & setClosestHitShader(uint32_t closestHitShader_)
Definition: vulkan.hpp:37309
RayTracingShaderGroupCreateInfoNV & operator=(VkRayTracingShaderGroupCreateInfoNV const &rhs)
Definition: vulkan.hpp:37286
bool operator!=(RayTracingShaderGroupCreateInfoNV const &rhs) const
Definition: vulkan.hpp:37348
RayTracingShaderGroupCreateInfoNV & setIntersectionShader(uint32_t intersectionShader_)
Definition: vulkan.hpp:37321
RayTracingShaderGroupCreateInfoNV(RayTracingShaderGroupTypeNV type_=RayTracingShaderGroupTypeNV::eGeneral, uint32_t generalShader_=0, uint32_t closestHitShader_=0, uint32_t anyHitShader_=0, uint32_t intersectionShader_=0)
Definition: vulkan.hpp:37268
Rect2D & operator=(VkRect2D const &rhs)
Definition: vulkan.hpp:5465
Rect2D & setExtent(Extent2D extent_)
Definition: vulkan.hpp:5476
Rect2D & setOffset(Offset2D offset_)
Definition: vulkan.hpp:5470
Rect2D(VkRect2D const &rhs)
Definition: vulkan.hpp:5460
bool operator!=(Rect2D const &rhs) const
Definition: vulkan.hpp:5498
Rect2D(Offset2D offset_=Offset2D(), Extent2D extent_=Extent2D())
Definition: vulkan.hpp:5453
bool operator==(Rect2D const &rhs) const
Definition: vulkan.hpp:5492
RectLayerKHR & setExtent(Extent2D extent_)
Definition: vulkan.hpp:7300
RectLayerKHR & setLayer(uint32_t layer_)
Definition: vulkan.hpp:7306
RectLayerKHR & setOffset(Offset2D offset_)
Definition: vulkan.hpp:7294
RectLayerKHR(Rect2D const &rect2D, uint32_t layer_=0)
Definition: vulkan.hpp:7277
bool operator==(RectLayerKHR const &rhs) const
Definition: vulkan.hpp:7322
RectLayerKHR & operator=(VkRectLayerKHR const &rhs)
Definition: vulkan.hpp:7289
RectLayerKHR(VkRectLayerKHR const &rhs)
Definition: vulkan.hpp:7284
RectLayerKHR(Offset2D offset_=Offset2D(), Extent2D extent_=Extent2D(), uint32_t layer_=0)
Definition: vulkan.hpp:7268
bool operator!=(RectLayerKHR const &rhs) const
Definition: vulkan.hpp:7329
bool operator==(RefreshCycleDurationGOOGLE const &rhs) const
Definition: vulkan.hpp:7466
bool operator!=(RefreshCycleDurationGOOGLE const &rhs) const
Definition: vulkan.hpp:7471
RenderPassBeginInfo & setFramebuffer(Framebuffer framebuffer_)
Definition: vulkan.hpp:11437
RenderPassBeginInfo & operator=(VkRenderPassBeginInfo const &rhs)
Definition: vulkan.hpp:11420
RenderPassBeginInfo(RenderPass renderPass_=RenderPass(), Framebuffer framebuffer_=Framebuffer(), Rect2D renderArea_=Rect2D(), uint32_t clearValueCount_=0, const ClearValue *pClearValues_=nullptr)
Definition: vulkan.hpp:11402
RenderPassBeginInfo & setRenderPass(RenderPass renderPass_)
Definition: vulkan.hpp:11431
RenderPassBeginInfo & setPClearValues(const ClearValue *pClearValues_)
Definition: vulkan.hpp:11455
RenderPassBeginInfo & setRenderArea(Rect2D renderArea_)
Definition: vulkan.hpp:11443
bool operator!=(RenderPassBeginInfo const &rhs) const
Definition: vulkan.hpp:11482
bool operator==(RenderPassBeginInfo const &rhs) const
Definition: vulkan.hpp:11471
RenderPassBeginInfo & setClearValueCount(uint32_t clearValueCount_)
Definition: vulkan.hpp:11449
RenderPassBeginInfo(VkRenderPassBeginInfo const &rhs)
Definition: vulkan.hpp:11415
RenderPassBeginInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:11425
RenderPassCreateInfo2KHR & setPDependencies(const SubpassDependency2KHR *pDependencies_)
Definition: vulkan.hpp:35278
bool operator!=(RenderPassCreateInfo2KHR const &rhs) const
Definition: vulkan.hpp:35321
const SubpassDescription2KHR * pSubpasses
Definition: vulkan.hpp:35335
bool operator==(RenderPassCreateInfo2KHR const &rhs) const
Definition: vulkan.hpp:35306
RenderPassCreateInfo2KHR & setPAttachments(const AttachmentDescription2KHR *pAttachments_)
Definition: vulkan.hpp:35254
RenderPassCreateInfo2KHR & setPCorrelatedViewMasks(const uint32_t *pCorrelatedViewMasks_)
Definition: vulkan.hpp:35290
RenderPassCreateInfo2KHR & setPSubpasses(const SubpassDescription2KHR *pSubpasses_)
Definition: vulkan.hpp:35266
RenderPassCreateInfo2KHR & setDependencyCount(uint32_t dependencyCount_)
Definition: vulkan.hpp:35272
RenderPassCreateInfo2KHR & setPNext(const void *pNext_)
Definition: vulkan.hpp:35236
RenderPassCreateInfo2KHR(VkRenderPassCreateInfo2KHR const &rhs)
Definition: vulkan.hpp:35226
RenderPassCreateInfo2KHR & setFlags(RenderPassCreateFlags flags_)
Definition: vulkan.hpp:35242
RenderPassCreateInfo2KHR & setCorrelatedViewMaskCount(uint32_t correlatedViewMaskCount_)
Definition: vulkan.hpp:35284
const SubpassDependency2KHR * pDependencies
Definition: vulkan.hpp:35337
const AttachmentDescription2KHR * pAttachments
Definition: vulkan.hpp:35333
RenderPassCreateInfo2KHR(RenderPassCreateFlags flags_=RenderPassCreateFlags(), uint32_t attachmentCount_=0, const AttachmentDescription2KHR *pAttachments_=nullptr, uint32_t subpassCount_=0, const SubpassDescription2KHR *pSubpasses_=nullptr, uint32_t dependencyCount_=0, const SubpassDependency2KHR *pDependencies_=nullptr, uint32_t correlatedViewMaskCount_=0, const uint32_t *pCorrelatedViewMasks_=nullptr)
Definition: vulkan.hpp:35205
RenderPassCreateInfo2KHR & operator=(VkRenderPassCreateInfo2KHR const &rhs)
Definition: vulkan.hpp:35231
RenderPassCreateInfo2KHR & setSubpassCount(uint32_t subpassCount_)
Definition: vulkan.hpp:35260
RenderPassCreateInfo2KHR & setAttachmentCount(uint32_t attachmentCount_)
Definition: vulkan.hpp:35248
const SubpassDependency * pDependencies
Definition: vulkan.hpp:35039
RenderPassCreateInfo & setPSubpasses(const SubpassDescription *pSubpasses_)
Definition: vulkan.hpp:34982
RenderPassCreateInfo & setFlags(RenderPassCreateFlags flags_)
Definition: vulkan.hpp:34958
RenderPassCreateInfo & setSubpassCount(uint32_t subpassCount_)
Definition: vulkan.hpp:34976
RenderPassCreateInfo(VkRenderPassCreateInfo const &rhs)
Definition: vulkan.hpp:34942
bool operator==(RenderPassCreateInfo const &rhs) const
Definition: vulkan.hpp:35010
bool operator!=(RenderPassCreateInfo const &rhs) const
Definition: vulkan.hpp:35023
RenderPassCreateInfo & setPAttachments(const AttachmentDescription *pAttachments_)
Definition: vulkan.hpp:34970
RenderPassCreateInfo & setDependencyCount(uint32_t dependencyCount_)
Definition: vulkan.hpp:34988
const AttachmentDescription * pAttachments
Definition: vulkan.hpp:35035
RenderPassCreateInfo(RenderPassCreateFlags flags_=RenderPassCreateFlags(), uint32_t attachmentCount_=0, const AttachmentDescription *pAttachments_=nullptr, uint32_t subpassCount_=0, const SubpassDescription *pSubpasses_=nullptr, uint32_t dependencyCount_=0, const SubpassDependency *pDependencies_=nullptr)
Definition: vulkan.hpp:34925
const SubpassDescription * pSubpasses
Definition: vulkan.hpp:35037
RenderPassCreateInfo & operator=(VkRenderPassCreateInfo const &rhs)
Definition: vulkan.hpp:34947
RenderPassCreateInfo & setPDependencies(const SubpassDependency *pDependencies_)
Definition: vulkan.hpp:34994
RenderPassCreateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:34952
RenderPassCreateInfo & setAttachmentCount(uint32_t attachmentCount_)
Definition: vulkan.hpp:34964
RenderPassInputAttachmentAspectCreateInfo(uint32_t aspectReferenceCount_=0, const InputAttachmentAspectReference *pAspectReferences_=nullptr)
Definition: vulkan.hpp:25689
RenderPassInputAttachmentAspectCreateInfo & setPAspectReferences(const InputAttachmentAspectReference *pAspectReferences_)
Definition: vulkan.hpp:25718
RenderPassInputAttachmentAspectCreateInfo(VkRenderPassInputAttachmentAspectCreateInfo const &rhs)
Definition: vulkan.hpp:25696
RenderPassInputAttachmentAspectCreateInfo & operator=(VkRenderPassInputAttachmentAspectCreateInfo const &rhs)
Definition: vulkan.hpp:25701
bool operator==(RenderPassInputAttachmentAspectCreateInfo const &rhs) const
Definition: vulkan.hpp:25734
RenderPassInputAttachmentAspectCreateInfo & setAspectReferenceCount(uint32_t aspectReferenceCount_)
Definition: vulkan.hpp:25712
const InputAttachmentAspectReference * pAspectReferences
Definition: vulkan.hpp:25753
RenderPassInputAttachmentAspectCreateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:25706
bool operator!=(RenderPassInputAttachmentAspectCreateInfo const &rhs) const
Definition: vulkan.hpp:25742
bool operator==(RenderPassMultiviewCreateInfo const &rhs) const
Definition: vulkan.hpp:14161
RenderPassMultiviewCreateInfo & setPViewOffsets(const int32_t *pViewOffsets_)
Definition: vulkan.hpp:14133
RenderPassMultiviewCreateInfo & setCorrelationMaskCount(uint32_t correlationMaskCount_)
Definition: vulkan.hpp:14139
RenderPassMultiviewCreateInfo & setSubpassCount(uint32_t subpassCount_)
Definition: vulkan.hpp:14115
RenderPassMultiviewCreateInfo & setPCorrelationMasks(const uint32_t *pCorrelationMasks_)
Definition: vulkan.hpp:14145
bool operator!=(RenderPassMultiviewCreateInfo const &rhs) const
Definition: vulkan.hpp:14173
RenderPassMultiviewCreateInfo & setDependencyCount(uint32_t dependencyCount_)
Definition: vulkan.hpp:14127
RenderPassMultiviewCreateInfo & operator=(VkRenderPassMultiviewCreateInfo const &rhs)
Definition: vulkan.hpp:14104
RenderPassMultiviewCreateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:14109
RenderPassMultiviewCreateInfo & setPViewMasks(const uint32_t *pViewMasks_)
Definition: vulkan.hpp:14121
RenderPassMultiviewCreateInfo(uint32_t subpassCount_=0, const uint32_t *pViewMasks_=nullptr, uint32_t dependencyCount_=0, const int32_t *pViewOffsets_=nullptr, uint32_t correlationMaskCount_=0, const uint32_t *pCorrelationMasks_=nullptr)
Definition: vulkan.hpp:14084
RenderPassMultiviewCreateInfo(VkRenderPassMultiviewCreateInfo const &rhs)
Definition: vulkan.hpp:14099
const AttachmentSampleLocationsEXT * pAttachmentInitialSampleLocations
Definition: vulkan.hpp:28271
RenderPassSampleLocationsBeginInfoEXT & setPNext(const void *pNext_)
Definition: vulkan.hpp:28210
const SubpassSampleLocationsEXT * pPostSubpassSampleLocations
Definition: vulkan.hpp:28273
RenderPassSampleLocationsBeginInfoEXT(uint32_t attachmentInitialSampleLocationsCount_=0, const AttachmentSampleLocationsEXT *pAttachmentInitialSampleLocations_=nullptr, uint32_t postSubpassSampleLocationsCount_=0, const SubpassSampleLocationsEXT *pPostSubpassSampleLocations_=nullptr)
Definition: vulkan.hpp:28189
RenderPassSampleLocationsBeginInfoEXT & setPPostSubpassSampleLocations(const SubpassSampleLocationsEXT *pPostSubpassSampleLocations_)
Definition: vulkan.hpp:28234
RenderPassSampleLocationsBeginInfoEXT(VkRenderPassSampleLocationsBeginInfoEXT const &rhs)
Definition: vulkan.hpp:28200
RenderPassSampleLocationsBeginInfoEXT & setPostSubpassSampleLocationsCount(uint32_t postSubpassSampleLocationsCount_)
Definition: vulkan.hpp:28228
bool operator==(RenderPassSampleLocationsBeginInfoEXT const &rhs) const
Definition: vulkan.hpp:28250
RenderPassSampleLocationsBeginInfoEXT & operator=(VkRenderPassSampleLocationsBeginInfoEXT const &rhs)
Definition: vulkan.hpp:28205
RenderPassSampleLocationsBeginInfoEXT & setPAttachmentInitialSampleLocations(const AttachmentSampleLocationsEXT *pAttachmentInitialSampleLocations_)
Definition: vulkan.hpp:28222
bool operator!=(RenderPassSampleLocationsBeginInfoEXT const &rhs) const
Definition: vulkan.hpp:28260
RenderPassSampleLocationsBeginInfoEXT & setAttachmentInitialSampleLocationsCount(uint32_t attachmentInitialSampleLocationsCount_)
Definition: vulkan.hpp:28216
ResultValue(Result r, T &&v)
Definition: vulkan.hpp:991
SampleLocationEXT(float x_=0, float y_=0)
Definition: vulkan.hpp:7630
bool operator==(SampleLocationEXT const &rhs) const
Definition: vulkan.hpp:7669
SampleLocationEXT(VkSampleLocationEXT const &rhs)
Definition: vulkan.hpp:7637
SampleLocationEXT & setY(float y_)
Definition: vulkan.hpp:7653
SampleLocationEXT & setX(float x_)
Definition: vulkan.hpp:7647
bool operator!=(SampleLocationEXT const &rhs) const
Definition: vulkan.hpp:7675
SampleLocationEXT & operator=(VkSampleLocationEXT const &rhs)
Definition: vulkan.hpp:7642
SampleLocationsInfoEXT(VkSampleLocationsInfoEXT const &rhs)
Definition: vulkan.hpp:27996
bool operator==(SampleLocationsInfoEXT const &rhs) const
Definition: vulkan.hpp:28046
SampleLocationsInfoEXT & setSampleLocationGridSize(Extent2D sampleLocationGridSize_)
Definition: vulkan.hpp:28018
const SampleLocationEXT * pSampleLocations
Definition: vulkan.hpp:28069
SampleLocationsInfoEXT & setSampleLocationsPerPixel(SampleCountFlagBits sampleLocationsPerPixel_)
Definition: vulkan.hpp:28012
SampleLocationsInfoEXT & setPSampleLocations(const SampleLocationEXT *pSampleLocations_)
Definition: vulkan.hpp:28030
SampleLocationsInfoEXT & operator=(VkSampleLocationsInfoEXT const &rhs)
Definition: vulkan.hpp:28001
SampleLocationsInfoEXT(SampleCountFlagBits sampleLocationsPerPixel_=SampleCountFlagBits::e1, Extent2D sampleLocationGridSize_=Extent2D(), uint32_t sampleLocationsCount_=0, const SampleLocationEXT *pSampleLocations_=nullptr)
Definition: vulkan.hpp:27985
SampleLocationsInfoEXT & setPNext(const void *pNext_)
Definition: vulkan.hpp:28006
bool operator!=(SampleLocationsInfoEXT const &rhs) const
Definition: vulkan.hpp:28056
SampleLocationsInfoEXT & setSampleLocationsCount(uint32_t sampleLocationsCount_)
Definition: vulkan.hpp:28024
bool operator!=(SamplerCreateInfo const &rhs) const
Definition: vulkan.hpp:11291
SamplerCreateInfo & setMaxAnisotropy(float maxAnisotropy_)
Definition: vulkan.hpp:11217
SamplerCreateInfo & setMipLodBias(float mipLodBias_)
Definition: vulkan.hpp:11205
SamplerCreateInfo & setBorderColor(BorderColor borderColor_)
Definition: vulkan.hpp:11247
SamplerCreateInfo & setCompareEnable(Bool32 compareEnable_)
Definition: vulkan.hpp:11223
SamplerCreateInfo & setMinFilter(Filter minFilter_)
Definition: vulkan.hpp:11175
SamplerCreateInfo & setMinLod(float minLod_)
Definition: vulkan.hpp:11235
SamplerCreateInfo & setCompareOp(CompareOp compareOp_)
Definition: vulkan.hpp:11229
SamplerCreateInfo(VkSamplerCreateInfo const &rhs)
Definition: vulkan.hpp:11147
bool operator==(SamplerCreateInfo const &rhs) const
Definition: vulkan.hpp:11269
SamplerCreateInfo(SamplerCreateFlags flags_=SamplerCreateFlags(), Filter magFilter_=Filter::eNearest, Filter minFilter_=Filter::eNearest, SamplerMipmapMode mipmapMode_=SamplerMipmapMode::eNearest, SamplerAddressMode addressModeU_=SamplerAddressMode::eRepeat, SamplerAddressMode addressModeV_=SamplerAddressMode::eRepeat, SamplerAddressMode addressModeW_=SamplerAddressMode::eRepeat, float mipLodBias_=0, Bool32 anisotropyEnable_=0, float maxAnisotropy_=0, Bool32 compareEnable_=0, CompareOp compareOp_=CompareOp::eNever, float minLod_=0, float maxLod_=0, BorderColor borderColor_=BorderColor::eFloatTransparentBlack, Bool32 unnormalizedCoordinates_=0)
Definition: vulkan.hpp:11112
SamplerCreateInfo & setFlags(SamplerCreateFlags flags_)
Definition: vulkan.hpp:11163
SamplerCreateInfo & setAddressModeU(SamplerAddressMode addressModeU_)
Definition: vulkan.hpp:11187
SamplerCreateInfo & setAnisotropyEnable(Bool32 anisotropyEnable_)
Definition: vulkan.hpp:11211
SamplerCreateInfo & setAddressModeW(SamplerAddressMode addressModeW_)
Definition: vulkan.hpp:11199
SamplerCreateInfo & setMaxLod(float maxLod_)
Definition: vulkan.hpp:11241
SamplerCreateInfo & setUnnormalizedCoordinates(Bool32 unnormalizedCoordinates_)
Definition: vulkan.hpp:11253
SamplerCreateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:11157
SamplerCreateInfo & setMipmapMode(SamplerMipmapMode mipmapMode_)
Definition: vulkan.hpp:11181
SamplerCreateInfo & operator=(VkSamplerCreateInfo const &rhs)
Definition: vulkan.hpp:11152
SamplerCreateInfo & setAddressModeV(SamplerAddressMode addressModeV_)
Definition: vulkan.hpp:11193
SamplerCreateInfo & setMagFilter(Filter magFilter_)
Definition: vulkan.hpp:11169
bool operator==(SamplerReductionModeCreateInfoEXT const &rhs) const
Definition: vulkan.hpp:35432
SamplerReductionModeCreateInfoEXT(SamplerReductionModeEXT reductionMode_=SamplerReductionModeEXT::eWeightedAverage)
Definition: vulkan.hpp:35395
SamplerReductionModeCreateInfoEXT & operator=(VkSamplerReductionModeCreateInfoEXT const &rhs)
Definition: vulkan.hpp:35405
bool operator!=(SamplerReductionModeCreateInfoEXT const &rhs) const
Definition: vulkan.hpp:35439
SamplerReductionModeCreateInfoEXT & setReductionMode(SamplerReductionModeEXT reductionMode_)
Definition: vulkan.hpp:35416
SamplerReductionModeCreateInfoEXT(VkSamplerReductionModeCreateInfoEXT const &rhs)
Definition: vulkan.hpp:35400
SamplerReductionModeCreateInfoEXT & setPNext(const void *pNext_)
Definition: vulkan.hpp:35410
SamplerYcbcrConversionCreateInfo & setFormat(Format format_)
Definition: vulkan.hpp:35590
SamplerYcbcrConversionCreateInfo & setChromaFilter(Filter chromaFilter_)
Definition: vulkan.hpp:35626
SamplerYcbcrConversionCreateInfo & setXChromaOffset(ChromaLocation xChromaOffset_)
Definition: vulkan.hpp:35614
SamplerYcbcrConversionCreateInfo(VkSamplerYcbcrConversionCreateInfo const &rhs)
Definition: vulkan.hpp:35574
SamplerYcbcrConversionCreateInfo & setYChromaOffset(ChromaLocation yChromaOffset_)
Definition: vulkan.hpp:35620
SamplerYcbcrConversionCreateInfo(Format format_=Format::eUndefined, SamplerYcbcrModelConversion ycbcrModel_=SamplerYcbcrModelConversion::eRgbIdentity, SamplerYcbcrRange ycbcrRange_=SamplerYcbcrRange::eItuFull, ComponentMapping components_=ComponentMapping(), ChromaLocation xChromaOffset_=ChromaLocation::eCositedEven, ChromaLocation yChromaOffset_=ChromaLocation::eCositedEven, Filter chromaFilter_=Filter::eNearest, Bool32 forceExplicitReconstruction_=0)
Definition: vulkan.hpp:35555
SamplerYcbcrConversionCreateInfo & operator=(VkSamplerYcbcrConversionCreateInfo const &rhs)
Definition: vulkan.hpp:35579
SamplerYcbcrConversionCreateInfo & setYcbcrModel(SamplerYcbcrModelConversion ycbcrModel_)
Definition: vulkan.hpp:35596
bool operator!=(SamplerYcbcrConversionCreateInfo const &rhs) const
Definition: vulkan.hpp:35662
SamplerYcbcrConversionCreateInfo & setComponents(ComponentMapping components_)
Definition: vulkan.hpp:35608
SamplerYcbcrConversionCreateInfo & setForceExplicitReconstruction(Bool32 forceExplicitReconstruction_)
Definition: vulkan.hpp:35632
bool operator==(SamplerYcbcrConversionCreateInfo const &rhs) const
Definition: vulkan.hpp:35648
SamplerYcbcrConversionCreateInfo & setYcbcrRange(SamplerYcbcrRange ycbcrRange_)
Definition: vulkan.hpp:35602
SamplerYcbcrConversionCreateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:35584
bool operator==(SamplerYcbcrConversionImageFormatProperties const &rhs) const
Definition: vulkan.hpp:16351
bool operator!=(SamplerYcbcrConversionImageFormatProperties const &rhs) const
Definition: vulkan.hpp:16358
SamplerYcbcrConversionInfo & operator=(VkSamplerYcbcrConversionInfo const &rhs)
Definition: vulkan.hpp:16227
bool operator==(SamplerYcbcrConversionInfo const &rhs) const
Definition: vulkan.hpp:16254
SamplerYcbcrConversionInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:16232
SamplerYcbcrConversionInfo(VkSamplerYcbcrConversionInfo const &rhs)
Definition: vulkan.hpp:16222
bool operator!=(SamplerYcbcrConversionInfo const &rhs) const
Definition: vulkan.hpp:16261
SamplerYcbcrConversionInfo(SamplerYcbcrConversion conversion_=SamplerYcbcrConversion())
Definition: vulkan.hpp:16217
SamplerYcbcrConversionInfo & setConversion(SamplerYcbcrConversion conversion_)
Definition: vulkan.hpp:16238
bool operator!=(SemaphoreCreateInfo const &rhs) const
Definition: vulkan.hpp:11606
bool operator==(SemaphoreCreateInfo const &rhs) const
Definition: vulkan.hpp:11599
SemaphoreCreateInfo(VkSemaphoreCreateInfo const &rhs)
Definition: vulkan.hpp:11567
SemaphoreCreateInfo(SemaphoreCreateFlags flags_=SemaphoreCreateFlags())
Definition: vulkan.hpp:11562
SemaphoreCreateInfo & operator=(VkSemaphoreCreateInfo const &rhs)
Definition: vulkan.hpp:11572
SemaphoreCreateInfo & setFlags(SemaphoreCreateFlags flags_)
Definition: vulkan.hpp:11583
SemaphoreCreateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:11577
SemaphoreGetFdInfoKHR & setSemaphore(Semaphore semaphore_)
Definition: vulkan.hpp:32664
SemaphoreGetFdInfoKHR & setPNext(const void *pNext_)
Definition: vulkan.hpp:32658
ExternalSemaphoreHandleTypeFlagBits handleType
Definition: vulkan.hpp:32705
bool operator!=(SemaphoreGetFdInfoKHR const &rhs) const
Definition: vulkan.hpp:32694
SemaphoreGetFdInfoKHR(Semaphore semaphore_=Semaphore(), ExternalSemaphoreHandleTypeFlagBits handleType_=ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd)
Definition: vulkan.hpp:32641
SemaphoreGetFdInfoKHR & setHandleType(ExternalSemaphoreHandleTypeFlagBits handleType_)
Definition: vulkan.hpp:32670
SemaphoreGetFdInfoKHR(VkSemaphoreGetFdInfoKHR const &rhs)
Definition: vulkan.hpp:32648
SemaphoreGetFdInfoKHR & operator=(VkSemaphoreGetFdInfoKHR const &rhs)
Definition: vulkan.hpp:32653
bool operator==(SemaphoreGetFdInfoKHR const &rhs) const
Definition: vulkan.hpp:32686
ShaderModuleCreateInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:10231
ShaderModuleCreateInfo & operator=(VkShaderModuleCreateInfo const &rhs)
Definition: vulkan.hpp:10226
ShaderModuleCreateInfo & setPCode(const uint32_t *pCode_)
Definition: vulkan.hpp:10249
ShaderModuleCreateInfo & setCodeSize(size_t codeSize_)
Definition: vulkan.hpp:10243
bool operator!=(ShaderModuleCreateInfo const &rhs) const
Definition: vulkan.hpp:10274
bool operator==(ShaderModuleCreateInfo const &rhs) const
Definition: vulkan.hpp:10265
ShaderModuleCreateInfo & setFlags(ShaderModuleCreateFlags flags_)
Definition: vulkan.hpp:10237
ShaderModuleCreateInfo(ShaderModuleCreateFlags flags_=ShaderModuleCreateFlags(), size_t codeSize_=0, const uint32_t *pCode_=nullptr)
Definition: vulkan.hpp:10212
ShaderModuleCreateInfo(VkShaderModuleCreateInfo const &rhs)
Definition: vulkan.hpp:10221
bool operator==(ShaderModuleValidationCacheCreateInfoEXT const &rhs) const
Definition: vulkan.hpp:17233
ShaderModuleValidationCacheCreateInfoEXT & setValidationCache(ValidationCacheEXT validationCache_)
Definition: vulkan.hpp:17217
ShaderModuleValidationCacheCreateInfoEXT(ValidationCacheEXT validationCache_=ValidationCacheEXT())
Definition: vulkan.hpp:17196
ShaderModuleValidationCacheCreateInfoEXT(VkShaderModuleValidationCacheCreateInfoEXT const &rhs)
Definition: vulkan.hpp:17201
ShaderModuleValidationCacheCreateInfoEXT & operator=(VkShaderModuleValidationCacheCreateInfoEXT const &rhs)
Definition: vulkan.hpp:17206
bool operator!=(ShaderModuleValidationCacheCreateInfoEXT const &rhs) const
Definition: vulkan.hpp:17240
ShaderModuleValidationCacheCreateInfoEXT & setPNext(const void *pNext_)
Definition: vulkan.hpp:17211
bool operator==(ShaderResourceUsageAMD const &rhs) const
Definition: vulkan.hpp:7697
bool operator!=(ShaderResourceUsageAMD const &rhs) const
Definition: vulkan.hpp:7706
bool operator!=(ShaderStatisticsInfoAMD const &rhs) const
Definition: vulkan.hpp:23338
bool operator==(ShaderStatisticsInfoAMD const &rhs) const
Definition: vulkan.hpp:23327
ShadingRatePaletteNV & operator=(VkShadingRatePaletteNV const &rhs)
Definition: vulkan.hpp:36543
ShadingRatePaletteNV(VkShadingRatePaletteNV const &rhs)
Definition: vulkan.hpp:36538
ShadingRatePaletteNV(uint32_t shadingRatePaletteEntryCount_=0, const ShadingRatePaletteEntryNV *pShadingRatePaletteEntries_=nullptr)
Definition: vulkan.hpp:36531
ShadingRatePaletteNV & setShadingRatePaletteEntryCount(uint32_t shadingRatePaletteEntryCount_)
Definition: vulkan.hpp:36548
const ShadingRatePaletteEntryNV * pShadingRatePaletteEntries
Definition: vulkan.hpp:36582
bool operator!=(ShadingRatePaletteNV const &rhs) const
Definition: vulkan.hpp:36576
ShadingRatePaletteNV & setPShadingRatePaletteEntries(const ShadingRatePaletteEntryNV *pShadingRatePaletteEntries_)
Definition: vulkan.hpp:36554
bool operator==(ShadingRatePaletteNV const &rhs) const
Definition: vulkan.hpp:36570
bool operator!=(SharedPresentSurfaceCapabilitiesKHR const &rhs) const
Definition: vulkan.hpp:23405
bool operator==(SharedPresentSurfaceCapabilitiesKHR const &rhs) const
Definition: vulkan.hpp:23398
bool operator==(SparseBufferMemoryBindInfo const &rhs) const
Definition: vulkan.hpp:26382
bool operator!=(SparseBufferMemoryBindInfo const &rhs) const
Definition: vulkan.hpp:26389
SparseBufferMemoryBindInfo & operator=(VkSparseBufferMemoryBindInfo const &rhs)
Definition: vulkan.hpp:26349
SparseBufferMemoryBindInfo(Buffer buffer_=Buffer(), uint32_t bindCount_=0, const SparseMemoryBind *pBinds_=nullptr)
Definition: vulkan.hpp:26335
SparseBufferMemoryBindInfo & setBuffer(Buffer buffer_)
Definition: vulkan.hpp:26354
SparseBufferMemoryBindInfo & setBindCount(uint32_t bindCount_)
Definition: vulkan.hpp:26360
SparseBufferMemoryBindInfo & setPBinds(const SparseMemoryBind *pBinds_)
Definition: vulkan.hpp:26366
SparseBufferMemoryBindInfo(VkSparseBufferMemoryBindInfo const &rhs)
Definition: vulkan.hpp:26344
bool operator==(SparseImageFormatProperties2 const &rhs) const
Definition: vulkan.hpp:26066
bool operator!=(SparseImageFormatProperties2 const &rhs) const
Definition: vulkan.hpp:26073
bool operator==(SparseImageFormatProperties const &rhs) const
Definition: vulkan.hpp:26002
bool operator!=(SparseImageFormatProperties const &rhs) const
Definition: vulkan.hpp:26009
SparseImageMemoryBind(ImageSubresource subresource_=ImageSubresource(), Offset3D offset_=Offset3D(), Extent3D extent_=Extent3D(), DeviceMemory memory_=DeviceMemory(), DeviceSize memoryOffset_=0, SparseMemoryBindFlags flags_=SparseMemoryBindFlags())
Definition: vulkan.hpp:26238
SparseImageMemoryBind & operator=(VkSparseImageMemoryBind const &rhs)
Definition: vulkan.hpp:26258
bool operator==(SparseImageMemoryBind const &rhs) const
Definition: vulkan.hpp:26309
SparseImageMemoryBind & setMemoryOffset(DeviceSize memoryOffset_)
Definition: vulkan.hpp:26287
SparseImageMemoryBind & setFlags(SparseMemoryBindFlags flags_)
Definition: vulkan.hpp:26293
SparseImageMemoryBind & setOffset(Offset3D offset_)
Definition: vulkan.hpp:26269
SparseImageMemoryBind & setExtent(Extent3D extent_)
Definition: vulkan.hpp:26275
bool operator!=(SparseImageMemoryBind const &rhs) const
Definition: vulkan.hpp:26319
SparseImageMemoryBind & setMemory(DeviceMemory memory_)
Definition: vulkan.hpp:26281
SparseImageMemoryBind(VkSparseImageMemoryBind const &rhs)
Definition: vulkan.hpp:26253
SparseImageMemoryBind & setSubresource(ImageSubresource subresource_)
Definition: vulkan.hpp:26263
SparseImageMemoryBindInfo(Image image_=Image(), uint32_t bindCount_=0, const SparseImageMemoryBind *pBinds_=nullptr)
Definition: vulkan.hpp:26469
SparseImageMemoryBindInfo & setBindCount(uint32_t bindCount_)
Definition: vulkan.hpp:26494
SparseImageMemoryBindInfo & setImage(Image image_)
Definition: vulkan.hpp:26488
bool operator!=(SparseImageMemoryBindInfo const &rhs) const
Definition: vulkan.hpp:26523
SparseImageMemoryBindInfo(VkSparseImageMemoryBindInfo const &rhs)
Definition: vulkan.hpp:26478
SparseImageMemoryBindInfo & setPBinds(const SparseImageMemoryBind *pBinds_)
Definition: vulkan.hpp:26500
SparseImageMemoryBindInfo & operator=(VkSparseImageMemoryBindInfo const &rhs)
Definition: vulkan.hpp:26483
bool operator==(SparseImageMemoryBindInfo const &rhs) const
Definition: vulkan.hpp:26516
const SparseImageMemoryBind * pBinds
Definition: vulkan.hpp:26530
bool operator==(SparseImageMemoryRequirements2 const &rhs) const
Definition: vulkan.hpp:26101
SparseImageMemoryRequirements memoryRequirements
Definition: vulkan.hpp:26118
bool operator!=(SparseImageMemoryRequirements2 const &rhs) const
Definition: vulkan.hpp:26108
bool operator==(SparseImageMemoryRequirements const &rhs) const
Definition: vulkan.hpp:26032
bool operator!=(SparseImageMemoryRequirements const &rhs) const
Definition: vulkan.hpp:26041
SparseImageOpaqueMemoryBindInfo(VkSparseImageOpaqueMemoryBindInfo const &rhs)
Definition: vulkan.hpp:26411
SparseImageOpaqueMemoryBindInfo(Image image_=Image(), uint32_t bindCount_=0, const SparseMemoryBind *pBinds_=nullptr)
Definition: vulkan.hpp:26402
SparseImageOpaqueMemoryBindInfo & setBindCount(uint32_t bindCount_)
Definition: vulkan.hpp:26427
bool operator!=(SparseImageOpaqueMemoryBindInfo const &rhs) const
Definition: vulkan.hpp:26456
SparseImageOpaqueMemoryBindInfo & operator=(VkSparseImageOpaqueMemoryBindInfo const &rhs)
Definition: vulkan.hpp:26416
bool operator==(SparseImageOpaqueMemoryBindInfo const &rhs) const
Definition: vulkan.hpp:26449
SparseImageOpaqueMemoryBindInfo & setImage(Image image_)
Definition: vulkan.hpp:26421
SparseImageOpaqueMemoryBindInfo & setPBinds(const SparseMemoryBind *pBinds_)
Definition: vulkan.hpp:26433
SparseMemoryBind & setResourceOffset(DeviceSize resourceOffset_)
Definition: vulkan.hpp:26174
SparseMemoryBind & setFlags(SparseMemoryBindFlags flags_)
Definition: vulkan.hpp:26198
SparseMemoryBind(VkSparseMemoryBind const &rhs)
Definition: vulkan.hpp:26164
SparseMemoryBind & setMemoryOffset(DeviceSize memoryOffset_)
Definition: vulkan.hpp:26192
SparseMemoryBind & setMemory(DeviceMemory memory_)
Definition: vulkan.hpp:26186
SparseMemoryBind & operator=(VkSparseMemoryBind const &rhs)
Definition: vulkan.hpp:26169
SparseMemoryBind & setSize(DeviceSize size_)
Definition: vulkan.hpp:26180
bool operator==(SparseMemoryBind const &rhs) const
Definition: vulkan.hpp:26214
SparseMemoryBind(DeviceSize resourceOffset_=0, DeviceSize size_=0, DeviceMemory memory_=DeviceMemory(), DeviceSize memoryOffset_=0, SparseMemoryBindFlags flags_=SparseMemoryBindFlags())
Definition: vulkan.hpp:26151
bool operator!=(SparseMemoryBind const &rhs) const
Definition: vulkan.hpp:26223
const SpecializationMapEntry * pMapEntries
Definition: vulkan.hpp:6068
SpecializationInfo & setPData(const void *pData_)
Definition: vulkan.hpp:6038
bool operator!=(SpecializationInfo const &rhs) const
Definition: vulkan.hpp:6062
SpecializationInfo(uint32_t mapEntryCount_=0, const SpecializationMapEntry *pMapEntries_=nullptr, size_t dataSize_=0, const void *pData_=nullptr)
Definition: vulkan.hpp:5999
SpecializationInfo & operator=(VkSpecializationInfo const &rhs)
Definition: vulkan.hpp:6015
bool operator==(SpecializationInfo const &rhs) const
Definition: vulkan.hpp:6054
SpecializationInfo & setPMapEntries(const SpecializationMapEntry *pMapEntries_)
Definition: vulkan.hpp:6026
SpecializationInfo & setDataSize(size_t dataSize_)
Definition: vulkan.hpp:6032
SpecializationInfo & setMapEntryCount(uint32_t mapEntryCount_)
Definition: vulkan.hpp:6020
SpecializationInfo(VkSpecializationInfo const &rhs)
Definition: vulkan.hpp:6010
Definition: vulkan.hpp:5931
bool operator!=(SpecializationMapEntry const &rhs) const
Definition: vulkan.hpp:5986
uint32_t offset
Definition: vulkan.hpp:5992
SpecializationMapEntry(uint32_t constantID_=0, uint32_t offset_=0, size_t size_=0)
Definition: vulkan.hpp:5932
uint32_t constantID
Definition: vulkan.hpp:5991
SpecializationMapEntry & setConstantID(uint32_t constantID_)
Definition: vulkan.hpp:5951
SpecializationMapEntry & operator=(VkSpecializationMapEntry const &rhs)
Definition: vulkan.hpp:5946
SpecializationMapEntry & setSize(size_t size_)
Definition: vulkan.hpp:5963
SpecializationMapEntry(VkSpecializationMapEntry const &rhs)
Definition: vulkan.hpp:5941
bool operator==(SpecializationMapEntry const &rhs) const
Definition: vulkan.hpp:5979
SpecializationMapEntry & setOffset(uint32_t offset_)
Definition: vulkan.hpp:5957
size_t size
Definition: vulkan.hpp:5993
StencilOpState & setDepthFailOp(StencilOp depthFailOp_)
Definition: vulkan.hpp:8615
StencilOpState & setCompareOp(CompareOp compareOp_)
Definition: vulkan.hpp:8621
StencilOpState & setFailOp(StencilOp failOp_)
Definition: vulkan.hpp:8603
StencilOpState & setReference(uint32_t reference_)
Definition: vulkan.hpp:8639
StencilOpState & setPassOp(StencilOp passOp_)
Definition: vulkan.hpp:8609
bool operator==(StencilOpState const &rhs) const
Definition: vulkan.hpp:8655
StencilOpState(StencilOp failOp_=StencilOp::eKeep, StencilOp passOp_=StencilOp::eKeep, StencilOp depthFailOp_=StencilOp::eKeep, CompareOp compareOp_=CompareOp::eNever, uint32_t compareMask_=0, uint32_t writeMask_=0, uint32_t reference_=0)
Definition: vulkan.hpp:8576
StencilOpState & setWriteMask(uint32_t writeMask_)
Definition: vulkan.hpp:8633
StencilOpState & setCompareMask(uint32_t compareMask_)
Definition: vulkan.hpp:8627
StencilOpState & operator=(VkStencilOpState const &rhs)
Definition: vulkan.hpp:8598
bool operator!=(StencilOpState const &rhs) const
Definition: vulkan.hpp:8666
StencilOpState(VkStencilOpState const &rhs)
Definition: vulkan.hpp:8593
const Semaphore * pSignalSemaphores
Definition: vulkan.hpp:39645
SubmitInfo & operator=(VkSubmitInfo const &rhs)
Definition: vulkan.hpp:39553
SubmitInfo & setWaitSemaphoreCount(uint32_t waitSemaphoreCount_)
Definition: vulkan.hpp:39564
SubmitInfo & setPWaitSemaphores(const Semaphore *pWaitSemaphores_)
Definition: vulkan.hpp:39570
SubmitInfo(VkSubmitInfo const &rhs)
Definition: vulkan.hpp:39548
const PipelineStageFlags * pWaitDstStageMask
Definition: vulkan.hpp:39641
SubmitInfo & setPSignalSemaphores(const Semaphore *pSignalSemaphores_)
Definition: vulkan.hpp:39600
bool operator==(SubmitInfo const &rhs) const
Definition: vulkan.hpp:39616
SubmitInfo & setPNext(const void *pNext_)
Definition: vulkan.hpp:39558
SubmitInfo & setPCommandBuffers(const CommandBuffer *pCommandBuffers_)
Definition: vulkan.hpp:39588
SubmitInfo(uint32_t waitSemaphoreCount_=0, const Semaphore *pWaitSemaphores_=nullptr, const PipelineStageFlags *pWaitDstStageMask_=nullptr, uint32_t commandBufferCount_=0, const CommandBuffer *pCommandBuffers_=nullptr, uint32_t signalSemaphoreCount_=0, const Semaphore *pSignalSemaphores_=nullptr)
Definition: vulkan.hpp:39531
bool operator!=(SubmitInfo const &rhs) const
Definition: vulkan.hpp:39629
const Semaphore * pWaitSemaphores
Definition: vulkan.hpp:39640
SubmitInfo & setCommandBufferCount(uint32_t commandBufferCount_)
Definition: vulkan.hpp:39582
SubmitInfo & setPWaitDstStageMask(const PipelineStageFlags *pWaitDstStageMask_)
Definition: vulkan.hpp:39576
SubmitInfo & setSignalSemaphoreCount(uint32_t signalSemaphoreCount_)
Definition: vulkan.hpp:39594
const CommandBuffer * pCommandBuffers
Definition: vulkan.hpp:39643
SubpassBeginInfoKHR(SubpassContents contents_=SubpassContents::eInline)
Definition: vulkan.hpp:21124
bool operator!=(SubpassBeginInfoKHR const &rhs) const
Definition: vulkan.hpp:21168
SubpassBeginInfoKHR & setContents(SubpassContents contents_)
Definition: vulkan.hpp:21145
SubpassBeginInfoKHR(VkSubpassBeginInfoKHR const &rhs)
Definition: vulkan.hpp:21129
bool operator==(SubpassBeginInfoKHR const &rhs) const
Definition: vulkan.hpp:21161
SubpassBeginInfoKHR & setPNext(const void *pNext_)
Definition: vulkan.hpp:21139
SubpassBeginInfoKHR & operator=(VkSubpassBeginInfoKHR const &rhs)
Definition: vulkan.hpp:21134
SubpassDependency2KHR & setDependencyFlags(DependencyFlags dependencyFlags_)
Definition: vulkan.hpp:29032
SubpassDependency2KHR & setSrcSubpass(uint32_t srcSubpass_)
Definition: vulkan.hpp:28996
SubpassDependency2KHR & setDstStageMask(PipelineStageFlags dstStageMask_)
Definition: vulkan.hpp:29014
bool operator!=(SubpassDependency2KHR const &rhs) const
Definition: vulkan.hpp:29068
SubpassDependency2KHR & operator=(VkSubpassDependency2KHR const &rhs)
Definition: vulkan.hpp:28985
SubpassDependency2KHR & setDstAccessMask(AccessFlags dstAccessMask_)
Definition: vulkan.hpp:29026
SubpassDependency2KHR & setSrcAccessMask(AccessFlags srcAccessMask_)
Definition: vulkan.hpp:29020
SubpassDependency2KHR(uint32_t srcSubpass_=0, uint32_t dstSubpass_=0, PipelineStageFlags srcStageMask_=PipelineStageFlags(), PipelineStageFlags dstStageMask_=PipelineStageFlags(), AccessFlags srcAccessMask_=AccessFlags(), AccessFlags dstAccessMask_=AccessFlags(), DependencyFlags dependencyFlags_=DependencyFlags(), int32_t viewOffset_=0)
Definition: vulkan.hpp:28961
SubpassDependency2KHR & setViewOffset(int32_t viewOffset_)
Definition: vulkan.hpp:29038
SubpassDependency2KHR & setSrcStageMask(PipelineStageFlags srcStageMask_)
Definition: vulkan.hpp:29008
SubpassDependency2KHR & setDstSubpass(uint32_t dstSubpass_)
Definition: vulkan.hpp:29002
SubpassDependency2KHR(VkSubpassDependency2KHR const &rhs)
Definition: vulkan.hpp:28980
bool operator==(SubpassDependency2KHR const &rhs) const
Definition: vulkan.hpp:29054
SubpassDependency2KHR & setPNext(const void *pNext_)
Definition: vulkan.hpp:28990
bool operator!=(SubpassDependency const &rhs) const
Definition: vulkan.hpp:28944
SubpassDependency(uint32_t srcSubpass_=0, uint32_t dstSubpass_=0, PipelineStageFlags srcStageMask_=PipelineStageFlags(), PipelineStageFlags dstStageMask_=PipelineStageFlags(), AccessFlags srcAccessMask_=AccessFlags(), AccessFlags dstAccessMask_=AccessFlags(), DependencyFlags dependencyFlags_=DependencyFlags())
Definition: vulkan.hpp:28854
SubpassDependency & setDependencyFlags(DependencyFlags dependencyFlags_)
Definition: vulkan.hpp:28917
bool operator==(SubpassDependency const &rhs) const
Definition: vulkan.hpp:28933
SubpassDependency(VkSubpassDependency const &rhs)
Definition: vulkan.hpp:28871
SubpassDependency & setDstAccessMask(AccessFlags dstAccessMask_)
Definition: vulkan.hpp:28911
SubpassDependency & setDstSubpass(uint32_t dstSubpass_)
Definition: vulkan.hpp:28887
SubpassDependency & setSrcSubpass(uint32_t srcSubpass_)
Definition: vulkan.hpp:28881
SubpassDependency & operator=(VkSubpassDependency const &rhs)
Definition: vulkan.hpp:28876
SubpassDependency & setSrcAccessMask(AccessFlags srcAccessMask_)
Definition: vulkan.hpp:28905
SubpassDependency & setSrcStageMask(PipelineStageFlags srcStageMask_)
Definition: vulkan.hpp:28893
SubpassDependency & setDstStageMask(PipelineStageFlags dstStageMask_)
Definition: vulkan.hpp:28899
SubpassDescription2KHR & setPipelineBindPoint(PipelineBindPoint pipelineBindPoint_)
Definition: vulkan.hpp:35092
SubpassDescription2KHR & operator=(VkSubpassDescription2KHR const &rhs)
Definition: vulkan.hpp:35075
SubpassDescription2KHR & setPColorAttachments(const AttachmentReference2KHR *pColorAttachments_)
Definition: vulkan.hpp:35122
bool operator==(SubpassDescription2KHR const &rhs) const
Definition: vulkan.hpp:35162
SubpassDescription2KHR & setPNext(const void *pNext_)
Definition: vulkan.hpp:35080
SubpassDescription2KHR & setViewMask(uint32_t viewMask_)
Definition: vulkan.hpp:35098
const AttachmentReference2KHR * pResolveAttachments
Definition: vulkan.hpp:35196
SubpassDescription2KHR & setPPreserveAttachments(const uint32_t *pPreserveAttachments_)
Definition: vulkan.hpp:35146
SubpassDescription2KHR & setPDepthStencilAttachment(const AttachmentReference2KHR *pDepthStencilAttachment_)
Definition: vulkan.hpp:35134
bool operator!=(SubpassDescription2KHR const &rhs) const
Definition: vulkan.hpp:35179
const AttachmentReference2KHR * pColorAttachments
Definition: vulkan.hpp:35195
const AttachmentReference2KHR * pInputAttachments
Definition: vulkan.hpp:35193
SubpassDescription2KHR(SubpassDescriptionFlags flags_=SubpassDescriptionFlags(), PipelineBindPoint pipelineBindPoint_=PipelineBindPoint::eGraphics, uint32_t viewMask_=0, uint32_t inputAttachmentCount_=0, const AttachmentReference2KHR *pInputAttachments_=nullptr, uint32_t colorAttachmentCount_=0, const AttachmentReference2KHR *pColorAttachments_=nullptr, const AttachmentReference2KHR *pResolveAttachments_=nullptr, const AttachmentReference2KHR *pDepthStencilAttachment_=nullptr, uint32_t preserveAttachmentCount_=0, const uint32_t *pPreserveAttachments_=nullptr)
Definition: vulkan.hpp:35045
const AttachmentReference2KHR * pDepthStencilAttachment
Definition: vulkan.hpp:35197
SubpassDescription2KHR & setPreserveAttachmentCount(uint32_t preserveAttachmentCount_)
Definition: vulkan.hpp:35140
SubpassDescription2KHR & setColorAttachmentCount(uint32_t colorAttachmentCount_)
Definition: vulkan.hpp:35116
SubpassDescription2KHR & setInputAttachmentCount(uint32_t inputAttachmentCount_)
Definition: vulkan.hpp:35104
SubpassDescription2KHR & setPInputAttachments(const AttachmentReference2KHR *pInputAttachments_)
Definition: vulkan.hpp:35110
SubpassDescription2KHR & setPResolveAttachments(const AttachmentReference2KHR *pResolveAttachments_)
Definition: vulkan.hpp:35128
SubpassDescription2KHR(VkSubpassDescription2KHR const &rhs)
Definition: vulkan.hpp:35070
SubpassDescription2KHR & setFlags(SubpassDescriptionFlags flags_)
Definition: vulkan.hpp:35086
const AttachmentReference * pInputAttachments
Definition: vulkan.hpp:34913
SubpassDescription & setPDepthStencilAttachment(const AttachmentReference *pDepthStencilAttachment_)
Definition: vulkan.hpp:34863
const AttachmentReference * pColorAttachments
Definition: vulkan.hpp:34915
SubpassDescription(SubpassDescriptionFlags flags_=SubpassDescriptionFlags(), PipelineBindPoint pipelineBindPoint_=PipelineBindPoint::eGraphics, uint32_t inputAttachmentCount_=0, const AttachmentReference *pInputAttachments_=nullptr, uint32_t colorAttachmentCount_=0, const AttachmentReference *pColorAttachments_=nullptr, const AttachmentReference *pResolveAttachments_=nullptr, const AttachmentReference *pDepthStencilAttachment_=nullptr, uint32_t preserveAttachmentCount_=0, const uint32_t *pPreserveAttachments_=nullptr)
Definition: vulkan.hpp:34788
SubpassDescription & setPColorAttachments(const AttachmentReference *pColorAttachments_)
Definition: vulkan.hpp:34851
SubpassDescription(VkSubpassDescription const &rhs)
Definition: vulkan.hpp:34811
SubpassDescription & setColorAttachmentCount(uint32_t colorAttachmentCount_)
Definition: vulkan.hpp:34845
SubpassDescription & setPreserveAttachmentCount(uint32_t preserveAttachmentCount_)
Definition: vulkan.hpp:34869
SubpassDescription & setInputAttachmentCount(uint32_t inputAttachmentCount_)
Definition: vulkan.hpp:34833
SubpassDescription & setPInputAttachments(const AttachmentReference *pInputAttachments_)
Definition: vulkan.hpp:34839
const AttachmentReference * pDepthStencilAttachment
Definition: vulkan.hpp:34917
SubpassDescription & setPPreserveAttachments(const uint32_t *pPreserveAttachments_)
Definition: vulkan.hpp:34875
bool operator==(SubpassDescription const &rhs) const
Definition: vulkan.hpp:34891
SubpassDescription & setPResolveAttachments(const AttachmentReference *pResolveAttachments_)
Definition: vulkan.hpp:34857
SubpassDescription & setFlags(SubpassDescriptionFlags flags_)
Definition: vulkan.hpp:34821
bool operator!=(SubpassDescription const &rhs) const
Definition: vulkan.hpp:34905
const AttachmentReference * pResolveAttachments
Definition: vulkan.hpp:34916
SubpassDescription & operator=(VkSubpassDescription const &rhs)
Definition: vulkan.hpp:34816
SubpassDescription & setPipelineBindPoint(PipelineBindPoint pipelineBindPoint_)
Definition: vulkan.hpp:34827
bool operator!=(SubpassEndInfoKHR const &rhs) const
Definition: vulkan.hpp:18243
SubpassEndInfoKHR(VkSubpassEndInfoKHR const &rhs)
Definition: vulkan.hpp:18211
SubpassEndInfoKHR & operator=(VkSubpassEndInfoKHR const &rhs)
Definition: vulkan.hpp:18216
bool operator==(SubpassEndInfoKHR const &rhs) const
Definition: vulkan.hpp:18237
SubpassEndInfoKHR & setPNext(const void *pNext_)
Definition: vulkan.hpp:18221
SubpassSampleLocationsEXT(uint32_t subpassIndex_=0, SampleLocationsInfoEXT sampleLocationsInfo_=SampleLocationsInfoEXT())
Definition: vulkan.hpp:28132
SubpassSampleLocationsEXT & operator=(VkSubpassSampleLocationsEXT const &rhs)
Definition: vulkan.hpp:28144
SubpassSampleLocationsEXT(VkSubpassSampleLocationsEXT const &rhs)
Definition: vulkan.hpp:28139
SubpassSampleLocationsEXT & setSampleLocationsInfo(SampleLocationsInfoEXT sampleLocationsInfo_)
Definition: vulkan.hpp:28155
bool operator==(SubpassSampleLocationsEXT const &rhs) const
Definition: vulkan.hpp:28171
SubpassSampleLocationsEXT & setSubpassIndex(uint32_t subpassIndex_)
Definition: vulkan.hpp:28149
bool operator!=(SubpassSampleLocationsEXT const &rhs) const
Definition: vulkan.hpp:28177
bool operator==(SubresourceLayout const &rhs) const
Definition: vulkan.hpp:5841
bool operator!=(SubresourceLayout const &rhs) const
Definition: vulkan.hpp:5850
SurfaceCounterFlagsEXT supportedSurfaceCounters
Definition: vulkan.hpp:33661
bool operator!=(SurfaceCapabilities2EXT const &rhs) const
Definition: vulkan.hpp:33641
SurfaceTransformFlagBitsKHR currentTransform
Definition: vulkan.hpp:33658
CompositeAlphaFlagsKHR supportedCompositeAlpha
Definition: vulkan.hpp:33659
bool operator==(SurfaceCapabilities2EXT const &rhs) const
Definition: vulkan.hpp:33624
SurfaceTransformFlagsKHR supportedTransforms
Definition: vulkan.hpp:33657
bool operator==(SurfaceCapabilities2KHR const &rhs) const
Definition: vulkan.hpp:29568
bool operator!=(SurfaceCapabilities2KHR const &rhs) const
Definition: vulkan.hpp:29575
SurfaceTransformFlagsKHR supportedTransforms
Definition: vulkan.hpp:29549
bool operator==(SurfaceCapabilitiesKHR const &rhs) const
Definition: vulkan.hpp:29524
bool operator!=(SurfaceCapabilitiesKHR const &rhs) const
Definition: vulkan.hpp:29538
CompositeAlphaFlagsKHR supportedCompositeAlpha
Definition: vulkan.hpp:29551
SurfaceTransformFlagBitsKHR currentTransform
Definition: vulkan.hpp:29550
bool operator!=(SurfaceFormat2KHR const &rhs) const
Definition: vulkan.hpp:29166
bool operator==(SurfaceFormat2KHR const &rhs) const
Definition: vulkan.hpp:29159
bool operator!=(SurfaceFormatKHR const &rhs) const
Definition: vulkan.hpp:29137
bool operator==(SurfaceFormatKHR const &rhs) const
Definition: vulkan.hpp:29131
SwapchainCounterCreateInfoEXT & setPNext(const void *pNext_)
Definition: vulkan.hpp:33682
bool operator!=(SwapchainCounterCreateInfoEXT const &rhs) const
Definition: vulkan.hpp:33711
bool operator==(SwapchainCounterCreateInfoEXT const &rhs) const
Definition: vulkan.hpp:33704
SwapchainCounterCreateInfoEXT & setSurfaceCounters(SurfaceCounterFlagsEXT surfaceCounters_)
Definition: vulkan.hpp:33688
SwapchainCounterCreateInfoEXT(VkSwapchainCounterCreateInfoEXT const &rhs)
Definition: vulkan.hpp:33672
SwapchainCounterCreateInfoEXT & operator=(VkSwapchainCounterCreateInfoEXT const &rhs)
Definition: vulkan.hpp:33677
SwapchainCounterCreateInfoEXT(SurfaceCounterFlagsEXT surfaceCounters_=SurfaceCounterFlagsEXT())
Definition: vulkan.hpp:33667
SwapchainCreateInfoKHR & setPQueueFamilyIndices(const uint32_t *pQueueFamilyIndices_)
Definition: vulkan.hpp:34398
SwapchainCreateInfoKHR & setOldSwapchain(SwapchainKHR oldSwapchain_)
Definition: vulkan.hpp:34428
SwapchainCreateInfoKHR & setQueueFamilyIndexCount(uint32_t queueFamilyIndexCount_)
Definition: vulkan.hpp:34392
SwapchainCreateInfoKHR & setClipped(Bool32 clipped_)
Definition: vulkan.hpp:34422
bool operator==(SwapchainCreateInfoKHR const &rhs) const
Definition: vulkan.hpp:34444
SwapchainCreateInfoKHR & setImageUsage(ImageUsageFlags imageUsage_)
Definition: vulkan.hpp:34380
SwapchainCreateInfoKHR & setPNext(const void *pNext_)
Definition: vulkan.hpp:34332
SwapchainCreateInfoKHR & setPreTransform(SurfaceTransformFlagBitsKHR preTransform_)
Definition: vulkan.hpp:34404
SwapchainCreateInfoKHR & setCompositeAlpha(CompositeAlphaFlagBitsKHR compositeAlpha_)
Definition: vulkan.hpp:34410
SwapchainCreateInfoKHR(SwapchainCreateFlagsKHR flags_=SwapchainCreateFlagsKHR(), SurfaceKHR surface_=SurfaceKHR(), uint32_t minImageCount_=0, Format imageFormat_=Format::eUndefined, ColorSpaceKHR imageColorSpace_=ColorSpaceKHR::eSrgbNonlinear, Extent2D imageExtent_=Extent2D(), uint32_t imageArrayLayers_=0, ImageUsageFlags imageUsage_=ImageUsageFlags(), SharingMode imageSharingMode_=SharingMode::eExclusive, uint32_t queueFamilyIndexCount_=0, const uint32_t *pQueueFamilyIndices_=nullptr, SurfaceTransformFlagBitsKHR preTransform_=SurfaceTransformFlagBitsKHR::eIdentity, CompositeAlphaFlagBitsKHR compositeAlpha_=CompositeAlphaFlagBitsKHR::eOpaque, PresentModeKHR presentMode_=PresentModeKHR::eImmediate, Bool32 clipped_=0, SwapchainKHR oldSwapchain_=SwapchainKHR())
Definition: vulkan.hpp:34287
SwapchainCreateInfoKHR & setSurface(SurfaceKHR surface_)
Definition: vulkan.hpp:34344
CompositeAlphaFlagBitsKHR compositeAlpha
Definition: vulkan.hpp:34488
SwapchainCreateInfoKHR & setImageExtent(Extent2D imageExtent_)
Definition: vulkan.hpp:34368
bool operator!=(SwapchainCreateInfoKHR const &rhs) const
Definition: vulkan.hpp:34466
SwapchainCreateInfoKHR & setImageSharingMode(SharingMode imageSharingMode_)
Definition: vulkan.hpp:34386
SwapchainCreateInfoKHR & setImageArrayLayers(uint32_t imageArrayLayers_)
Definition: vulkan.hpp:34374
SwapchainCreateInfoKHR & operator=(VkSwapchainCreateInfoKHR const &rhs)
Definition: vulkan.hpp:34327
SwapchainCreateInfoKHR(VkSwapchainCreateInfoKHR const &rhs)
Definition: vulkan.hpp:34322
SwapchainCreateInfoKHR & setImageFormat(Format imageFormat_)
Definition: vulkan.hpp:34356
SwapchainCreateInfoKHR & setMinImageCount(uint32_t minImageCount_)
Definition: vulkan.hpp:34350
SwapchainCreateInfoKHR & setFlags(SwapchainCreateFlagsKHR flags_)
Definition: vulkan.hpp:34338
SwapchainCreateInfoKHR & setPresentMode(PresentModeKHR presentMode_)
Definition: vulkan.hpp:34416
SurfaceTransformFlagBitsKHR preTransform
Definition: vulkan.hpp:34487
SwapchainCreateInfoKHR & setImageColorSpace(ColorSpaceKHR imageColorSpace_)
Definition: vulkan.hpp:34362
bool operator==(TextureLODGatherFormatPropertiesAMD const &rhs) const
Definition: vulkan.hpp:16386
bool operator!=(TextureLODGatherFormatPropertiesAMD const &rhs) const
Definition: vulkan.hpp:16393
ValidationCacheCreateInfoEXT & setPNext(const void *pNext_)
Definition: vulkan.hpp:17135
bool operator!=(ValidationCacheCreateInfoEXT const &rhs) const
Definition: vulkan.hpp:17178
ValidationCacheCreateInfoEXT & operator=(VkValidationCacheCreateInfoEXT const &rhs)
Definition: vulkan.hpp:17130
ValidationCacheCreateInfoEXT & setPInitialData(const void *pInitialData_)
Definition: vulkan.hpp:17153
ValidationCacheCreateInfoEXT & setInitialDataSize(size_t initialDataSize_)
Definition: vulkan.hpp:17147
ValidationCacheCreateInfoEXT(ValidationCacheCreateFlagsEXT flags_=ValidationCacheCreateFlagsEXT(), size_t initialDataSize_=0, const void *pInitialData_=nullptr)
Definition: vulkan.hpp:17116
ValidationCacheCreateInfoEXT & setFlags(ValidationCacheCreateFlagsEXT flags_)
Definition: vulkan.hpp:17141
ValidationCacheCreateInfoEXT(VkValidationCacheCreateInfoEXT const &rhs)
Definition: vulkan.hpp:17125
bool operator==(ValidationCacheCreateInfoEXT const &rhs) const
Definition: vulkan.hpp:17169
ValidationFlagsEXT(VkValidationFlagsEXT const &rhs)
Definition: vulkan.hpp:30384
ValidationFlagsEXT & setPDisabledValidationChecks(const ValidationCheckEXT *pDisabledValidationChecks_)
Definition: vulkan.hpp:30406
ValidationFlagsEXT & setDisabledValidationCheckCount(uint32_t disabledValidationCheckCount_)
Definition: vulkan.hpp:30400
bool operator!=(ValidationFlagsEXT const &rhs) const
Definition: vulkan.hpp:30430
ValidationFlagsEXT & operator=(VkValidationFlagsEXT const &rhs)
Definition: vulkan.hpp:30389
ValidationFlagsEXT(uint32_t disabledValidationCheckCount_=0, const ValidationCheckEXT *pDisabledValidationChecks_=nullptr)
Definition: vulkan.hpp:30377
bool operator==(ValidationFlagsEXT const &rhs) const
Definition: vulkan.hpp:30422
ValidationFlagsEXT & setPNext(const void *pNext_)
Definition: vulkan.hpp:30394
const ValidationCheckEXT * pDisabledValidationChecks
Definition: vulkan.hpp:30441
VertexInputAttributeDescription & operator=(VkVertexInputAttributeDescription const &rhs)
Definition: vulkan.hpp:9080
VertexInputAttributeDescription(VkVertexInputAttributeDescription const &rhs)
Definition: vulkan.hpp:9075
VertexInputAttributeDescription & setOffset(uint32_t offset_)
Definition: vulkan.hpp:9103
bool operator==(VertexInputAttributeDescription const &rhs) const
Definition: vulkan.hpp:9119
VertexInputAttributeDescription & setLocation(uint32_t location_)
Definition: vulkan.hpp:9085
bool operator!=(VertexInputAttributeDescription const &rhs) const
Definition: vulkan.hpp:9127
VertexInputAttributeDescription & setBinding(uint32_t binding_)
Definition: vulkan.hpp:9091
VertexInputAttributeDescription(uint32_t location_=0, uint32_t binding_=0, Format format_=Format::eUndefined, uint32_t offset_=0)
Definition: vulkan.hpp:9064
VertexInputAttributeDescription & setFormat(Format format_)
Definition: vulkan.hpp:9097
VertexInputBindingDescription & setInputRate(VertexInputRate inputRate_)
Definition: vulkan.hpp:8763
VertexInputBindingDescription(VkVertexInputBindingDescription const &rhs)
Definition: vulkan.hpp:8741
VertexInputBindingDescription(uint32_t binding_=0, uint32_t stride_=0, VertexInputRate inputRate_=VertexInputRate::eVertex)
Definition: vulkan.hpp:8732
bool operator==(VertexInputBindingDescription const &rhs) const
Definition: vulkan.hpp:8779
bool operator!=(VertexInputBindingDescription const &rhs) const
Definition: vulkan.hpp:8786
VertexInputBindingDescription & operator=(VkVertexInputBindingDescription const &rhs)
Definition: vulkan.hpp:8746
VertexInputBindingDescription & setStride(uint32_t stride_)
Definition: vulkan.hpp:8757
VertexInputBindingDescription & setBinding(uint32_t binding_)
Definition: vulkan.hpp:8751
VertexInputBindingDivisorDescriptionEXT(uint32_t binding_=0, uint32_t divisor_=0)
Definition: vulkan.hpp:7721
VertexInputBindingDivisorDescriptionEXT & operator=(VkVertexInputBindingDivisorDescriptionEXT const &rhs)
Definition: vulkan.hpp:7733
VertexInputBindingDivisorDescriptionEXT(VkVertexInputBindingDivisorDescriptionEXT const &rhs)
Definition: vulkan.hpp:7728
bool operator!=(VertexInputBindingDivisorDescriptionEXT const &rhs) const
Definition: vulkan.hpp:7766
bool operator==(VertexInputBindingDivisorDescriptionEXT const &rhs) const
Definition: vulkan.hpp:7760
VertexInputBindingDivisorDescriptionEXT & setBinding(uint32_t binding_)
Definition: vulkan.hpp:7738
VertexInputBindingDivisorDescriptionEXT & setDivisor(uint32_t divisor_)
Definition: vulkan.hpp:7744
Viewport & operator=(VkViewport const &rhs)
Definition: vulkan.hpp:5376
Viewport & setY(float y_)
Definition: vulkan.hpp:5387
Viewport & setMaxDepth(float maxDepth_)
Definition: vulkan.hpp:5411
bool operator==(Viewport const &rhs) const
Definition: vulkan.hpp:5427
Viewport & setWidth(float width_)
Definition: vulkan.hpp:5393
Viewport & setX(float x_)
Definition: vulkan.hpp:5381
Viewport(VkViewport const &rhs)
Definition: vulkan.hpp:5371
Viewport & setHeight(float height_)
Definition: vulkan.hpp:5399
Viewport(float x_=0, float y_=0, float width_=0, float height_=0, float minDepth_=0, float maxDepth_=0)
Definition: vulkan.hpp:5356
Viewport & setMinDepth(float minDepth_)
Definition: vulkan.hpp:5405
bool operator!=(Viewport const &rhs) const
Definition: vulkan.hpp:5437
ViewportSwizzleNV(ViewportCoordinateSwizzleNV x_=ViewportCoordinateSwizzleNV::ePositiveX, ViewportCoordinateSwizzleNV y_=ViewportCoordinateSwizzleNV::ePositiveX, ViewportCoordinateSwizzleNV z_=ViewportCoordinateSwizzleNV::ePositiveX, ViewportCoordinateSwizzleNV w_=ViewportCoordinateSwizzleNV::ePositiveX)
Definition: vulkan.hpp:34509
ViewportSwizzleNV & setY(ViewportCoordinateSwizzleNV y_)
Definition: vulkan.hpp:34536
ViewportSwizzleNV & operator=(VkViewportSwizzleNV const &rhs)
Definition: vulkan.hpp:34525
bool operator!=(ViewportSwizzleNV const &rhs) const
Definition: vulkan.hpp:34572
ViewportSwizzleNV & setW(ViewportCoordinateSwizzleNV w_)
Definition: vulkan.hpp:34548
ViewportSwizzleNV(VkViewportSwizzleNV const &rhs)
Definition: vulkan.hpp:34520
ViewportCoordinateSwizzleNV y
Definition: vulkan.hpp:34578
ViewportCoordinateSwizzleNV z
Definition: vulkan.hpp:34579
ViewportSwizzleNV & setZ(ViewportCoordinateSwizzleNV z_)
Definition: vulkan.hpp:34542
ViewportSwizzleNV & setX(ViewportCoordinateSwizzleNV x_)
Definition: vulkan.hpp:34530
ViewportCoordinateSwizzleNV x
Definition: vulkan.hpp:34577
ViewportCoordinateSwizzleNV w
Definition: vulkan.hpp:34580
bool operator==(ViewportSwizzleNV const &rhs) const
Definition: vulkan.hpp:34564
ViewportWScalingNV(VkViewportWScalingNV const &rhs)
Definition: vulkan.hpp:7580
ViewportWScalingNV & setYcoeff(float ycoeff_)
Definition: vulkan.hpp:7596
ViewportWScalingNV(float xcoeff_=0, float ycoeff_=0)
Definition: vulkan.hpp:7573
ViewportWScalingNV & operator=(VkViewportWScalingNV const &rhs)
Definition: vulkan.hpp:7585
bool operator!=(ViewportWScalingNV const &rhs) const
Definition: vulkan.hpp:7618
bool operator==(ViewportWScalingNV const &rhs) const
Definition: vulkan.hpp:7612
ViewportWScalingNV & setXcoeff(float xcoeff_)
Definition: vulkan.hpp:7590
bool operator==(WriteDescriptorSetAccelerationStructureNV const &rhs) const
Definition: vulkan.hpp:20690
WriteDescriptorSetAccelerationStructureNV & setAccelerationStructureCount(uint32_t accelerationStructureCount_)
Definition: vulkan.hpp:20668
WriteDescriptorSetAccelerationStructureNV & operator=(VkWriteDescriptorSetAccelerationStructureNV const &rhs)
Definition: vulkan.hpp:20657
WriteDescriptorSetAccelerationStructureNV & setPAccelerationStructures(const AccelerationStructureNV *pAccelerationStructures_)
Definition: vulkan.hpp:20674
WriteDescriptorSetAccelerationStructureNV(uint32_t accelerationStructureCount_=0, const AccelerationStructureNV *pAccelerationStructures_=nullptr)
Definition: vulkan.hpp:20645
WriteDescriptorSetAccelerationStructureNV(VkWriteDescriptorSetAccelerationStructureNV const &rhs)
Definition: vulkan.hpp:20652
bool operator!=(WriteDescriptorSetAccelerationStructureNV const &rhs) const
Definition: vulkan.hpp:20698
WriteDescriptorSetAccelerationStructureNV & setPNext(const void *pNext_)
Definition: vulkan.hpp:20662
const DescriptorImageInfo * pImageInfo
Definition: vulkan.hpp:9984
WriteDescriptorSet(VkWriteDescriptorSet const &rhs)
Definition: vulkan.hpp:9881
WriteDescriptorSet & setDstBinding(uint32_t dstBinding_)
Definition: vulkan.hpp:9903
WriteDescriptorSet & setDstSet(DescriptorSet dstSet_)
Definition: vulkan.hpp:9897
WriteDescriptorSet(DescriptorSet dstSet_=DescriptorSet(), uint32_t dstBinding_=0, uint32_t dstArrayElement_=0, uint32_t descriptorCount_=0, DescriptorType descriptorType_=DescriptorType::eSampler, const DescriptorImageInfo *pImageInfo_=nullptr, const DescriptorBufferInfo *pBufferInfo_=nullptr, const BufferView *pTexelBufferView_=nullptr)
Definition: vulkan.hpp:9862
bool operator!=(WriteDescriptorSet const &rhs) const
Definition: vulkan.hpp:9969
WriteDescriptorSet & operator=(VkWriteDescriptorSet const &rhs)
Definition: vulkan.hpp:9886
WriteDescriptorSet & setDescriptorCount(uint32_t descriptorCount_)
Definition: vulkan.hpp:9915
bool operator==(WriteDescriptorSet const &rhs) const
Definition: vulkan.hpp:9955
WriteDescriptorSet & setPBufferInfo(const DescriptorBufferInfo *pBufferInfo_)
Definition: vulkan.hpp:9933
WriteDescriptorSet & setPTexelBufferView(const BufferView *pTexelBufferView_)
Definition: vulkan.hpp:9939
WriteDescriptorSet & setDescriptorType(DescriptorType descriptorType_)
Definition: vulkan.hpp:9921
WriteDescriptorSet & setPImageInfo(const DescriptorImageInfo *pImageInfo_)
Definition: vulkan.hpp:9927
WriteDescriptorSet & setDstArrayElement(uint32_t dstArrayElement_)
Definition: vulkan.hpp:9909
const DescriptorBufferInfo * pBufferInfo
Definition: vulkan.hpp:9985
WriteDescriptorSet & setPNext(const void *pNext_)
Definition: vulkan.hpp:9891
WriteDescriptorSetInlineUniformBlockEXT & setDataSize(uint32_t dataSize_)
Definition: vulkan.hpp:16939
WriteDescriptorSetInlineUniformBlockEXT & setPData(const void *pData_)
Definition: vulkan.hpp:16945
WriteDescriptorSetInlineUniformBlockEXT & setPNext(const void *pNext_)
Definition: vulkan.hpp:16933
WriteDescriptorSetInlineUniformBlockEXT(VkWriteDescriptorSetInlineUniformBlockEXT const &rhs)
Definition: vulkan.hpp:16923
bool operator==(WriteDescriptorSetInlineUniformBlockEXT const &rhs) const
Definition: vulkan.hpp:16961
WriteDescriptorSetInlineUniformBlockEXT & operator=(VkWriteDescriptorSetInlineUniformBlockEXT const &rhs)
Definition: vulkan.hpp:16928
WriteDescriptorSetInlineUniformBlockEXT(uint32_t dataSize_=0, const void *pData_=nullptr)
Definition: vulkan.hpp:16916
bool operator!=(WriteDescriptorSetInlineUniformBlockEXT const &rhs) const
Definition: vulkan.hpp:16969
bool operator!=(XYColorEXT const &rhs) const
Definition: vulkan.hpp:7444
XYColorEXT & operator=(VkXYColorEXT const &rhs)
Definition: vulkan.hpp:7411
XYColorEXT(float x_=0, float y_=0)
Definition: vulkan.hpp:7399
XYColorEXT & setX(float x_)
Definition: vulkan.hpp:7416
XYColorEXT & setY(float y_)
Definition: vulkan.hpp:7422
bool operator==(XYColorEXT const &rhs) const
Definition: vulkan.hpp:7438
XYColorEXT(VkXYColorEXT const &rhs)
Definition: vulkan.hpp:7406
Definition: vulkan_core.h:4347
Definition: vulkan_core.h:6894
Definition: vulkan_core.h:6883
Definition: vulkan_core.h:6907
Definition: vulkan_core.h:6888
Definition: vulkan_core.h:6914
Definition: vulkan_core.h:6901
Definition: vulkan_core.h:2284
static SDL_Event events[EVENT_BUF_SIZE]
Definition: testgesture.c:39
static Uint32 callback(Uint32 interval, void *param)
Definition: testtimer.c:34
ClearColorValue(const std::array< float, 4 > &float32_={ {0} })
Definition: vulkan.hpp:6076
ClearColorValue & setUint32(std::array< uint32_t, 4 > uint32_)
Definition: vulkan.hpp:6103
ClearColorValue & setInt32(std::array< int32_t, 4 > int32_)
Definition: vulkan.hpp:6097
ClearColorValue & setFloat32(std::array< float, 4 > float32_)
Definition: vulkan.hpp:6091
ClearColorValue(const std::array< uint32_t, 4 > &uint32_)
Definition: vulkan.hpp:6086
ClearColorValue(const std::array< int32_t, 4 > &int32_)
Definition: vulkan.hpp:6081
ClearValue(ClearDepthStencilValue depthStencil_)
Definition: vulkan.hpp:6188
ClearValue(ClearColorValue color_=ClearColorValue())
Definition: vulkan.hpp:6183
ClearValue & setColor(ClearColorValue color_)
Definition: vulkan.hpp:6193
VkClearDepthStencilValue depthStencil
Definition: vulkan.hpp:6220
ClearValue & setDepthStencil(ClearDepthStencilValue depthStencil_)
Definition: vulkan.hpp:6199
#define VULKAN_HPP_ASSERT
Definition: vulkan.hpp:54
#define VULKAN_HPP_NAMESPACE_STRING
Definition: vulkan.hpp:135
#define VULKAN_HPP_TYPESAFE_EXPLICIT
Definition: vulkan.hpp:119
#define VULKAN_HPP_CONSTEXPR
Definition: vulkan.hpp:125
#define VULKAN_HPP_INLINE
Definition: vulkan.hpp:112
VkResult(VKAPI_PTR * PFN_vkGetAndroidHardwareBufferPropertiesANDROID)(VkDevice device, const struct AHardwareBuffer *buffer, VkAndroidHardwareBufferPropertiesANDROID *pProperties)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
VkResult(VKAPI_PTR * PFN_vkGetMemoryAndroidHardwareBufferANDROID)(VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID *pInfo, struct AHardwareBuffer **pBuffer)
VKAPI_ATTR VkResult VKAPI_CALL vkGetAndroidHardwareBufferPropertiesANDROID(VkDevice device, const struct AHardwareBuffer *buffer, VkAndroidHardwareBufferPropertiesANDROID *pProperties)
VkResult(VKAPI_PTR * PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryAndroidHardwareBufferANDROID(VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID *pInfo, struct AHardwareBuffer **pBuffer)
VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV *pShadingRatePalettes)
VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain)
#define VK_LUID_SIZE
Definition: vulkan_core.h:3796
VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkLayerProperties *pProperties)
@ VK_DEBUG_REPORT_INFORMATION_BIT_EXT
Definition: vulkan_core.h:6198
@ VK_DEBUG_REPORT_WARNING_BIT_EXT
Definition: vulkan_core.h:6199
@ VK_DEBUG_REPORT_DEBUG_BIT_EXT
Definition: vulkan_core.h:6202
@ VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT
Definition: vulkan_core.h:6200
@ VK_DEBUG_REPORT_ERROR_BIT_EXT
Definition: vulkan_core.h:6201
VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain)
void(VKAPI_PTR * PFN_vkGetAccelerationStructureMemoryRequirementsNV)(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2KHR *pMemoryRequirements)
Definition: vulkan_core.h:8317
VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers)
VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator)
@ VK_SAMPLER_REDUCTION_MODE_MIN_EXT
Definition: vulkan_core.h:7541
@ VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT
Definition: vulkan_core.h:7540
@ VK_SAMPLER_REDUCTION_MODE_MAX_EXT
Definition: vulkan_core.h:7542
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT *pMultisampleProperties)
@ VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR
Definition: vulkan_core.h:4795
@ VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR
Definition: vulkan_core.h:4796
void(VKAPI_PTR * PFN_vkCmdBeginRenderPass2KHR)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, const VkSubpassBeginInfoKHR *pSubpassBeginInfo)
Definition: vulkan_core.h:5628
void(VKAPI_PTR * PFN_vkCmdCopyAccelerationStructureNV)(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeNV mode)
Definition: vulkan_core.h:8320
VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance, const char *pName)
void(VKAPI_PTR * PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, VkSubpassContents contents)
Definition: vulkan_core.h:2983
VkResult(VKAPI_PTR * PFN_vkCreateObjectTableNVX)(VkDevice device, const VkObjectTableCreateInfoNVX *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkObjectTableNVX *pObjectTable)
Definition: vulkan_core.h:6926
VKAPI_ATTR void VKAPI_CALL vkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo)
VKAPI_ATTR void VKAPI_CALL vkDestroyAccelerationStructureNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks *pAllocator)
void(VKAPI_PTR * PFN_vkFreeFunction)(void *pUserData, void *pMemory)
Definition: vulkan_core.h:1768
VkFlags VkPipelineStageFlags
Definition: vulkan_core.h:1455
VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV *pViewportWScalings)
void(VKAPI_PTR * PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:2886
VkResult(VKAPI_PTR * PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
Definition: vulkan_core.h:2916
VkResult(VKAPI_PTR * PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImageView *pView)
Definition: vulkan_core.h:2907
void(VKAPI_PTR * PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
Definition: vulkan_core.h:2954
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures)
VkResult(VKAPI_PTR * PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo, const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory)
Definition: vulkan_core.h:2871
VkTimeDomainEXT
Definition: vulkan_core.h:8516
@ VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT
Definition: vulkan_core.h:8520
@ VK_TIME_DOMAIN_DEVICE_EXT
Definition: vulkan_core.h:8517
@ VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT
Definition: vulkan_core.h:8519
@ VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT
Definition: vulkan_core.h:8518
void(VKAPI_PTR * PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions)
Definition: vulkan_core.h:2966
#define VK_MAX_MEMORY_HEAPS
Definition: vulkan_core.h:107
void(VKAPI_PTR * PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4])
Definition: vulkan_core.h:2948
void(VKAPI_PTR * PFN_vkCmdSetDeviceMask)(VkCommandBuffer commandBuffer, uint32_t deviceMask)
Definition: vulkan_core.h:4493
VkResult(VKAPI_PTR * PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkLayerProperties *pProperties)
Definition: vulkan_core.h:2866
VKAPI_ATTR VkResult VKAPI_CALL vkBindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV *pBindInfos)
void(VKAPI_PTR * PFN_vkDestroyDebugReportCallbackEXT)(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:6227
void(VKAPI_PTR * PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
Definition: vulkan_core.h:2970
void(VKAPI_PTR * PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
Definition: vulkan_core.h:2960
VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
VkResult(VKAPI_PTR * PFN_vkBindImageMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
Definition: vulkan_core.h:6001
VkResult(VKAPI_PTR * PFN_vkBindAccelerationStructureMemoryNV)(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV *pBindInfos)
Definition: vulkan_core.h:8318
@ VK_SPARSE_MEMORY_BIND_METADATA_BIT
Definition: vulkan_core.h:1486
VkResult(VKAPI_PTR * PFN_vkRegisterObjectsNVX)(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectTableEntryNVX *const *ppObjectTableEntries, const uint32_t *pObjectIndices)
Definition: vulkan_core.h:6928
VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureMemoryRequirementsNV(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2KHR *pMemoryRequirements)
VkResult(VKAPI_PTR * PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
Definition: vulkan_core.h:2915
void(VKAPI_PTR * PFN_vkCmdDebugMarkerInsertEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo)
Definition: vulkan_core.h:6334
VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo, const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory)
VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue)
VkResult(VKAPI_PTR * PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages)
Definition: vulkan_core.h:4889
@ VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT
Definition: vulkan_core.h:1315
@ VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT
Definition: vulkan_core.h:1322
@ VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT
Definition: vulkan_core.h:1311
@ VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT
Definition: vulkan_core.h:1312
@ VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT
Definition: vulkan_core.h:1304
@ VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT
Definition: vulkan_core.h:1309
@ VK_FORMAT_FEATURE_TRANSFER_DST_BIT
Definition: vulkan_core.h:1317
@ VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT
Definition: vulkan_core.h:1307
@ VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT
Definition: vulkan_core.h:1303
@ VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT
Definition: vulkan_core.h:1308
@ VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT
Definition: vulkan_core.h:1326
@ VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT
Definition: vulkan_core.h:1324
@ VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG
Definition: vulkan_core.h:1325
@ VK_FORMAT_FEATURE_BLIT_SRC_BIT
Definition: vulkan_core.h:1313
@ VK_FORMAT_FEATURE_TRANSFER_SRC_BIT
Definition: vulkan_core.h:1316
@ VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT
Definition: vulkan_core.h:1318
@ VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT
Definition: vulkan_core.h:1310
@ VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT
Definition: vulkan_core.h:1319
@ VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT
Definition: vulkan_core.h:1321
@ VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT
Definition: vulkan_core.h:1320
@ VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT
Definition: vulkan_core.h:1306
@ VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT
Definition: vulkan_core.h:1305
@ VK_FORMAT_FEATURE_BLIT_DST_BIT
Definition: vulkan_core.h:1314
@ VK_FORMAT_FEATURE_DISJOINT_BIT
Definition: vulkan_core.h:1323
#define VK_MAX_EXTENSION_NAME_SIZE
Definition: vulkan_core.h:108
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties)
VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceVersion(uint32_t *pApiVersion)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
void(VKAPI_PTR * PFN_vkQueueEndDebugUtilsLabelEXT)(VkQueue queue)
Definition: vulkan_core.h:7476
#define VK_MAX_MEMORY_TYPES
Definition: vulkan_core.h:106
VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo)
VKAPI_ATTR void VKAPI_CALL vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT *pSurfaceCapabilities)
Definition: vulkan_core.h:7051
void(VKAPI_PTR * PFN_vkCmdDebugMarkerEndEXT)(VkCommandBuffer commandBuffer)
Definition: vulkan_core.h:6333
@ VK_QUERY_CONTROL_PRECISE_BIT
Definition: vulkan_core.h:1715
@ VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV
Definition: vulkan_core.h:6614
@ VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV
Definition: vulkan_core.h:6615
@ VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV
Definition: vulkan_core.h:6613
VkImageLayout
Definition: vulkan_core.h:865
@ VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL
Definition: vulkan_core.h:872
@ VK_IMAGE_LAYOUT_PRESENT_SRC_KHR
Definition: vulkan_core.h:877
@ VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL
Definition: vulkan_core.h:869
@ VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL
Definition: vulkan_core.h:876
@ VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
Definition: vulkan_core.h:871
@ VK_IMAGE_LAYOUT_PREINITIALIZED
Definition: vulkan_core.h:874
@ VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
Definition: vulkan_core.h:868
@ VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL
Definition: vulkan_core.h:870
@ VK_IMAGE_LAYOUT_UNDEFINED
Definition: vulkan_core.h:866
@ VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
Definition: vulkan_core.h:873
@ VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR
Definition: vulkan_core.h:878
@ VK_IMAGE_LAYOUT_GENERAL
Definition: vulkan_core.h:867
@ VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV
Definition: vulkan_core.h:879
@ VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL
Definition: vulkan_core.h:875
VkResult(VKAPI_PTR * PFN_vkBindBufferMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos)
Definition: vulkan_core.h:4490
void(VKAPI_PTR * PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:2872
VkResult(VKAPI_PTR * PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer)
Definition: vulkan_core.h:2930
VKAPI_ATTR VkResult VKAPI_CALL vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences)
void(VKAPI_PTR * PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:2891
@ VK_COMMAND_BUFFER_LEVEL_PRIMARY
Definition: vulkan_core.h:1216
@ VK_COMMAND_BUFFER_LEVEL_SECONDARY
Definition: vulkan_core.h:1217
void(VKAPI_PTR * PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:2917
VkResult(VKAPI_PTR * PFN_vkCreateValidationCacheEXT)(VkDevice device, const VkValidationCacheCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkValidationCacheEXT *pValidationCache)
Definition: vulkan_core.h:7884
VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures)
VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
@ VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT
Definition: vulkan_core.h:1560
@ VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV
Definition: vulkan_core.h:1562
@ VK_PIPELINE_CREATE_DERIVATIVE_BIT
Definition: vulkan_core.h:1559
@ VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT
Definition: vulkan_core.h:1558
@ VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT
Definition: vulkan_core.h:1557
@ VK_PIPELINE_CREATE_DISPATCH_BASE
Definition: vulkan_core.h:1561
VkResult(VKAPI_PTR * PFN_vkSetEvent)(VkDevice device, VkEvent event)
Definition: vulkan_core.h:2895
VkIndexType
Definition: vulkan_core.h:1224
@ VK_INDEX_TYPE_UINT16
Definition: vulkan_core.h:1225
@ VK_INDEX_TYPE_UINT32
Definition: vulkan_core.h:1226
@ VK_INDEX_TYPE_NONE_NV
Definition: vulkan_core.h:1227
VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkEvent *pEvent)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore)
VKAPI_ATTR VkResult VKAPI_CALL vkCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader)
VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks *pAllocator)
VkResult(VKAPI_PTR * PFN_vkRegisterDeviceEventEXT)(VkDevice device, const VkDeviceEventInfoEXT *pDeviceEventInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
Definition: vulkan_core.h:7117
void(VKAPI_PTR * PFN_vkCmdPushDescriptorSetKHR)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites)
Definition: vulkan_core.h:5453
void(VKAPI_PTR * PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
Definition: vulkan_core.h:2979
VkResult(VKAPI_PTR * PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache *pSrcCaches)
Definition: vulkan_core.h:2914
VkShaderStageFlagBits
Definition: vulkan_core.h:1570
@ VK_SHADER_STAGE_VERTEX_BIT
Definition: vulkan_core.h:1571
@ VK_SHADER_STAGE_COMPUTE_BIT
Definition: vulkan_core.h:1576
@ VK_SHADER_STAGE_ALL
Definition: vulkan_core.h:1578
@ VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV
Definition: vulkan_core.h:1581
@ VK_SHADER_STAGE_INTERSECTION_BIT_NV
Definition: vulkan_core.h:1583
@ VK_SHADER_STAGE_ANY_HIT_BIT_NV
Definition: vulkan_core.h:1580
@ VK_SHADER_STAGE_TASK_BIT_NV
Definition: vulkan_core.h:1585
@ VK_SHADER_STAGE_CALLABLE_BIT_NV
Definition: vulkan_core.h:1584
@ VK_SHADER_STAGE_MESH_BIT_NV
Definition: vulkan_core.h:1586
@ VK_SHADER_STAGE_GEOMETRY_BIT
Definition: vulkan_core.h:1574
@ VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT
Definition: vulkan_core.h:1572
@ VK_SHADER_STAGE_MISS_BIT_NV
Definition: vulkan_core.h:1582
@ VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT
Definition: vulkan_core.h:1573
@ VK_SHADER_STAGE_RAYGEN_BIT_NV
Definition: vulkan_core.h:1579
@ VK_SHADER_STAGE_FRAGMENT_BIT
Definition: vulkan_core.h:1575
@ VK_SHADER_STAGE_ALL_GRAPHICS
Definition: vulkan_core.h:1577
VKAPI_ATTR void VKAPI_CALL vkCmdReserveSpaceForCommandsNVX(VkCommandBuffer commandBuffer, const VkCmdReserveSpaceForCommandsInfoNVX *pReserveSpaceInfo)
void(VKAPI_PTR * PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements)
Definition: vulkan_core.h:2881
VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures)
@ VK_SHARING_MODE_CONCURRENT
Definition: vulkan_core.h:858
@ VK_SHARING_MODE_EXCLUSIVE
Definition: vulkan_core.h:857
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t *pPropertyCount, VkSparseImageFormatProperties *pProperties)
@ VK_DEPENDENCY_VIEW_LOCAL_BIT
Definition: vulkan_core.h:1685
@ VK_DEPENDENCY_BY_REGION_BIT
Definition: vulkan_core.h:1683
@ VK_DEPENDENCY_DEVICE_GROUP_BIT
Definition: vulkan_core.h:1684
void(VKAPI_PTR * PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:2936
VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR *pAcquireInfo, uint32_t *pImageIndex)
@ VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT
Definition: vulkan_core.h:1406
@ VK_MEMORY_PROPERTY_HOST_COHERENT_BIT
Definition: vulkan_core.h:1404
@ VK_MEMORY_PROPERTY_PROTECTED_BIT
Definition: vulkan_core.h:1407
@ VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT
Definition: vulkan_core.h:1402
@ VK_MEMORY_PROPERTY_HOST_CACHED_BIT
Definition: vulkan_core.h:1405
@ VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
Definition: vulkan_core.h:1403
VkResult(VKAPI_PTR * PFN_vkRegisterDisplayEventEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT *pDisplayEventInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
Definition: vulkan_core.h:7118
VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties)
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
VkResult(VKAPI_PTR * PFN_vkUnregisterObjectsNVX)(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectEntryTypeNVX *pObjectEntryTypes, const uint32_t *pObjectIndices)
Definition: vulkan_core.h:6929
VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupportKHR(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport)
VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer)
void(VKAPI_PTR * PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue)
Definition: vulkan_core.h:2867
VKAPI_ATTR void VKAPI_CALL vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator)
@ VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT
Definition: vulkan_core.h:7076
void(VKAPI_PTR * PFN_vkDestroyValidationCacheEXT)(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:7885
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainEXT *pTimeDomains)
VkResult(VKAPI_PTR * PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence)
Definition: vulkan_core.h:2868
VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets)
void(VKAPI_PTR * PFN_vkGetDeviceQueue2)(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue)
Definition: vulkan_core.h:4507
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT)(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT *pMultisampleProperties)
Definition: vulkan_core.h:7682
VKAPI_ATTR VkResult VKAPI_CALL vkDisplayPowerControlEXT(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT *pDisplayPowerInfo)
VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions)
void(VKAPI_PTR * PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:2921
VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties *pQueueFamilyProperties)
Definition: vulkan_core.h:2857
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures)
Definition: vulkan_core.h:2853
VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo)
VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve *pRegions)
#define VK_HEADER_VERSION
Definition: vulkan_core.h:46
VkBool32(VKAPI_PTR * PFN_vkDebugUtilsMessengerCallbackEXT)(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData, void *pUserData)
Definition: vulkan_core.h:7456
void(VKAPI_PTR * PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
Definition: vulkan_core.h:2974
VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
VkFlags VkMemoryMapFlags
Definition: vulkan_core.h:1456
VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource *pSubresource, VkSubresourceLayout *pLayout)
void(VKAPI_PTR * PFN_vkCmdEndConditionalRenderingEXT)(VkCommandBuffer commandBuffer)
Definition: vulkan_core.h:6745
VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysNV(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceMemoryProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
Definition: vulkan_core.h:4504
@ VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV
Definition: vulkan_core.h:1113
@ VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV
Definition: vulkan_core.h:1110
@ VK_DYNAMIC_STATE_DEPTH_BIAS
Definition: vulkan_core.h:1104
@ VK_DYNAMIC_STATE_BLEND_CONSTANTS
Definition: vulkan_core.h:1105
@ VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV
Definition: vulkan_core.h:1114
@ VK_DYNAMIC_STATE_LINE_WIDTH
Definition: vulkan_core.h:1103
@ VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT
Definition: vulkan_core.h:1111
@ VK_DYNAMIC_STATE_STENCIL_WRITE_MASK
Definition: vulkan_core.h:1108
@ VK_DYNAMIC_STATE_VIEWPORT
Definition: vulkan_core.h:1101
@ VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV
Definition: vulkan_core.h:1115
@ VK_DYNAMIC_STATE_DEPTH_BOUNDS
Definition: vulkan_core.h:1106
@ VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK
Definition: vulkan_core.h:1107
@ VK_DYNAMIC_STATE_STENCIL_REFERENCE
Definition: vulkan_core.h:1109
@ VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT
Definition: vulkan_core.h:1112
@ VK_DYNAMIC_STATE_SCISSOR
Definition: vulkan_core.h:1102
VKAPI_ATTR VkResult VKAPI_CALL vkGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT *pTimestampInfos, uint64_t *pTimestamps, uint64_t *pMaxDeviation)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t *pPropertyCount, VkSparseImageFormatProperties *pProperties)
Definition: vulkan_core.h:2883
VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements *pMemoryRequirements)
VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth)
VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures)
VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties)
VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers)
void(VKAPI_PTR * PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents)
Definition: vulkan_core.h:2984
VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void *pData)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBufferView *pView)
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceFeatures2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures)
Definition: vulkan_core.h:5140
VKAPI_ATTR void VKAPI_CALL vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator)
VkFlags VkImageUsageFlags
Definition: vulkan_core.h:1352
void(VKAPI_PTR * PFN_vkDestroySamplerYcbcrConversion)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:4509
@ VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT
Definition: vulkan_core.h:3813
@ VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT
Definition: vulkan_core.h:3812
VkResult(VKAPI_PTR * PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCommandPool *pCommandPool)
Definition: vulkan_core.h:2935
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
VKAPI_ATTR void VKAPI_CALL vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index)
VkResult(VKAPI_PTR * PFN_vkGetDeviceGroupPresentCapabilitiesKHR)(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR *pDeviceGroupPresentCapabilities)
Definition: vulkan_core.h:4892
VKAPI_ATTR VkResult VKAPI_CALL vkCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex)
@ VK_SYSTEM_ALLOCATION_SCOPE_OBJECT
Definition: vulkan_core.h:526
@ VK_SYSTEM_ALLOCATION_SCOPE_CACHE
Definition: vulkan_core.h:527
@ VK_SYSTEM_ALLOCATION_SCOPE_DEVICE
Definition: vulkan_core.h:528
@ VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE
Definition: vulkan_core.h:529
@ VK_SYSTEM_ALLOCATION_SCOPE_COMMAND
Definition: vulkan_core.h:525
VkResult(VKAPI_PTR * PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer)
Definition: vulkan_core.h:2941
VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
@ VK_IMAGE_VIEW_TYPE_1D
Definition: vulkan_core.h:889
@ VK_IMAGE_VIEW_TYPE_2D_ARRAY
Definition: vulkan_core.h:894
@ VK_IMAGE_VIEW_TYPE_1D_ARRAY
Definition: vulkan_core.h:893
@ VK_IMAGE_VIEW_TYPE_CUBE_ARRAY
Definition: vulkan_core.h:895
@ VK_IMAGE_VIEW_TYPE_3D
Definition: vulkan_core.h:891
@ VK_IMAGE_VIEW_TYPE_2D
Definition: vulkan_core.h:890
@ VK_IMAGE_VIEW_TYPE_CUBE
Definition: vulkan_core.h:892
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceQueueFamilyProperties2)(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties)
Definition: vulkan_core.h:4503
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties *pMemoryProperties)
Definition: vulkan_core.h:2858
void(VKAPI_PTR * PFN_vkCmdWriteAccelerationStructuresPropertiesNV)(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV *pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
Definition: vulkan_core.h:8325
VKAPI_ATTR VkResult VKAPI_CALL vkCreateAccelerationStructureNV(VkDevice device, const VkAccelerationStructureCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureNV *pAccelerationStructure)
void(VKAPI_PTR * PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:2851
VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
@ VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT
Definition: vulkan_core.h:7922
@ VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT
Definition: vulkan_core.h:7920
@ VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT
Definition: vulkan_core.h:7923
@ VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT
Definition: vulkan_core.h:7921
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties)
@ VK_GEOMETRY_OPAQUE_BIT_NV
Definition: vulkan_core.h:8173
@ VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NV
Definition: vulkan_core.h:8174
VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers)
VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator)
VkResult(VKAPI_PTR * PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
Definition: vulkan_core.h:2932
void(VKAPI_PTR * PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory)
Definition: vulkan_core.h:2874
VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR *pDeviceGroupPresentCapabilities)
VkResult(VKAPI_PTR * PFN_vkGetMemoryHostPointerPropertiesEXT)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void *pHostPointer, VkMemoryHostPointerPropertiesEXT *pMemoryHostPointerProperties)
Definition: vulkan_core.h:8486
VKAPI_ATTR void VKAPI_CALL vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator)
VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo)
void(VKAPI_PTR * PFN_vkGetDescriptorSetLayoutSupportKHR)(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport)
Definition: vulkan_core.h:6024
VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkInstance *pInstance)
VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle(VkQueue queue)
VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeNV mode)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties)
Definition: vulkan_core.h:4500
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties)
Definition: vulkan_core.h:5141
VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties)
Definition: vulkan_core.h:5144
VkFlags VkDependencyFlags
Definition: vulkan_core.h:1690
VkResult(VKAPI_PTR * PFN_vkEnumeratePhysicalDeviceGroups)(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties)
Definition: vulkan_core.h:4495
VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice device, const char *pName)
VkResult(VKAPI_PTR * PFN_vkCreateDescriptorUpdateTemplateKHR)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
Definition: vulkan_core.h:5523
VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroupsKHR(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties)
VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents)
VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit *pRegions, VkFilter filter)
VkResult(VKAPI_PTR * PFN_vkCreateIndirectCommandsLayoutNVX)(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkIndirectCommandsLayoutNVX *pIndirectCommandsLayout)
Definition: vulkan_core.h:6924
VkCoarseSampleOrderTypeNV
Definition: vulkan_core.h:8032
@ VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV
Definition: vulkan_core.h:8035
@ VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV
Definition: vulkan_core.h:8034
@ VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV
Definition: vulkan_core.h:8036
@ VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV
Definition: vulkan_core.h:8033
VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
VkResult(VKAPI_PTR * PFN_vkGetAccelerationStructureHandleNV)(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void *pData)
Definition: vulkan_core.h:8324
void(VKAPI_PTR * PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
Definition: vulkan_core.h:2947
VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
VkResult(VKAPI_PTR * PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
Definition: vulkan_core.h:2885
VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorPool *pDescriptorPool)
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPlaneProperties2KHR *pProperties)
VkResult(VKAPI_PTR * PFN_vkGetMemoryFdKHR)(VkDevice device, const VkMemoryGetFdInfoKHR *pGetFdInfo, int *pFd)
Definition: vulkan_core.h:5351
VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo, VkDescriptorSet *pDescriptorSets)
void(VKAPI_PTR * PFN_vkCmdEndDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer)
Definition: vulkan_core.h:7479
VkResult(VKAPI_PTR * PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
Definition: vulkan_core.h:5031
VKAPI_ATTR VkResult VKAPI_CALL vkReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display)
VkResult(VKAPI_PTR * PFN_vkEnumerateInstanceLayerProperties)(uint32_t *pPropertyCount, VkLayerProperties *pProperties)
Definition: vulkan_core.h:2865
void(VKAPI_PTR * PFN_vkCmdDispatchBase)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
Definition: vulkan_core.h:4494
VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT *pSampleLocationsInfo)
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties)
VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t *pDisplayCount, VkDisplayKHR *pDisplays)
VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(VkDevice device)
VKAPI_ATTR void VKAPI_CALL vkDestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks *pAllocator)
VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT *pNameInfo)
void(VKAPI_PTR * PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers)
Definition: vulkan_core.h:2939
void(VKAPI_PTR * PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D *pGranularity)
Definition: vulkan_core.h:2934
VKAPI_ATTR void VKAPI_CALL vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer)
VkResult(VKAPI_PTR * PFN_vkEnumeratePhysicalDeviceGroupsKHR)(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties)
Definition: vulkan_core.h:5268
uint64_t VkDeviceSize
Definition: vulkan_core.h:66
void(VKAPI_PTR * PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy *pRegions)
Definition: vulkan_core.h:2963
void(VKAPI_PTR * PFN_vkCmdDrawIndexedIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
Definition: vulkan_core.h:6481
#define VK_MAX_DESCRIPTION_SIZE
Definition: vulkan_core.h:109
VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask)
VKAPI_ATTR VkResult VKAPI_CALL vkGetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT *pProperties)
void(VKAPI_PTR * PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers)
Definition: vulkan_core.h:2986
@ VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT
Definition: vulkan_core.h:1721
VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImage *pImage)
void(VKAPI_PTR * PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer)
Definition: vulkan_core.h:2985
VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator)
VkResult(VKAPI_PTR * PFN_vkReleaseDisplayEXT)(VkPhysicalDevice physicalDevice, VkDisplayKHR display)
Definition: vulkan_core.h:7015
VkResult(VKAPI_PTR * PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorSetLayout *pSetLayout)
Definition: vulkan_core.h:2922
VkResult(VKAPI_PTR * PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
Definition: vulkan_core.h:2879
@ VK_IMAGE_CREATE_PROTECTED_BIT
Definition: vulkan_core.h:1365
@ VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT
Definition: vulkan_core.h:1362
@ VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT
Definition: vulkan_core.h:1359
@ VK_IMAGE_CREATE_ALIAS_BIT
Definition: vulkan_core.h:1360
@ VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT
Definition: vulkan_core.h:1361
@ VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT
Definition: vulkan_core.h:1358
@ VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV
Definition: vulkan_core.h:1367
@ VK_IMAGE_CREATE_EXTENDED_USAGE_BIT
Definition: vulkan_core.h:1364
@ VK_IMAGE_CREATE_SPARSE_ALIASED_BIT
Definition: vulkan_core.h:1357
@ VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT
Definition: vulkan_core.h:1356
@ VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT
Definition: vulkan_core.h:1363
@ VK_IMAGE_CREATE_SPARSE_BINDING_BIT
Definition: vulkan_core.h:1355
@ VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT
Definition: vulkan_core.h:1368
@ VK_IMAGE_CREATE_DISJOINT_BIT
Definition: vulkan_core.h:1366
VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy *pRegions)
#define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE
Definition: vulkan_core.h:104
VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreFdKHR(VkDevice device, const VkImportSemaphoreFdInfoKHR *pImportSemaphoreFdInfo)
VkResult(VKAPI_PTR * PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBufferView *pView)
Definition: vulkan_core.h:2902
VkResult(VKAPI_PTR * PFN_vkSetDebugUtilsObjectTagEXT)(VkDevice device, const VkDebugUtilsObjectTagInfoEXT *pTagInfo)
Definition: vulkan_core.h:7474
VkResult(VKAPI_PTR * PFN_vkCreateAccelerationStructureNV)(VkDevice device, const VkAccelerationStructureCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureNV *pAccelerationStructure)
Definition: vulkan_core.h:8315
void(VKAPI_PTR * PFN_vkCmdBindTransformFeedbackBuffersEXT)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes)
Definition: vulkan_core.h:6423
VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
@ VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX
Definition: vulkan_core.h:6769
@ VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX
Definition: vulkan_core.h:6768
@ VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX
Definition: vulkan_core.h:6766
@ VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX
Definition: vulkan_core.h:6771
@ VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX
Definition: vulkan_core.h:6770
@ VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX
Definition: vulkan_core.h:6772
@ VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX
Definition: vulkan_core.h:6767
@ VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX
Definition: vulkan_core.h:6765
void(VKAPI_PTR * PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
Definition: vulkan_core.h:2968
void(VKAPI_PTR * PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize *pCommittedMemoryInBytes)
Definition: vulkan_core.h:2877
VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties *pFormatProperties)
Definition: vulkan_core.h:2854
VKAPI_ATTR void VKAPI_CALL vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks *pAllocator)
VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4])
VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorSetLayout *pSetLayout)
VkResult(VKAPI_PTR * PFN_vkGetSwapchainCounterEXT)(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t *pCounterValue)
Definition: vulkan_core.h:7119
void(VKAPI_PTR * PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet *pDescriptorCopies)
Definition: vulkan_core.h:2929
VkFlags VkStencilFaceFlags
Definition: vulkan_core.h:1732
VKAPI_ATTR void VKAPI_CALL vkCmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void *pCheckpointMarker)
VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask)
@ VK_GEOMETRY_TYPE_AABBS_NV
Definition: vulkan_core.h:8136
@ VK_GEOMETRY_TYPE_TRIANGLES_NV
Definition: vulkan_core.h:8135
VkResult(VKAPI_PTR * PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo *pBindInfo, VkFence fence)
Definition: vulkan_core.h:2884
VkResult(VKAPI_PTR * PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSampler *pSampler)
Definition: vulkan_core.h:2920
VkFlags VkExternalMemoryHandleTypeFlagsNV
Definition: vulkan_core.h:6610
VKAPI_ATTR void VKAPI_CALL vkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo)
VkResult(VKAPI_PTR * PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineCache *pPipelineCache)
Definition: vulkan_core.h:2911
void(VKAPI_PTR * PFN_vkUpdateDescriptorSetWithTemplateKHR)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData)
Definition: vulkan_core.h:5525
void(VKAPI_PTR * PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
Definition: vulkan_core.h:2950
VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(VkPhysicalDevice physicalDevice, VkDeviceGeneratedCommandsFeaturesNVX *pFeatures, VkDeviceGeneratedCommandsLimitsNVX *pLimits)
VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfoKHR *pSubpassBeginInfo, const VkSubpassEndInfoKHR *pSubpassEndInfo)
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion)
@ VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT
Definition: vulkan_core.h:7084
VKAPI_ATTR VkResult VKAPI_CALL vkGetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t *pInfoSize, void *pInfo)
@ VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT
Definition: vulkan_core.h:1629
@ VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT
Definition: vulkan_core.h:1628
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pPresentModeCount, VkPresentModeKHR *pPresentModes)
VkImageTiling
Definition: vulkan_core.h:822
@ VK_IMAGE_TILING_OPTIMAL
Definition: vulkan_core.h:823
@ VK_IMAGE_TILING_LINEAR
Definition: vulkan_core.h:824
@ VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT
Definition: vulkan_core.h:825
@ VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT
Definition: vulkan_core.h:1707
@ VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT
Definition: vulkan_core.h:1708
@ VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT
Definition: vulkan_core.h:1709
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPropertiesKHR *pProperties)
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties *pFormatProperties)
void(VKAPI_PTR * PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
Definition: vulkan_core.h:2951
VkPipelineBindPoint
Definition: vulkan_core.h:1205
@ VK_PIPELINE_BIND_POINT_GRAPHICS
Definition: vulkan_core.h:1206
@ VK_PIPELINE_BIND_POINT_COMPUTE
Definition: vulkan_core.h:1207
@ VK_PIPELINE_BIND_POINT_RAY_TRACING_NV
Definition: vulkan_core.h:1208
void(VKAPI_PTR * PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy *pRegions)
Definition: vulkan_core.h:2965
VkFlags VkCommandPoolTrimFlags
Definition: vulkan_core.h:3905
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties)
VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV *pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceFormatProperties2)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties)
Definition: vulkan_core.h:4501
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties *pMemoryProperties)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateValidationCacheEXT(VkDevice device, const VkValidationCacheCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkValidationCacheEXT *pValidationCache)
VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, VkSubpassContents contents)
VkResult(VKAPI_PTR * PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
Definition: vulkan_core.h:2875
void(VKAPI_PTR * PFN_vkCmdDrawMeshTasksNV)(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask)
Definition: vulkan_core.h:8683
VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData)
void(VKAPI_PTR * PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
Definition: vulkan_core.h:2956
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, VkSurfaceCapabilities2KHR *pSurfaceCapabilities)
void(VKAPI_PTR * PFN_vkSubmitDebugUtilsMessageEXT)(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData)
Definition: vulkan_core.h:7483
VkResult(VKAPI_PTR * PFN_vkGetPastPresentationTimingGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pPresentationTimingCount, VkPastPresentationTimingGOOGLE *pPresentationTimings)
Definition: vulkan_core.h:7177
void *(VKAPI_PTR * PFN_vkAllocationFunction)(void *pUserData, size_t size, size_t alignment, VkSystemAllocationScope allocationScope)
Definition: vulkan_core.h:1755
void(VKAPI_PTR * PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
Definition: vulkan_core.h:2952
void(VKAPI_PTR * PFN_vkTrimCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
Definition: vulkan_core.h:4506
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainEXT *pTimeDomains)
Definition: vulkan_core.h:8534
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties)
Definition: vulkan_core.h:4502
void(VKAPI_PTR * PFN_vkCmdSetSampleLocationsEXT)(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT *pSampleLocationsInfo)
Definition: vulkan_core.h:7681
VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void *pData)
VkResult(VKAPI_PTR * PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t *pPhysicalDeviceCount, VkPhysicalDevice *pPhysicalDevices)
Definition: vulkan_core.h:2852
VkResult(VKAPI_PTR * PFN_vkSetDebugUtilsObjectNameEXT)(VkDevice device, const VkDebugUtilsObjectNameInfoEXT *pNameInfo)
Definition: vulkan_core.h:7473
void(VKAPI_PTR * PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
Definition: vulkan_core.h:2959
@ VK_SUBGROUP_FEATURE_SHUFFLE_BIT
Definition: vulkan_core.h:3877
@ VK_SUBGROUP_FEATURE_VOTE_BIT
Definition: vulkan_core.h:3874
@ VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT
Definition: vulkan_core.h:3878
@ VK_SUBGROUP_FEATURE_QUAD_BIT
Definition: vulkan_core.h:3880
@ VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV
Definition: vulkan_core.h:3881
@ VK_SUBGROUP_FEATURE_BASIC_BIT
Definition: vulkan_core.h:3873
@ VK_SUBGROUP_FEATURE_CLUSTERED_BIT
Definition: vulkan_core.h:3879
@ VK_SUBGROUP_FEATURE_ARITHMETIC_BIT
Definition: vulkan_core.h:3875
@ VK_SUBGROUP_FEATURE_BALLOT_BIT
Definition: vulkan_core.h:3876
VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR *pGetFdInfo, int *pFd)
VkResult(VKAPI_PTR * PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR *pCapabilities)
Definition: vulkan_core.h:5030
VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent(VkDevice device, VkEvent event)
VkShaderInfoTypeAMD
Definition: vulkan_core.h:6535
@ VK_SHADER_INFO_TYPE_BINARY_AMD
Definition: vulkan_core.h:6537
@ VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD
Definition: vulkan_core.h:6538
@ VK_SHADER_INFO_TYPE_STATISTICS_AMD
Definition: vulkan_core.h:6536
VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus(VkDevice device, VkEvent event)
@ VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR
Definition: vulkan_core.h:3863
@ VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET
Definition: vulkan_core.h:3862
VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
@ VK_SEMAPHORE_IMPORT_TEMPORARY_BIT
Definition: vulkan_core.h:3972
@ VK_STENCIL_OP_INCREMENT_AND_CLAMP
Definition: vulkan_core.h:982
@ VK_STENCIL_OP_DECREMENT_AND_CLAMP
Definition: vulkan_core.h:983
@ VK_STENCIL_OP_INCREMENT_AND_WRAP
Definition: vulkan_core.h:985
@ VK_STENCIL_OP_KEEP
Definition: vulkan_core.h:979
@ VK_STENCIL_OP_REPLACE
Definition: vulkan_core.h:981
@ VK_STENCIL_OP_ZERO
Definition: vulkan_core.h:980
@ VK_STENCIL_OP_DECREMENT_AND_WRAP
Definition: vulkan_core.h:986
@ VK_STENCIL_OP_INVERT
Definition: vulkan_core.h:984
VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask)
VkResult(VKAPI_PTR * PFN_vkGetCalibratedTimestampsEXT)(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT *pTimestampInfos, uint64_t *pTimestamps, uint64_t *pMaxDeviation)
Definition: vulkan_core.h:8535
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void *pHostPointer, VkMemoryHostPointerPropertiesEXT *pMemoryHostPointerProperties)
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties)
void(VKAPI_PTR * PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy *pRegions)
Definition: vulkan_core.h:2962
VKAPI_ATTR VkResult VKAPI_CALL vkUnregisterObjectsNVX(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectEntryTypeNVX *pObjectEntryTypes, const uint32_t *pObjectIndices)
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdKHR(VkDevice device, const VkMemoryGetFdInfoKHR *pGetFdInfo, int *pFd)
VKAPI_ATTR VkResult VKAPI_CALL vkMergeValidationCachesEXT(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT *pSrcCaches)
@ VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD
Definition: vulkan_core.h:8582
@ VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD
Definition: vulkan_core.h:8583
@ VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD
Definition: vulkan_core.h:8584
VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy *pRegions)
void(VKAPI_PTR * PFN_vkCmdBeginTransformFeedbackEXT)(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
Definition: vulkan_core.h:6424
VkResult(VKAPI_PTR * PFN_vkCreateInstance)(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkInstance *pInstance)
Definition: vulkan_core.h:2850
@ VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV
Definition: vulkan_core.h:8162
@ VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV
Definition: vulkan_core.h:8164
@ VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV
Definition: vulkan_core.h:8163
@ VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR
Definition: vulkan_core.h:4804
@ VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR
Definition: vulkan_core.h:4805
@ VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR
Definition: vulkan_core.h:4802
@ VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR
Definition: vulkan_core.h:4803
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties)
Definition: vulkan_core.h:2856
VkResult(VKAPI_PTR * PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo)
Definition: vulkan_core.h:2940
VkResult(VKAPI_PTR * PFN_vkGetRefreshCycleDurationGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE *pDisplayTimingProperties)
Definition: vulkan_core.h:7176
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT *pSurfaceCapabilities)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDisplayModeKHR *pMode)
VKAPI_ATTR void VKAPI_CALL vkQueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo)
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties)
VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT *pTagInfo)
#define VK_MAX_DRIVER_NAME_SIZE_KHR
Definition: vulkan_core.h:6088
VkResult(VKAPI_PTR * PFN_vkGetFenceFdKHR)(VkDevice device, const VkFenceGetFdInfoKHR *pGetFdInfo, int *pFd)
Definition: vulkan_core.h:5735
@ VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV
Definition: vulkan_core.h:8018
@ VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV
Definition: vulkan_core.h:8015
@ VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV
Definition: vulkan_core.h:8025
@ VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV
Definition: vulkan_core.h:8020
@ VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV
Definition: vulkan_core.h:8023
@ VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV
Definition: vulkan_core.h:8021
@ VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV
Definition: vulkan_core.h:8016
@ VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV
Definition: vulkan_core.h:8024
@ VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV
Definition: vulkan_core.h:8014
@ VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV
Definition: vulkan_core.h:8017
@ VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV
Definition: vulkan_core.h:8022
@ VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV
Definition: vulkan_core.h:8019
@ VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES
Definition: vulkan_core.h:3801
@ VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY
Definition: vulkan_core.h:3802
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties)
Definition: vulkan_core.h:5143
void(VKAPI_PTR * PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:2905
@ VK_CULL_MODE_FRONT_AND_BACK
Definition: vulkan_core.h:1599
@ VK_CULL_MODE_FRONT_BIT
Definition: vulkan_core.h:1597
@ VK_CULL_MODE_NONE
Definition: vulkan_core.h:1596
@ VK_CULL_MODE_BACK_BIT
Definition: vulkan_core.h:1598
VkResult(VKAPI_PTR * PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkEvent *pEvent)
Definition: vulkan_core.h:2892
@ VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV
Definition: vulkan_core.h:8191
@ VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV
Definition: vulkan_core.h:8192
@ VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV
Definition: vulkan_core.h:8190
@ VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NV
Definition: vulkan_core.h:8193
@ VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV
Definition: vulkan_core.h:8189
VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator)
VKAPI_ATTR VkResult VKAPI_CALL vkRegisterObjectsNVX(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectTableEntryNVX *const *ppObjectTableEntries, const uint32_t *pObjectIndices)
VKAPI_ATTR void VKAPI_CALL vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties)
@ VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE
Definition: vulkan_core.h:1158
@ VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK
Definition: vulkan_core.h:1154
@ VK_BORDER_COLOR_INT_OPAQUE_WHITE
Definition: vulkan_core.h:1159
@ VK_BORDER_COLOR_INT_TRANSPARENT_BLACK
Definition: vulkan_core.h:1155
@ VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK
Definition: vulkan_core.h:1156
@ VK_BORDER_COLOR_INT_OPAQUE_BLACK
Definition: vulkan_core.h:1157
VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags)
VKAPI_ATTR void VKAPI_CALL vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index)
VkResult(VKAPI_PTR * PFN_vkImportFenceFdKHR)(VkDevice device, const VkImportFenceFdInfoKHR *pImportFenceFdInfo)
Definition: vulkan_core.h:5734
VkSurfaceCounterFlagBitsEXT
Definition: vulkan_core.h:7028
@ VK_SURFACE_COUNTER_VBLANK_EXT
Definition: vulkan_core.h:7029
@ VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT
Definition: vulkan_core.h:1422
VkResult(VKAPI_PTR * PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, uint64_t timeout)
Definition: vulkan_core.h:2889
VkDebugReportObjectTypeEXT
Definition: vulkan_core.h:6148
@ VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT
Definition: vulkan_core.h:6155
@ VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT
Definition: vulkan_core.h:6159
@ VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT
Definition: vulkan_core.h:6166
@ VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT
Definition: vulkan_core.h:6185
@ VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT
Definition: vulkan_core.h:6151
@ VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT
Definition: vulkan_core.h:6150
@ VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT
Definition: vulkan_core.h:6178
@ VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT
Definition: vulkan_core.h:6157
@ VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT
Definition: vulkan_core.h:6183
@ VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT
Definition: vulkan_core.h:6174
@ VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT
Definition: vulkan_core.h:6172
@ VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT
Definition: vulkan_core.h:6162
@ VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT
Definition: vulkan_core.h:6158
@ VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT
Definition: vulkan_core.h:6156
@ VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT
Definition: vulkan_core.h:6163
@ VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT
Definition: vulkan_core.h:6180
@ VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT
Definition: vulkan_core.h:6165
@ VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT
Definition: vulkan_core.h:6149
@ VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT
Definition: vulkan_core.h:6164
@ VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT
Definition: vulkan_core.h:6177
@ VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT
Definition: vulkan_core.h:6170
@ VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT
Definition: vulkan_core.h:6169
@ VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT
Definition: vulkan_core.h:6179
@ VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT
Definition: vulkan_core.h:6182
@ VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT
Definition: vulkan_core.h:6160
@ VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT
Definition: vulkan_core.h:6175
@ VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT
Definition: vulkan_core.h:6152
@ VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT
Definition: vulkan_core.h:6173
@ VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT
Definition: vulkan_core.h:6167
@ VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT
Definition: vulkan_core.h:6161
@ VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT
Definition: vulkan_core.h:6184
@ VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT
Definition: vulkan_core.h:6181
@ VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT
Definition: vulkan_core.h:6154
@ VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT
Definition: vulkan_core.h:6176
@ VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT
Definition: vulkan_core.h:6171
@ VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT
Definition: vulkan_core.h:6168
@ VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT
Definition: vulkan_core.h:6153
VkResult(VKAPI_PTR * PFN_vkResetEvent)(VkDevice device, VkEvent event)
Definition: vulkan_core.h:2896
VkResult(VKAPI_PTR * PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo, VkDescriptorSet *pDescriptorSets)
Definition: vulkan_core.h:2927
VKAPI_ATTR void VKAPI_CALL vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
VkResult(VKAPI_PTR * PFN_vkDisplayPowerControlEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT *pDisplayPowerInfo)
Definition: vulkan_core.h:7116
@ VK_SAMPLER_MIPMAP_MODE_NEAREST
Definition: vulkan_core.h:1133
@ VK_SAMPLER_MIPMAP_MODE_LINEAR
Definition: vulkan_core.h:1134
void(VKAPI_PTR * PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements *pSparseMemoryRequirements)
Definition: vulkan_core.h:2882
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities)
Definition: vulkan_core.h:4753
VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char *pLayerPrefix, const char *pMessage)
VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
VkResult(VKAPI_PTR * PFN_vkBindBufferMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos)
Definition: vulkan_core.h:6000
VkFlags VkPeerMemoryFeatureFlags
Definition: vulkan_core.h:3897
@ VK_RASTERIZATION_ORDER_RELAXED_AMD
Definition: vulkan_core.h:6275
@ VK_RASTERIZATION_ORDER_STRICT_AMD
Definition: vulkan_core.h:6274
@ VK_IMAGE_ASPECT_PLANE_2_BIT
Definition: vulkan_core.h:1465
@ VK_IMAGE_ASPECT_PLANE_0_BIT
Definition: vulkan_core.h:1463
@ VK_IMAGE_ASPECT_METADATA_BIT
Definition: vulkan_core.h:1462
@ VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT
Definition: vulkan_core.h:1468
@ VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT
Definition: vulkan_core.h:1466
@ VK_IMAGE_ASPECT_COLOR_BIT
Definition: vulkan_core.h:1459
@ VK_IMAGE_ASPECT_STENCIL_BIT
Definition: vulkan_core.h:1461
@ VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT
Definition: vulkan_core.h:1469
@ VK_IMAGE_ASPECT_DEPTH_BIT
Definition: vulkan_core.h:1460
@ VK_IMAGE_ASPECT_PLANE_1_BIT
Definition: vulkan_core.h:1464
@ VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT
Definition: vulkan_core.h:1467
void(VKAPI_PTR * PFN_vkGetDeviceGroupPeerMemoryFeatures)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures)
Definition: vulkan_core.h:4492
VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceFdKHR(VkDevice device, const VkImportFenceFdInfoKHR *pImportFenceFdInfo)
@ VK_IMAGE_USAGE_TRANSFER_DST_BIT
Definition: vulkan_core.h:1342
@ VK_IMAGE_USAGE_SAMPLED_BIT
Definition: vulkan_core.h:1343
@ VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT
Definition: vulkan_core.h:1346
@ VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV
Definition: vulkan_core.h:1349
@ VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT
Definition: vulkan_core.h:1348
@ VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT
Definition: vulkan_core.h:1345
@ VK_IMAGE_USAGE_TRANSFER_SRC_BIT
Definition: vulkan_core.h:1341
@ VK_IMAGE_USAGE_STORAGE_BIT
Definition: vulkan_core.h:1344
@ VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT
Definition: vulkan_core.h:1347
VKAPI_ATTR void VKAPI_CALL vkQueueEndDebugUtilsLabelEXT(VkQueue queue)
VKAPI_ATTR void VKAPI_CALL vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks *pAllocator)
VKAPI_ATTR void VKAPI_CALL vkSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData)
void(VKAPI_PTR * PFN_vkCmdBeginDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo)
Definition: vulkan_core.h:7478
void(VKAPI_PTR * PFN_vkCmdReserveSpaceForCommandsNVX)(VkCommandBuffer commandBuffer, const VkCmdReserveSpaceForCommandsInfoNVX *pReserveSpaceInfo)
Definition: vulkan_core.h:6923
VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t *pDataSize, void *pData)
@ VK_MEMORY_HEAP_MULTI_INSTANCE_BIT
Definition: vulkan_core.h:1414
@ VK_MEMORY_HEAP_DEVICE_LOCAL_BIT
Definition: vulkan_core.h:1413
VkResult(VKAPI_PTR * PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
Definition: vulkan_core.h:2937
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties)
@ VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT
Definition: vulkan_core.h:3900
void(VKAPI_PTR * PFN_vkCmdEndRenderPass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassEndInfoKHR *pSubpassEndInfo)
Definition: vulkan_core.h:5630
void(VKAPI_PTR * PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void *pValues)
Definition: vulkan_core.h:2982
VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass(VkCommandBuffer commandBuffer)
VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
VkSampleCountFlagBits
Definition: vulkan_core.h:1379
@ VK_SAMPLE_COUNT_8_BIT
Definition: vulkan_core.h:1383
@ VK_SAMPLE_COUNT_64_BIT
Definition: vulkan_core.h:1386
@ VK_SAMPLE_COUNT_32_BIT
Definition: vulkan_core.h:1385
@ VK_SAMPLE_COUNT_2_BIT
Definition: vulkan_core.h:1381
@ VK_SAMPLE_COUNT_1_BIT
Definition: vulkan_core.h:1380
@ VK_SAMPLE_COUNT_4_BIT
Definition: vulkan_core.h:1382
@ VK_SAMPLE_COUNT_16_BIT
Definition: vulkan_core.h:1384
VkExternalMemoryHandleTypeFlagBits
Definition: vulkan_core.h:3908
@ VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID
Definition: vulkan_core.h:3917
@ VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT
Definition: vulkan_core.h:3913
@ VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT
Definition: vulkan_core.h:3911
@ VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT
Definition: vulkan_core.h:3919
@ VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT
Definition: vulkan_core.h:3910
@ VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT
Definition: vulkan_core.h:3912
@ VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT
Definition: vulkan_core.h:3916
@ VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT
Definition: vulkan_core.h:3909
@ VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT
Definition: vulkan_core.h:3914
@ VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT
Definition: vulkan_core.h:3915
@ VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT
Definition: vulkan_core.h:3918
void(VKAPI_PTR * PFN_vkCmdEndQueryIndexedEXT)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index)
Definition: vulkan_core.h:6427
VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t *pPropertyCount, VkDisplayModeProperties2KHR *pProperties)
VkQueryType
Definition: vulkan_core.h:844
@ VK_QUERY_TYPE_PIPELINE_STATISTICS
Definition: vulkan_core.h:846
@ VK_QUERY_TYPE_OCCLUSION
Definition: vulkan_core.h:845
@ VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV
Definition: vulkan_core.h:849
@ VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT
Definition: vulkan_core.h:848
@ VK_QUERY_TYPE_TIMESTAMP
Definition: vulkan_core.h:847
void(VKAPI_PTR * PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
Definition: vulkan_core.h:2943
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties *pImageFormatProperties)
Definition: vulkan_core.h:2855
@ VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709
Definition: vulkan_core.h:3825
@ VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020
Definition: vulkan_core.h:3827
@ VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601
Definition: vulkan_core.h:3826
@ VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY
Definition: vulkan_core.h:3824
@ VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY
Definition: vulkan_core.h:3823
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPlanePropertiesKHR *pProperties)
Definition: vulkan_core.h:5026
VkResult(VKAPI_PTR * PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDevice *pDevice)
Definition: vulkan_core.h:2861
VkResult(VKAPI_PTR * PFN_vkGetDisplayPlaneCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR *pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR *pCapabilities)
Definition: vulkan_core.h:5855
VkResult(VKAPI_PTR * PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool)
Definition: vulkan_core.h:2897
VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue *pColor, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
VkResult(VKAPI_PTR * PFN_vkCreateSamplerYcbcrConversion)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion)
Definition: vulkan_core.h:4508
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties)
Definition: vulkan_core.h:5691
VkFlags VkDebugUtilsMessageTypeFlagsEXT
Definition: vulkan_core.h:7414
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceExternalFenceProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties)
Definition: vulkan_core.h:4514
VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool)
#define VK_UUID_SIZE
Definition: vulkan_core.h:105
@ VK_CHROMA_LOCATION_COSITED_EVEN
Definition: vulkan_core.h:3851
@ VK_CHROMA_LOCATION_MIDPOINT
Definition: vulkan_core.h:3852
void(VKAPI_PTR * PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:2931
VkResult(VKAPI_PTR * PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence *pFences)
Definition: vulkan_core.h:2887
void(VKAPI_PTR * PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
Definition: vulkan_core.h:2958
void(VKAPI_PTR * PFN_vkCmdBindShadingRateImageNV)(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
Definition: vulkan_core.h:8093
@ VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX
Definition: vulkan_core.h:1645
@ VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX
Definition: vulkan_core.h:1644
VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSampler *pSampler)
void(VKAPI_PTR * PFN_vkCmdDrawIndirectCountKHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
Definition: vulkan_core.h:6037
VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR *pCapabilities)
VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites)
VkResult(VKAPI_PTR * PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t *pDataSize, void *pData)
Definition: vulkan_core.h:2913
VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceMemoryProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
Definition: vulkan_core.h:5145
@ VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT
Definition: vulkan_core.h:7306
@ VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT
Definition: vulkan_core.h:7307
@ VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT
Definition: vulkan_core.h:7308
@ VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR
Definition: vulkan_core.h:4724
@ VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR
Definition: vulkan_core.h:4727
@ VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR
Definition: vulkan_core.h:4726
@ VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR
Definition: vulkan_core.h:4725
VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPlanePropertiesKHR *pProperties)
VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets)
VKAPI_ATTR void VKAPI_CALL vkQueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo)
VkFlags VkQueryControlFlags
Definition: vulkan_core.h:1718
VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfoKHR *pSubpassEndInfo)
VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineCache *pPipelineCache)
VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator)
VKAPI_ATTR VkResult VKAPI_CALL vkGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, size_t *pDataSize, void *pData)
VkResult(VKAPI_PTR * PFN_vkCreateSamplerYcbcrConversionKHR)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion)
Definition: vulkan_core.h:5975
VkResult(VKAPI_PTR * PFN_vkGetDisplayModeProperties2KHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t *pPropertyCount, VkDisplayModeProperties2KHR *pProperties)
Definition: vulkan_core.h:5854
VkResult(VKAPI_PTR * PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void **ppData)
Definition: vulkan_core.h:2873
VKAPI_ATTR VkResult VKAPI_CALL vkGetRefreshCycleDurationGOOGLE(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE *pDisplayTimingProperties)
VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR *pModes)
void(VKAPI_PTR * PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements *pMemoryRequirements)
Definition: vulkan_core.h:2880
void(VKAPI_PTR * PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:4751
VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache *pSrcCaches)
VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
@ VK_COMPARE_OP_LESS_OR_EQUAL
Definition: vulkan_core.h:967
@ VK_COMPARE_OP_LESS
Definition: vulkan_core.h:965
@ VK_COMPARE_OP_NOT_EQUAL
Definition: vulkan_core.h:969
@ VK_COMPARE_OP_NEVER
Definition: vulkan_core.h:964
@ VK_COMPARE_OP_ALWAYS
Definition: vulkan_core.h:971
@ VK_COMPARE_OP_EQUAL
Definition: vulkan_core.h:966
@ VK_COMPARE_OP_GREATER_OR_EQUAL
Definition: vulkan_core.h:970
@ VK_COMPARE_OP_GREATER
Definition: vulkan_core.h:968
VkResult(VKAPI_PTR * PFN_vkDebugMarkerSetObjectTagEXT)(VkDevice device, const VkDebugMarkerObjectTagInfoEXT *pTagInfo)
Definition: vulkan_core.h:6330
void(VKAPI_PTR * PFN_vkCmdBeginQueryIndexedEXT)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index)
Definition: vulkan_core.h:6426
void(VKAPI_PTR * PFN_vkCmdTraceRaysNV)(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth)
Definition: vulkan_core.h:8321
void(VKAPI_PTR * PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:2908
VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks *pAllocator)
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPropertiesKHR *pProperties)
Definition: vulkan_core.h:5025
@ VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV
Definition: vulkan_core.h:6607
@ VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV
Definition: vulkan_core.h:6604
@ VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV
Definition: vulkan_core.h:6606
@ VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV
Definition: vulkan_core.h:6605
VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties)
@ VK_LOGIC_OP_AND
Definition: vulkan_core.h:995
@ VK_LOGIC_OP_CLEAR
Definition: vulkan_core.h:994
@ VK_LOGIC_OP_EQUIVALENT
Definition: vulkan_core.h:1003
@ VK_LOGIC_OP_AND_REVERSE
Definition: vulkan_core.h:996
@ VK_LOGIC_OP_SET
Definition: vulkan_core.h:1009
@ VK_LOGIC_OP_NOR
Definition: vulkan_core.h:1002
@ VK_LOGIC_OP_NO_OP
Definition: vulkan_core.h:999
@ VK_LOGIC_OP_COPY
Definition: vulkan_core.h:997
@ VK_LOGIC_OP_NAND
Definition: vulkan_core.h:1008
@ VK_LOGIC_OP_OR_REVERSE
Definition: vulkan_core.h:1005
@ VK_LOGIC_OP_COPY_INVERTED
Definition: vulkan_core.h:1006
@ VK_LOGIC_OP_OR
Definition: vulkan_core.h:1001
@ VK_LOGIC_OP_OR_INVERTED
Definition: vulkan_core.h:1007
@ VK_LOGIC_OP_AND_INVERTED
Definition: vulkan_core.h:998
@ VK_LOGIC_OP_INVERT
Definition: vulkan_core.h:1004
@ VK_LOGIC_OP_XOR
Definition: vulkan_core.h:1000
VKAPI_ATTR void VKAPI_CALL vkCmdProcessCommandsNVX(VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX *pProcessCommandsInfo)
VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent(VkDevice device, VkEvent event)
@ VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT
Definition: vulkan_core.h:3890
@ VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT
Definition: vulkan_core.h:3889
@ VK_PEER_MEMORY_FEATURE_COPY_DST_BIT
Definition: vulkan_core.h:3888
@ VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT
Definition: vulkan_core.h:3887
void(VKAPI_PTR * PFN_vkCmdWaitEvents)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers)
Definition: vulkan_core.h:2975
VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue)
VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR *pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR *pCapabilities)
void(VKAPI_PTR * PFN_vkCmdDrawMeshTasksIndirectNV)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
Definition: vulkan_core.h:8684
@ VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT
Definition: vulkan_core.h:1701
@ VK_BLEND_OP_MULTIPLY_EXT
Definition: vulkan_core.h:1060
@ VK_BLEND_OP_ADD
Definition: vulkan_core.h:1043
@ VK_BLEND_OP_CONTRAST_EXT
Definition: vulkan_core.h:1089
@ VK_BLEND_OP_HARDLIGHT_EXT
Definition: vulkan_core.h:1067
@ VK_BLEND_OP_OVERLAY_EXT
Definition: vulkan_core.h:1062
@ VK_BLEND_OP_COLORDODGE_EXT
Definition: vulkan_core.h:1065
@ VK_BLEND_OP_SUBTRACT
Definition: vulkan_core.h:1044
@ VK_BLEND_OP_BLUE_EXT
Definition: vulkan_core.h:1093
@ VK_BLEND_OP_PLUS_DARKER_EXT
Definition: vulkan_core.h:1086
@ VK_BLEND_OP_HSL_COLOR_EXT
Definition: vulkan_core.h:1081
@ VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT
Definition: vulkan_core.h:1085
@ VK_BLEND_OP_DARKEN_EXT
Definition: vulkan_core.h:1063
@ VK_BLEND_OP_GREEN_EXT
Definition: vulkan_core.h:1092
@ VK_BLEND_OP_PLUS_EXT
Definition: vulkan_core.h:1083
@ VK_BLEND_OP_SRC_IN_EXT
Definition: vulkan_core.h:1053
@ VK_BLEND_OP_INVERT_RGB_EXT
Definition: vulkan_core.h:1072
@ VK_BLEND_OP_XOR_EXT
Definition: vulkan_core.h:1059
@ VK_BLEND_OP_DST_OVER_EXT
Definition: vulkan_core.h:1052
@ VK_BLEND_OP_SOFTLIGHT_EXT
Definition: vulkan_core.h:1068
@ VK_BLEND_OP_LIGHTEN_EXT
Definition: vulkan_core.h:1064
@ VK_BLEND_OP_SRC_OUT_EXT
Definition: vulkan_core.h:1055
@ VK_BLEND_OP_MIN
Definition: vulkan_core.h:1046
@ VK_BLEND_OP_MINUS_EXT
Definition: vulkan_core.h:1087
@ VK_BLEND_OP_DST_EXT
Definition: vulkan_core.h:1050
@ VK_BLEND_OP_SRC_EXT
Definition: vulkan_core.h:1049
@ VK_BLEND_OP_SRC_ATOP_EXT
Definition: vulkan_core.h:1057
@ VK_BLEND_OP_HSL_HUE_EXT
Definition: vulkan_core.h:1079
@ VK_BLEND_OP_HSL_SATURATION_EXT
Definition: vulkan_core.h:1080
@ VK_BLEND_OP_PINLIGHT_EXT
Definition: vulkan_core.h:1077
@ VK_BLEND_OP_SCREEN_EXT
Definition: vulkan_core.h:1061
@ VK_BLEND_OP_INVERT_OVG_EXT
Definition: vulkan_core.h:1090
@ VK_BLEND_OP_SRC_OVER_EXT
Definition: vulkan_core.h:1051
@ VK_BLEND_OP_MAX
Definition: vulkan_core.h:1047
@ VK_BLEND_OP_HSL_LUMINOSITY_EXT
Definition: vulkan_core.h:1082
@ VK_BLEND_OP_ZERO_EXT
Definition: vulkan_core.h:1048
@ VK_BLEND_OP_LINEARDODGE_EXT
Definition: vulkan_core.h:1073
@ VK_BLEND_OP_LINEARLIGHT_EXT
Definition: vulkan_core.h:1076
@ VK_BLEND_OP_INVERT_EXT
Definition: vulkan_core.h:1071
@ VK_BLEND_OP_DST_IN_EXT
Definition: vulkan_core.h:1054
@ VK_BLEND_OP_RED_EXT
Definition: vulkan_core.h:1091
@ VK_BLEND_OP_VIVIDLIGHT_EXT
Definition: vulkan_core.h:1075
@ VK_BLEND_OP_PLUS_CLAMPED_EXT
Definition: vulkan_core.h:1084
@ VK_BLEND_OP_MINUS_CLAMPED_EXT
Definition: vulkan_core.h:1088
@ VK_BLEND_OP_EXCLUSION_EXT
Definition: vulkan_core.h:1070
@ VK_BLEND_OP_COLORBURN_EXT
Definition: vulkan_core.h:1066
@ VK_BLEND_OP_DIFFERENCE_EXT
Definition: vulkan_core.h:1069
@ VK_BLEND_OP_DST_OUT_EXT
Definition: vulkan_core.h:1056
@ VK_BLEND_OP_HARDMIX_EXT
Definition: vulkan_core.h:1078
@ VK_BLEND_OP_LINEARBURN_EXT
Definition: vulkan_core.h:1074
@ VK_BLEND_OP_REVERSE_SUBTRACT
Definition: vulkan_core.h:1045
@ VK_BLEND_OP_DST_ATOP_EXT
Definition: vulkan_core.h:1058
@ VK_COMPONENT_SWIZZLE_G
Definition: vulkan_core.h:907
@ VK_COMPONENT_SWIZZLE_B
Definition: vulkan_core.h:908
@ VK_COMPONENT_SWIZZLE_ONE
Definition: vulkan_core.h:905
@ VK_COMPONENT_SWIZZLE_A
Definition: vulkan_core.h:909
@ VK_COMPONENT_SWIZZLE_IDENTITY
Definition: vulkan_core.h:903
@ VK_COMPONENT_SWIZZLE_R
Definition: vulkan_core.h:906
@ VK_COMPONENT_SWIZZLE_ZERO
Definition: vulkan_core.h:904
void(VKAPI_PTR * PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:2912
VkFlags VkCommandPoolResetFlags
Definition: vulkan_core.h:1704
void(VKAPI_PTR * PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:2910
void(VKAPI_PTR * PFN_vkDebugReportMessageEXT)(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char *pLayerPrefix, const char *pMessage)
Definition: vulkan_core.h:6228
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties)
VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks *pAllocator)
void(VKAPI_PTR * PFN_vkCmdDrawMeshTasksIndirectCountNV)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
Definition: vulkan_core.h:8685
void(VKAPI_PTR * PFN_vkUpdateDescriptorSetWithTemplate)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData)
Definition: vulkan_core.h:4512
void(VKAPI_PTR * PFN_vkCmdDrawIndexedIndirectCountKHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
Definition: vulkan_core.h:6038
void(VKAPI_PTR * PFN_vkGetImageMemoryRequirements2)(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
Definition: vulkan_core.h:4496
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
VkResult(VKAPI_PTR * PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t *pPropertyCount, VkDisplayModePropertiesKHR *pProperties)
Definition: vulkan_core.h:5028
void(VKAPI_PTR * PFN_vkCmdEndTransformFeedbackEXT)(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
Definition: vulkan_core.h:6425
@ VK_COVERAGE_MODULATION_MODE_RGBA_NV
Definition: vulkan_core.h:7762
@ VK_COVERAGE_MODULATION_MODE_ALPHA_NV
Definition: vulkan_core.h:7761
@ VK_COVERAGE_MODULATION_MODE_RGB_NV
Definition: vulkan_core.h:7760
@ VK_COVERAGE_MODULATION_MODE_NONE_NV
Definition: vulkan_core.h:7759
void(VKAPI_PTR * PFN_vkGetBufferMemoryRequirements2KHR)(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
Definition: vulkan_core.h:5914
void(VKAPI_PTR * PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment *pAttachments, uint32_t rectCount, const VkClearRect *pRects)
Definition: vulkan_core.h:2971
@ VK_PIPELINE_CACHE_HEADER_VERSION_ONE
Definition: vulkan_core.h:113
VkFlags VkShaderStageFlags
Definition: vulkan_core.h:1617
VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
VKAPI_ATTR void VKAPI_CALL vkDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks *pAllocator)
void(VKAPI_PTR * PFN_vkInternalFreeNotification)(void *pUserData, size_t size, VkInternalAllocationType allocationType, VkSystemAllocationScope allocationScope)
Definition: vulkan_core.h:1778
void(VKAPI_PTR * PFN_vkGetBufferMemoryRequirements2)(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
Definition: vulkan_core.h:4497
void(VKAPI_PTR * PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource *pSubresource, VkSubresourceLayout *pLayout)
Definition: vulkan_core.h:2906
VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingShaderGroupHandlesNV(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2KHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
void(VKAPI_PTR * PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport *pViewports)
Definition: vulkan_core.h:2944
VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutNVX(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkIndirectCommandsLayoutNVX *pIndirectCommandsLayout)
VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32 *pSupported)
@ VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE
Definition: vulkan_core.h:537
VkResult(VKAPI_PTR * PFN_vkGetFenceStatus)(VkDevice device, VkFence fence)
Definition: vulkan_core.h:2888
void(VKAPI_PTR * PFN_vkCmdInsertDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo)
Definition: vulkan_core.h:7480
@ VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT
Definition: vulkan_core.h:3933
@ VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT
Definition: vulkan_core.h:3932
@ VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT
Definition: vulkan_core.h:3934
@ VK_VALIDATION_CHECK_ALL_EXT
Definition: vulkan_core.h:6666
@ VK_VALIDATION_CHECK_SHADERS_EXT
Definition: vulkan_core.h:6667
@ VK_STENCIL_FRONT_AND_BACK
Definition: vulkan_core.h:1729
@ VK_STENCIL_FACE_FRONT_BIT
Definition: vulkan_core.h:1727
@ VK_STENCIL_FACE_BACK_BIT
Definition: vulkan_core.h:1728
VkResult(VKAPI_PTR * PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorPool *pDescriptorPool)
Definition: vulkan_core.h:2924
PFN_vkVoidFunction(VKAPI_PTR * PFN_vkGetDeviceProcAddr)(VkDevice device, const char *pName)
Definition: vulkan_core.h:2860
VKAPI_ATTR VkResult VKAPI_CALL vkGetAccelerationStructureHandleNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void *pData)
VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, uint64_t timeout)
void(VKAPI_PTR * PFN_vkGetImageSparseMemoryRequirements2)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
Definition: vulkan_core.h:4498
void(VKAPI_PTR * PFN_vkCmdDrawIndirectByteCountEXT)(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride)
Definition: vulkan_core.h:6428
VKAPI_ATTR void VKAPI_CALL vkCmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV *pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities)
VkResult(VKAPI_PTR * PFN_vkGetEventStatus)(VkDevice device, VkEvent event)
Definition: vulkan_core.h:2894
void(VKAPI_PTR * PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
Definition: vulkan_core.h:2957
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceExternalBufferProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties)
Definition: vulkan_core.h:4513
VkBool32(VKAPI_PTR * PFN_vkDebugReportCallbackEXT)(VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char *pLayerPrefix, const char *pMessage, void *pUserData)
Definition: vulkan_core.h:6207
VkResult(VKAPI_PTR * PFN_vkGetSemaphoreFdKHR)(VkDevice device, const VkSemaphoreGetFdInfoKHR *pGetFdInfo, int *pFd)
Definition: vulkan_core.h:5429
VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCommandPool *pCommandPool)
void(VKAPI_PTR * PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:2898
void(VKAPI_PTR * PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:2919
VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D *pGranularity)
VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks *pAllocator)
void(VKAPI_PTR * PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:2925
void *(VKAPI_PTR * PFN_vkReallocationFunction)(void *pUserData, void *pOriginal, size_t size, size_t alignment, VkSystemAllocationScope allocationScope)
Definition: vulkan_core.h:1761
@ VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV
Definition: vulkan_core.h:8180
@ VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_NV
Definition: vulkan_core.h:8181
@ VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NV
Definition: vulkan_core.h:8183
@ VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NV
Definition: vulkan_core.h:8182
VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer)
void(VKAPI_PTR * PFN_vkDestroySamplerYcbcrConversionKHR)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:5976
VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
VkResult(VKAPI_PTR * PFN_vkQueueWaitIdle)(VkQueue queue)
Definition: vulkan_core.h:2869
VkResult(VKAPI_PTR * PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
Definition: vulkan_core.h:2876
@ VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT
Definition: vulkan_core.h:1478
@ VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT
Definition: vulkan_core.h:1480
@ VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT
Definition: vulkan_core.h:1479
VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugUtilsMessengerEXT *pMessenger)
void(VKAPI_PTR * PFN_vkCmdSetExclusiveScissorNV)(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D *pExclusiveScissors)
Definition: vulkan_core.h:8752
void(VKAPI_PTR * PFN_vkCmdDrawIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
Definition: vulkan_core.h:6480
VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
void(VKAPI_PTR * PFN_vkCmdSetViewportWScalingNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV *pViewportWScalings)
Definition: vulkan_core.h:7001
void(VKAPI_PTR * PFN_vkDestroyDescriptorUpdateTemplate)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:4511
@ VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV
Definition: vulkan_core.h:8144
@ VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV
Definition: vulkan_core.h:8145
VkResult(VKAPI_PTR * PFN_vkCompileDeferredNV)(VkDevice device, VkPipeline pipeline, uint32_t shader)
Definition: vulkan_core.h:8326
VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, const VkSubpassBeginInfoKHR *pSubpassBeginInfo)
VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence)
VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
VkImageType
Definition: vulkan_core.h:812
@ VK_IMAGE_TYPE_2D
Definition: vulkan_core.h:814
@ VK_IMAGE_TYPE_3D
Definition: vulkan_core.h:815
@ VK_IMAGE_TYPE_1D
Definition: vulkan_core.h:813
@ VK_SAMPLER_YCBCR_RANGE_ITU_NARROW
Definition: vulkan_core.h:3841
@ VK_SAMPLER_YCBCR_RANGE_ITU_FULL
Definition: vulkan_core.h:3840
VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
void(VKAPI_PTR * PFN_vkCmdBuildAccelerationStructureNV)(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV *pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset)
Definition: vulkan_core.h:8319
VKAPI_ATTR void VKAPI_CALL vkSetHdrMetadataEXT(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR *pSwapchains, const VkHdrMetadataEXT *pMetadata)
void(VKAPI_PTR * PFN_vkCmdSetDeviceMaskKHR)(VkCommandBuffer commandBuffer, uint32_t deviceMask)
Definition: vulkan_core.h:5212
VkResult(VKAPI_PTR * PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
Definition: vulkan_core.h:2878
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, uint32_t *pSurfaceFormatCount, VkSurfaceFormat2KHR *pSurfaceFormats)
@ VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU
Definition: vulkan_core.h:836
@ VK_PHYSICAL_DEVICE_TYPE_OTHER
Definition: vulkan_core.h:833
@ VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU
Definition: vulkan_core.h:834
@ VK_PHYSICAL_DEVICE_TYPE_CPU
Definition: vulkan_core.h:837
@ VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU
Definition: vulkan_core.h:835
@ VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR
Definition: vulkan_core.h:4960
@ VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR
Definition: vulkan_core.h:4957
@ VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR
Definition: vulkan_core.h:4958
@ VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR
Definition: vulkan_core.h:4959
@ VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT
Definition: vulkan_core.h:3995
@ VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT
Definition: vulkan_core.h:3994
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties)
VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks *pAllocator)
VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, VkPhysicalDevice *pPhysicalDevices)
@ VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT
Definition: vulkan_core.h:7860
@ VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT
Definition: vulkan_core.h:3945
@ VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT
Definition: vulkan_core.h:3943
@ VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT
Definition: vulkan_core.h:3946
@ VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT
Definition: vulkan_core.h:3944
VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointDataNV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointDataNV *pCheckpointData)
VkResult(VKAPI_PTR * PFN_vkGetRayTracingShaderGroupHandlesNV)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
Definition: vulkan_core.h:8323
VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t *pDynamicOffsets)
VKAPI_ATTR VkResult VKAPI_CALL vkGetPastPresentationTimingGOOGLE(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pPresentationTimingCount, VkPastPresentationTimingGOOGLE *pPresentationTimings)
VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversionKHR(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator)
VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void **ppData)
#define VK_MAX_DEVICE_GROUP_SIZE
Definition: vulkan_core.h:3795
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, VkSurfaceCapabilities2KHR *pSurfaceCapabilities)
Definition: vulkan_core.h:5792
VkResult(VKAPI_PTR * PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer)
Definition: vulkan_core.h:2900
@ VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT
Definition: vulkan_core.h:1502
@ VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT
Definition: vulkan_core.h:1504
@ VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT
Definition: vulkan_core.h:1501
@ VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT
Definition: vulkan_core.h:1510
@ VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT
Definition: vulkan_core.h:1508
@ VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT
Definition: vulkan_core.h:1503
@ VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT
Definition: vulkan_core.h:1505
@ VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT
Definition: vulkan_core.h:1506
@ VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT
Definition: vulkan_core.h:1509
@ VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT
Definition: vulkan_core.h:1507
@ VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT
Definition: vulkan_core.h:1511
void(VKAPI_PTR * PFN_vkGetImageMemoryRequirements2KHR)(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
Definition: vulkan_core.h:5913
VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImageView *pView)
void(VKAPI_PTR * PFN_vkDestroyObjectTableNVX)(VkDevice device, VkObjectTableNVX objectTable, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:6927
VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties)
Definition: vulkan_core.h:5385
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceFormatProperties2KHR)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties)
Definition: vulkan_core.h:5142
@ VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT
Definition: vulkan_core.h:1538
@ VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT
Definition: vulkan_core.h:1537
@ VK_BUFFER_USAGE_TRANSFER_DST_BIT
Definition: vulkan_core.h:1536
@ VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT
Definition: vulkan_core.h:1543
@ VK_BUFFER_USAGE_INDEX_BUFFER_BIT
Definition: vulkan_core.h:1541
@ VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT
Definition: vulkan_core.h:1544
@ VK_BUFFER_USAGE_RAY_TRACING_BIT_NV
Definition: vulkan_core.h:1547
@ VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT
Definition: vulkan_core.h:1539
@ VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT
Definition: vulkan_core.h:1545
@ VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT
Definition: vulkan_core.h:1546
@ VK_BUFFER_USAGE_VERTEX_BUFFER_BIT
Definition: vulkan_core.h:1542
@ VK_BUFFER_USAGE_STORAGE_BUFFER_BIT
Definition: vulkan_core.h:1540
@ VK_BUFFER_USAGE_TRANSFER_SRC_BIT
Definition: vulkan_core.h:1535
void(VKAPI_PTR * PFN_vkDestroyIndirectCommandsLayoutNVX)(VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:6925
void(VKAPI_PTR * PFN_vkGetDescriptorSetLayoutSupport)(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport)
Definition: vulkan_core.h:4516
void(VKAPI_PTR * PFN_vkQueueInsertDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo)
Definition: vulkan_core.h:7477
VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer)
VkResult(VKAPI_PTR * PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
Definition: vulkan_core.h:2942
@ VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT
Definition: vulkan_core.h:1622
@ VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR
Definition: vulkan_core.h:1621
VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pCallback)
VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query)
@ VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST
Definition: vulkan_core.h:929
@ VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP
Definition: vulkan_core.h:930
@ VK_PRIMITIVE_TOPOLOGY_PATCH_LIST
Definition: vulkan_core.h:936
@ VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN
Definition: vulkan_core.h:931
@ VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY
Definition: vulkan_core.h:933
@ VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY
Definition: vulkan_core.h:932
@ VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY
Definition: vulkan_core.h:934
@ VK_PRIMITIVE_TOPOLOGY_POINT_LIST
Definition: vulkan_core.h:926
@ VK_PRIMITIVE_TOPOLOGY_LINE_STRIP
Definition: vulkan_core.h:928
@ VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY
Definition: vulkan_core.h:935
@ VK_PRIMITIVE_TOPOLOGY_LINE_LIST
Definition: vulkan_core.h:927
void(VKAPI_PTR * PFN_vkGetImageSparseMemoryRequirements2KHR)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
Definition: vulkan_core.h:5915
VkResult(VKAPI_PTR * PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t *pDisplayCount, VkDisplayKHR *pDisplays)
Definition: vulkan_core.h:5027
VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment *pAttachments, uint32_t rectCount, const VkClearRect *pRects)
VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t *pPropertyCount, VkDisplayModePropertiesKHR *pProperties)
VkFlags VkDeviceGroupPresentModeFlagsKHR
Definition: vulkan_core.h:4808
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32 *pSupported)
Definition: vulkan_core.h:4752
VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy *pRegions)
VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
void(VKAPI_PTR * PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue *pColor, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
Definition: vulkan_core.h:2969
VkFilter
Definition: vulkan_core.h:1122
@ VK_FILTER_NEAREST
Definition: vulkan_core.h:1123
@ VK_FILTER_LINEAR
Definition: vulkan_core.h:1124
@ VK_FILTER_CUBIC_IMG
Definition: vulkan_core.h:1125
void(VKAPI_PTR * PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:2862
@ VK_QUEUE_SPARSE_BINDING_BIT
Definition: vulkan_core.h:1395
@ VK_QUEUE_PROTECTED_BIT
Definition: vulkan_core.h:1396
@ VK_QUEUE_COMPUTE_BIT
Definition: vulkan_core.h:1393
@ VK_QUEUE_TRANSFER_BIT
Definition: vulkan_core.h:1394
@ VK_QUEUE_GRAPHICS_BIT
Definition: vulkan_core.h:1392
@ VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX
Definition: vulkan_core.h:6803
@ VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX
Definition: vulkan_core.h:6802
VkFlags VkQueryResultFlags
Definition: vulkan_core.h:1523
VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
uint32_t VkFlags
Definition: vulkan_core.h:64
VKAPI_ATTR void VKAPI_CALL vkCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo, VkCommandBuffer *pCommandBuffers)
VKAPI_ATTR void VKAPI_CALL vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
VkFlags VkImageCreateFlags
Definition: vulkan_core.h:1377
VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties)
VKAPI_ATTR void VKAPI_CALL vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
VKAPI_ATTR void VKAPI_CALL vkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin)
@ VK_FRONT_FACE_CLOCKWISE
Definition: vulkan_core.h:956
@ VK_FRONT_FACE_COUNTER_CLOCKWISE
Definition: vulkan_core.h:955
void(VKAPI_PTR * PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth)
Definition: vulkan_core.h:2946
VkResult
Definition: vulkan_core.h:120
@ VK_ERROR_FRAGMENTATION_EXT
Definition: vulkan_core.h:149
@ VK_ERROR_VALIDATION_FAILED_EXT
Definition: vulkan_core.h:146
@ VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT
Definition: vulkan_core.h:148
@ VK_ERROR_INVALID_SHADER_NV
Definition: vulkan_core.h:147
@ VK_SUBOPTIMAL_KHR
Definition: vulkan_core.h:143
@ VK_ERROR_EXTENSION_NOT_PRESENT
Definition: vulkan_core.h:133
@ VK_INCOMPLETE
Definition: vulkan_core.h:126
@ VK_ERROR_INVALID_EXTERNAL_HANDLE
Definition: vulkan_core.h:140
@ VK_ERROR_DEVICE_LOST
Definition: vulkan_core.h:130
@ VK_SUCCESS
Definition: vulkan_core.h:121
@ VK_EVENT_SET
Definition: vulkan_core.h:124
@ VK_EVENT_RESET
Definition: vulkan_core.h:125
@ VK_ERROR_OUT_OF_HOST_MEMORY
Definition: vulkan_core.h:127
@ VK_ERROR_INITIALIZATION_FAILED
Definition: vulkan_core.h:129
@ VK_ERROR_INCOMPATIBLE_DISPLAY_KHR
Definition: vulkan_core.h:145
@ VK_ERROR_OUT_OF_DEVICE_MEMORY
Definition: vulkan_core.h:128
@ VK_ERROR_NATIVE_WINDOW_IN_USE_KHR
Definition: vulkan_core.h:142
@ VK_ERROR_NOT_PERMITTED_EXT
Definition: vulkan_core.h:150
@ VK_ERROR_OUT_OF_DATE_KHR
Definition: vulkan_core.h:144
@ VK_TIMEOUT
Definition: vulkan_core.h:123
@ VK_ERROR_FORMAT_NOT_SUPPORTED
Definition: vulkan_core.h:137
@ VK_ERROR_FRAGMENTED_POOL
Definition: vulkan_core.h:138
@ VK_ERROR_SURFACE_LOST_KHR
Definition: vulkan_core.h:141
@ VK_NOT_READY
Definition: vulkan_core.h:122
@ VK_ERROR_FEATURE_NOT_PRESENT
Definition: vulkan_core.h:134
@ VK_ERROR_TOO_MANY_OBJECTS
Definition: vulkan_core.h:136
@ VK_ERROR_MEMORY_MAP_FAILED
Definition: vulkan_core.h:131
@ VK_ERROR_LAYER_NOT_PRESENT
Definition: vulkan_core.h:132
@ VK_ERROR_INCOMPATIBLE_DRIVER
Definition: vulkan_core.h:135
@ VK_ERROR_OUT_OF_POOL_MEMORY
Definition: vulkan_core.h:139
VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
void(VKAPI_PTR * PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
Definition: vulkan_core.h:2981
@ VK_ACCESS_HOST_READ_BIT
Definition: vulkan_core.h:1664
@ VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT
Definition: vulkan_core.h:1661
@ VK_ACCESS_TRANSFER_WRITE_BIT
Definition: vulkan_core.h:1663
@ VK_ACCESS_HOST_WRITE_BIT
Definition: vulkan_core.h:1665
@ VK_ACCESS_MEMORY_READ_BIT
Definition: vulkan_core.h:1666
@ VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT
Definition: vulkan_core.h:1653
@ VK_ACCESS_INPUT_ATTACHMENT_READ_BIT
Definition: vulkan_core.h:1655
@ VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT
Definition: vulkan_core.h:1659
@ VK_ACCESS_INDIRECT_COMMAND_READ_BIT
Definition: vulkan_core.h:1651
@ VK_ACCESS_TRANSFER_READ_BIT
Definition: vulkan_core.h:1662
@ VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT
Definition: vulkan_core.h:1669
@ VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT
Definition: vulkan_core.h:1674
@ VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV
Definition: vulkan_core.h:1675
@ VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT
Definition: vulkan_core.h:1660
@ VK_ACCESS_SHADER_WRITE_BIT
Definition: vulkan_core.h:1657
@ VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX
Definition: vulkan_core.h:1673
@ VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV
Definition: vulkan_core.h:1676
@ VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV
Definition: vulkan_core.h:1677
@ VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX
Definition: vulkan_core.h:1672
@ VK_ACCESS_SHADER_READ_BIT
Definition: vulkan_core.h:1656
@ VK_ACCESS_MEMORY_WRITE_BIT
Definition: vulkan_core.h:1667
@ VK_ACCESS_UNIFORM_READ_BIT
Definition: vulkan_core.h:1654
@ VK_ACCESS_INDEX_READ_BIT
Definition: vulkan_core.h:1652
@ VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT
Definition: vulkan_core.h:1671
@ VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT
Definition: vulkan_core.h:1670
@ VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT
Definition: vulkan_core.h:1668
@ VK_ACCESS_COLOR_ATTACHMENT_READ_BIT
Definition: vulkan_core.h:1658
VkResult(VKAPI_PTR * PFN_vkEnumerateInstanceExtensionProperties)(const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties)
Definition: vulkan_core.h:2863
@ VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER
Definition: vulkan_core.h:1172
@ VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE
Definition: vulkan_core.h:1169
@ VK_DESCRIPTOR_TYPE_SAMPLER
Definition: vulkan_core.h:1167
@ VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER
Definition: vulkan_core.h:1173
@ VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC
Definition: vulkan_core.h:1175
@ VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT
Definition: vulkan_core.h:1178
@ VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER
Definition: vulkan_core.h:1171
@ VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC
Definition: vulkan_core.h:1176
@ VK_DESCRIPTOR_TYPE_STORAGE_BUFFER
Definition: vulkan_core.h:1174
@ VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV
Definition: vulkan_core.h:1179
@ VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT
Definition: vulkan_core.h:1177
@ VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER
Definition: vulkan_core.h:1168
@ VK_DESCRIPTOR_TYPE_STORAGE_IMAGE
Definition: vulkan_core.h:1170
@ VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR
Definition: vulkan_core.h:4716
@ VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR
Definition: vulkan_core.h:4713
@ VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR
Definition: vulkan_core.h:4710
@ VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR
Definition: vulkan_core.h:4714
@ VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR
Definition: vulkan_core.h:4718
@ VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR
Definition: vulkan_core.h:4711
@ VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR
Definition: vulkan_core.h:4717
@ VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR
Definition: vulkan_core.h:4712
@ VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR
Definition: vulkan_core.h:4715
VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDeviceEventEXT(VkDevice device, const VkDeviceEventInfoEXT *pDeviceEventInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
VKAPI_ATTR void VKAPI_CALL vkDestroyObjectTableNVX(VkDevice device, VkObjectTableNVX objectTable, const VkAllocationCallbacks *pAllocator)
void(VKAPI_PTR * PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D *pScissors)
Definition: vulkan_core.h:2945
void(VKAPI_PTR * PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void *pData)
Definition: vulkan_core.h:2967
VkResult(VKAPI_PTR * PFN_vkGetMemoryFdPropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR *pMemoryFdProperties)
Definition: vulkan_core.h:5352
VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
VkResult(VKAPI_PTR * PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets)
Definition: vulkan_core.h:2928
void(VKAPI_PTR * PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:2903
void(VKAPI_PTR * PFN_vkDestroyAccelerationStructureNV)(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:8316
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDevicePresentRectanglesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pRectCount, VkRect2D *pRects)
Definition: vulkan_core.h:4894
VkCopyAccelerationStructureModeNV
Definition: vulkan_core.h:8152
@ VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV
Definition: vulkan_core.h:8154
@ VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV
Definition: vulkan_core.h:8153
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats)
@ VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT
Definition: vulkan_core.h:8445
@ VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT
Definition: vulkan_core.h:8446
@ VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT
Definition: vulkan_core.h:8447
@ VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT
Definition: vulkan_core.h:8444
void(VKAPI_PTR * PFN_vkDestroyDebugUtilsMessengerEXT)(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:7482
void(VKAPI_PTR * PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
Definition: vulkan_core.h:2961
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceExternalSemaphoreProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties)
Definition: vulkan_core.h:4515
VkResult(VKAPI_PTR * PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain)
Definition: vulkan_core.h:4887
@ VK_FENCE_IMPORT_TEMPORARY_BIT
Definition: vulkan_core.h:3965
VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDisplayEventEXT(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT *pDisplayEventInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks *pAllocator)
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceSparseImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties)
Definition: vulkan_core.h:4505
void(VKAPI_PTR * PFN_vkVoidFunction)(void)
Definition: vulkan_core.h:2024
@ VK_BUFFER_CREATE_PROTECTED_BIT
Definition: vulkan_core.h:1529
@ VK_BUFFER_CREATE_SPARSE_ALIASED_BIT
Definition: vulkan_core.h:1528
@ VK_BUFFER_CREATE_SPARSE_BINDING_BIT
Definition: vulkan_core.h:1526
@ VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT
Definition: vulkan_core.h:1527
VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo *pBindInfo, VkFence fence)
void(VKAPI_PTR * PFN_vkCmdDebugMarkerBeginEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo)
Definition: vulkan_core.h:6332
VkResult(VKAPI_PTR * PFN_vkDebugMarkerSetObjectNameEXT)(VkDevice device, const VkDebugMarkerObjectNameInfoEXT *pNameInfo)
Definition: vulkan_core.h:6331
void(VKAPI_PTR * PFN_vkCmdPipelineBarrier)(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers)
Definition: vulkan_core.h:2976
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties)
void(VKAPI_PTR * PFN_vkCmdDispatchBaseKHR)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
Definition: vulkan_core.h:5213
VkResult(VKAPI_PTR * PFN_vkCreateDebugUtilsMessengerEXT)(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugUtilsMessengerEXT *pMessenger)
Definition: vulkan_core.h:7481
VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D *pScissors)
VkResult(VKAPI_PTR * PFN_vkGetSwapchainStatusKHR)(VkDevice device, VkSwapchainKHR swapchain)
Definition: vulkan_core.h:5665
void(VKAPI_PTR * PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets)
Definition: vulkan_core.h:2955
void(VKAPI_PTR * PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve *pRegions)
Definition: vulkan_core.h:2972
VkObjectEntryTypeNVX
Definition: vulkan_core.h:6779
@ VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX
Definition: vulkan_core.h:6784
@ VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX
Definition: vulkan_core.h:6781
@ VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX
Definition: vulkan_core.h:6780
@ VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX
Definition: vulkan_core.h:6782
@ VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX
Definition: vulkan_core.h:6783
VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectCommandsLayoutNVX(VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout, const VkAllocationCallbacks *pAllocator)
void(VKAPI_PTR * PFN_vkQueueBeginDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo)
Definition: vulkan_core.h:7475
@ VK_DRIVER_ID_MESA_RADV_KHR
Definition: vulkan_core.h:6097
@ VK_DRIVER_ID_AMD_PROPRIETARY_KHR
Definition: vulkan_core.h:6095
@ VK_DRIVER_ID_IMAGINATION_PROPRIETARY_KHR
Definition: vulkan_core.h:6101
@ VK_DRIVER_ID_ARM_PROPRIETARY_KHR
Definition: vulkan_core.h:6103
@ VK_DRIVER_ID_NVIDIA_PROPRIETARY_KHR
Definition: vulkan_core.h:6098
@ VK_DRIVER_ID_QUALCOMM_PROPRIETARY_KHR
Definition: vulkan_core.h:6102
@ VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR
Definition: vulkan_core.h:6096
@ VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS_KHR
Definition: vulkan_core.h:6099
@ VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA_KHR
Definition: vulkan_core.h:6100
VkFlags VkDebugReportFlagsEXT
Definition: vulkan_core.h:6205
VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchains)
VKAPI_ATTR void VKAPI_CALL vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator)
VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks *pAllocator)
void(VKAPI_PTR * PFN_vkGetQueueCheckpointDataNV)(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointDataNV *pCheckpointData)
Definition: vulkan_core.h:8781
VKAPI_ATTR void VKAPI_CALL vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes)
void(VKAPI_PTR * PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:2933
@ VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT
Definition: vulkan_core.h:1143
@ VK_SAMPLER_ADDRESS_MODE_REPEAT
Definition: vulkan_core.h:1142
@ VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE
Definition: vulkan_core.h:1144
@ VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE
Definition: vulkan_core.h:1146
@ VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER
Definition: vulkan_core.h:1145
VKAPI_ATTR void VKAPI_CALL vkUnmapMemory(VkDevice device, VkDeviceMemory memory)
void(VKAPI_PTR * PFN_vkCmdNextSubpass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassBeginInfoKHR *pSubpassBeginInfo, const VkSubpassEndInfoKHR *pSubpassEndInfo)
Definition: vulkan_core.h:5629
VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(uint32_t *pPropertyCount, VkLayerProperties *pProperties)
VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
VkResult(VKAPI_PTR * PFN_vkImportSemaphoreFdKHR)(VkDevice device, const VkImportSemaphoreFdInfoKHR *pImportSemaphoreFdInfo)
Definition: vulkan_core.h:5428
VkPresentModeKHR
Definition: vulkan_core.h:4695
@ VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR
Definition: vulkan_core.h:4700
@ VK_PRESENT_MODE_IMMEDIATE_KHR
Definition: vulkan_core.h:4696
@ VK_PRESENT_MODE_MAILBOX_KHR
Definition: vulkan_core.h:4697
@ VK_PRESENT_MODE_FIFO_RELAXED_KHR
Definition: vulkan_core.h:4699
@ VK_PRESENT_MODE_FIFO_KHR
Definition: vulkan_core.h:4698
@ VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR
Definition: vulkan_core.h:4701
VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos)
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceDisplayProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayProperties2KHR *pProperties)
Definition: vulkan_core.h:5852
#define VK_NULL_HANDLE
Definition: vulkan_core.h:49
@ VK_VERTEX_INPUT_RATE_VERTEX
Definition: vulkan_core.h:917
@ VK_VERTEX_INPUT_RATE_INSTANCE
Definition: vulkan_core.h:918
VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdPropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR *pMemoryFdProperties)
@ VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX
Definition: vulkan_core.h:6793
@ VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX
Definition: vulkan_core.h:6796
@ VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX
Definition: vulkan_core.h:6794
@ VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX
Definition: vulkan_core.h:6795
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties *pQueueFamilyProperties)
@ VK_COLOR_COMPONENT_R_BIT
Definition: vulkan_core.h:1608
@ VK_COLOR_COMPONENT_A_BIT
Definition: vulkan_core.h:1611
@ VK_COLOR_COMPONENT_B_BIT
Definition: vulkan_core.h:1610
@ VK_COLOR_COMPONENT_G_BIT
Definition: vulkan_core.h:1609
VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
void(VKAPI_PTR * PFN_vkCmdWriteBufferMarkerAMD)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
Definition: vulkan_core.h:8500
VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void *pData, VkDeviceSize stride, VkQueryResultFlags flags)
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties *pImageFormatProperties)
void(VKAPI_PTR * PFN_vkCmdBeginConditionalRenderingEXT)(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin)
Definition: vulkan_core.h:6744
VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride)
@ VK_DISPLAY_POWER_STATE_ON_EXT
Definition: vulkan_core.h:7068
@ VK_DISPLAY_POWER_STATE_SUSPEND_EXT
Definition: vulkan_core.h:7067
@ VK_DISPLAY_POWER_STATE_OFF_EXT
Definition: vulkan_core.h:7066
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties)
Definition: vulkan_core.h:5146
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPlaneProperties2KHR *pProperties)
Definition: vulkan_core.h:5853
VkResult(VKAPI_PTR * PFN_vkGetShaderInfoAMD)(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t *pInfoSize, void *pInfo)
Definition: vulkan_core.h:6564
VkFormat
Definition: vulkan_core.h:544
@ VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG
Definition: vulkan_core.h:765
@ VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM
Definition: vulkan_core.h:734
@ VK_FORMAT_R16G16B16A16_UNORM
Definition: vulkan_core.h:636
@ VK_FORMAT_A1R5G5B5_UNORM_PACK16
Definition: vulkan_core.h:553
@ VK_FORMAT_ASTC_12x12_SRGB_BLOCK
Definition: vulkan_core.h:729
@ VK_FORMAT_R64G64B64_UINT
Definition: vulkan_core.h:661
@ VK_FORMAT_R8G8B8A8_SRGB
Definition: vulkan_core.h:588
@ VK_FORMAT_R32G32B32_UINT
Definition: vulkan_core.h:649
@ VK_FORMAT_R16G16_SNORM
Definition: vulkan_core.h:623
@ VK_FORMAT_R16G16B16_SINT
Definition: vulkan_core.h:634
@ VK_FORMAT_G8_B8R8_2PLANE_422_UNORM
Definition: vulkan_core.h:735
@ VK_FORMAT_R64G64B64A64_SFLOAT
Definition: vulkan_core.h:666
@ VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM
Definition: vulkan_core.h:761
@ VK_FORMAT_A8B8G8R8_USCALED_PACK32
Definition: vulkan_core.h:598
@ VK_FORMAT_G16_B16R16_2PLANE_422_UNORM
Definition: vulkan_core.h:762
@ VK_FORMAT_BC2_UNORM_BLOCK
Definition: vulkan_core.h:680
@ VK_FORMAT_B8G8R8_UINT
Definition: vulkan_core.h:579
@ VK_FORMAT_ASTC_8x8_SRGB_BLOCK
Definition: vulkan_core.h:717
@ VK_FORMAT_R8G8B8_SINT
Definition: vulkan_core.h:573
@ VK_FORMAT_B8G8R8A8_UINT
Definition: vulkan_core.h:593
@ VK_FORMAT_R8G8B8_UNORM
Definition: vulkan_core.h:568
@ VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16
Definition: vulkan_core.h:755
@ VK_FORMAT_D24_UNORM_S8_UINT
Definition: vulkan_core.h:674
@ VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16
Definition: vulkan_core.h:742
@ VK_FORMAT_ASTC_4x4_SRGB_BLOCK
Definition: vulkan_core.h:703
@ VK_FORMAT_D32_SFLOAT
Definition: vulkan_core.h:671
@ VK_FORMAT_B8G8R8A8_UNORM
Definition: vulkan_core.h:589
@ VK_FORMAT_R8G8B8A8_SSCALED
Definition: vulkan_core.h:585
@ VK_FORMAT_A2R10G10B10_SNORM_PACK32
Definition: vulkan_core.h:604
@ VK_FORMAT_ASTC_5x5_UNORM_BLOCK
Definition: vulkan_core.h:706
@ VK_FORMAT_R8G8B8_SNORM
Definition: vulkan_core.h:569
@ VK_FORMAT_A2B10G10R10_SSCALED_PACK32
Definition: vulkan_core.h:612
@ VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG
Definition: vulkan_core.h:766
@ VK_FORMAT_ASTC_10x6_SRGB_BLOCK
Definition: vulkan_core.h:721
@ VK_FORMAT_R16G16B16A16_SNORM
Definition: vulkan_core.h:637
@ VK_FORMAT_R16G16B16_UINT
Definition: vulkan_core.h:633
@ VK_FORMAT_R8G8_SNORM
Definition: vulkan_core.h:562
@ VK_FORMAT_R16G16B16_USCALED
Definition: vulkan_core.h:631
@ VK_FORMAT_BC7_SRGB_BLOCK
Definition: vulkan_core.h:691
@ VK_FORMAT_R10X6_UNORM_PACK16
Definition: vulkan_core.h:737
@ VK_FORMAT_R16G16_SFLOAT
Definition: vulkan_core.h:628
@ VK_FORMAT_R64G64B64_SFLOAT
Definition: vulkan_core.h:663
@ VK_FORMAT_A2B10G10R10_SINT_PACK32
Definition: vulkan_core.h:614
@ VK_FORMAT_R8G8B8_UINT
Definition: vulkan_core.h:572
@ VK_FORMAT_R32G32_SFLOAT
Definition: vulkan_core.h:648
@ VK_FORMAT_R16G16B16A16_USCALED
Definition: vulkan_core.h:638
@ VK_FORMAT_ASTC_6x5_SRGB_BLOCK
Definition: vulkan_core.h:709
@ VK_FORMAT_B4G4R4A4_UNORM_PACK16
Definition: vulkan_core.h:548
@ VK_FORMAT_R8_SNORM
Definition: vulkan_core.h:555
@ VK_FORMAT_G16_B16R16_2PLANE_420_UNORM
Definition: vulkan_core.h:760
@ VK_FORMAT_BC2_SRGB_BLOCK
Definition: vulkan_core.h:681
@ VK_FORMAT_R12X4G12X4_UNORM_2PACK16
Definition: vulkan_core.h:748
@ VK_FORMAT_R16G16B16_SNORM
Definition: vulkan_core.h:630
@ VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16
Definition: vulkan_core.h:744
@ VK_FORMAT_R10X6G10X6_UNORM_2PACK16
Definition: vulkan_core.h:738
@ VK_FORMAT_R16G16_SSCALED
Definition: vulkan_core.h:625
@ VK_FORMAT_R16_SFLOAT
Definition: vulkan_core.h:621
@ VK_FORMAT_R16G16B16_SFLOAT
Definition: vulkan_core.h:635
@ VK_FORMAT_R8G8_UNORM
Definition: vulkan_core.h:561
@ VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16
Definition: vulkan_core.h:740
@ VK_FORMAT_BC1_RGBA_SRGB_BLOCK
Definition: vulkan_core.h:679
@ VK_FORMAT_R16G16B16_SSCALED
Definition: vulkan_core.h:632
@ VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM
Definition: vulkan_core.h:736
@ VK_FORMAT_B8G8R8_SRGB
Definition: vulkan_core.h:581
@ VK_FORMAT_R64_UINT
Definition: vulkan_core.h:655
@ VK_FORMAT_R32_SINT
Definition: vulkan_core.h:644
@ VK_FORMAT_B8G8R8G8_422_UNORM
Definition: vulkan_core.h:731
@ VK_FORMAT_R16G16_UINT
Definition: vulkan_core.h:626
@ VK_FORMAT_ASTC_8x5_SRGB_BLOCK
Definition: vulkan_core.h:713
@ VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG
Definition: vulkan_core.h:771
@ VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK
Definition: vulkan_core.h:693
@ VK_FORMAT_R16_USCALED
Definition: vulkan_core.h:617
@ VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16
Definition: vulkan_core.h:750
@ VK_FORMAT_S8_UINT
Definition: vulkan_core.h:672
@ VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK
Definition: vulkan_core.h:694
@ VK_FORMAT_R8G8_SRGB
Definition: vulkan_core.h:567
@ VK_FORMAT_ASTC_12x12_UNORM_BLOCK
Definition: vulkan_core.h:728
@ VK_FORMAT_E5B9G9R9_UFLOAT_PACK32
Definition: vulkan_core.h:668
@ VK_FORMAT_ASTC_5x4_SRGB_BLOCK
Definition: vulkan_core.h:705
@ VK_FORMAT_BC3_UNORM_BLOCK
Definition: vulkan_core.h:682
@ VK_FORMAT_ASTC_10x5_SRGB_BLOCK
Definition: vulkan_core.h:719
@ VK_FORMAT_R8_UNORM
Definition: vulkan_core.h:554
@ VK_FORMAT_G16B16G16R16_422_UNORM
Definition: vulkan_core.h:757
@ VK_FORMAT_ASTC_8x8_UNORM_BLOCK
Definition: vulkan_core.h:716
@ VK_FORMAT_R32G32B32A32_SFLOAT
Definition: vulkan_core.h:654
@ VK_FORMAT_R32G32B32A32_UINT
Definition: vulkan_core.h:652
@ VK_FORMAT_B8G8R8_SINT
Definition: vulkan_core.h:580
@ VK_FORMAT_G8B8G8R8_422_UNORM
Definition: vulkan_core.h:730
@ VK_FORMAT_R64G64_SFLOAT
Definition: vulkan_core.h:660
@ VK_FORMAT_A8B8G8R8_SRGB_PACK32
Definition: vulkan_core.h:602
@ VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK
Definition: vulkan_core.h:696
@ VK_FORMAT_D16_UNORM_S8_UINT
Definition: vulkan_core.h:673
@ VK_FORMAT_BC6H_SFLOAT_BLOCK
Definition: vulkan_core.h:689
@ VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM
Definition: vulkan_core.h:763
@ VK_FORMAT_B8G8R8_USCALED
Definition: vulkan_core.h:577
@ VK_FORMAT_A2B10G10R10_UINT_PACK32
Definition: vulkan_core.h:613
@ VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16
Definition: vulkan_core.h:743
@ VK_FORMAT_R8G8_SSCALED
Definition: vulkan_core.h:564
@ VK_FORMAT_EAC_R11_UNORM_BLOCK
Definition: vulkan_core.h:698
@ VK_FORMAT_R5G6B5_UNORM_PACK16
Definition: vulkan_core.h:549
@ VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM
Definition: vulkan_core.h:759
@ VK_FORMAT_R32_SFLOAT
Definition: vulkan_core.h:645
@ VK_FORMAT_A2R10G10B10_SINT_PACK32
Definition: vulkan_core.h:608
@ VK_FORMAT_A2R10G10B10_USCALED_PACK32
Definition: vulkan_core.h:605
@ VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK
Definition: vulkan_core.h:695
@ VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16
Definition: vulkan_core.h:756
@ VK_FORMAT_ASTC_8x6_SRGB_BLOCK
Definition: vulkan_core.h:715
@ VK_FORMAT_R16G16B16_UNORM
Definition: vulkan_core.h:629
@ VK_FORMAT_R64_SINT
Definition: vulkan_core.h:656
@ VK_FORMAT_R12X4_UNORM_PACK16
Definition: vulkan_core.h:747
@ VK_FORMAT_R16G16_USCALED
Definition: vulkan_core.h:624
@ VK_FORMAT_R4G4B4A4_UNORM_PACK16
Definition: vulkan_core.h:547
@ VK_FORMAT_ASTC_6x5_UNORM_BLOCK
Definition: vulkan_core.h:708
@ VK_FORMAT_ASTC_12x10_SRGB_BLOCK
Definition: vulkan_core.h:727
@ VK_FORMAT_R16G16B16A16_SINT
Definition: vulkan_core.h:641
@ VK_FORMAT_A2B10G10R10_UNORM_PACK32
Definition: vulkan_core.h:609
@ VK_FORMAT_B8G8R8A8_SRGB
Definition: vulkan_core.h:595
@ VK_FORMAT_EAC_R11G11_UNORM_BLOCK
Definition: vulkan_core.h:700
@ VK_FORMAT_A8B8G8R8_SINT_PACK32
Definition: vulkan_core.h:601
@ VK_FORMAT_R8G8B8A8_UNORM
Definition: vulkan_core.h:582
@ VK_FORMAT_R8G8_USCALED
Definition: vulkan_core.h:563
@ VK_FORMAT_A2B10G10R10_USCALED_PACK32
Definition: vulkan_core.h:611
@ VK_FORMAT_A8B8G8R8_UINT_PACK32
Definition: vulkan_core.h:600
@ VK_FORMAT_ASTC_8x6_UNORM_BLOCK
Definition: vulkan_core.h:714
@ VK_FORMAT_ASTC_5x4_UNORM_BLOCK
Definition: vulkan_core.h:704
@ VK_FORMAT_A8B8G8R8_SSCALED_PACK32
Definition: vulkan_core.h:599
@ VK_FORMAT_R16G16_SINT
Definition: vulkan_core.h:627
@ VK_FORMAT_R8G8_SINT
Definition: vulkan_core.h:566
@ VK_FORMAT_ASTC_10x10_UNORM_BLOCK
Definition: vulkan_core.h:724
@ VK_FORMAT_ASTC_8x5_UNORM_BLOCK
Definition: vulkan_core.h:712
@ VK_FORMAT_A2B10G10R10_SNORM_PACK32
Definition: vulkan_core.h:610
@ VK_FORMAT_ASTC_10x8_SRGB_BLOCK
Definition: vulkan_core.h:723
@ VK_FORMAT_R5G5B5A1_UNORM_PACK16
Definition: vulkan_core.h:551
@ VK_FORMAT_UNDEFINED
Definition: vulkan_core.h:545
@ VK_FORMAT_R16_SINT
Definition: vulkan_core.h:620
@ VK_FORMAT_B8G8R8A8_SINT
Definition: vulkan_core.h:594
@ VK_FORMAT_A8B8G8R8_SNORM_PACK32
Definition: vulkan_core.h:597
@ VK_FORMAT_R8G8B8_SRGB
Definition: vulkan_core.h:574
@ VK_FORMAT_B5G5R5A1_UNORM_PACK16
Definition: vulkan_core.h:552
@ VK_FORMAT_BC1_RGB_UNORM_BLOCK
Definition: vulkan_core.h:676
@ VK_FORMAT_R64G64_SINT
Definition: vulkan_core.h:659
@ VK_FORMAT_R8G8B8_USCALED
Definition: vulkan_core.h:570
@ VK_FORMAT_R64_SFLOAT
Definition: vulkan_core.h:657
@ VK_FORMAT_B8G8R8A8_SNORM
Definition: vulkan_core.h:590
@ VK_FORMAT_BC4_SNORM_BLOCK
Definition: vulkan_core.h:685
@ VK_FORMAT_EAC_R11_SNORM_BLOCK
Definition: vulkan_core.h:699
@ VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16
Definition: vulkan_core.h:739
@ VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG
Definition: vulkan_core.h:769
@ VK_FORMAT_R8G8B8_SSCALED
Definition: vulkan_core.h:571
@ VK_FORMAT_B16G16R16G16_422_UNORM
Definition: vulkan_core.h:758
@ VK_FORMAT_R32G32B32_SINT
Definition: vulkan_core.h:650
@ VK_FORMAT_R16_UNORM
Definition: vulkan_core.h:615
@ VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG
Definition: vulkan_core.h:764
@ VK_FORMAT_BC6H_UFLOAT_BLOCK
Definition: vulkan_core.h:688
@ VK_FORMAT_R8G8B8A8_USCALED
Definition: vulkan_core.h:584
@ VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16
Definition: vulkan_core.h:745
@ VK_FORMAT_R8_SINT
Definition: vulkan_core.h:559
@ VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG
Definition: vulkan_core.h:768
@ VK_FORMAT_ASTC_10x8_UNORM_BLOCK
Definition: vulkan_core.h:722
@ VK_FORMAT_BC7_UNORM_BLOCK
Definition: vulkan_core.h:690
@ VK_FORMAT_B8G8R8_SNORM
Definition: vulkan_core.h:576
@ VK_FORMAT_D16_UNORM
Definition: vulkan_core.h:669
@ VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16
Definition: vulkan_core.h:754
@ VK_FORMAT_R16_UINT
Definition: vulkan_core.h:619
@ VK_FORMAT_R8_UINT
Definition: vulkan_core.h:558
@ VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16
Definition: vulkan_core.h:741
@ VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM
Definition: vulkan_core.h:732
@ VK_FORMAT_A8B8G8R8_UNORM_PACK32
Definition: vulkan_core.h:596
@ VK_FORMAT_ASTC_12x10_UNORM_BLOCK
Definition: vulkan_core.h:726
@ VK_FORMAT_R16G16B16A16_SFLOAT
Definition: vulkan_core.h:642
@ VK_FORMAT_A2R10G10B10_SSCALED_PACK32
Definition: vulkan_core.h:606
@ VK_FORMAT_ASTC_10x5_UNORM_BLOCK
Definition: vulkan_core.h:718
@ VK_FORMAT_R16G16_UNORM
Definition: vulkan_core.h:622
@ VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16
Definition: vulkan_core.h:746
@ VK_FORMAT_BC5_UNORM_BLOCK
Definition: vulkan_core.h:686
@ VK_FORMAT_R64G64B64A64_UINT
Definition: vulkan_core.h:664
@ VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK
Definition: vulkan_core.h:692
@ VK_FORMAT_R8G8B8A8_SINT
Definition: vulkan_core.h:587
@ VK_FORMAT_R8_USCALED
Definition: vulkan_core.h:556
@ VK_FORMAT_A2R10G10B10_UNORM_PACK32
Definition: vulkan_core.h:603
@ VK_FORMAT_R32G32_UINT
Definition: vulkan_core.h:646
@ VK_FORMAT_R8G8B8A8_SNORM
Definition: vulkan_core.h:583
@ VK_FORMAT_R16_SSCALED
Definition: vulkan_core.h:618
@ VK_FORMAT_BC1_RGB_SRGB_BLOCK
Definition: vulkan_core.h:677
@ VK_FORMAT_R16G16B16A16_UINT
Definition: vulkan_core.h:640
@ VK_FORMAT_R32G32B32A32_SINT
Definition: vulkan_core.h:653
@ VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16
Definition: vulkan_core.h:752
@ VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16
Definition: vulkan_core.h:749
@ VK_FORMAT_BC3_SRGB_BLOCK
Definition: vulkan_core.h:683
@ VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG
Definition: vulkan_core.h:770
@ VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16
Definition: vulkan_core.h:753
@ VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK
Definition: vulkan_core.h:697
@ VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG
Definition: vulkan_core.h:767
@ VK_FORMAT_B8G8R8A8_SSCALED
Definition: vulkan_core.h:592
@ VK_FORMAT_R32G32B32_SFLOAT
Definition: vulkan_core.h:651
@ VK_FORMAT_R8G8B8A8_UINT
Definition: vulkan_core.h:586
@ VK_FORMAT_ASTC_10x6_UNORM_BLOCK
Definition: vulkan_core.h:720
@ VK_FORMAT_BC1_RGBA_UNORM_BLOCK
Definition: vulkan_core.h:678
@ VK_FORMAT_R4G4_UNORM_PACK8
Definition: vulkan_core.h:546
@ VK_FORMAT_A2R10G10B10_UINT_PACK32
Definition: vulkan_core.h:607
@ VK_FORMAT_R16_SNORM
Definition: vulkan_core.h:616
@ VK_FORMAT_ASTC_10x10_SRGB_BLOCK
Definition: vulkan_core.h:725
@ VK_FORMAT_B10G11R11_UFLOAT_PACK32
Definition: vulkan_core.h:667
@ VK_FORMAT_R8_SSCALED
Definition: vulkan_core.h:557
@ VK_FORMAT_R8G8_UINT
Definition: vulkan_core.h:565
@ VK_FORMAT_R16G16B16A16_SSCALED
Definition: vulkan_core.h:639
@ VK_FORMAT_ASTC_5x5_SRGB_BLOCK
Definition: vulkan_core.h:707
@ VK_FORMAT_G8_B8R8_2PLANE_420_UNORM
Definition: vulkan_core.h:733
@ VK_FORMAT_ASTC_4x4_UNORM_BLOCK
Definition: vulkan_core.h:702
@ VK_FORMAT_B8G8R8A8_USCALED
Definition: vulkan_core.h:591
@ VK_FORMAT_R64G64B64A64_SINT
Definition: vulkan_core.h:665
@ VK_FORMAT_R64G64_UINT
Definition: vulkan_core.h:658
@ VK_FORMAT_BC5_SNORM_BLOCK
Definition: vulkan_core.h:687
@ VK_FORMAT_R64G64B64_SINT
Definition: vulkan_core.h:662
@ VK_FORMAT_BC4_UNORM_BLOCK
Definition: vulkan_core.h:684
@ VK_FORMAT_B8G8R8_SSCALED
Definition: vulkan_core.h:578
@ VK_FORMAT_B5G6R5_UNORM_PACK16
Definition: vulkan_core.h:550
@ VK_FORMAT_D32_SFLOAT_S8_UINT
Definition: vulkan_core.h:675
@ VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16
Definition: vulkan_core.h:751
@ VK_FORMAT_B8G8R8_UNORM
Definition: vulkan_core.h:575
@ VK_FORMAT_X8_D24_UNORM_PACK32
Definition: vulkan_core.h:670
@ VK_FORMAT_ASTC_6x6_SRGB_BLOCK
Definition: vulkan_core.h:711
@ VK_FORMAT_EAC_R11G11_SNORM_BLOCK
Definition: vulkan_core.h:701
@ VK_FORMAT_R32G32_SINT
Definition: vulkan_core.h:647
@ VK_FORMAT_ASTC_6x6_UNORM_BLOCK
Definition: vulkan_core.h:710
@ VK_FORMAT_R8_SRGB
Definition: vulkan_core.h:560
@ VK_FORMAT_R32_UINT
Definition: vulkan_core.h:643
VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkShaderModule *pShaderModule)
VkSubpassContents
Definition: vulkan_core.h:1234
@ VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS
Definition: vulkan_core.h:1236
@ VK_SUBPASS_CONTENTS_INLINE
Definition: vulkan_core.h:1235
VkResult(VKAPI_PTR * PFN_vkGetImageDrmFormatModifierPropertiesEXT)(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT *pProperties)
Definition: vulkan_core.h:7843
@ VK_BLEND_FACTOR_ONE
Definition: vulkan_core.h:1018
@ VK_BLEND_FACTOR_SRC1_ALPHA
Definition: vulkan_core.h:1034
@ VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA
Definition: vulkan_core.h:1026
@ VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR
Definition: vulkan_core.h:1033
@ VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR
Definition: vulkan_core.h:1020
@ VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR
Definition: vulkan_core.h:1028
@ VK_BLEND_FACTOR_SRC_COLOR
Definition: vulkan_core.h:1019
@ VK_BLEND_FACTOR_CONSTANT_COLOR
Definition: vulkan_core.h:1027
@ VK_BLEND_FACTOR_SRC_ALPHA
Definition: vulkan_core.h:1023
@ VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA
Definition: vulkan_core.h:1030
@ VK_BLEND_FACTOR_CONSTANT_ALPHA
Definition: vulkan_core.h:1029
@ VK_BLEND_FACTOR_DST_ALPHA
Definition: vulkan_core.h:1025
@ VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA
Definition: vulkan_core.h:1035
@ VK_BLEND_FACTOR_ZERO
Definition: vulkan_core.h:1017
@ VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA
Definition: vulkan_core.h:1024
@ VK_BLEND_FACTOR_DST_COLOR
Definition: vulkan_core.h:1021
@ VK_BLEND_FACTOR_SRC_ALPHA_SATURATE
Definition: vulkan_core.h:1031
@ VK_BLEND_FACTOR_SRC1_COLOR
Definition: vulkan_core.h:1032
@ VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR
Definition: vulkan_core.h:1022
@ VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT
Definition: vulkan_core.h:1638
VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks *pAllocator)
@ VK_ATTACHMENT_LOAD_OP_CLEAR
Definition: vulkan_core.h:1188
@ VK_ATTACHMENT_LOAD_OP_LOAD
Definition: vulkan_core.h:1187
@ VK_ATTACHMENT_LOAD_OP_DONT_CARE
Definition: vulkan_core.h:1189
VKAPI_ATTR VkResult VKAPI_CALL vkCreateObjectTableNVX(VkDevice device, const VkObjectTableCreateInfoNVX *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkObjectTableNVX *pObjectTable)
VkResult(VKAPI_PTR * PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkShaderModule *pShaderModule)
Definition: vulkan_core.h:2909
VkFlags VkDescriptorPoolResetFlags
Definition: vulkan_core.h:1633
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties)
@ VK_COLOR_SPACE_SRGB_NONLINEAR_KHR
Definition: vulkan_core.h:4673
@ VK_COLOR_SPACE_HDR10_HLG_EXT
Definition: vulkan_core.h:4683
@ VK_COLOR_SPACE_DOLBYVISION_EXT
Definition: vulkan_core.h:4682
@ VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT
Definition: vulkan_core.h:4674
@ VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT
Definition: vulkan_core.h:4684
@ VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT
Definition: vulkan_core.h:4675
@ VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT
Definition: vulkan_core.h:4687
@ VK_COLOR_SPACE_BT2020_LINEAR_EXT
Definition: vulkan_core.h:4680
@ VK_COLOR_SPACE_BT709_NONLINEAR_EXT
Definition: vulkan_core.h:4679
@ VK_COLOR_SPACE_BT709_LINEAR_EXT
Definition: vulkan_core.h:4678
@ VK_COLOR_SPACE_PASS_THROUGH_EXT
Definition: vulkan_core.h:4686
@ VK_COLOR_SPACE_HDR10_ST2084_EXT
Definition: vulkan_core.h:4681
@ VK_COLOR_SPACE_DCI_P3_LINEAR_EXT
Definition: vulkan_core.h:4676
@ VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT
Definition: vulkan_core.h:4677
@ VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT
Definition: vulkan_core.h:4685
VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport *pViewports)
VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize *pCommittedMemoryInBytes)
VkResult(VKAPI_PTR * PFN_vkEnumerateInstanceVersion)(uint32_t *pApiVersion)
Definition: vulkan_core.h:4489
@ VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT
Definition: vulkan_core.h:6717
VkResult(VKAPI_PTR * PFN_vkQueuePresentKHR)(VkQueue queue, const VkPresentInfoKHR *pPresentInfo)
Definition: vulkan_core.h:4891
VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
VkResult(VKAPI_PTR * PFN_vkMergeValidationCachesEXT)(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT *pSrcCaches)
Definition: vulkan_core.h:7886
VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet *pDescriptorCopies)
VKAPI_ATTR void VKAPI_CALL vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer)
VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D *pDiscardRectangles)
VkResult(VKAPI_PTR * PFN_vkGetValidationCacheDataEXT)(VkDevice device, VkValidationCacheEXT validationCache, size_t *pDataSize, void *pData)
Definition: vulkan_core.h:7887
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX)(VkPhysicalDevice physicalDevice, VkDeviceGeneratedCommandsFeaturesNVX *pFeatures, VkDeviceGeneratedCommandsLimitsNVX *pLimits)
Definition: vulkan_core.h:6930
VkResult(VKAPI_PTR * PFN_vkDeviceWaitIdle)(VkDevice device)
Definition: vulkan_core.h:2870
VkResult(VKAPI_PTR * PFN_vkGetDeviceGroupSurfacePresentModesKHR)(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR *pModes)
Definition: vulkan_core.h:4893
VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT *pTagInfo)
void(VKAPI_PTR * PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:2893
void(VKAPI_PTR * PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit *pRegions, VkFilter filter)
Definition: vulkan_core.h:2964
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats)
Definition: vulkan_core.h:4754
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties)
void(VKAPI_PTR * PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
Definition: vulkan_core.h:2980
VkResult(VKAPI_PTR * PFN_vkCreateRenderPass2KHR)(VkDevice device, const VkRenderPassCreateInfo2KHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
Definition: vulkan_core.h:5627
VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator)
void(VKAPI_PTR * PFN_vkDestroyDescriptorUpdateTemplateKHR)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:5524
VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void *pValues)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversionKHR(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion)
VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT *pNameInfo)
void(VKAPI_PTR * PFN_vkInternalAllocationNotification)(void *pUserData, size_t size, VkInternalAllocationType allocationType, VkSystemAllocationScope allocationScope)
Definition: vulkan_core.h:1772
void(VKAPI_PTR * PFN_vkCmdBindDescriptorSets)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t *pDynamicOffsets)
Definition: vulkan_core.h:2953
@ VK_BLEND_OVERLAP_CONJOINT_EXT
Definition: vulkan_core.h:7703
@ VK_BLEND_OVERLAP_DISJOINT_EXT
Definition: vulkan_core.h:7702
@ VK_BLEND_OVERLAP_UNCORRELATED_EXT
Definition: vulkan_core.h:7701
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayProperties2KHR *pProperties)
@ VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV
Definition: vulkan_core.h:7231
@ VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV
Definition: vulkan_core.h:7225
@ VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV
Definition: vulkan_core.h:7228
@ VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV
Definition: vulkan_core.h:7227
@ VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV
Definition: vulkan_core.h:7232
@ VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV
Definition: vulkan_core.h:7229
@ VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV
Definition: vulkan_core.h:7226
@ VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV
Definition: vulkan_core.h:7230
@ VK_ATTACHMENT_STORE_OP_DONT_CARE
Definition: vulkan_core.h:1198
@ VK_ATTACHMENT_STORE_OP_STORE
Definition: vulkan_core.h:1197
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties)
VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainCounterEXT(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t *pCounterValue)
VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2KHR(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
@ VK_COMMAND_POOL_CREATE_TRANSIENT_BIT
Definition: vulkan_core.h:1693
@ VK_COMMAND_POOL_CREATE_PROTECTED_BIT
Definition: vulkan_core.h:1695
@ VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT
Definition: vulkan_core.h:1694
VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer(VkCommandBuffer commandBuffer)
void(VKAPI_PTR * PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
Definition: vulkan_core.h:2949
@ VK_POLYGON_MODE_FILL_RECTANGLE_NV
Definition: vulkan_core.h:947
@ VK_POLYGON_MODE_FILL
Definition: vulkan_core.h:944
@ VK_POLYGON_MODE_LINE
Definition: vulkan_core.h:945
@ VK_POLYGON_MODE_POINT
Definition: vulkan_core.h:946
void(VKAPI_PTR * PFN_vkSetHdrMetadataEXT)(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR *pSwapchains, const VkHdrMetadataEXT *pMetadata)
Definition: vulkan_core.h:7369
uint32_t VkBool32
Definition: vulkan_core.h:65
void(VKAPI_PTR * PFN_vkCmdSetCheckpointNV)(VkCommandBuffer commandBuffer, const void *pCheckpointMarker)
Definition: vulkan_core.h:8780
VkPipelineStageFlagBits
Definition: vulkan_core.h:1427
@ VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT
Definition: vulkan_core.h:1434
@ VK_PIPELINE_STAGE_VERTEX_INPUT_BIT
Definition: vulkan_core.h:1430
@ VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT
Definition: vulkan_core.h:1443
@ VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT
Definition: vulkan_core.h:1439
@ VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV
Definition: vulkan_core.h:1450
@ VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
Definition: vulkan_core.h:1435
@ VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV
Definition: vulkan_core.h:1449
@ VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT
Definition: vulkan_core.h:1428
@ VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV
Definition: vulkan_core.h:1451
@ VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT
Definition: vulkan_core.h:1433
@ VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT
Definition: vulkan_core.h:1438
@ VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT
Definition: vulkan_core.h:1437
@ VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT
Definition: vulkan_core.h:1446
@ VK_PIPELINE_STAGE_ALL_COMMANDS_BIT
Definition: vulkan_core.h:1444
@ VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT
Definition: vulkan_core.h:1441
@ VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT
Definition: vulkan_core.h:1429
@ VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV
Definition: vulkan_core.h:1448
@ VK_PIPELINE_STAGE_VERTEX_SHADER_BIT
Definition: vulkan_core.h:1431
@ VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT
Definition: vulkan_core.h:1432
@ VK_PIPELINE_STAGE_HOST_BIT
Definition: vulkan_core.h:1442
@ VK_PIPELINE_STAGE_TRANSFER_BIT
Definition: vulkan_core.h:1440
@ VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT
Definition: vulkan_core.h:1436
@ VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX
Definition: vulkan_core.h:1447
@ VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV
Definition: vulkan_core.h:1452
@ VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT
Definition: vulkan_core.h:1445
VkResult(VKAPI_PTR * PFN_vkCreateRayTracingPipelinesNV)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
Definition: vulkan_core.h:8322
#define VK_MAX_DRIVER_INFO_SIZE_KHR
Definition: vulkan_core.h:6089
void(VKAPI_PTR * PFN_vkCmdPushDescriptorSetWithTemplateKHR)(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void *pData)
Definition: vulkan_core.h:5454
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, uint32_t *pSurfaceFormatCount, VkSurfaceFormat2KHR *pSurfaceFormats)
Definition: vulkan_core.h:5793
VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
void(VKAPI_PTR * PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:2923
VkResult(VKAPI_PTR * PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void *pData, VkDeviceSize stride, VkQueryResultFlags flags)
Definition: vulkan_core.h:2899
VkResult(VKAPI_PTR * PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDisplayModeKHR *pMode)
Definition: vulkan_core.h:5029
@ VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV
Definition: vulkan_core.h:8127
@ VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV
Definition: vulkan_core.h:8126
@ VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV
Definition: vulkan_core.h:8125
@ VK_VENDOR_ID_VIV
Definition: vulkan_core.h:1291
@ VK_VENDOR_ID_VSI
Definition: vulkan_core.h:1292
@ VK_VENDOR_ID_KAZAN
Definition: vulkan_core.h:1293
VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
VKAPI_ATTR void VKAPI_CALL vkCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV *pCustomSampleOrders)
VkResult(VKAPI_PTR * PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
Definition: vulkan_core.h:2926
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties)
Definition: vulkan_core.h:5304
void(VKAPI_PTR * PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures)
Definition: vulkan_core.h:5211
@ VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT
Definition: vulkan_core.h:7265
@ VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT
Definition: vulkan_core.h:7264
PFN_vkVoidFunction(VKAPI_PTR * PFN_vkGetInstanceProcAddr)(VkInstance instance, const char *pName)
Definition: vulkan_core.h:2859
VkResult(VKAPI_PTR * PFN_vkBindImageMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
Definition: vulkan_core.h:4491
VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplateKHR(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator)
VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages)
VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks *pAllocator)
VkResult(VKAPI_PTR * PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore)
Definition: vulkan_core.h:2890
@ VK_OBJECT_TYPE_PIPELINE
Definition: vulkan_core.h:1263
@ VK_OBJECT_TYPE_FRAMEBUFFER
Definition: vulkan_core.h:1268
@ VK_OBJECT_TYPE_IMAGE
Definition: vulkan_core.h:1254
@ VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE
Definition: vulkan_core.h:1271
@ VK_OBJECT_TYPE_QUERY_POOL
Definition: vulkan_core.h:1256
@ VK_OBJECT_TYPE_DEVICE_MEMORY
Definition: vulkan_core.h:1252
@ VK_OBJECT_TYPE_DESCRIPTOR_POOL
Definition: vulkan_core.h:1266
@ VK_OBJECT_TYPE_COMMAND_BUFFER
Definition: vulkan_core.h:1250
@ VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION
Definition: vulkan_core.h:1270
@ VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV
Definition: vulkan_core.h:1281
@ VK_OBJECT_TYPE_EVENT
Definition: vulkan_core.h:1255
@ VK_OBJECT_TYPE_PIPELINE_LAYOUT
Definition: vulkan_core.h:1261
@ VK_OBJECT_TYPE_QUEUE
Definition: vulkan_core.h:1248
@ VK_OBJECT_TYPE_DEVICE
Definition: vulkan_core.h:1247
@ VK_OBJECT_TYPE_RENDER_PASS
Definition: vulkan_core.h:1262
@ VK_OBJECT_TYPE_DESCRIPTOR_SET
Definition: vulkan_core.h:1267
@ VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT
Definition: vulkan_core.h:1264
@ VK_OBJECT_TYPE_OBJECT_TABLE_NVX
Definition: vulkan_core.h:1277
@ VK_OBJECT_TYPE_SHADER_MODULE
Definition: vulkan_core.h:1259
@ VK_OBJECT_TYPE_DISPLAY_KHR
Definition: vulkan_core.h:1274
@ VK_OBJECT_TYPE_IMAGE_VIEW
Definition: vulkan_core.h:1258
@ VK_OBJECT_TYPE_UNKNOWN
Definition: vulkan_core.h:1244
@ VK_OBJECT_TYPE_COMMAND_POOL
Definition: vulkan_core.h:1269
@ VK_OBJECT_TYPE_SWAPCHAIN_KHR
Definition: vulkan_core.h:1273
@ VK_OBJECT_TYPE_PIPELINE_CACHE
Definition: vulkan_core.h:1260
@ VK_OBJECT_TYPE_PHYSICAL_DEVICE
Definition: vulkan_core.h:1246
@ VK_OBJECT_TYPE_SURFACE_KHR
Definition: vulkan_core.h:1272
@ VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT
Definition: vulkan_core.h:1276
@ VK_OBJECT_TYPE_SAMPLER
Definition: vulkan_core.h:1265
@ VK_OBJECT_TYPE_BUFFER_VIEW
Definition: vulkan_core.h:1257
@ VK_OBJECT_TYPE_SEMAPHORE
Definition: vulkan_core.h:1249
@ VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX
Definition: vulkan_core.h:1278
@ VK_OBJECT_TYPE_VALIDATION_CACHE_EXT
Definition: vulkan_core.h:1280
@ VK_OBJECT_TYPE_FENCE
Definition: vulkan_core.h:1251
@ VK_OBJECT_TYPE_INSTANCE
Definition: vulkan_core.h:1245
@ VK_OBJECT_TYPE_DISPLAY_MODE_KHR
Definition: vulkan_core.h:1275
@ VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT
Definition: vulkan_core.h:1279
@ VK_OBJECT_TYPE_BUFFER
Definition: vulkan_core.h:1253
VkResult(VKAPI_PTR * PFN_vkCreateSharedSwapchainsKHR)(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchains)
Definition: vulkan_core.h:5089
@ VK_QUERY_RESULT_PARTIAL_BIT
Definition: vulkan_core.h:1520
@ VK_QUERY_RESULT_64_BIT
Definition: vulkan_core.h:1517
@ VK_QUERY_RESULT_WAIT_BIT
Definition: vulkan_core.h:1518
@ VK_QUERY_RESULT_WITH_AVAILABILITY_BIT
Definition: vulkan_core.h:1519
void(VKAPI_PTR * PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
Definition: vulkan_core.h:2973
VkResult(VKAPI_PTR * PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImage *pImage)
Definition: vulkan_core.h:2904
VkResult(VKAPI_PTR * PFN_vkCreateDescriptorUpdateTemplate)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
Definition: vulkan_core.h:4510
VkResult(VKAPI_PTR * PFN_vkCreateDebugReportCallbackEXT)(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pCallback)
Definition: vulkan_core.h:6226
@ VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT
Definition: vulkan_core.h:3957
@ VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT
Definition: vulkan_core.h:3956
VkResult(VKAPI_PTR * PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout)
Definition: vulkan_core.h:2918
void(VKAPI_PTR * PFN_vkTrimCommandPoolKHR)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
Definition: vulkan_core.h:5249
@ VK_FENCE_CREATE_SIGNALED_BIT
Definition: vulkan_core.h:1492
VKAPI_ATTR void VKAPI_CALL vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
VkResult(VKAPI_PTR * PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex)
Definition: vulkan_core.h:4890
VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplateKHR(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures)
VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos)
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pRectCount, VkRect2D *pRects)
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pPresentModeCount, VkPresentModeKHR *pPresentModes)
Definition: vulkan_core.h:4755
VkResult(VKAPI_PTR * PFN_vkAcquireNextImage2KHR)(VkDevice device, const VkAcquireNextImageInfoKHR *pAcquireInfo, uint32_t *pImageIndex)
Definition: vulkan_core.h:4895
void(VKAPI_PTR * PFN_vkCmdSetCoarseSampleOrderNV)(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV *pCustomSampleOrders)
Definition: vulkan_core.h:8095
VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers)
void(VKAPI_PTR * PFN_vkCmdProcessCommandsNVX)(VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX *pProcessCommandsInfo)
Definition: vulkan_core.h:6922
VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR *pGetFdInfo, int *pFd)
@ VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT
Definition: vulkan_core.h:3983
@ VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT
Definition: vulkan_core.h:3980
@ VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT
Definition: vulkan_core.h:3982
@ VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT
Definition: vulkan_core.h:3979
@ VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT
Definition: vulkan_core.h:3981
void(VKAPI_PTR * PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags)
Definition: vulkan_core.h:2977
VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData)
VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator)
VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator)
VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks *pAllocator)
VkResult(VKAPI_PTR * PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV *pExternalImageFormatProperties)
Definition: vulkan_core.h:6628
void(VKAPI_PTR * PFN_vkCmdSetDiscardRectangleEXT)(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D *pDiscardRectangles)
Definition: vulkan_core.h:7290
VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements *pSparseMemoryRequirements)
VkFlags VkCommandBufferResetFlags
Definition: vulkan_core.h:1724
VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout)
VkResult(VKAPI_PTR * PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo, VkCommandBuffer *pCommandBuffers)
Definition: vulkan_core.h:2938
void(VKAPI_PTR * PFN_vkGetPhysicalDeviceFeatures2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures)
Definition: vulkan_core.h:4499
VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus(VkDevice device, VkFence fence)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDevice *pDevice)
VkResult(VKAPI_PTR * PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties)
Definition: vulkan_core.h:2864
void(VKAPI_PTR * PFN_vkCmdSetViewportShadingRatePaletteNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV *pShadingRatePalettes)
Definition: vulkan_core.h:8094
void(VKAPI_PTR * PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query)
Definition: vulkan_core.h:2978
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceExternalImageFormatPropertiesNV(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV *pExternalImageFormatProperties)
VKAPI_ATTR void VKAPI_CALL vkCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D *pExclusiveScissors)
void(VKAPI_PTR * PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:4888
VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator)
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT
Definition: vulkan_core.h:328
@ VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO
Definition: vulkan_core.h:207
@ VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES
Definition: vulkan_core.h:270
@ VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR
Definition: vulkan_core.h:366
@ VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO
Definition: vulkan_core.h:187
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT
Definition: vulkan_core.h:443
@ VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO
Definition: vulkan_core.h:239
@ VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2
Definition: vulkan_core.h:224
@ VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR
Definition: vulkan_core.h:351
@ VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT
Definition: vulkan_core.h:329
@ VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR
Definition: vulkan_core.h:319
@ VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV
Definition: vulkan_core.h:431
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO
Definition: vulkan_core.h:257
@ VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO
Definition: vulkan_core.h:189
@ VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO
Definition: vulkan_core.h:208
@ VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK
Definition: vulkan_core.h:373
@ VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX
Definition: vulkan_core.h:331
@ VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID
Definition: vulkan_core.h:383
@ VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO
Definition: vulkan_core.h:218
@ VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT
Definition: vulkan_core.h:434
@ VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO_KHR
Definition: vulkan_core.h:356
@ VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR
Definition: vulkan_core.h:358
@ VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV
Definition: vulkan_core.h:424
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT
Definition: vulkan_core.h:299
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR
Definition: vulkan_core.h:437
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR
Definition: vulkan_core.h:364
@ VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR
Definition: vulkan_core.h:289
@ VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO
Definition: vulkan_core.h:186
@ VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID
Definition: vulkan_core.h:382
@ VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV
Definition: vulkan_core.h:429
@ VK_STRUCTURE_TYPE_BIND_SPARSE_INFO
Definition: vulkan_core.h:167
@ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT
Definition: vulkan_core.h:300
@ VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES
Definition: vulkan_core.h:258
@ VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT
Definition: vulkan_core.h:338
@ VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV
Definition: vulkan_core.h:422
@ VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR
Definition: vulkan_core.h:323
@ VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR
Definition: vulkan_core.h:318
@ VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX
Definition: vulkan_core.h:336
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV
Definition: vulkan_core.h:302
@ VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO
Definition: vulkan_core.h:180
@ VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO
Definition: vulkan_core.h:169
@ VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT
Definition: vulkan_core.h:390
@ VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2
Definition: vulkan_core.h:234
@ VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV
Definition: vulkan_core.h:428
@ VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT
Definition: vulkan_core.h:327
@ VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO
Definition: vulkan_core.h:190
@ VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV
Definition: vulkan_core.h:337
@ VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID
Definition: vulkan_core.h:381
@ VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR
Definition: vulkan_core.h:278
@ VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2
Definition: vulkan_core.h:227
@ VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID
Definition: vulkan_core.h:379
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT
Definition: vulkan_core.h:385
@ VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT
Definition: vulkan_core.h:395
@ VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR
Definition: vulkan_core.h:282
@ VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT
Definition: vulkan_core.h:402
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV
Definition: vulkan_core.h:417
@ VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO
Definition: vulkan_core.h:220
@ VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT
Definition: vulkan_core.h:294
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES
Definition: vulkan_core.h:248
@ VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV
Definition: vulkan_core.h:426
@ VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS
Definition: vulkan_core.h:213
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD
Definition: vulkan_core.h:439
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR
Definition: vulkan_core.h:454
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES
Definition: vulkan_core.h:247
@ VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2
Definition: vulkan_core.h:249
@ VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX
Definition: vulkan_core.h:335
@ VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO
Definition: vulkan_core.h:184
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2
Definition: vulkan_core.h:230
@ VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR
Definition: vulkan_core.h:396
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2
Definition: vulkan_core.h:233
@ VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO
Definition: vulkan_core.h:223
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT
Definition: vulkan_core.h:298
@ VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET
Definition: vulkan_core.h:196
@ VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO
Definition: vulkan_core.h:173
@ VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT
Definition: vulkan_core.h:347
@ VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2
Definition: vulkan_core.h:232
@ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO
Definition: vulkan_core.h:183
@ VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO
Definition: vulkan_core.h:268
@ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT
Definition: vulkan_core.h:272
@ VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT
Definition: vulkan_core.h:342
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT
Definition: vulkan_core.h:346
@ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT
Definition: vulkan_core.h:410
@ VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO
Definition: vulkan_core.h:210
@ VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT
Definition: vulkan_core.h:403
@ VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT
Definition: vulkan_core.h:377
@ VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO
Definition: vulkan_core.h:251
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES
Definition: vulkan_core.h:222
@ VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO
Definition: vulkan_core.h:191
@ VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO
Definition: vulkan_core.h:197
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV
Definition: vulkan_core.h:427
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX
Definition: vulkan_core.h:344
@ VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV
Definition: vulkan_core.h:453
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT
Definition: vulkan_core.h:441
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT
Definition: vulkan_core.h:394
@ VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR
Definition: vulkan_core.h:324
@ VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO
Definition: vulkan_core.h:162
@ VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO
Definition: vulkan_core.h:201
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES
Definition: vulkan_core.h:238
@ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT
Definition: vulkan_core.h:413
@ VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO
Definition: vulkan_core.h:250
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES
Definition: vulkan_core.h:254
@ VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR
Definition: vulkan_core.h:314
@ VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2
Definition: vulkan_core.h:228
@ VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO
Definition: vulkan_core.h:172
@ VK_STRUCTURE_TYPE_HDR_METADATA_EXT
Definition: vulkan_core.h:350
@ VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV
Definition: vulkan_core.h:345
@ VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR
Definition: vulkan_core.h:325
@ VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR
Definition: vulkan_core.h:367
@ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO
Definition: vulkan_core.h:192
@ VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT
Definition: vulkan_core.h:375
@ VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX
Definition: vulkan_core.h:332
@ VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV
Definition: vulkan_core.h:296
@ VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT
Definition: vulkan_core.h:290
@ VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2
Definition: vulkan_core.h:236
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR
Definition: vulkan_core.h:444
@ VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV
Definition: vulkan_core.h:304
@ VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO
Definition: vulkan_core.h:217
@ VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO
Definition: vulkan_core.h:221
@ VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT
Definition: vulkan_core.h:339
@ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO
Definition: vulkan_core.h:174
@ VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD
Definition: vulkan_core.h:301
@ VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT
Definition: vulkan_core.h:341
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR
Definition: vulkan_core.h:326
@ VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT
Definition: vulkan_core.h:393
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT
Definition: vulkan_core.h:455
@ VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO
Definition: vulkan_core.h:171
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV
Definition: vulkan_core.h:430
@ VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO
Definition: vulkan_core.h:200
@ VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR
Definition: vulkan_core.h:287
@ VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO
Definition: vulkan_core.h:242
@ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT
Definition: vulkan_core.h:349
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES
Definition: vulkan_core.h:244
@ VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR
Definition: vulkan_core.h:285
@ VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT
Definition: vulkan_core.h:406
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR
Definition: vulkan_core.h:433
@ VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR
Definition: vulkan_core.h:359
@ VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR
Definition: vulkan_core.h:353
@ VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX
Definition: vulkan_core.h:333
@ VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV
Definition: vulkan_core.h:452
@ VK_STRUCTURE_TYPE_APPLICATION_INFO
Definition: vulkan_core.h:160
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT
Definition: vulkan_core.h:348
@ VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT
Definition: vulkan_core.h:386
@ VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV
Definition: vulkan_core.h:415
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT
Definition: vulkan_core.h:397
@ VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT
Definition: vulkan_core.h:391
@ VK_STRUCTURE_TYPE_SUBPASS_END_INFO_KHR
Definition: vulkan_core.h:357
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT
Definition: vulkan_core.h:412
@ VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO
Definition: vulkan_core.h:211
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2
Definition: vulkan_core.h:235
@ VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET
Definition: vulkan_core.h:195
@ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO
Definition: vulkan_core.h:202
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT
Definition: vulkan_core.h:311
@ VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR
Definition: vulkan_core.h:279
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES
Definition: vulkan_core.h:245
@ VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO
Definition: vulkan_core.h:219
@ VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV
Definition: vulkan_core.h:295
@ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT
Definition: vulkan_core.h:414
@ VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV
Definition: vulkan_core.h:419
@ VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT
Definition: vulkan_core.h:293
@ VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID
Definition: vulkan_core.h:380
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV
Definition: vulkan_core.h:447
@ VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR
Definition: vulkan_core.h:330
@ VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR
Definition: vulkan_core.h:361
@ VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK
Definition: vulkan_core.h:372
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO
Definition: vulkan_core.h:259
@ VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT
Definition: vulkan_core.h:405
@ VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2
Definition: vulkan_core.h:225
@ VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR
Definition: vulkan_core.h:369
@ VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO
Definition: vulkan_core.h:264
@ VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO
Definition: vulkan_core.h:262
@ VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR
Definition: vulkan_core.h:286
@ VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR
Definition: vulkan_core.h:312
@ VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT
Definition: vulkan_core.h:340
@ VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO
Definition: vulkan_core.h:256
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT
Definition: vulkan_core.h:436
@ VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO
Definition: vulkan_core.h:161
@ VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO
Definition: vulkan_core.h:240
@ VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR
Definition: vulkan_core.h:276
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT
Definition: vulkan_core.h:388
@ VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR
Definition: vulkan_core.h:288
@ VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT
Definition: vulkan_core.h:432
@ VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO
Definition: vulkan_core.h:214
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT
Definition: vulkan_core.h:404
@ VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR
Definition: vulkan_core.h:274
@ VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV
Definition: vulkan_core.h:425
@ VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES
Definition: vulkan_core.h:260
@ VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR
Definition: vulkan_core.h:371
@ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO
Definition: vulkan_core.h:175
@ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO
Definition: vulkan_core.h:198
@ VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR
Definition: vulkan_core.h:352
@ VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV
Definition: vulkan_core.h:401
@ VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT
Definition: vulkan_core.h:408
@ VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT
Definition: vulkan_core.h:376
@ VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT
Definition: vulkan_core.h:308
@ VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR
Definition: vulkan_core.h:281
@ VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO
Definition: vulkan_core.h:246
@ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO
Definition: vulkan_core.h:215
@ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO
Definition: vulkan_core.h:194
@ VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO
Definition: vulkan_core.h:176
@ VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT
Definition: vulkan_core.h:310
@ VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT
Definition: vulkan_core.h:292
@ VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA
Definition: vulkan_core.h:456
@ VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
Definition: vulkan_core.h:178
@ VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO
Definition: vulkan_core.h:188
@ VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR
Definition: vulkan_core.h:317
@ VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR
Definition: vulkan_core.h:284
@ VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR
Definition: vulkan_core.h:283
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV
Definition: vulkan_core.h:416
@ VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN
Definition: vulkan_core.h:309
@ VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO
Definition: vulkan_core.h:165
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES
Definition: vulkan_core.h:271
@ VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT
Definition: vulkan_core.h:442
@ VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV
Definition: vulkan_core.h:418
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV
Definition: vulkan_core.h:445
@ VK_STRUCTURE_TYPE_EVENT_CREATE_INFO
Definition: vulkan_core.h:170
@ VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2
Definition: vulkan_core.h:226
@ VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR
Definition: vulkan_core.h:354
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT
Definition: vulkan_core.h:411
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV
Definition: vulkan_core.h:451
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV
Definition: vulkan_core.h:449
@ VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO
Definition: vulkan_core.h:267
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2
Definition: vulkan_core.h:229
@ VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO
Definition: vulkan_core.h:216
@ VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT
Definition: vulkan_core.h:378
@ VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR
Definition: vulkan_core.h:316
@ VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO
Definition: vulkan_core.h:193
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES
Definition: vulkan_core.h:273
@ VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR
Definition: vulkan_core.h:321
@ VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT
Definition: vulkan_core.h:438
@ VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO
Definition: vulkan_core.h:253
@ VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV
Definition: vulkan_core.h:297
@ VK_STRUCTURE_TYPE_FENCE_CREATE_INFO
Definition: vulkan_core.h:168
@ VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD
Definition: vulkan_core.h:440
@ VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO
Definition: vulkan_core.h:163
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES
Definition: vulkan_core.h:261
@ VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO
Definition: vulkan_core.h:203
@ VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV
Definition: vulkan_core.h:420
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO
Definition: vulkan_core.h:269
@ VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR
Definition: vulkan_core.h:365
@ VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR
Definition: vulkan_core.h:322
@ VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV
Definition: vulkan_core.h:450
@ VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX
Definition: vulkan_core.h:334
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT
Definition: vulkan_core.h:398
@ VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT
Definition: vulkan_core.h:389
@ VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO
Definition: vulkan_core.h:181
@ VK_STRUCTURE_TYPE_MEMORY_BARRIER
Definition: vulkan_core.h:206
@ VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR
Definition: vulkan_core.h:277
@ VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER
Definition: vulkan_core.h:204
@ VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES
Definition: vulkan_core.h:255
@ VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT
Definition: vulkan_core.h:374
@ VK_STRUCTURE_TYPE_SUBMIT_INFO
Definition: vulkan_core.h:164
@ VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT
Definition: vulkan_core.h:399
@ VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV
Definition: vulkan_core.h:306
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES
Definition: vulkan_core.h:209
@ VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT
Definition: vulkan_core.h:409
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT
Definition: vulkan_core.h:387
@ VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV
Definition: vulkan_core.h:400
@ VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO
Definition: vulkan_core.h:182
@ VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR
Definition: vulkan_core.h:362
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES
Definition: vulkan_core.h:243
@ VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV
Definition: vulkan_core.h:307
@ VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO
Definition: vulkan_core.h:241
@ VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR
Definition: vulkan_core.h:370
@ VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV
Definition: vulkan_core.h:423
@ VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR
Definition: vulkan_core.h:368
@ VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR
Definition: vulkan_core.h:363
@ VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE
Definition: vulkan_core.h:166
@ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD
Definition: vulkan_core.h:291
@ VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV
Definition: vulkan_core.h:305
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV
Definition: vulkan_core.h:446
@ VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR
Definition: vulkan_core.h:313
@ VK_STRUCTURE_TYPE_GEOMETRY_NV
Definition: vulkan_core.h:421
@ VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2
Definition: vulkan_core.h:231
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2
Definition: vulkan_core.h:237
@ VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID
Definition: vulkan_core.h:384
@ VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE
Definition: vulkan_core.h:343
@ VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT
Definition: vulkan_core.h:435
@ VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO
Definition: vulkan_core.h:177
@ VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO
Definition: vulkan_core.h:252
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV
Definition: vulkan_core.h:448
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES
Definition: vulkan_core.h:212
@ VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV
Definition: vulkan_core.h:303
@ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO
Definition: vulkan_core.h:265
@ VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES
Definition: vulkan_core.h:266
@ VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT
Definition: vulkan_core.h:392
@ VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO
Definition: vulkan_core.h:179
@ VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR
Definition: vulkan_core.h:360
@ VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT
Definition: vulkan_core.h:407
@ VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO
Definition: vulkan_core.h:199
@ VK_STRUCTURE_TYPE_PRESENT_INFO_KHR
Definition: vulkan_core.h:275
@ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER
Definition: vulkan_core.h:205
@ VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR
Definition: vulkan_core.h:315
@ VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO
Definition: vulkan_core.h:263
@ VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR
Definition: vulkan_core.h:320
@ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR
Definition: vulkan_core.h:355
@ VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR
Definition: vulkan_core.h:280
@ VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO
Definition: vulkan_core.h:185
VkDebugUtilsMessageSeverityFlagBitsEXT
Definition: vulkan_core.h:7399
@ VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT
Definition: vulkan_core.h:7403
@ VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT
Definition: vulkan_core.h:7401
@ VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT
Definition: vulkan_core.h:7400
@ VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT
Definition: vulkan_core.h:7402
VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport)
@ VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT
Definition: vulkan_core.h:7409
@ VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT
Definition: vulkan_core.h:7411
@ VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT
Definition: vulkan_core.h:7410
VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo)
void(VKAPI_PTR * PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:2901
VKAPI_ATTR VkResult VKAPI_CALL vkCreateImagePipeSurfaceFUCHSIA(VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
VkResult(VKAPI_PTR * PFN_vkCreateImagePipeSurfaceFUCHSIA)(VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
VkResult(VKAPI_PTR * PFN_vkCreateIOSSurfaceMVK)(VkInstance instance, const VkIOSSurfaceCreateInfoMVK *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
Definition: vulkan_ios.h:44
VKAPI_ATTR VkResult VKAPI_CALL vkCreateIOSSurfaceMVK(VkInstance instance, const VkIOSSurfaceCreateInfoMVK *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
VkResult(VKAPI_PTR * PFN_vkCreateMacOSSurfaceMVK)(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
Definition: vulkan_macos.h:44
VKAPI_ATTR VkResult VKAPI_CALL vkCreateMacOSSurfaceMVK(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateViSurfaceNN(VkInstance instance, const VkViSurfaceCreateInfoNN *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
VkResult(VKAPI_PTR * PFN_vkCreateViSurfaceNN)(VkInstance instance, const VkViSurfaceCreateInfoNN *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
Definition: vulkan_vi.h:44
VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display *display)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
VkBool32(VKAPI_PTR * PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display *display)
VkResult(VKAPI_PTR * PFN_vkCreateWaylandSurfaceKHR)(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHR(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle)
VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceWin32HandleKHR(VkDevice device, const VkFenceGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle)
VkResult(VKAPI_PTR * PFN_vkGetSemaphoreWin32HandleKHR)(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle)
Definition: vulkan_win32.h:168
VkResult(VKAPI_PTR * PFN_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR *pMemoryWin32HandleProperties)
Definition: vulkan_win32.h:95
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR(VkDevice device, const VkMemoryGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle)
VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHR(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR *pImportSemaphoreWin32HandleInfo)
VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceWin32HandleKHR(VkDevice device, const VkImportFenceWin32HandleInfoKHR *pImportFenceWin32HandleInfo)
VkResult(VKAPI_PTR * PFN_vkGetMemoryWin32HandleNV)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE *pHandle)
Definition: vulkan_win32.h:244
VkResult(VKAPI_PTR * PFN_vkGetMemoryWin32HandleKHR)(VkDevice device, const VkMemoryGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle)
Definition: vulkan_win32.h:94
VkResult(VKAPI_PTR * PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, const VkWin32SurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
Definition: vulkan_win32.h:45
VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex)
VkBool32(VKAPI_PTR * PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex)
Definition: vulkan_win32.h:46
VkResult(VKAPI_PTR * PFN_vkImportFenceWin32HandleKHR)(VkDevice device, const VkImportFenceWin32HandleInfoKHR *pImportFenceWin32HandleInfo)
Definition: vulkan_win32.h:211
VkResult(VKAPI_PTR * PFN_vkImportSemaphoreWin32HandleKHR)(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR *pImportSemaphoreWin32HandleInfo)
Definition: vulkan_win32.h:167
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR *pMemoryWin32HandleProperties)
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE *pHandle)
VkResult(VKAPI_PTR * PFN_vkGetFenceWin32HandleKHR)(VkDevice device, const VkFenceGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle)
Definition: vulkan_win32.h:212
VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
VkResult(VKAPI_PTR * PFN_vkCreateXcbSurfaceKHR)(VkInstance instance, const VkXcbSurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
Definition: vulkan_xcb.h:45
VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t *connection, xcb_visualid_t visual_id)
VkBool32(VKAPI_PTR * PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t *connection, xcb_visualid_t visual_id)
Definition: vulkan_xcb.h:46
VkResult(VKAPI_PTR * PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, const VkXlibSurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
Definition: vulkan_xlib.h:45
VkBool32(VKAPI_PTR * PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display *dpy, VisualID visualID)
Definition: vulkan_xlib.h:46
VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display *dpy, VisualID visualID)
VKAPI_ATTR VkResult VKAPI_CALL vkGetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display *dpy, RROutput rrOutput, VkDisplayKHR *pDisplay)
VkResult(VKAPI_PTR * PFN_vkGetRandROutputDisplayEXT)(VkPhysicalDevice physicalDevice, Display *dpy, RROutput rrOutput, VkDisplayKHR *pDisplay)
VkResult(VKAPI_PTR * PFN_vkAcquireXlibDisplayEXT)(VkPhysicalDevice physicalDevice, Display *dpy, VkDisplayKHR display)
VKAPI_ATTR VkResult VKAPI_CALL vkAcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display *dpy, VkDisplayKHR display)